1 | import { Reader as $Reader } from 'protobufjs/minimal';
|
2 | import { decode as decodeBitset } from '@statechart/scpb-bitset';
|
3 | import {
|
4 | state as stateTypes,
|
5 | transition as transitionTypes,
|
6 | expression as expressionTypes,
|
7 | } from './types';
|
8 |
|
9 | export default function decodeDocument(reader, length) {
|
10 | if (!(reader instanceof $Reader))
|
11 | reader = $Reader.create(reader);
|
12 | let end = length === undefined ? reader.len : reader.pos + length, message = {
|
13 | states: [],
|
14 | transitions: [],
|
15 | meta: {},
|
16 | };
|
17 | while (reader.pos < end) {
|
18 | let tag = reader.uint32();
|
19 | switch (tag >>> 3) {
|
20 | case 1:
|
21 | message.name = reader.string();
|
22 | break;
|
23 | case 2:
|
24 | message.states.push(decodeState(reader, reader.uint32()));
|
25 | break;
|
26 | case 3:
|
27 | message.transitions.push(decodeTransition(reader, reader.uint32()));
|
28 | break;
|
29 | case 4:
|
30 | message.datamodel = reader.string();
|
31 | break;
|
32 | case 5:
|
33 | reader.skip().pos++;
|
34 | let key = reader.string();
|
35 | reader.pos++;
|
36 | message.meta[key] = reader.string();
|
37 | break;
|
38 | default:
|
39 | reader.skipType(tag & 7);
|
40 | break;
|
41 | }
|
42 | }
|
43 | return message;
|
44 | }
|
45 |
|
46 | function decodeState(reader, length) {
|
47 | if (!(reader instanceof $Reader))
|
48 | reader = $Reader.create(reader);
|
49 | let end = length === undefined ? reader.len : reader.pos + length, message = {
|
50 | onEnter: [],
|
51 | onExit: [],
|
52 | invocations: [],
|
53 | data: [],
|
54 | };
|
55 | while (reader.pos < end) {
|
56 | let tag = reader.uint32();
|
57 | switch (tag >>> 3) {
|
58 | case 1:
|
59 | message.type = stateTypes[reader.uint32()];
|
60 | break;
|
61 | case 2:
|
62 | message.idx = reader.uint32();
|
63 | break;
|
64 | case 3:
|
65 | message.id = reader.string();
|
66 | break;
|
67 | case 4:
|
68 | message.onEnter.push(decodeExpression(reader, reader.uint32()));
|
69 | break;
|
70 | case 5:
|
71 | message.onExit.push(decodeExpression(reader, reader.uint32()));
|
72 | break;
|
73 | case 6:
|
74 | message.invocations.push(decodeInvocation(reader, reader.uint32()));
|
75 | break;
|
76 | case 7:
|
77 | message.data.push(decodeData(reader, reader.uint32()));
|
78 | break;
|
79 | case 8:
|
80 | message.parent = reader.uint32();
|
81 | break;
|
82 | case 9:
|
83 | message.children = decodeBitset(reader.bytes());
|
84 | break;
|
85 | case 10:
|
86 | message.ancestors = decodeBitset(reader.bytes());
|
87 | break;
|
88 | case 11:
|
89 | message.completion = decodeBitset(reader.bytes());
|
90 | break;
|
91 | case 12:
|
92 | message.transitions = decodeBitset(reader.bytes());
|
93 | break;
|
94 | case 13:
|
95 | message.hasHistory = reader.bool();
|
96 | break;
|
97 | default:
|
98 | reader.skipType(tag & 7);
|
99 | break;
|
100 | }
|
101 | }
|
102 | return message;
|
103 | }
|
104 |
|
105 | function decodeTransition(reader, length) {
|
106 | if (!(reader instanceof $Reader))
|
107 | reader = $Reader.create(reader);
|
108 | let end = length === undefined ? reader.len : reader.pos + length, message = {
|
109 | events: [],
|
110 | onTransition: [],
|
111 | };
|
112 | while (reader.pos < end) {
|
113 | let tag = reader.uint32();
|
114 | switch (tag >>> 3) {
|
115 | case 1:
|
116 | message.type = transitionTypes[reader.uint32()];
|
117 | break;
|
118 | case 2:
|
119 | message.idx = reader.uint32();
|
120 | break;
|
121 | case 3:
|
122 | message.source = reader.uint32();
|
123 | break;
|
124 | case 4:
|
125 | message.events.push(reader.string());
|
126 | break;
|
127 | case 5:
|
128 | message.condition = decodeExpression(reader, reader.uint32());
|
129 | break;
|
130 | case 6:
|
131 | message.onTransition.push(decodeExpression(reader, reader.uint32()));
|
132 | break;
|
133 | case 7:
|
134 | message.targets = decodeBitset(reader.bytes());
|
135 | break;
|
136 | case 8:
|
137 | message.conflicts = decodeBitset(reader.bytes());
|
138 | break;
|
139 | case 9:
|
140 | message.exits = decodeBitset(reader.bytes());
|
141 | break;
|
142 | default:
|
143 | reader.skipType(tag & 7);
|
144 | break;
|
145 | }
|
146 | }
|
147 | return message;
|
148 | }
|
149 |
|
150 | function decodeExpression(reader, length) {
|
151 | if (!(reader instanceof $Reader))
|
152 | reader = $Reader.create(reader);
|
153 | let end = length === undefined ? reader.len : reader.pos + length, message = {
|
154 | children: [],
|
155 | };
|
156 | while (reader.pos < end) {
|
157 | let tag = reader.uint32();
|
158 | switch (tag >>> 3) {
|
159 | case 1:
|
160 | message.type = expressionTypes[reader.uint32()];
|
161 | break;
|
162 | case 2:
|
163 | message.value = reader.string();
|
164 | break;
|
165 | case 3:
|
166 | reader.skip().pos++;
|
167 | if (!message.props)
|
168 | message.props = {};
|
169 | let key = reader.string();
|
170 | reader.pos++;
|
171 | message.props[key] = decodeExpression(reader, reader.uint32());
|
172 | break;
|
173 | case 4:
|
174 | message.children.push(decodeExpression(reader, reader.uint32()));
|
175 | break;
|
176 | default:
|
177 | reader.skipType(tag & 7);
|
178 | break;
|
179 | }
|
180 | }
|
181 | return message;
|
182 | }
|
183 |
|
184 | function decodeInvocation(reader, length) {
|
185 | if (!(reader instanceof $Reader))
|
186 | reader = $Reader.create(reader);
|
187 | let end = length === undefined ? reader.len : reader.pos + length, message = {
|
188 | params: [],
|
189 | onExit: [],
|
190 | };
|
191 | while (reader.pos < end) {
|
192 | let tag = reader.uint32();
|
193 | switch (tag >>> 3) {
|
194 | case 1:
|
195 | message.type = decodeExpression(reader, reader.uint32());
|
196 | break;
|
197 | case 2:
|
198 | message.src = decodeExpression(reader, reader.uint32());
|
199 | break;
|
200 | case 3:
|
201 | message.id = decodeExpression(reader, reader.uint32());
|
202 | break;
|
203 | case 4:
|
204 | message.params.push(decodeExpression(reader, reader.uint32()));
|
205 | break;
|
206 | case 5:
|
207 | message.content = decodeExpression(reader, reader.uint32());
|
208 | break;
|
209 | case 6:
|
210 | message.onExit.push(decodeExpression(reader, reader.uint32()));
|
211 | break;
|
212 | case 7:
|
213 | message.autoforward = reader.bool();
|
214 | break;
|
215 | default:
|
216 | reader.skipType(tag & 7);
|
217 | break;
|
218 | }
|
219 | }
|
220 | return message;
|
221 | }
|
222 |
|
223 | function decodeData(reader, length) {
|
224 | if (!(reader instanceof $Reader))
|
225 | reader = $Reader.create(reader);
|
226 | let end = length === undefined ? reader.len : reader.pos + length, message = {};
|
227 | while (reader.pos < end) {
|
228 | let tag = reader.uint32();
|
229 | switch (tag >>> 3) {
|
230 | case 1:
|
231 | message.id = reader.string();
|
232 | break;
|
233 | case 2:
|
234 | message.value = decodeExpression(reader, reader.uint32());
|
235 | break;
|
236 | case 3:
|
237 | message.src = reader.string();
|
238 | break;
|
239 | default:
|
240 | reader.skipType(tag & 7);
|
241 | break;
|
242 | }
|
243 | }
|
244 | return message;
|
245 | }
|