|
| 1 | +// ******************************************************************************* |
| 2 | +// Copyright (c) 2026 Contributors to the Eclipse Foundation |
| 3 | +// |
| 4 | +// See the NOTICE file(s) distributed with this work for additional |
| 5 | +// information regarding copyright ownership. |
| 6 | +// |
| 7 | +// This program and the accompanying materials are made available under the |
| 8 | +// terms of the Apache License Version 2.0 which is available at |
| 9 | +// <https://www.apache.org/licenses/LICENSE-2.0> |
| 10 | +// |
| 11 | +// SPDX-License-Identifier: Apache-2.0 |
| 12 | +// ******************************************************************************* |
| 13 | + |
| 14 | +use flatbuffers::FlatBufferBuilder; |
| 15 | +use sequence_fbs::sequence_metamodel as fb; |
| 16 | +use sequence_logic::{ConditionType, Event, SequenceNode}; |
| 17 | + |
| 18 | +pub struct SequenceSerializer; |
| 19 | + |
| 20 | +impl SequenceSerializer { |
| 21 | + pub fn serialize( |
| 22 | + nodes: &[SequenceNode], |
| 23 | + name: Option<&str>, |
| 24 | + source_files: &[String], |
| 25 | + version: Option<&str>, |
| 26 | + ) -> Vec<u8> { |
| 27 | + let mut builder = FlatBufferBuilder::new(); |
| 28 | + |
| 29 | + let name_offset = name.map(|n| builder.create_string(n)); |
| 30 | + |
| 31 | + let node_offsets: Vec<_> = nodes |
| 32 | + .iter() |
| 33 | + .map(|node| Self::serialize_node(&mut builder, node)) |
| 34 | + .collect(); |
| 35 | + let nodes_offset = builder.create_vector(&node_offsets); |
| 36 | + |
| 37 | + let source_offsets: Vec<_> = source_files |
| 38 | + .iter() |
| 39 | + .map(|s| builder.create_string(s)) |
| 40 | + .collect(); |
| 41 | + let source_files_offset = builder.create_vector(&source_offsets); |
| 42 | + |
| 43 | + let version_offset = version.map(|v| builder.create_string(v)); |
| 44 | + |
| 45 | + let root = fb::SequenceDiagram::create( |
| 46 | + &mut builder, |
| 47 | + &fb::SequenceDiagramArgs { |
| 48 | + name: name_offset, |
| 49 | + root_interactions: Some(nodes_offset), |
| 50 | + source_files: Some(source_files_offset), |
| 51 | + version: version_offset, |
| 52 | + }, |
| 53 | + ); |
| 54 | + |
| 55 | + builder.finish(root, Some("SEQD")); |
| 56 | + builder.finished_data().to_vec() |
| 57 | + } |
| 58 | + |
| 59 | + fn serialize_node<'a>( |
| 60 | + builder: &mut FlatBufferBuilder<'a>, |
| 61 | + node: &SequenceNode, |
| 62 | + ) -> flatbuffers::WIPOffset<fb::SequenceNode<'a>> { |
| 63 | + // Recursively serialize child nodes first (depth-first). |
| 64 | + let branch_offsets: Vec<_> = node |
| 65 | + .branches_node |
| 66 | + .iter() |
| 67 | + .map(|child| Self::serialize_node(builder, child)) |
| 68 | + .collect(); |
| 69 | + let branches_offset = builder.create_vector(&branch_offsets); |
| 70 | + |
| 71 | + // Serialize the event union. |
| 72 | + let (event_type, event_offset) = Self::serialize_event(builder, &node.event); |
| 73 | + |
| 74 | + fb::SequenceNode::create( |
| 75 | + builder, |
| 76 | + &fb::SequenceNodeArgs { |
| 77 | + event_type, |
| 78 | + event: Some(event_offset), |
| 79 | + branches_node: Some(branches_offset), |
| 80 | + }, |
| 81 | + ) |
| 82 | + } |
| 83 | + |
| 84 | + fn serialize_event<'a>( |
| 85 | + builder: &mut FlatBufferBuilder<'a>, |
| 86 | + event: &Event, |
| 87 | + ) -> ( |
| 88 | + fb::Event, |
| 89 | + flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>, |
| 90 | + ) { |
| 91 | + match event { |
| 92 | + Event::Interaction(interaction) => { |
| 93 | + let caller = builder.create_string(&interaction.caller); |
| 94 | + let callee = builder.create_string(&interaction.callee); |
| 95 | + let method = builder.create_string(&interaction.method); |
| 96 | + let offset = fb::Interaction::create( |
| 97 | + builder, |
| 98 | + &fb::InteractionArgs { |
| 99 | + caller: Some(caller), |
| 100 | + callee: Some(callee), |
| 101 | + method: Some(method), |
| 102 | + }, |
| 103 | + ); |
| 104 | + (fb::Event::Interaction, offset.as_union_value()) |
| 105 | + } |
| 106 | + Event::Return(ret) => { |
| 107 | + let caller = builder.create_string(&ret.caller); |
| 108 | + let callee = builder.create_string(&ret.callee); |
| 109 | + let return_content = builder.create_string(&ret.return_content); |
| 110 | + let offset = fb::Return::create( |
| 111 | + builder, |
| 112 | + &fb::ReturnArgs { |
| 113 | + caller: Some(caller), |
| 114 | + callee: Some(callee), |
| 115 | + return_content: Some(return_content), |
| 116 | + }, |
| 117 | + ); |
| 118 | + (fb::Event::Return, offset.as_union_value()) |
| 119 | + } |
| 120 | + Event::Condition(cond) => { |
| 121 | + let condition_value = builder.create_string(&cond.condition_value); |
| 122 | + let offset = fb::Condition::create( |
| 123 | + builder, |
| 124 | + &fb::ConditionArgs { |
| 125 | + condition_type: Self::map_condition_type(cond.condition_type.clone()), |
| 126 | + condition_value: Some(condition_value), |
| 127 | + }, |
| 128 | + ); |
| 129 | + (fb::Event::Condition, offset.as_union_value()) |
| 130 | + } |
| 131 | + } |
| 132 | + } |
| 133 | + |
| 134 | + fn map_condition_type(ct: ConditionType) -> fb::ConditionType { |
| 135 | + match ct { |
| 136 | + ConditionType::Opt => fb::ConditionType::Opt, |
| 137 | + ConditionType::Alt => fb::ConditionType::Alt, |
| 138 | + ConditionType::Loop => fb::ConditionType::Loop, |
| 139 | + ConditionType::Par => fb::ConditionType::Par, |
| 140 | + ConditionType::Par2 => fb::ConditionType::Par2, |
| 141 | + ConditionType::Break => fb::ConditionType::Break, |
| 142 | + ConditionType::Critical => fb::ConditionType::Critical, |
| 143 | + ConditionType::Else => fb::ConditionType::Else, |
| 144 | + ConditionType::Also => fb::ConditionType::Also, |
| 145 | + ConditionType::End => fb::ConditionType::End, |
| 146 | + ConditionType::Group => fb::ConditionType::Group, |
| 147 | + } |
| 148 | + } |
| 149 | +} |
0 commit comments