1 /*
2 This file is part of GNU APL, a free implementation of the
3 ISO/IEC Standard 13751, "Programming Language APL, Extended"
4
5 Copyright (C) 2008-2014 Dr. Jürgen Sauermann
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21
22 /********
23
24 Usage:
25
26 m4 -D Svar_signals=def_file < tcp_signal.m4 > $@
27
28 This reads a Svar_signals specification from file def_file.def and prints
29 a header file on stdout that defines (the serialization of) signals according
30 to def_file.def.
31
32 In a Makefile, you would use it, for example, like this:
33
34 my_signal.hh: tcp_signal.m4 my_signal.def
35 m4 -D Svar_signals=tcp_signal $< > $@
36
37 to produce my_signal.hh from my_signal.def. After that, my_signal.hh
38 can be used to send the signals defined in tcp_signal.def from one process
39 to another process.
40
41 That is:
42
43 my_signal.def
44 |
45 |
46 | tcp_signal.m4
47 |
48 V
49 my_signal.hh
50 |
51 |
52 |
53 |
54 V
55 my_client_program.cc
56 my_server_program.cc
57 |
58 |
59 | compile
60 | & link
61 V
62 my_client_program
63 my_server_program
64
65
66 and then:
67
68 my_client_program --- signals defined in ---> my_server_program
69 my_server_program --- in my_signal.def ---> my_client_program
70
71 ********/
72
73 #include <assert.h>
74 #include <errno.h>
75 #include <stdint.h>
76 #include <string.h>
77 #include <sys/select.h>
78 #include <sys/socket.h>
79 #include <sys/types.h>
80 #include <netinet/in.h>
81
82 #include <string>
83 #include <iostream>
84 #include <iomanip>
85
86 using namespace std;
87
88 //-----------------------------------------------------------------------------
89 /// an integer signal item of size \b bytes
90 template<typename T, int bytes>
91 class Sig_item_int
92 {
93 public:
94 /// construct an item with value \b v
Sig_item_int(T v)95 Sig_item_int(T v) : value(v & get_mask()) {}
96
97 /// construct (deserialize) this item from a (received) buffer
Sig_item_int(const uint8_t * & buffer)98 Sig_item_int(const uint8_t * & buffer)
99 {
100 value = 0;
101 for (int b = 0; b < bytes; ++b)
102 value = value << 8 | *buffer++;
103
104 if (bytes == 6 && (value & 0x000080000000000ULL))
105 value |= 0xFFFF000000000000ULL;
106 }
107
108 /// return the value of the item
get_value() const109 T get_value() const { return value; }
110
111 /// store (aka. serialize) this item into a string
store(string & buffer) const112 void store(string & buffer) const
113 {
114 for (int b = bytes; b > 0;) buffer += char(value >> (8*--b));
115 }
116
117 /// print the item
print(ostream & out) const118 ostream & print(ostream & out) const
119 {
120 return out << value;
121 }
122
123 /// return the mask of the item, e.g. 0x00FFFFFF for a 3-byte integer
get_mask()124 static uint64_t get_mask()
125 { uint64_t mask = 0;
126 for (int b = 0; b < bytes; ++b) mask = mask << 8 | 0x00FF;
127 return mask;
128 }
129
130 /// the value of the item
131 T value;
132 };
133 //-----------------------------------------------------------------------------
134 /// a hexadecimal integer signal item of size \b bytes
135 template<typename T, int bytes>
136 class Sig_item_xint : public Sig_item_int<T, bytes>
137 {
138 public:
139 /// construct an item with value \b v
Sig_item_xint(T v)140 Sig_item_xint(T v) : Sig_item_int<T, bytes>(v) {}
141
142 /// construct (deserialize) this item from a (received) buffer
Sig_item_xint(const uint8_t * & buffer)143 Sig_item_xint(const uint8_t * & buffer) : Sig_item_int<T, bytes>(buffer) {}
144
145 /// print the item
print(ostream & out) const146 ostream & print(ostream & out) const
147 {
148 return out << "0x" << hex << setfill('0') << setw(bytes)
149 << Sig_item_int<T, bytes>::value
150 << setfill(' ') << dec;
151 }
152 };
153 //-----------------------------------------------------------------------------
154 typedef Sig_item_int < int16_t, 1> Sig_item_i8; ///< 8-bit signed integer
155 typedef Sig_item_int <uint16_t, 1> Sig_item_u8; ///< 8-bit unsigned integer
156 typedef Sig_item_xint<uint16_t, 1> Sig_item_x8; ///< 8-bit hex integer
157 typedef Sig_item_int < int16_t, 2> Sig_item_i16; ///< 16-bit signed integer
158 typedef Sig_item_int <uint16_t, 2> Sig_item_u16; ///< 16-bit unsigned integer
159 typedef Sig_item_xint<uint16_t, 2> Sig_item_x16; ///< 16-bit hex integer
160 typedef Sig_item_int < int32_t, 3> Sig_item_i24; ///< 24-bit signed integer
161 typedef Sig_item_int <uint32_t, 3> Sig_item_u24; ///< 24-bit unsigned integer
162 typedef Sig_item_xint<uint32_t, 3> Sig_item_x24; ///< 24-bit hex integer
163 typedef Sig_item_int < int32_t, 4> Sig_item_i32; ///< 32-bit signed integer
164 typedef Sig_item_int <uint32_t, 4> Sig_item_u32; ///< 32-bit unsigned integer
165 typedef Sig_item_xint<uint32_t, 4> Sig_item_x32; ///< 32-bit hex integer
166 typedef Sig_item_int < int64_t, 6> Sig_item_i48; ///< 48-bit signed integer
167 typedef Sig_item_int <uint64_t, 6> Sig_item_u48; ///< 48-bit unsigned integer
168 typedef Sig_item_xint<uint64_t, 6> Sig_item_x48; ///< 48-bit hex integer
169 typedef Sig_item_int < int64_t, 8> Sig_item_i64; ///< 64-bit signed integer
170 typedef Sig_item_int <uint64_t, 8> Sig_item_u64; ///< 64-bit unsigned integer
171 typedef Sig_item_xint<uint64_t, 8> Sig_item_x64; ///< 64-bit hex integer
172
173 /// a string signal item of size \b bytes
174 class Sig_item_string
175 {
176 public:
177 /// construct an item with value \b v
Sig_item_string(const string & str)178 Sig_item_string(const string & str)
179 : value(str)
180 {}
181
182 /// construct (deserialize) this item from a (received) buffer
Sig_item_string(const uint8_t * & buffer)183 Sig_item_string(const uint8_t * & buffer)
184 {
185 Sig_item_u16 len (buffer);
186 value.reserve(len.get_value() + 2);
187 for (int b = 0; b < len.get_value(); ++b) value += *buffer++;
188 }
189
190 /// return the value of the item
get_value() const191 const string get_value() const { return value; }
192
193 /// store (aka. serialize) this item into a buffer
store(string & buffer) const194 void store(string & buffer) const
195 {
196 const Sig_item_u16 len (value.size());
197 len.store(buffer);
198 for (size_t b = 0; b < value.size(); ++b) buffer += value[b];
199 }
200
201 /// print the item
print(ostream & out) const202 ostream & print(ostream & out) const
203 {
204 bool printable = true;
205 for (size_t b = 0; b < value.size(); ++b)
206 {
207 const int v = value[b] & 0xFF;
208 if (v < ' ' || v > '~') { printable = false; break; }
209 }
210
211 if (printable) return out << "\"" << value << "\"";
212
213 out << hex << setfill('0');
214 for (size_t b = 0; b < value.size(); ++b)
215 {
216 if (b > 16) { out << "..."; break; }
217 out << " " << setw(2) << (value[b] & 0xFF);
218 }
219 return out << dec << setfill(' ');
220 }
221
222 protected:
223 /// the value of the item
224 string value;
225 };
226 //-----------------------------------------------------------------------------
227 //----------------------------------------------------------------------------
228 /// a number identifying the signal
229 enum Signal_id
230 {
231 /*
232 */
233
234
235 /// APserver request: ⎕SVO
236 sid_MAKE_OFFER,
237 /// APserver request: ⎕SVR
238 sid_RETRACT_OFFER,
239 /// APserver request: ⎕SVR
240 sid_RETRACT_VAR,
241
242 /// APserver request: set state of shared var \b key
243 sid_SET_STATE,
244
245 /// APserver request: set control of shared var \b key
246 sid_SET_CONTROL,
247
248 /// APserver request: X←SVAR
249 sid_GET_VALUE,
250
251 /// APserver result for: X←SVAR
252 sid_VALUE_IS,
253
254 /// APserver request: SVAR←X
255 sid_ASSIGN_VALUE,
256 /// APserver result for: SVAR←X
257 sid_SVAR_ASSIGNED,
258
259 /// APserver request: Can svar key be referenced ?
260 sid_MAY_USE,
261
262 /// APserver request: Can svar key be assigned ?
263 sid_MAY_SET,
264
265 /// APserver request: read SVAR database record from APserver
266 ///
267 /// apl/APnnn --> READ_SVAR_RECORD APserver
268 /// <-- SVAR_RECORD_IS
269 ///
270 sid_READ_SVAR_RECORD,
271 /// APserver result (record) for: read SVAR database record from APserver
272 sid_SVAR_RECORD_IS,
273
274 /// APserver request: is ID registered ?
275 sid_IS_REGISTERED_ID,
276
277 /// APserver result: yes (1) or no (0)
278 sid_YES_NO,
279
280 /// APserver request: register processor proc in APserver
281 sid_REGISTER_PROCESSOR,
282
283 /// APserver request: match offered shared variable or make a new offer
284 sid_MATCH_OR_MAKE,
285
286 /// APserver result for: match or make
287 sid_MATCH_OR_MAKE_RESULT,
288
289
290 /// APserver request: find processor ID that offers \b key
291 sid_FIND_OFFERING_ID,
292
293 /// APserver result for: find processor ID that offers \b key
294 sid_OFFERING_ID_IS,
295
296 /// APserver request: get offering processors (⎕SVQ)
297 sid_GET_OFFERING_PROCS,
298
299 /// APserver result for: get offering processors (⎕SVQ)
300 sid_OFFERING_PROCS_ARE,
301
302 /// APserver request: get offered variables (⎕SVQ)
303 sid_GET_OFFERED_VARS,
304
305 /// APserver result for: get offered variables (⎕SVQ)
306 sid_OFFERED_VARS_ARE,
307
308 /// APserver request: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
309 sid_FIND_PAIRING_KEY,
310
311 /// APserver result for: find pairing key
312 sid_PAIRING_KEY_IS,
313
314 /// APserver result for: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
315 /// get events for one processor (first shared var with an event)
316 sid_GET_EVENTS,
317
318 /// APserver request: clear all events for one processor
319 sid_CLEAR_ALL_EVENTS,
320
321
322 /// APserver result for: clear all events for one processor (first cleared svar
323 sid_EVENTS_ARE,
324
325 /// APserver request: add an event for \b key
326 sid_ADD_EVENT,
327
328 /// APserver request: ws-ws SVAR←X
329 sid_ASSIGN_WSWS_VAR,
330 /// APserver request: X←ws-ws SVAR
331 sid_READ_WSWS_VAR,
332 /// APserver result for: X←ws-ws SVAR
333 sid_WSWS_VALUE_IS,
334
335 /// APserver request: print the entire database (for command ]SVARS)
336 sid_PRINT_SVAR_DB,
337 /// APserver result for: print the entire database
338 sid_SVAR_DB_PRINTED,
339
340 sid_MAX,
341 };
342 //----------------------------------------------------------------------------
343 /// the base class for all signal classes
344 class Signal_base
345 {
346 public:
347 /// destructor
~Signal_base()348 virtual ~Signal_base() {}
349
350 /// store (encode) the signal into buffer
351 virtual void store(string & buffer) const = 0;
352
353 /// print the signal
354 virtual ostream & print(ostream & out) const = 0;
355
356 /// return the ID of the signal
357 virtual Signal_id get_sigID() const = 0;
358
359 /// return the name of the ID of the signal
360 virtual const char * get_sigName() const = 0;
361
362 /// get function for an item that is not defined for the signal
bad_get(const char * signal,const char * member) const363 void bad_get(const char * signal, const char * member) const
364 {
365 cerr << endl << "*** called function get_" << signal << "__" << member
366 << "() with wrong signal " << get_sigName() << endl;
367 assert(0 && "bad_get()");
368 }
369
370 /*
371 */
372
373
374 /// APserver request: ⎕SVO
375 /// access functions for signal MAKE_OFFER...
get__MAKE_OFFER__key() const376 virtual uint64_t get__MAKE_OFFER__key() const ///< dito
377 { bad_get("MAKE_OFFER", "key"); return 0; }
378
379 /// APserver request: ⎕SVR
380 /// access functions for signal RETRACT_OFFER...
get__RETRACT_OFFER__key() const381 virtual uint64_t get__RETRACT_OFFER__key() const ///< dito
382 { bad_get("RETRACT_OFFER", "key"); return 0; }
383
384 /// APserver request: ⎕SVR
385 /// access functions for signal RETRACT_VAR...
get__RETRACT_VAR__key() const386 virtual uint64_t get__RETRACT_VAR__key() const ///< dito
387 { bad_get("RETRACT_VAR", "key"); return 0; }
388
389
390 /// APserver request: set state of shared var \b key
391 /// access functions for signal SET_STATE...
get__SET_STATE__key() const392 virtual uint64_t get__SET_STATE__key() const ///< dito
393 { bad_get("SET_STATE", "key"); return 0; }
get__SET_STATE__new_state() const394 virtual uint8_t get__SET_STATE__new_state() const ///< dito
395 { bad_get("SET_STATE", "new_state"); return 0; }
get__SET_STATE__sloc() const396 virtual string get__SET_STATE__sloc() const ///< dito
397 { bad_get("SET_STATE", "sloc"); return 0; }
398
399
400 /// APserver request: set control of shared var \b key
401 /// access functions for signal SET_CONTROL...
get__SET_CONTROL__key() const402 virtual uint64_t get__SET_CONTROL__key() const ///< dito
403 { bad_get("SET_CONTROL", "key"); return 0; }
get__SET_CONTROL__new_control() const404 virtual uint8_t get__SET_CONTROL__new_control() const ///< dito
405 { bad_get("SET_CONTROL", "new_control"); return 0; }
406
407
408 /// APserver request: X←SVAR
409 /// access functions for signal GET_VALUE...
get__GET_VALUE__key() const410 virtual uint64_t get__GET_VALUE__key() const ///< dito
411 { bad_get("GET_VALUE", "key"); return 0; }
412
413
414 /// APserver result for: X←SVAR
415 /// access functions for signal VALUE_IS...
get__VALUE_IS__key() const416 virtual uint64_t get__VALUE_IS__key() const ///< dito
417 { bad_get("VALUE_IS", "key"); return 0; }
get__VALUE_IS__error() const418 virtual uint32_t get__VALUE_IS__error() const ///< dito
419 { bad_get("VALUE_IS", "error"); return 0; }
get__VALUE_IS__error_loc() const420 virtual string get__VALUE_IS__error_loc() const ///< dito
421 { bad_get("VALUE_IS", "error_loc"); return 0; }
get__VALUE_IS__cdr_value() const422 virtual string get__VALUE_IS__cdr_value() const ///< dito
423 { bad_get("VALUE_IS", "cdr_value"); return 0; }
424
425
426 /// APserver request: SVAR←X
427 /// access functions for signal ASSIGN_VALUE...
get__ASSIGN_VALUE__key() const428 virtual uint64_t get__ASSIGN_VALUE__key() const ///< dito
429 { bad_get("ASSIGN_VALUE", "key"); return 0; }
get__ASSIGN_VALUE__cdr_value() const430 virtual string get__ASSIGN_VALUE__cdr_value() const ///< dito
431 { bad_get("ASSIGN_VALUE", "cdr_value"); return 0; }
432
433 /// APserver result for: SVAR←X
434 /// access functions for signal SVAR_ASSIGNED...
get__SVAR_ASSIGNED__key() const435 virtual uint64_t get__SVAR_ASSIGNED__key() const ///< dito
436 { bad_get("SVAR_ASSIGNED", "key"); return 0; }
get__SVAR_ASSIGNED__error() const437 virtual uint32_t get__SVAR_ASSIGNED__error() const ///< dito
438 { bad_get("SVAR_ASSIGNED", "error"); return 0; }
get__SVAR_ASSIGNED__error_loc() const439 virtual string get__SVAR_ASSIGNED__error_loc() const ///< dito
440 { bad_get("SVAR_ASSIGNED", "error_loc"); return 0; }
441
442
443 /// APserver request: Can svar key be referenced ?
444 /// access functions for signal MAY_USE...
get__MAY_USE__key() const445 virtual uint64_t get__MAY_USE__key() const ///< dito
446 { bad_get("MAY_USE", "key"); return 0; }
get__MAY_USE__attempt() const447 virtual int32_t get__MAY_USE__attempt() const ///< dito
448 { bad_get("MAY_USE", "attempt"); return 0; }
449
450
451 /// APserver request: Can svar key be assigned ?
452 /// access functions for signal MAY_SET...
get__MAY_SET__key() const453 virtual uint64_t get__MAY_SET__key() const ///< dito
454 { bad_get("MAY_SET", "key"); return 0; }
get__MAY_SET__attempt() const455 virtual int32_t get__MAY_SET__attempt() const ///< dito
456 { bad_get("MAY_SET", "attempt"); return 0; }
457
458
459 /// APserver request: read SVAR database record from APserver
460 ///
461 /// apl/APnnn --> READ_SVAR_RECORD APserver
462 /// <-- SVAR_RECORD_IS
463 ///
464 /// access functions for signal READ_SVAR_RECORD...
get__READ_SVAR_RECORD__key() const465 virtual uint64_t get__READ_SVAR_RECORD__key() const ///< dito
466 { bad_get("READ_SVAR_RECORD", "key"); return 0; }
467
468 /// APserver result (record) for: read SVAR database record from APserver
469 /// access functions for signal SVAR_RECORD_IS...
get__SVAR_RECORD_IS__record() const470 virtual string get__SVAR_RECORD_IS__record() const ///< dito
471 { bad_get("SVAR_RECORD_IS", "record"); return 0; }
472
473
474 /// APserver request: is ID registered ?
475 /// access functions for signal IS_REGISTERED_ID...
get__IS_REGISTERED_ID__proc() const476 virtual uint32_t get__IS_REGISTERED_ID__proc() const ///< dito
477 { bad_get("IS_REGISTERED_ID", "proc"); return 0; }
get__IS_REGISTERED_ID__parent() const478 virtual uint32_t get__IS_REGISTERED_ID__parent() const ///< dito
479 { bad_get("IS_REGISTERED_ID", "parent"); return 0; }
get__IS_REGISTERED_ID__grand() const480 virtual uint32_t get__IS_REGISTERED_ID__grand() const ///< dito
481 { bad_get("IS_REGISTERED_ID", "grand"); return 0; }
482
483
484 /// APserver result: yes (1) or no (0)
485 /// access functions for signal YES_NO...
get__YES_NO__yes() const486 virtual uint8_t get__YES_NO__yes() const ///< dito
487 { bad_get("YES_NO", "yes"); return 0; }
488
489
490 /// APserver request: register processor proc in APserver
491 /// access functions for signal REGISTER_PROCESSOR...
get__REGISTER_PROCESSOR__proc() const492 virtual uint32_t get__REGISTER_PROCESSOR__proc() const ///< dito
493 { bad_get("REGISTER_PROCESSOR", "proc"); return 0; }
get__REGISTER_PROCESSOR__parent() const494 virtual uint32_t get__REGISTER_PROCESSOR__parent() const ///< dito
495 { bad_get("REGISTER_PROCESSOR", "parent"); return 0; }
get__REGISTER_PROCESSOR__grand() const496 virtual uint32_t get__REGISTER_PROCESSOR__grand() const ///< dito
497 { bad_get("REGISTER_PROCESSOR", "grand"); return 0; }
get__REGISTER_PROCESSOR__evconn() const498 virtual uint8_t get__REGISTER_PROCESSOR__evconn() const ///< dito
499 { bad_get("REGISTER_PROCESSOR", "evconn"); return 0; }
get__REGISTER_PROCESSOR__progname() const500 virtual string get__REGISTER_PROCESSOR__progname() const ///< dito
501 { bad_get("REGISTER_PROCESSOR", "progname"); return 0; }
502
503
504 /// APserver request: match offered shared variable or make a new offer
505 /// access functions for signal MATCH_OR_MAKE...
get__MATCH_OR_MAKE__varname() const506 virtual string get__MATCH_OR_MAKE__varname() const ///< dito
507 { bad_get("MATCH_OR_MAKE", "varname"); return 0; }
get__MATCH_OR_MAKE__to_proc() const508 virtual uint32_t get__MATCH_OR_MAKE__to_proc() const ///< dito
509 { bad_get("MATCH_OR_MAKE", "to_proc"); return 0; }
get__MATCH_OR_MAKE__to_parent() const510 virtual uint32_t get__MATCH_OR_MAKE__to_parent() const ///< dito
511 { bad_get("MATCH_OR_MAKE", "to_parent"); return 0; }
get__MATCH_OR_MAKE__to_grand() const512 virtual uint32_t get__MATCH_OR_MAKE__to_grand() const ///< dito
513 { bad_get("MATCH_OR_MAKE", "to_grand"); return 0; }
get__MATCH_OR_MAKE__from_proc() const514 virtual uint32_t get__MATCH_OR_MAKE__from_proc() const ///< dito
515 { bad_get("MATCH_OR_MAKE", "from_proc"); return 0; }
get__MATCH_OR_MAKE__from_parent() const516 virtual uint32_t get__MATCH_OR_MAKE__from_parent() const ///< dito
517 { bad_get("MATCH_OR_MAKE", "from_parent"); return 0; }
get__MATCH_OR_MAKE__from_grand() const518 virtual uint32_t get__MATCH_OR_MAKE__from_grand() const ///< dito
519 { bad_get("MATCH_OR_MAKE", "from_grand"); return 0; }
520
521
522 /// APserver result for: match or make
523 /// access functions for signal MATCH_OR_MAKE_RESULT...
get__MATCH_OR_MAKE_RESULT__key() const524 virtual uint64_t get__MATCH_OR_MAKE_RESULT__key() const ///< dito
525 { bad_get("MATCH_OR_MAKE_RESULT", "key"); return 0; }
526
527
528
529 /// APserver request: find processor ID that offers \b key
530 /// access functions for signal FIND_OFFERING_ID...
get__FIND_OFFERING_ID__key() const531 virtual uint64_t get__FIND_OFFERING_ID__key() const ///< dito
532 { bad_get("FIND_OFFERING_ID", "key"); return 0; }
533
534
535 /// APserver result for: find processor ID that offers \b key
536 /// access functions for signal OFFERING_ID_IS...
get__OFFERING_ID_IS__proc() const537 virtual uint32_t get__OFFERING_ID_IS__proc() const ///< dito
538 { bad_get("OFFERING_ID_IS", "proc"); return 0; }
get__OFFERING_ID_IS__parent() const539 virtual uint32_t get__OFFERING_ID_IS__parent() const ///< dito
540 { bad_get("OFFERING_ID_IS", "parent"); return 0; }
get__OFFERING_ID_IS__grand() const541 virtual uint32_t get__OFFERING_ID_IS__grand() const ///< dito
542 { bad_get("OFFERING_ID_IS", "grand"); return 0; }
543
544
545 /// APserver request: get offering processors (⎕SVQ)
546 /// access functions for signal GET_OFFERING_PROCS...
get__GET_OFFERING_PROCS__offered_to_proc() const547 virtual uint32_t get__GET_OFFERING_PROCS__offered_to_proc() const ///< dito
548 { bad_get("GET_OFFERING_PROCS", "offered_to_proc"); return 0; }
549
550
551 /// APserver result for: get offering processors (⎕SVQ)
552 /// access functions for signal OFFERING_PROCS_ARE...
get__OFFERING_PROCS_ARE__offering_procs() const553 virtual string get__OFFERING_PROCS_ARE__offering_procs() const ///< dito
554 { bad_get("OFFERING_PROCS_ARE", "offering_procs"); return 0; }
555
556
557 /// APserver request: get offered variables (⎕SVQ)
558 /// access functions for signal GET_OFFERED_VARS...
get__GET_OFFERED_VARS__offered_to_proc() const559 virtual uint32_t get__GET_OFFERED_VARS__offered_to_proc() const ///< dito
560 { bad_get("GET_OFFERED_VARS", "offered_to_proc"); return 0; }
get__GET_OFFERED_VARS__accepted_by_proc() const561 virtual uint32_t get__GET_OFFERED_VARS__accepted_by_proc() const ///< dito
562 { bad_get("GET_OFFERED_VARS", "accepted_by_proc"); return 0; }
563
564
565 /// APserver result for: get offered variables (⎕SVQ)
566 /// access functions for signal OFFERED_VARS_ARE...
get__OFFERED_VARS_ARE__offered_vars() const567 virtual string get__OFFERED_VARS_ARE__offered_vars() const ///< dito
568 { bad_get("OFFERED_VARS_ARE", "offered_vars"); return 0; }
569
570
571 /// APserver request: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
572 /// access functions for signal FIND_PAIRING_KEY...
get__FIND_PAIRING_KEY__key() const573 virtual uint64_t get__FIND_PAIRING_KEY__key() const ///< dito
574 { bad_get("FIND_PAIRING_KEY", "key"); return 0; }
575
576
577 /// APserver result for: find pairing key
578 /// access functions for signal PAIRING_KEY_IS...
get__PAIRING_KEY_IS__pairing_key() const579 virtual uint64_t get__PAIRING_KEY_IS__pairing_key() const ///< dito
580 { bad_get("PAIRING_KEY_IS", "pairing_key"); return 0; }
581
582
583 /// APserver result for: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
584 /// get events for one processor (first shared var with an event)
585 /// access functions for signal GET_EVENTS...
get__GET_EVENTS__proc() const586 virtual uint32_t get__GET_EVENTS__proc() const ///< dito
587 { bad_get("GET_EVENTS", "proc"); return 0; }
get__GET_EVENTS__parent() const588 virtual uint32_t get__GET_EVENTS__parent() const ///< dito
589 { bad_get("GET_EVENTS", "parent"); return 0; }
get__GET_EVENTS__grand() const590 virtual uint32_t get__GET_EVENTS__grand() const ///< dito
591 { bad_get("GET_EVENTS", "grand"); return 0; }
592
593
594 /// APserver request: clear all events for one processor
595 /// access functions for signal CLEAR_ALL_EVENTS...
get__CLEAR_ALL_EVENTS__proc() const596 virtual uint32_t get__CLEAR_ALL_EVENTS__proc() const ///< dito
597 { bad_get("CLEAR_ALL_EVENTS", "proc"); return 0; }
get__CLEAR_ALL_EVENTS__parent() const598 virtual uint32_t get__CLEAR_ALL_EVENTS__parent() const ///< dito
599 { bad_get("CLEAR_ALL_EVENTS", "parent"); return 0; }
get__CLEAR_ALL_EVENTS__grand() const600 virtual uint32_t get__CLEAR_ALL_EVENTS__grand() const ///< dito
601 { bad_get("CLEAR_ALL_EVENTS", "grand"); return 0; }
602
603
604
605 /// APserver result for: clear all events for one processor (first cleared svar
606 /// access functions for signal EVENTS_ARE...
get__EVENTS_ARE__key() const607 virtual uint64_t get__EVENTS_ARE__key() const ///< dito
608 { bad_get("EVENTS_ARE", "key"); return 0; }
get__EVENTS_ARE__events() const609 virtual uint32_t get__EVENTS_ARE__events() const ///< dito
610 { bad_get("EVENTS_ARE", "events"); return 0; }
611
612
613 /// APserver request: add an event for \b key
614 /// access functions for signal ADD_EVENT...
get__ADD_EVENT__key() const615 virtual uint64_t get__ADD_EVENT__key() const ///< dito
616 { bad_get("ADD_EVENT", "key"); return 0; }
get__ADD_EVENT__proc() const617 virtual uint32_t get__ADD_EVENT__proc() const ///< dito
618 { bad_get("ADD_EVENT", "proc"); return 0; }
get__ADD_EVENT__parent() const619 virtual uint32_t get__ADD_EVENT__parent() const ///< dito
620 { bad_get("ADD_EVENT", "parent"); return 0; }
get__ADD_EVENT__grand() const621 virtual uint32_t get__ADD_EVENT__grand() const ///< dito
622 { bad_get("ADD_EVENT", "grand"); return 0; }
get__ADD_EVENT__event() const623 virtual uint32_t get__ADD_EVENT__event() const ///< dito
624 { bad_get("ADD_EVENT", "event"); return 0; }
625
626
627 /// APserver request: ws-ws SVAR←X
628 /// access functions for signal ASSIGN_WSWS_VAR...
get__ASSIGN_WSWS_VAR__key() const629 virtual uint64_t get__ASSIGN_WSWS_VAR__key() const ///< dito
630 { bad_get("ASSIGN_WSWS_VAR", "key"); return 0; }
get__ASSIGN_WSWS_VAR__cdr_value() const631 virtual string get__ASSIGN_WSWS_VAR__cdr_value() const ///< dito
632 { bad_get("ASSIGN_WSWS_VAR", "cdr_value"); return 0; }
633
634 /// APserver request: X←ws-ws SVAR
635 /// access functions for signal READ_WSWS_VAR...
get__READ_WSWS_VAR__key() const636 virtual uint64_t get__READ_WSWS_VAR__key() const ///< dito
637 { bad_get("READ_WSWS_VAR", "key"); return 0; }
638
639 /// APserver result for: X←ws-ws SVAR
640 /// access functions for signal WSWS_VALUE_IS...
get__WSWS_VALUE_IS__cdr_value() const641 virtual string get__WSWS_VALUE_IS__cdr_value() const ///< dito
642 { bad_get("WSWS_VALUE_IS", "cdr_value"); return 0; }
643
644
645 /// APserver request: print the entire database (for command ]SVARS)
646 /// access functions for signal PRINT_SVAR_DB...
647
648 /// APserver result for: print the entire database
649 /// access functions for signal SVAR_DB_PRINTED...
get__SVAR_DB_PRINTED__printout() const650 virtual string get__SVAR_DB_PRINTED__printout() const ///< dito
651 { bad_get("SVAR_DB_PRINTED", "printout"); return 0; }
652
653
654
655 /// receive a signal (TCP)
656 inline static Signal_base * recv_TCP(int tcp_sock, char * buffer,
657 int bufsize, char * & del,
658 ostream * debug);
659
660 protected:
661
662 /// send this signal on TCP (or AF_UNIX) socket tcp_sock
send_TCP(int tcp_sock) const663 int send_TCP(int tcp_sock) const
664 {
665 string buffer;
666 store(buffer);
667
668 uint32_t ll = htonl(buffer.size());
669 send(tcp_sock, &ll, 4, 0);
670 ssize_t sent = send(tcp_sock, buffer.data(), buffer.size(), 0);
671 return sent;
672 }
673 };
674
675 /*
676 */
677
678
679 /// APserver request: ⎕SVO
680 //----------------------------------------------------------------------------
681 /// The class for signal MAKE_OFFER
682 class MAKE_OFFER_c : public Signal_base
683 {
684 public:
685
686 /// contructor that creates the signal and sends it on TCP socket s
MAKE_OFFER_c(int s,Sig_item_x64 _key)687 MAKE_OFFER_c(int s,
688 Sig_item_x64 _key)
689 : key(_key)
690 { send_TCP(s); }
691
692 /// construct (deserialize) this item from a (received) buffer
693 /// id has already been load()ed.
MAKE_OFFER_c(const uint8_t * & buffer)694 MAKE_OFFER_c(const uint8_t * & buffer)
695 : key(buffer)
696 {}
697
698 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const699 virtual void store(string & buffer) const
700 {
701 const Sig_item_u16 signal_id(sid_MAKE_OFFER);
702 signal_id.store(buffer);
703 key.store(buffer);
704 }
705
706 /// print this signal on out.
print(ostream & out) const707 virtual ostream & print(ostream & out) const
708 {
709 out << "MAKE_OFFER(";
710 key.print(out);
711 return out << ")" << endl;
712 }
713
714 /// a unique number for this signal
get_sigID() const715 virtual Signal_id get_sigID() const { return sid_MAKE_OFFER; }
716
717 /// the name of this signal
get_sigName() const718 virtual const char * get_sigName() const { return "MAKE_OFFER"; }
719
720 /// return item key of this signal
get__MAKE_OFFER__key() const721 virtual uint64_t get__MAKE_OFFER__key() const { return key.get_value(); }
722
723
724 protected:
725 Sig_item_x64 key; ///< key
726 };
727 /// APserver request: ⎕SVR
728 //----------------------------------------------------------------------------
729 /// The class for signal RETRACT_OFFER
730 class RETRACT_OFFER_c : public Signal_base
731 {
732 public:
733
734 /// contructor that creates the signal and sends it on TCP socket s
RETRACT_OFFER_c(int s,Sig_item_x64 _key)735 RETRACT_OFFER_c(int s,
736 Sig_item_x64 _key)
737 : key(_key)
738 { send_TCP(s); }
739
740 /// construct (deserialize) this item from a (received) buffer
741 /// id has already been load()ed.
RETRACT_OFFER_c(const uint8_t * & buffer)742 RETRACT_OFFER_c(const uint8_t * & buffer)
743 : key(buffer)
744 {}
745
746 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const747 virtual void store(string & buffer) const
748 {
749 const Sig_item_u16 signal_id(sid_RETRACT_OFFER);
750 signal_id.store(buffer);
751 key.store(buffer);
752 }
753
754 /// print this signal on out.
print(ostream & out) const755 virtual ostream & print(ostream & out) const
756 {
757 out << "RETRACT_OFFER(";
758 key.print(out);
759 return out << ")" << endl;
760 }
761
762 /// a unique number for this signal
get_sigID() const763 virtual Signal_id get_sigID() const { return sid_RETRACT_OFFER; }
764
765 /// the name of this signal
get_sigName() const766 virtual const char * get_sigName() const { return "RETRACT_OFFER"; }
767
768 /// return item key of this signal
get__RETRACT_OFFER__key() const769 virtual uint64_t get__RETRACT_OFFER__key() const { return key.get_value(); }
770
771
772 protected:
773 Sig_item_x64 key; ///< key
774 };
775 /// APserver request: ⎕SVR
776 //----------------------------------------------------------------------------
777 /// The class for signal RETRACT_VAR
778 class RETRACT_VAR_c : public Signal_base
779 {
780 public:
781
782 /// contructor that creates the signal and sends it on TCP socket s
RETRACT_VAR_c(int s,Sig_item_x64 _key)783 RETRACT_VAR_c(int s,
784 Sig_item_x64 _key)
785 : key(_key)
786 { send_TCP(s); }
787
788 /// construct (deserialize) this item from a (received) buffer
789 /// id has already been load()ed.
RETRACT_VAR_c(const uint8_t * & buffer)790 RETRACT_VAR_c(const uint8_t * & buffer)
791 : key(buffer)
792 {}
793
794 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const795 virtual void store(string & buffer) const
796 {
797 const Sig_item_u16 signal_id(sid_RETRACT_VAR);
798 signal_id.store(buffer);
799 key.store(buffer);
800 }
801
802 /// print this signal on out.
print(ostream & out) const803 virtual ostream & print(ostream & out) const
804 {
805 out << "RETRACT_VAR(";
806 key.print(out);
807 return out << ")" << endl;
808 }
809
810 /// a unique number for this signal
get_sigID() const811 virtual Signal_id get_sigID() const { return sid_RETRACT_VAR; }
812
813 /// the name of this signal
get_sigName() const814 virtual const char * get_sigName() const { return "RETRACT_VAR"; }
815
816 /// return item key of this signal
get__RETRACT_VAR__key() const817 virtual uint64_t get__RETRACT_VAR__key() const { return key.get_value(); }
818
819
820 protected:
821 Sig_item_x64 key; ///< key
822 };
823
824 /// APserver request: set state of shared var \b key
825 //----------------------------------------------------------------------------
826 /// The class for signal SET_STATE
827 class SET_STATE_c : public Signal_base
828 {
829 public:
830
831 /// contructor that creates the signal and sends it on TCP socket s
SET_STATE_c(int s,Sig_item_x64 _key,Sig_item_u8 _new_state,Sig_item_string _sloc)832 SET_STATE_c(int s,
833 Sig_item_x64 _key,
834 Sig_item_u8 _new_state,
835 Sig_item_string _sloc)
836 : key(_key),
837 new_state(_new_state),
838 sloc(_sloc)
839 { send_TCP(s); }
840
841 /// construct (deserialize) this item from a (received) buffer
842 /// id has already been load()ed.
SET_STATE_c(const uint8_t * & buffer)843 SET_STATE_c(const uint8_t * & buffer)
844 : key(buffer),
845 new_state(buffer),
846 sloc(buffer)
847 {}
848
849 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const850 virtual void store(string & buffer) const
851 {
852 const Sig_item_u16 signal_id(sid_SET_STATE);
853 signal_id.store(buffer);
854 key.store(buffer);
855 new_state.store(buffer);
856 sloc.store(buffer);
857 }
858
859 /// print this signal on out.
print(ostream & out) const860 virtual ostream & print(ostream & out) const
861 {
862 out << "SET_STATE(";
863 key.print(out); out << ", ";
864 new_state.print(out); out << ", ";
865 sloc.print(out);
866 return out << ")" << endl;
867 }
868
869 /// a unique number for this signal
get_sigID() const870 virtual Signal_id get_sigID() const { return sid_SET_STATE; }
871
872 /// the name of this signal
get_sigName() const873 virtual const char * get_sigName() const { return "SET_STATE"; }
874
875 /// return item key of this signal
get__SET_STATE__key() const876 virtual uint64_t get__SET_STATE__key() const { return key.get_value(); }
877
878 /// return item new_state of this signal
get__SET_STATE__new_state() const879 virtual uint8_t get__SET_STATE__new_state() const { return new_state.get_value(); }
880
881 /// return item sloc of this signal
get__SET_STATE__sloc() const882 virtual string get__SET_STATE__sloc() const { return sloc.get_value(); }
883
884
885 protected:
886 Sig_item_x64 key; ///< key
887 Sig_item_u8 new_state; ///< new_state
888 Sig_item_string sloc; ///< sloc
889 };
890
891 /// APserver request: set control of shared var \b key
892 //----------------------------------------------------------------------------
893 /// The class for signal SET_CONTROL
894 class SET_CONTROL_c : public Signal_base
895 {
896 public:
897
898 /// contructor that creates the signal and sends it on TCP socket s
SET_CONTROL_c(int s,Sig_item_x64 _key,Sig_item_u8 _new_control)899 SET_CONTROL_c(int s,
900 Sig_item_x64 _key,
901 Sig_item_u8 _new_control)
902 : key(_key),
903 new_control(_new_control)
904 { send_TCP(s); }
905
906 /// construct (deserialize) this item from a (received) buffer
907 /// id has already been load()ed.
SET_CONTROL_c(const uint8_t * & buffer)908 SET_CONTROL_c(const uint8_t * & buffer)
909 : key(buffer),
910 new_control(buffer)
911 {}
912
913 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const914 virtual void store(string & buffer) const
915 {
916 const Sig_item_u16 signal_id(sid_SET_CONTROL);
917 signal_id.store(buffer);
918 key.store(buffer);
919 new_control.store(buffer);
920 }
921
922 /// print this signal on out.
print(ostream & out) const923 virtual ostream & print(ostream & out) const
924 {
925 out << "SET_CONTROL(";
926 key.print(out); out << ", ";
927 new_control.print(out);
928 return out << ")" << endl;
929 }
930
931 /// a unique number for this signal
get_sigID() const932 virtual Signal_id get_sigID() const { return sid_SET_CONTROL; }
933
934 /// the name of this signal
get_sigName() const935 virtual const char * get_sigName() const { return "SET_CONTROL"; }
936
937 /// return item key of this signal
get__SET_CONTROL__key() const938 virtual uint64_t get__SET_CONTROL__key() const { return key.get_value(); }
939
940 /// return item new_control of this signal
get__SET_CONTROL__new_control() const941 virtual uint8_t get__SET_CONTROL__new_control() const { return new_control.get_value(); }
942
943
944 protected:
945 Sig_item_x64 key; ///< key
946 Sig_item_u8 new_control; ///< new_control
947 };
948
949 /// APserver request: X←SVAR
950 //----------------------------------------------------------------------------
951 /// The class for signal GET_VALUE
952 class GET_VALUE_c : public Signal_base
953 {
954 public:
955
956 /// contructor that creates the signal and sends it on TCP socket s
GET_VALUE_c(int s,Sig_item_x64 _key)957 GET_VALUE_c(int s,
958 Sig_item_x64 _key)
959 : key(_key)
960 { send_TCP(s); }
961
962 /// construct (deserialize) this item from a (received) buffer
963 /// id has already been load()ed.
GET_VALUE_c(const uint8_t * & buffer)964 GET_VALUE_c(const uint8_t * & buffer)
965 : key(buffer)
966 {}
967
968 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const969 virtual void store(string & buffer) const
970 {
971 const Sig_item_u16 signal_id(sid_GET_VALUE);
972 signal_id.store(buffer);
973 key.store(buffer);
974 }
975
976 /// print this signal on out.
print(ostream & out) const977 virtual ostream & print(ostream & out) const
978 {
979 out << "GET_VALUE(";
980 key.print(out);
981 return out << ")" << endl;
982 }
983
984 /// a unique number for this signal
get_sigID() const985 virtual Signal_id get_sigID() const { return sid_GET_VALUE; }
986
987 /// the name of this signal
get_sigName() const988 virtual const char * get_sigName() const { return "GET_VALUE"; }
989
990 /// return item key of this signal
get__GET_VALUE__key() const991 virtual uint64_t get__GET_VALUE__key() const { return key.get_value(); }
992
993
994 protected:
995 Sig_item_x64 key; ///< key
996 };
997
998 /// APserver result for: X←SVAR
999 //----------------------------------------------------------------------------
1000 /// The class for signal VALUE_IS
1001 class VALUE_IS_c : public Signal_base
1002 {
1003 public:
1004
1005 /// contructor that creates the signal and sends it on TCP socket s
VALUE_IS_c(int s,Sig_item_x64 _key,Sig_item_u32 _error,Sig_item_string _error_loc,Sig_item_string _cdr_value)1006 VALUE_IS_c(int s,
1007 Sig_item_x64 _key,
1008 Sig_item_u32 _error,
1009 Sig_item_string _error_loc,
1010 Sig_item_string _cdr_value)
1011 : key(_key),
1012 error(_error),
1013 error_loc(_error_loc),
1014 cdr_value(_cdr_value)
1015 { send_TCP(s); }
1016
1017 /// construct (deserialize) this item from a (received) buffer
1018 /// id has already been load()ed.
VALUE_IS_c(const uint8_t * & buffer)1019 VALUE_IS_c(const uint8_t * & buffer)
1020 : key(buffer),
1021 error(buffer),
1022 error_loc(buffer),
1023 cdr_value(buffer)
1024 {}
1025
1026 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1027 virtual void store(string & buffer) const
1028 {
1029 const Sig_item_u16 signal_id(sid_VALUE_IS);
1030 signal_id.store(buffer);
1031 key.store(buffer);
1032 error.store(buffer);
1033 error_loc.store(buffer);
1034 cdr_value.store(buffer);
1035 }
1036
1037 /// print this signal on out.
print(ostream & out) const1038 virtual ostream & print(ostream & out) const
1039 {
1040 out << "VALUE_IS(";
1041 key.print(out); out << ", ";
1042 error.print(out); out << ", ";
1043 error_loc.print(out); out << ", ";
1044 cdr_value.print(out);
1045 return out << ")" << endl;
1046 }
1047
1048 /// a unique number for this signal
get_sigID() const1049 virtual Signal_id get_sigID() const { return sid_VALUE_IS; }
1050
1051 /// the name of this signal
get_sigName() const1052 virtual const char * get_sigName() const { return "VALUE_IS"; }
1053
1054 /// return item key of this signal
get__VALUE_IS__key() const1055 virtual uint64_t get__VALUE_IS__key() const { return key.get_value(); }
1056
1057 /// return item error of this signal
get__VALUE_IS__error() const1058 virtual uint32_t get__VALUE_IS__error() const { return error.get_value(); }
1059
1060 /// return item error_loc of this signal
get__VALUE_IS__error_loc() const1061 virtual string get__VALUE_IS__error_loc() const { return error_loc.get_value(); }
1062
1063 /// return item cdr_value of this signal
get__VALUE_IS__cdr_value() const1064 virtual string get__VALUE_IS__cdr_value() const { return cdr_value.get_value(); }
1065
1066
1067 protected:
1068 Sig_item_x64 key; ///< key
1069 Sig_item_u32 error; ///< error
1070 Sig_item_string error_loc; ///< error_loc
1071 Sig_item_string cdr_value; ///< cdr_value
1072 };
1073
1074 /// APserver request: SVAR←X
1075 //----------------------------------------------------------------------------
1076 /// The class for signal ASSIGN_VALUE
1077 class ASSIGN_VALUE_c : public Signal_base
1078 {
1079 public:
1080
1081 /// contructor that creates the signal and sends it on TCP socket s
ASSIGN_VALUE_c(int s,Sig_item_x64 _key,Sig_item_string _cdr_value)1082 ASSIGN_VALUE_c(int s,
1083 Sig_item_x64 _key,
1084 Sig_item_string _cdr_value)
1085 : key(_key),
1086 cdr_value(_cdr_value)
1087 { send_TCP(s); }
1088
1089 /// construct (deserialize) this item from a (received) buffer
1090 /// id has already been load()ed.
ASSIGN_VALUE_c(const uint8_t * & buffer)1091 ASSIGN_VALUE_c(const uint8_t * & buffer)
1092 : key(buffer),
1093 cdr_value(buffer)
1094 {}
1095
1096 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1097 virtual void store(string & buffer) const
1098 {
1099 const Sig_item_u16 signal_id(sid_ASSIGN_VALUE);
1100 signal_id.store(buffer);
1101 key.store(buffer);
1102 cdr_value.store(buffer);
1103 }
1104
1105 /// print this signal on out.
print(ostream & out) const1106 virtual ostream & print(ostream & out) const
1107 {
1108 out << "ASSIGN_VALUE(";
1109 key.print(out); out << ", ";
1110 cdr_value.print(out);
1111 return out << ")" << endl;
1112 }
1113
1114 /// a unique number for this signal
get_sigID() const1115 virtual Signal_id get_sigID() const { return sid_ASSIGN_VALUE; }
1116
1117 /// the name of this signal
get_sigName() const1118 virtual const char * get_sigName() const { return "ASSIGN_VALUE"; }
1119
1120 /// return item key of this signal
get__ASSIGN_VALUE__key() const1121 virtual uint64_t get__ASSIGN_VALUE__key() const { return key.get_value(); }
1122
1123 /// return item cdr_value of this signal
get__ASSIGN_VALUE__cdr_value() const1124 virtual string get__ASSIGN_VALUE__cdr_value() const { return cdr_value.get_value(); }
1125
1126
1127 protected:
1128 Sig_item_x64 key; ///< key
1129 Sig_item_string cdr_value; ///< cdr_value
1130 };
1131 /// APserver result for: SVAR←X
1132 //----------------------------------------------------------------------------
1133 /// The class for signal SVAR_ASSIGNED
1134 class SVAR_ASSIGNED_c : public Signal_base
1135 {
1136 public:
1137
1138 /// contructor that creates the signal and sends it on TCP socket s
SVAR_ASSIGNED_c(int s,Sig_item_x64 _key,Sig_item_u32 _error,Sig_item_string _error_loc)1139 SVAR_ASSIGNED_c(int s,
1140 Sig_item_x64 _key,
1141 Sig_item_u32 _error,
1142 Sig_item_string _error_loc)
1143 : key(_key),
1144 error(_error),
1145 error_loc(_error_loc)
1146 { send_TCP(s); }
1147
1148 /// construct (deserialize) this item from a (received) buffer
1149 /// id has already been load()ed.
SVAR_ASSIGNED_c(const uint8_t * & buffer)1150 SVAR_ASSIGNED_c(const uint8_t * & buffer)
1151 : key(buffer),
1152 error(buffer),
1153 error_loc(buffer)
1154 {}
1155
1156 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1157 virtual void store(string & buffer) const
1158 {
1159 const Sig_item_u16 signal_id(sid_SVAR_ASSIGNED);
1160 signal_id.store(buffer);
1161 key.store(buffer);
1162 error.store(buffer);
1163 error_loc.store(buffer);
1164 }
1165
1166 /// print this signal on out.
print(ostream & out) const1167 virtual ostream & print(ostream & out) const
1168 {
1169 out << "SVAR_ASSIGNED(";
1170 key.print(out); out << ", ";
1171 error.print(out); out << ", ";
1172 error_loc.print(out);
1173 return out << ")" << endl;
1174 }
1175
1176 /// a unique number for this signal
get_sigID() const1177 virtual Signal_id get_sigID() const { return sid_SVAR_ASSIGNED; }
1178
1179 /// the name of this signal
get_sigName() const1180 virtual const char * get_sigName() const { return "SVAR_ASSIGNED"; }
1181
1182 /// return item key of this signal
get__SVAR_ASSIGNED__key() const1183 virtual uint64_t get__SVAR_ASSIGNED__key() const { return key.get_value(); }
1184
1185 /// return item error of this signal
get__SVAR_ASSIGNED__error() const1186 virtual uint32_t get__SVAR_ASSIGNED__error() const { return error.get_value(); }
1187
1188 /// return item error_loc of this signal
get__SVAR_ASSIGNED__error_loc() const1189 virtual string get__SVAR_ASSIGNED__error_loc() const { return error_loc.get_value(); }
1190
1191
1192 protected:
1193 Sig_item_x64 key; ///< key
1194 Sig_item_u32 error; ///< error
1195 Sig_item_string error_loc; ///< error_loc
1196 };
1197
1198 /// APserver request: Can svar key be referenced ?
1199 //----------------------------------------------------------------------------
1200 /// The class for signal MAY_USE
1201 class MAY_USE_c : public Signal_base
1202 {
1203 public:
1204
1205 /// contructor that creates the signal and sends it on TCP socket s
MAY_USE_c(int s,Sig_item_x64 _key,Sig_item_i32 _attempt)1206 MAY_USE_c(int s,
1207 Sig_item_x64 _key,
1208 Sig_item_i32 _attempt)
1209 : key(_key),
1210 attempt(_attempt)
1211 { send_TCP(s); }
1212
1213 /// construct (deserialize) this item from a (received) buffer
1214 /// id has already been load()ed.
MAY_USE_c(const uint8_t * & buffer)1215 MAY_USE_c(const uint8_t * & buffer)
1216 : key(buffer),
1217 attempt(buffer)
1218 {}
1219
1220 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1221 virtual void store(string & buffer) const
1222 {
1223 const Sig_item_u16 signal_id(sid_MAY_USE);
1224 signal_id.store(buffer);
1225 key.store(buffer);
1226 attempt.store(buffer);
1227 }
1228
1229 /// print this signal on out.
print(ostream & out) const1230 virtual ostream & print(ostream & out) const
1231 {
1232 out << "MAY_USE(";
1233 key.print(out); out << ", ";
1234 attempt.print(out);
1235 return out << ")" << endl;
1236 }
1237
1238 /// a unique number for this signal
get_sigID() const1239 virtual Signal_id get_sigID() const { return sid_MAY_USE; }
1240
1241 /// the name of this signal
get_sigName() const1242 virtual const char * get_sigName() const { return "MAY_USE"; }
1243
1244 /// return item key of this signal
get__MAY_USE__key() const1245 virtual uint64_t get__MAY_USE__key() const { return key.get_value(); }
1246
1247 /// return item attempt of this signal
get__MAY_USE__attempt() const1248 virtual int32_t get__MAY_USE__attempt() const { return attempt.get_value(); }
1249
1250
1251 protected:
1252 Sig_item_x64 key; ///< key
1253 Sig_item_i32 attempt; ///< attempt
1254 };
1255
1256 /// APserver request: Can svar key be assigned ?
1257 //----------------------------------------------------------------------------
1258 /// The class for signal MAY_SET
1259 class MAY_SET_c : public Signal_base
1260 {
1261 public:
1262
1263 /// contructor that creates the signal and sends it on TCP socket s
MAY_SET_c(int s,Sig_item_x64 _key,Sig_item_i32 _attempt)1264 MAY_SET_c(int s,
1265 Sig_item_x64 _key,
1266 Sig_item_i32 _attempt)
1267 : key(_key),
1268 attempt(_attempt)
1269 { send_TCP(s); }
1270
1271 /// construct (deserialize) this item from a (received) buffer
1272 /// id has already been load()ed.
MAY_SET_c(const uint8_t * & buffer)1273 MAY_SET_c(const uint8_t * & buffer)
1274 : key(buffer),
1275 attempt(buffer)
1276 {}
1277
1278 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1279 virtual void store(string & buffer) const
1280 {
1281 const Sig_item_u16 signal_id(sid_MAY_SET);
1282 signal_id.store(buffer);
1283 key.store(buffer);
1284 attempt.store(buffer);
1285 }
1286
1287 /// print this signal on out.
print(ostream & out) const1288 virtual ostream & print(ostream & out) const
1289 {
1290 out << "MAY_SET(";
1291 key.print(out); out << ", ";
1292 attempt.print(out);
1293 return out << ")" << endl;
1294 }
1295
1296 /// a unique number for this signal
get_sigID() const1297 virtual Signal_id get_sigID() const { return sid_MAY_SET; }
1298
1299 /// the name of this signal
get_sigName() const1300 virtual const char * get_sigName() const { return "MAY_SET"; }
1301
1302 /// return item key of this signal
get__MAY_SET__key() const1303 virtual uint64_t get__MAY_SET__key() const { return key.get_value(); }
1304
1305 /// return item attempt of this signal
get__MAY_SET__attempt() const1306 virtual int32_t get__MAY_SET__attempt() const { return attempt.get_value(); }
1307
1308
1309 protected:
1310 Sig_item_x64 key; ///< key
1311 Sig_item_i32 attempt; ///< attempt
1312 };
1313
1314 /// APserver request: read SVAR database record from APserver
1315 ///
1316 /// apl/APnnn --> READ_SVAR_RECORD APserver
1317 /// <-- SVAR_RECORD_IS
1318 ///
1319 //----------------------------------------------------------------------------
1320 /// The class for signal READ_SVAR_RECORD
1321 class READ_SVAR_RECORD_c : public Signal_base
1322 {
1323 public:
1324
1325 /// contructor that creates the signal and sends it on TCP socket s
READ_SVAR_RECORD_c(int s,Sig_item_x64 _key)1326 READ_SVAR_RECORD_c(int s,
1327 Sig_item_x64 _key)
1328 : key(_key)
1329 { send_TCP(s); }
1330
1331 /// construct (deserialize) this item from a (received) buffer
1332 /// id has already been load()ed.
READ_SVAR_RECORD_c(const uint8_t * & buffer)1333 READ_SVAR_RECORD_c(const uint8_t * & buffer)
1334 : key(buffer)
1335 {}
1336
1337 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1338 virtual void store(string & buffer) const
1339 {
1340 const Sig_item_u16 signal_id(sid_READ_SVAR_RECORD);
1341 signal_id.store(buffer);
1342 key.store(buffer);
1343 }
1344
1345 /// print this signal on out.
print(ostream & out) const1346 virtual ostream & print(ostream & out) const
1347 {
1348 out << "READ_SVAR_RECORD(";
1349 key.print(out);
1350 return out << ")" << endl;
1351 }
1352
1353 /// a unique number for this signal
get_sigID() const1354 virtual Signal_id get_sigID() const { return sid_READ_SVAR_RECORD; }
1355
1356 /// the name of this signal
get_sigName() const1357 virtual const char * get_sigName() const { return "READ_SVAR_RECORD"; }
1358
1359 /// return item key of this signal
get__READ_SVAR_RECORD__key() const1360 virtual uint64_t get__READ_SVAR_RECORD__key() const { return key.get_value(); }
1361
1362
1363 protected:
1364 Sig_item_x64 key; ///< key
1365 };
1366 /// APserver result (record) for: read SVAR database record from APserver
1367 //----------------------------------------------------------------------------
1368 /// The class for signal SVAR_RECORD_IS
1369 class SVAR_RECORD_IS_c : public Signal_base
1370 {
1371 public:
1372
1373 /// contructor that creates the signal and sends it on TCP socket s
SVAR_RECORD_IS_c(int s,Sig_item_string _record)1374 SVAR_RECORD_IS_c(int s,
1375 Sig_item_string _record)
1376 : record(_record)
1377 { send_TCP(s); }
1378
1379 /// construct (deserialize) this item from a (received) buffer
1380 /// id has already been load()ed.
SVAR_RECORD_IS_c(const uint8_t * & buffer)1381 SVAR_RECORD_IS_c(const uint8_t * & buffer)
1382 : record(buffer)
1383 {}
1384
1385 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1386 virtual void store(string & buffer) const
1387 {
1388 const Sig_item_u16 signal_id(sid_SVAR_RECORD_IS);
1389 signal_id.store(buffer);
1390 record.store(buffer);
1391 }
1392
1393 /// print this signal on out.
print(ostream & out) const1394 virtual ostream & print(ostream & out) const
1395 {
1396 out << "SVAR_RECORD_IS(";
1397 record.print(out);
1398 return out << ")" << endl;
1399 }
1400
1401 /// a unique number for this signal
get_sigID() const1402 virtual Signal_id get_sigID() const { return sid_SVAR_RECORD_IS; }
1403
1404 /// the name of this signal
get_sigName() const1405 virtual const char * get_sigName() const { return "SVAR_RECORD_IS"; }
1406
1407 /// return item record of this signal
get__SVAR_RECORD_IS__record() const1408 virtual string get__SVAR_RECORD_IS__record() const { return record.get_value(); }
1409
1410
1411 protected:
1412 Sig_item_string record; ///< record
1413 };
1414
1415 /// APserver request: is ID registered ?
1416 //----------------------------------------------------------------------------
1417 /// The class for signal IS_REGISTERED_ID
1418 class IS_REGISTERED_ID_c : public Signal_base
1419 {
1420 public:
1421
1422 /// contructor that creates the signal and sends it on TCP socket s
IS_REGISTERED_ID_c(int s,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand)1423 IS_REGISTERED_ID_c(int s,
1424 Sig_item_u32 _proc,
1425 Sig_item_u32 _parent,
1426 Sig_item_u32 _grand)
1427 : proc(_proc),
1428 parent(_parent),
1429 grand(_grand)
1430 { send_TCP(s); }
1431
1432 /// construct (deserialize) this item from a (received) buffer
1433 /// id has already been load()ed.
IS_REGISTERED_ID_c(const uint8_t * & buffer)1434 IS_REGISTERED_ID_c(const uint8_t * & buffer)
1435 : proc(buffer),
1436 parent(buffer),
1437 grand(buffer)
1438 {}
1439
1440 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1441 virtual void store(string & buffer) const
1442 {
1443 const Sig_item_u16 signal_id(sid_IS_REGISTERED_ID);
1444 signal_id.store(buffer);
1445 proc.store(buffer);
1446 parent.store(buffer);
1447 grand.store(buffer);
1448 }
1449
1450 /// print this signal on out.
print(ostream & out) const1451 virtual ostream & print(ostream & out) const
1452 {
1453 out << "IS_REGISTERED_ID(";
1454 proc.print(out); out << ", ";
1455 parent.print(out); out << ", ";
1456 grand.print(out);
1457 return out << ")" << endl;
1458 }
1459
1460 /// a unique number for this signal
get_sigID() const1461 virtual Signal_id get_sigID() const { return sid_IS_REGISTERED_ID; }
1462
1463 /// the name of this signal
get_sigName() const1464 virtual const char * get_sigName() const { return "IS_REGISTERED_ID"; }
1465
1466 /// return item proc of this signal
get__IS_REGISTERED_ID__proc() const1467 virtual uint32_t get__IS_REGISTERED_ID__proc() const { return proc.get_value(); }
1468
1469 /// return item parent of this signal
get__IS_REGISTERED_ID__parent() const1470 virtual uint32_t get__IS_REGISTERED_ID__parent() const { return parent.get_value(); }
1471
1472 /// return item grand of this signal
get__IS_REGISTERED_ID__grand() const1473 virtual uint32_t get__IS_REGISTERED_ID__grand() const { return grand.get_value(); }
1474
1475
1476 protected:
1477 Sig_item_u32 proc; ///< proc
1478 Sig_item_u32 parent; ///< parent
1479 Sig_item_u32 grand; ///< grand
1480 };
1481
1482 /// APserver result: yes (1) or no (0)
1483 //----------------------------------------------------------------------------
1484 /// The class for signal YES_NO
1485 class YES_NO_c : public Signal_base
1486 {
1487 public:
1488
1489 /// contructor that creates the signal and sends it on TCP socket s
YES_NO_c(int s,Sig_item_u8 _yes)1490 YES_NO_c(int s,
1491 Sig_item_u8 _yes)
1492 : yes(_yes)
1493 { send_TCP(s); }
1494
1495 /// construct (deserialize) this item from a (received) buffer
1496 /// id has already been load()ed.
YES_NO_c(const uint8_t * & buffer)1497 YES_NO_c(const uint8_t * & buffer)
1498 : yes(buffer)
1499 {}
1500
1501 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1502 virtual void store(string & buffer) const
1503 {
1504 const Sig_item_u16 signal_id(sid_YES_NO);
1505 signal_id.store(buffer);
1506 yes.store(buffer);
1507 }
1508
1509 /// print this signal on out.
print(ostream & out) const1510 virtual ostream & print(ostream & out) const
1511 {
1512 out << "YES_NO(";
1513 yes.print(out);
1514 return out << ")" << endl;
1515 }
1516
1517 /// a unique number for this signal
get_sigID() const1518 virtual Signal_id get_sigID() const { return sid_YES_NO; }
1519
1520 /// the name of this signal
get_sigName() const1521 virtual const char * get_sigName() const { return "YES_NO"; }
1522
1523 /// return item yes of this signal
get__YES_NO__yes() const1524 virtual uint8_t get__YES_NO__yes() const { return yes.get_value(); }
1525
1526
1527 protected:
1528 Sig_item_u8 yes; ///< yes
1529 };
1530
1531 /// APserver request: register processor proc in APserver
1532 //----------------------------------------------------------------------------
1533 /// The class for signal REGISTER_PROCESSOR
1534 class REGISTER_PROCESSOR_c : public Signal_base
1535 {
1536 public:
1537
1538 /// contructor that creates the signal and sends it on TCP socket s
REGISTER_PROCESSOR_c(int s,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand,Sig_item_u8 _evconn,Sig_item_string _progname)1539 REGISTER_PROCESSOR_c(int s,
1540 Sig_item_u32 _proc,
1541 Sig_item_u32 _parent,
1542 Sig_item_u32 _grand,
1543 Sig_item_u8 _evconn,
1544 Sig_item_string _progname)
1545 : proc(_proc),
1546 parent(_parent),
1547 grand(_grand),
1548 evconn(_evconn),
1549 progname(_progname)
1550 { send_TCP(s); }
1551
1552 /// construct (deserialize) this item from a (received) buffer
1553 /// id has already been load()ed.
REGISTER_PROCESSOR_c(const uint8_t * & buffer)1554 REGISTER_PROCESSOR_c(const uint8_t * & buffer)
1555 : proc(buffer),
1556 parent(buffer),
1557 grand(buffer),
1558 evconn(buffer),
1559 progname(buffer)
1560 {}
1561
1562 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1563 virtual void store(string & buffer) const
1564 {
1565 const Sig_item_u16 signal_id(sid_REGISTER_PROCESSOR);
1566 signal_id.store(buffer);
1567 proc.store(buffer);
1568 parent.store(buffer);
1569 grand.store(buffer);
1570 evconn.store(buffer);
1571 progname.store(buffer);
1572 }
1573
1574 /// print this signal on out.
print(ostream & out) const1575 virtual ostream & print(ostream & out) const
1576 {
1577 out << "REGISTER_PROCESSOR(";
1578 proc.print(out); out << ", ";
1579 parent.print(out); out << ", ";
1580 grand.print(out); out << ", ";
1581 evconn.print(out); out << ", ";
1582 progname.print(out);
1583 return out << ")" << endl;
1584 }
1585
1586 /// a unique number for this signal
get_sigID() const1587 virtual Signal_id get_sigID() const { return sid_REGISTER_PROCESSOR; }
1588
1589 /// the name of this signal
get_sigName() const1590 virtual const char * get_sigName() const { return "REGISTER_PROCESSOR"; }
1591
1592 /// return item proc of this signal
get__REGISTER_PROCESSOR__proc() const1593 virtual uint32_t get__REGISTER_PROCESSOR__proc() const { return proc.get_value(); }
1594
1595 /// return item parent of this signal
get__REGISTER_PROCESSOR__parent() const1596 virtual uint32_t get__REGISTER_PROCESSOR__parent() const { return parent.get_value(); }
1597
1598 /// return item grand of this signal
get__REGISTER_PROCESSOR__grand() const1599 virtual uint32_t get__REGISTER_PROCESSOR__grand() const { return grand.get_value(); }
1600
1601 /// return item evconn of this signal
get__REGISTER_PROCESSOR__evconn() const1602 virtual uint8_t get__REGISTER_PROCESSOR__evconn() const { return evconn.get_value(); }
1603
1604 /// return item progname of this signal
get__REGISTER_PROCESSOR__progname() const1605 virtual string get__REGISTER_PROCESSOR__progname() const { return progname.get_value(); }
1606
1607
1608 protected:
1609 Sig_item_u32 proc; ///< proc
1610 Sig_item_u32 parent; ///< parent
1611 Sig_item_u32 grand; ///< grand
1612 Sig_item_u8 evconn; ///< evconn
1613 Sig_item_string progname; ///< progname
1614 };
1615
1616 /// APserver request: match offered shared variable or make a new offer
1617 //----------------------------------------------------------------------------
1618 /// The class for signal MATCH_OR_MAKE
1619 class MATCH_OR_MAKE_c : public Signal_base
1620 {
1621 public:
1622
1623 /// contructor that creates the signal and sends it on TCP socket s
MATCH_OR_MAKE_c(int s,Sig_item_string _varname,Sig_item_u32 _to_proc,Sig_item_u32 _to_parent,Sig_item_u32 _to_grand,Sig_item_u32 _from_proc,Sig_item_u32 _from_parent,Sig_item_u32 _from_grand)1624 MATCH_OR_MAKE_c(int s,
1625 Sig_item_string _varname,
1626 Sig_item_u32 _to_proc,
1627 Sig_item_u32 _to_parent,
1628 Sig_item_u32 _to_grand,
1629 Sig_item_u32 _from_proc,
1630 Sig_item_u32 _from_parent,
1631 Sig_item_u32 _from_grand)
1632 : varname(_varname),
1633 to_proc(_to_proc),
1634 to_parent(_to_parent),
1635 to_grand(_to_grand),
1636 from_proc(_from_proc),
1637 from_parent(_from_parent),
1638 from_grand(_from_grand)
1639 { send_TCP(s); }
1640
1641 /// construct (deserialize) this item from a (received) buffer
1642 /// id has already been load()ed.
MATCH_OR_MAKE_c(const uint8_t * & buffer)1643 MATCH_OR_MAKE_c(const uint8_t * & buffer)
1644 : varname(buffer),
1645 to_proc(buffer),
1646 to_parent(buffer),
1647 to_grand(buffer),
1648 from_proc(buffer),
1649 from_parent(buffer),
1650 from_grand(buffer)
1651 {}
1652
1653 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1654 virtual void store(string & buffer) const
1655 {
1656 const Sig_item_u16 signal_id(sid_MATCH_OR_MAKE);
1657 signal_id.store(buffer);
1658 varname.store(buffer);
1659 to_proc.store(buffer);
1660 to_parent.store(buffer);
1661 to_grand.store(buffer);
1662 from_proc.store(buffer);
1663 from_parent.store(buffer);
1664 from_grand.store(buffer);
1665 }
1666
1667 /// print this signal on out.
print(ostream & out) const1668 virtual ostream & print(ostream & out) const
1669 {
1670 out << "MATCH_OR_MAKE(";
1671 varname.print(out); out << ", ";
1672 to_proc.print(out); out << ", ";
1673 to_parent.print(out); out << ", ";
1674 to_grand.print(out); out << ", ";
1675 from_proc.print(out); out << ", ";
1676 from_parent.print(out); out << ", ";
1677 from_grand.print(out);
1678 return out << ")" << endl;
1679 }
1680
1681 /// a unique number for this signal
get_sigID() const1682 virtual Signal_id get_sigID() const { return sid_MATCH_OR_MAKE; }
1683
1684 /// the name of this signal
get_sigName() const1685 virtual const char * get_sigName() const { return "MATCH_OR_MAKE"; }
1686
1687 /// return item varname of this signal
get__MATCH_OR_MAKE__varname() const1688 virtual string get__MATCH_OR_MAKE__varname() const { return varname.get_value(); }
1689
1690 /// return item to_proc of this signal
get__MATCH_OR_MAKE__to_proc() const1691 virtual uint32_t get__MATCH_OR_MAKE__to_proc() const { return to_proc.get_value(); }
1692
1693 /// return item to_parent of this signal
get__MATCH_OR_MAKE__to_parent() const1694 virtual uint32_t get__MATCH_OR_MAKE__to_parent() const { return to_parent.get_value(); }
1695
1696 /// return item to_grand of this signal
get__MATCH_OR_MAKE__to_grand() const1697 virtual uint32_t get__MATCH_OR_MAKE__to_grand() const { return to_grand.get_value(); }
1698
1699 /// return item from_proc of this signal
get__MATCH_OR_MAKE__from_proc() const1700 virtual uint32_t get__MATCH_OR_MAKE__from_proc() const { return from_proc.get_value(); }
1701
1702 /// return item from_parent of this signal
get__MATCH_OR_MAKE__from_parent() const1703 virtual uint32_t get__MATCH_OR_MAKE__from_parent() const { return from_parent.get_value(); }
1704
1705 /// return item from_grand of this signal
get__MATCH_OR_MAKE__from_grand() const1706 virtual uint32_t get__MATCH_OR_MAKE__from_grand() const { return from_grand.get_value(); }
1707
1708
1709 protected:
1710 Sig_item_string varname; ///< varname
1711 Sig_item_u32 to_proc; ///< to_proc
1712 Sig_item_u32 to_parent; ///< to_parent
1713 Sig_item_u32 to_grand; ///< to_grand
1714 Sig_item_u32 from_proc; ///< from_proc
1715 Sig_item_u32 from_parent; ///< from_parent
1716 Sig_item_u32 from_grand; ///< from_grand
1717 };
1718
1719 /// APserver result for: match or make
1720 //----------------------------------------------------------------------------
1721 /// The class for signal MATCH_OR_MAKE_RESULT
1722 class MATCH_OR_MAKE_RESULT_c : public Signal_base
1723 {
1724 public:
1725
1726 /// contructor that creates the signal and sends it on TCP socket s
MATCH_OR_MAKE_RESULT_c(int s,Sig_item_x64 _key)1727 MATCH_OR_MAKE_RESULT_c(int s,
1728 Sig_item_x64 _key)
1729 : key(_key)
1730 { send_TCP(s); }
1731
1732 /// construct (deserialize) this item from a (received) buffer
1733 /// id has already been load()ed.
MATCH_OR_MAKE_RESULT_c(const uint8_t * & buffer)1734 MATCH_OR_MAKE_RESULT_c(const uint8_t * & buffer)
1735 : key(buffer)
1736 {}
1737
1738 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1739 virtual void store(string & buffer) const
1740 {
1741 const Sig_item_u16 signal_id(sid_MATCH_OR_MAKE_RESULT);
1742 signal_id.store(buffer);
1743 key.store(buffer);
1744 }
1745
1746 /// print this signal on out.
print(ostream & out) const1747 virtual ostream & print(ostream & out) const
1748 {
1749 out << "MATCH_OR_MAKE_RESULT(";
1750 key.print(out);
1751 return out << ")" << endl;
1752 }
1753
1754 /// a unique number for this signal
get_sigID() const1755 virtual Signal_id get_sigID() const { return sid_MATCH_OR_MAKE_RESULT; }
1756
1757 /// the name of this signal
get_sigName() const1758 virtual const char * get_sigName() const { return "MATCH_OR_MAKE_RESULT"; }
1759
1760 /// return item key of this signal
get__MATCH_OR_MAKE_RESULT__key() const1761 virtual uint64_t get__MATCH_OR_MAKE_RESULT__key() const { return key.get_value(); }
1762
1763
1764 protected:
1765 Sig_item_x64 key; ///< key
1766 };
1767
1768
1769 /// APserver request: find processor ID that offers \b key
1770 //----------------------------------------------------------------------------
1771 /// The class for signal FIND_OFFERING_ID
1772 class FIND_OFFERING_ID_c : public Signal_base
1773 {
1774 public:
1775
1776 /// contructor that creates the signal and sends it on TCP socket s
FIND_OFFERING_ID_c(int s,Sig_item_x64 _key)1777 FIND_OFFERING_ID_c(int s,
1778 Sig_item_x64 _key)
1779 : key(_key)
1780 { send_TCP(s); }
1781
1782 /// construct (deserialize) this item from a (received) buffer
1783 /// id has already been load()ed.
FIND_OFFERING_ID_c(const uint8_t * & buffer)1784 FIND_OFFERING_ID_c(const uint8_t * & buffer)
1785 : key(buffer)
1786 {}
1787
1788 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1789 virtual void store(string & buffer) const
1790 {
1791 const Sig_item_u16 signal_id(sid_FIND_OFFERING_ID);
1792 signal_id.store(buffer);
1793 key.store(buffer);
1794 }
1795
1796 /// print this signal on out.
print(ostream & out) const1797 virtual ostream & print(ostream & out) const
1798 {
1799 out << "FIND_OFFERING_ID(";
1800 key.print(out);
1801 return out << ")" << endl;
1802 }
1803
1804 /// a unique number for this signal
get_sigID() const1805 virtual Signal_id get_sigID() const { return sid_FIND_OFFERING_ID; }
1806
1807 /// the name of this signal
get_sigName() const1808 virtual const char * get_sigName() const { return "FIND_OFFERING_ID"; }
1809
1810 /// return item key of this signal
get__FIND_OFFERING_ID__key() const1811 virtual uint64_t get__FIND_OFFERING_ID__key() const { return key.get_value(); }
1812
1813
1814 protected:
1815 Sig_item_x64 key; ///< key
1816 };
1817
1818 /// APserver result for: find processor ID that offers \b key
1819 //----------------------------------------------------------------------------
1820 /// The class for signal OFFERING_ID_IS
1821 class OFFERING_ID_IS_c : public Signal_base
1822 {
1823 public:
1824
1825 /// contructor that creates the signal and sends it on TCP socket s
OFFERING_ID_IS_c(int s,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand)1826 OFFERING_ID_IS_c(int s,
1827 Sig_item_u32 _proc,
1828 Sig_item_u32 _parent,
1829 Sig_item_u32 _grand)
1830 : proc(_proc),
1831 parent(_parent),
1832 grand(_grand)
1833 { send_TCP(s); }
1834
1835 /// construct (deserialize) this item from a (received) buffer
1836 /// id has already been load()ed.
OFFERING_ID_IS_c(const uint8_t * & buffer)1837 OFFERING_ID_IS_c(const uint8_t * & buffer)
1838 : proc(buffer),
1839 parent(buffer),
1840 grand(buffer)
1841 {}
1842
1843 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1844 virtual void store(string & buffer) const
1845 {
1846 const Sig_item_u16 signal_id(sid_OFFERING_ID_IS);
1847 signal_id.store(buffer);
1848 proc.store(buffer);
1849 parent.store(buffer);
1850 grand.store(buffer);
1851 }
1852
1853 /// print this signal on out.
print(ostream & out) const1854 virtual ostream & print(ostream & out) const
1855 {
1856 out << "OFFERING_ID_IS(";
1857 proc.print(out); out << ", ";
1858 parent.print(out); out << ", ";
1859 grand.print(out);
1860 return out << ")" << endl;
1861 }
1862
1863 /// a unique number for this signal
get_sigID() const1864 virtual Signal_id get_sigID() const { return sid_OFFERING_ID_IS; }
1865
1866 /// the name of this signal
get_sigName() const1867 virtual const char * get_sigName() const { return "OFFERING_ID_IS"; }
1868
1869 /// return item proc of this signal
get__OFFERING_ID_IS__proc() const1870 virtual uint32_t get__OFFERING_ID_IS__proc() const { return proc.get_value(); }
1871
1872 /// return item parent of this signal
get__OFFERING_ID_IS__parent() const1873 virtual uint32_t get__OFFERING_ID_IS__parent() const { return parent.get_value(); }
1874
1875 /// return item grand of this signal
get__OFFERING_ID_IS__grand() const1876 virtual uint32_t get__OFFERING_ID_IS__grand() const { return grand.get_value(); }
1877
1878
1879 protected:
1880 Sig_item_u32 proc; ///< proc
1881 Sig_item_u32 parent; ///< parent
1882 Sig_item_u32 grand; ///< grand
1883 };
1884
1885 /// APserver request: get offering processors (⎕SVQ)
1886 //----------------------------------------------------------------------------
1887 /// The class for signal GET_OFFERING_PROCS
1888 class GET_OFFERING_PROCS_c : public Signal_base
1889 {
1890 public:
1891
1892 /// contructor that creates the signal and sends it on TCP socket s
GET_OFFERING_PROCS_c(int s,Sig_item_u32 _offered_to_proc)1893 GET_OFFERING_PROCS_c(int s,
1894 Sig_item_u32 _offered_to_proc)
1895 : offered_to_proc(_offered_to_proc)
1896 { send_TCP(s); }
1897
1898 /// construct (deserialize) this item from a (received) buffer
1899 /// id has already been load()ed.
GET_OFFERING_PROCS_c(const uint8_t * & buffer)1900 GET_OFFERING_PROCS_c(const uint8_t * & buffer)
1901 : offered_to_proc(buffer)
1902 {}
1903
1904 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1905 virtual void store(string & buffer) const
1906 {
1907 const Sig_item_u16 signal_id(sid_GET_OFFERING_PROCS);
1908 signal_id.store(buffer);
1909 offered_to_proc.store(buffer);
1910 }
1911
1912 /// print this signal on out.
print(ostream & out) const1913 virtual ostream & print(ostream & out) const
1914 {
1915 out << "GET_OFFERING_PROCS(";
1916 offered_to_proc.print(out);
1917 return out << ")" << endl;
1918 }
1919
1920 /// a unique number for this signal
get_sigID() const1921 virtual Signal_id get_sigID() const { return sid_GET_OFFERING_PROCS; }
1922
1923 /// the name of this signal
get_sigName() const1924 virtual const char * get_sigName() const { return "GET_OFFERING_PROCS"; }
1925
1926 /// return item offered_to_proc of this signal
get__GET_OFFERING_PROCS__offered_to_proc() const1927 virtual uint32_t get__GET_OFFERING_PROCS__offered_to_proc() const { return offered_to_proc.get_value(); }
1928
1929
1930 protected:
1931 Sig_item_u32 offered_to_proc; ///< offered_to_proc
1932 };
1933
1934 /// APserver result for: get offering processors (⎕SVQ)
1935 //----------------------------------------------------------------------------
1936 /// The class for signal OFFERING_PROCS_ARE
1937 class OFFERING_PROCS_ARE_c : public Signal_base
1938 {
1939 public:
1940
1941 /// contructor that creates the signal and sends it on TCP socket s
OFFERING_PROCS_ARE_c(int s,Sig_item_string _offering_procs)1942 OFFERING_PROCS_ARE_c(int s,
1943 Sig_item_string _offering_procs)
1944 : offering_procs(_offering_procs)
1945 { send_TCP(s); }
1946
1947 /// construct (deserialize) this item from a (received) buffer
1948 /// id has already been load()ed.
OFFERING_PROCS_ARE_c(const uint8_t * & buffer)1949 OFFERING_PROCS_ARE_c(const uint8_t * & buffer)
1950 : offering_procs(buffer)
1951 {}
1952
1953 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const1954 virtual void store(string & buffer) const
1955 {
1956 const Sig_item_u16 signal_id(sid_OFFERING_PROCS_ARE);
1957 signal_id.store(buffer);
1958 offering_procs.store(buffer);
1959 }
1960
1961 /// print this signal on out.
print(ostream & out) const1962 virtual ostream & print(ostream & out) const
1963 {
1964 out << "OFFERING_PROCS_ARE(";
1965 offering_procs.print(out);
1966 return out << ")" << endl;
1967 }
1968
1969 /// a unique number for this signal
get_sigID() const1970 virtual Signal_id get_sigID() const { return sid_OFFERING_PROCS_ARE; }
1971
1972 /// the name of this signal
get_sigName() const1973 virtual const char * get_sigName() const { return "OFFERING_PROCS_ARE"; }
1974
1975 /// return item offering_procs of this signal
get__OFFERING_PROCS_ARE__offering_procs() const1976 virtual string get__OFFERING_PROCS_ARE__offering_procs() const { return offering_procs.get_value(); }
1977
1978
1979 protected:
1980 Sig_item_string offering_procs; ///< offering_procs
1981 };
1982
1983 /// APserver request: get offered variables (⎕SVQ)
1984 //----------------------------------------------------------------------------
1985 /// The class for signal GET_OFFERED_VARS
1986 class GET_OFFERED_VARS_c : public Signal_base
1987 {
1988 public:
1989
1990 /// contructor that creates the signal and sends it on TCP socket s
GET_OFFERED_VARS_c(int s,Sig_item_u32 _offered_to_proc,Sig_item_u32 _accepted_by_proc)1991 GET_OFFERED_VARS_c(int s,
1992 Sig_item_u32 _offered_to_proc,
1993 Sig_item_u32 _accepted_by_proc)
1994 : offered_to_proc(_offered_to_proc),
1995 accepted_by_proc(_accepted_by_proc)
1996 { send_TCP(s); }
1997
1998 /// construct (deserialize) this item from a (received) buffer
1999 /// id has already been load()ed.
GET_OFFERED_VARS_c(const uint8_t * & buffer)2000 GET_OFFERED_VARS_c(const uint8_t * & buffer)
2001 : offered_to_proc(buffer),
2002 accepted_by_proc(buffer)
2003 {}
2004
2005 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2006 virtual void store(string & buffer) const
2007 {
2008 const Sig_item_u16 signal_id(sid_GET_OFFERED_VARS);
2009 signal_id.store(buffer);
2010 offered_to_proc.store(buffer);
2011 accepted_by_proc.store(buffer);
2012 }
2013
2014 /// print this signal on out.
print(ostream & out) const2015 virtual ostream & print(ostream & out) const
2016 {
2017 out << "GET_OFFERED_VARS(";
2018 offered_to_proc.print(out); out << ", ";
2019 accepted_by_proc.print(out);
2020 return out << ")" << endl;
2021 }
2022
2023 /// a unique number for this signal
get_sigID() const2024 virtual Signal_id get_sigID() const { return sid_GET_OFFERED_VARS; }
2025
2026 /// the name of this signal
get_sigName() const2027 virtual const char * get_sigName() const { return "GET_OFFERED_VARS"; }
2028
2029 /// return item offered_to_proc of this signal
get__GET_OFFERED_VARS__offered_to_proc() const2030 virtual uint32_t get__GET_OFFERED_VARS__offered_to_proc() const { return offered_to_proc.get_value(); }
2031
2032 /// return item accepted_by_proc of this signal
get__GET_OFFERED_VARS__accepted_by_proc() const2033 virtual uint32_t get__GET_OFFERED_VARS__accepted_by_proc() const { return accepted_by_proc.get_value(); }
2034
2035
2036 protected:
2037 Sig_item_u32 offered_to_proc; ///< offered_to_proc
2038 Sig_item_u32 accepted_by_proc; ///< accepted_by_proc
2039 };
2040
2041 /// APserver result for: get offered variables (⎕SVQ)
2042 //----------------------------------------------------------------------------
2043 /// The class for signal OFFERED_VARS_ARE
2044 class OFFERED_VARS_ARE_c : public Signal_base
2045 {
2046 public:
2047
2048 /// contructor that creates the signal and sends it on TCP socket s
OFFERED_VARS_ARE_c(int s,Sig_item_string _offered_vars)2049 OFFERED_VARS_ARE_c(int s,
2050 Sig_item_string _offered_vars)
2051 : offered_vars(_offered_vars)
2052 { send_TCP(s); }
2053
2054 /// construct (deserialize) this item from a (received) buffer
2055 /// id has already been load()ed.
OFFERED_VARS_ARE_c(const uint8_t * & buffer)2056 OFFERED_VARS_ARE_c(const uint8_t * & buffer)
2057 : offered_vars(buffer)
2058 {}
2059
2060 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2061 virtual void store(string & buffer) const
2062 {
2063 const Sig_item_u16 signal_id(sid_OFFERED_VARS_ARE);
2064 signal_id.store(buffer);
2065 offered_vars.store(buffer);
2066 }
2067
2068 /// print this signal on out.
print(ostream & out) const2069 virtual ostream & print(ostream & out) const
2070 {
2071 out << "OFFERED_VARS_ARE(";
2072 offered_vars.print(out);
2073 return out << ")" << endl;
2074 }
2075
2076 /// a unique number for this signal
get_sigID() const2077 virtual Signal_id get_sigID() const { return sid_OFFERED_VARS_ARE; }
2078
2079 /// the name of this signal
get_sigName() const2080 virtual const char * get_sigName() const { return "OFFERED_VARS_ARE"; }
2081
2082 /// return item offered_vars of this signal
get__OFFERED_VARS_ARE__offered_vars() const2083 virtual string get__OFFERED_VARS_ARE__offered_vars() const { return offered_vars.get_value(); }
2084
2085
2086 protected:
2087 Sig_item_string offered_vars; ///< offered_vars
2088 };
2089
2090 /// APserver request: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2091 //----------------------------------------------------------------------------
2092 /// The class for signal FIND_PAIRING_KEY
2093 class FIND_PAIRING_KEY_c : public Signal_base
2094 {
2095 public:
2096
2097 /// contructor that creates the signal and sends it on TCP socket s
FIND_PAIRING_KEY_c(int s,Sig_item_x64 _key)2098 FIND_PAIRING_KEY_c(int s,
2099 Sig_item_x64 _key)
2100 : key(_key)
2101 { send_TCP(s); }
2102
2103 /// construct (deserialize) this item from a (received) buffer
2104 /// id has already been load()ed.
FIND_PAIRING_KEY_c(const uint8_t * & buffer)2105 FIND_PAIRING_KEY_c(const uint8_t * & buffer)
2106 : key(buffer)
2107 {}
2108
2109 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2110 virtual void store(string & buffer) const
2111 {
2112 const Sig_item_u16 signal_id(sid_FIND_PAIRING_KEY);
2113 signal_id.store(buffer);
2114 key.store(buffer);
2115 }
2116
2117 /// print this signal on out.
print(ostream & out) const2118 virtual ostream & print(ostream & out) const
2119 {
2120 out << "FIND_PAIRING_KEY(";
2121 key.print(out);
2122 return out << ")" << endl;
2123 }
2124
2125 /// a unique number for this signal
get_sigID() const2126 virtual Signal_id get_sigID() const { return sid_FIND_PAIRING_KEY; }
2127
2128 /// the name of this signal
get_sigName() const2129 virtual const char * get_sigName() const { return "FIND_PAIRING_KEY"; }
2130
2131 /// return item key of this signal
get__FIND_PAIRING_KEY__key() const2132 virtual uint64_t get__FIND_PAIRING_KEY__key() const { return key.get_value(); }
2133
2134
2135 protected:
2136 Sig_item_x64 key; ///< key
2137 };
2138
2139 /// APserver result for: find pairing key
2140 //----------------------------------------------------------------------------
2141 /// The class for signal PAIRING_KEY_IS
2142 class PAIRING_KEY_IS_c : public Signal_base
2143 {
2144 public:
2145
2146 /// contructor that creates the signal and sends it on TCP socket s
PAIRING_KEY_IS_c(int s,Sig_item_x64 _pairing_key)2147 PAIRING_KEY_IS_c(int s,
2148 Sig_item_x64 _pairing_key)
2149 : pairing_key(_pairing_key)
2150 { send_TCP(s); }
2151
2152 /// construct (deserialize) this item from a (received) buffer
2153 /// id has already been load()ed.
PAIRING_KEY_IS_c(const uint8_t * & buffer)2154 PAIRING_KEY_IS_c(const uint8_t * & buffer)
2155 : pairing_key(buffer)
2156 {}
2157
2158 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2159 virtual void store(string & buffer) const
2160 {
2161 const Sig_item_u16 signal_id(sid_PAIRING_KEY_IS);
2162 signal_id.store(buffer);
2163 pairing_key.store(buffer);
2164 }
2165
2166 /// print this signal on out.
print(ostream & out) const2167 virtual ostream & print(ostream & out) const
2168 {
2169 out << "PAIRING_KEY_IS(";
2170 pairing_key.print(out);
2171 return out << ")" << endl;
2172 }
2173
2174 /// a unique number for this signal
get_sigID() const2175 virtual Signal_id get_sigID() const { return sid_PAIRING_KEY_IS; }
2176
2177 /// the name of this signal
get_sigName() const2178 virtual const char * get_sigName() const { return "PAIRING_KEY_IS"; }
2179
2180 /// return item pairing_key of this signal
get__PAIRING_KEY_IS__pairing_key() const2181 virtual uint64_t get__PAIRING_KEY_IS__pairing_key() const { return pairing_key.get_value(); }
2182
2183
2184 protected:
2185 Sig_item_x64 pairing_key; ///< pairing_key
2186 };
2187
2188 /// APserver result for: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2189 /// get events for one processor (first shared var with an event)
2190 //----------------------------------------------------------------------------
2191 /// The class for signal GET_EVENTS
2192 class GET_EVENTS_c : public Signal_base
2193 {
2194 public:
2195
2196 /// contructor that creates the signal and sends it on TCP socket s
GET_EVENTS_c(int s,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand)2197 GET_EVENTS_c(int s,
2198 Sig_item_u32 _proc,
2199 Sig_item_u32 _parent,
2200 Sig_item_u32 _grand)
2201 : proc(_proc),
2202 parent(_parent),
2203 grand(_grand)
2204 { send_TCP(s); }
2205
2206 /// construct (deserialize) this item from a (received) buffer
2207 /// id has already been load()ed.
GET_EVENTS_c(const uint8_t * & buffer)2208 GET_EVENTS_c(const uint8_t * & buffer)
2209 : proc(buffer),
2210 parent(buffer),
2211 grand(buffer)
2212 {}
2213
2214 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2215 virtual void store(string & buffer) const
2216 {
2217 const Sig_item_u16 signal_id(sid_GET_EVENTS);
2218 signal_id.store(buffer);
2219 proc.store(buffer);
2220 parent.store(buffer);
2221 grand.store(buffer);
2222 }
2223
2224 /// print this signal on out.
print(ostream & out) const2225 virtual ostream & print(ostream & out) const
2226 {
2227 out << "GET_EVENTS(";
2228 proc.print(out); out << ", ";
2229 parent.print(out); out << ", ";
2230 grand.print(out);
2231 return out << ")" << endl;
2232 }
2233
2234 /// a unique number for this signal
get_sigID() const2235 virtual Signal_id get_sigID() const { return sid_GET_EVENTS; }
2236
2237 /// the name of this signal
get_sigName() const2238 virtual const char * get_sigName() const { return "GET_EVENTS"; }
2239
2240 /// return item proc of this signal
get__GET_EVENTS__proc() const2241 virtual uint32_t get__GET_EVENTS__proc() const { return proc.get_value(); }
2242
2243 /// return item parent of this signal
get__GET_EVENTS__parent() const2244 virtual uint32_t get__GET_EVENTS__parent() const { return parent.get_value(); }
2245
2246 /// return item grand of this signal
get__GET_EVENTS__grand() const2247 virtual uint32_t get__GET_EVENTS__grand() const { return grand.get_value(); }
2248
2249
2250 protected:
2251 Sig_item_u32 proc; ///< proc
2252 Sig_item_u32 parent; ///< parent
2253 Sig_item_u32 grand; ///< grand
2254 };
2255
2256 /// APserver request: clear all events for one processor
2257 //----------------------------------------------------------------------------
2258 /// The class for signal CLEAR_ALL_EVENTS
2259 class CLEAR_ALL_EVENTS_c : public Signal_base
2260 {
2261 public:
2262
2263 /// contructor that creates the signal and sends it on TCP socket s
CLEAR_ALL_EVENTS_c(int s,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand)2264 CLEAR_ALL_EVENTS_c(int s,
2265 Sig_item_u32 _proc,
2266 Sig_item_u32 _parent,
2267 Sig_item_u32 _grand)
2268 : proc(_proc),
2269 parent(_parent),
2270 grand(_grand)
2271 { send_TCP(s); }
2272
2273 /// construct (deserialize) this item from a (received) buffer
2274 /// id has already been load()ed.
CLEAR_ALL_EVENTS_c(const uint8_t * & buffer)2275 CLEAR_ALL_EVENTS_c(const uint8_t * & buffer)
2276 : proc(buffer),
2277 parent(buffer),
2278 grand(buffer)
2279 {}
2280
2281 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2282 virtual void store(string & buffer) const
2283 {
2284 const Sig_item_u16 signal_id(sid_CLEAR_ALL_EVENTS);
2285 signal_id.store(buffer);
2286 proc.store(buffer);
2287 parent.store(buffer);
2288 grand.store(buffer);
2289 }
2290
2291 /// print this signal on out.
print(ostream & out) const2292 virtual ostream & print(ostream & out) const
2293 {
2294 out << "CLEAR_ALL_EVENTS(";
2295 proc.print(out); out << ", ";
2296 parent.print(out); out << ", ";
2297 grand.print(out);
2298 return out << ")" << endl;
2299 }
2300
2301 /// a unique number for this signal
get_sigID() const2302 virtual Signal_id get_sigID() const { return sid_CLEAR_ALL_EVENTS; }
2303
2304 /// the name of this signal
get_sigName() const2305 virtual const char * get_sigName() const { return "CLEAR_ALL_EVENTS"; }
2306
2307 /// return item proc of this signal
get__CLEAR_ALL_EVENTS__proc() const2308 virtual uint32_t get__CLEAR_ALL_EVENTS__proc() const { return proc.get_value(); }
2309
2310 /// return item parent of this signal
get__CLEAR_ALL_EVENTS__parent() const2311 virtual uint32_t get__CLEAR_ALL_EVENTS__parent() const { return parent.get_value(); }
2312
2313 /// return item grand of this signal
get__CLEAR_ALL_EVENTS__grand() const2314 virtual uint32_t get__CLEAR_ALL_EVENTS__grand() const { return grand.get_value(); }
2315
2316
2317 protected:
2318 Sig_item_u32 proc; ///< proc
2319 Sig_item_u32 parent; ///< parent
2320 Sig_item_u32 grand; ///< grand
2321 };
2322
2323
2324 /// APserver result for: clear all events for one processor (first cleared svar
2325 //----------------------------------------------------------------------------
2326 /// The class for signal EVENTS_ARE
2327 class EVENTS_ARE_c : public Signal_base
2328 {
2329 public:
2330
2331 /// contructor that creates the signal and sends it on TCP socket s
EVENTS_ARE_c(int s,Sig_item_x64 _key,Sig_item_u32 _events)2332 EVENTS_ARE_c(int s,
2333 Sig_item_x64 _key,
2334 Sig_item_u32 _events)
2335 : key(_key),
2336 events(_events)
2337 { send_TCP(s); }
2338
2339 /// construct (deserialize) this item from a (received) buffer
2340 /// id has already been load()ed.
EVENTS_ARE_c(const uint8_t * & buffer)2341 EVENTS_ARE_c(const uint8_t * & buffer)
2342 : key(buffer),
2343 events(buffer)
2344 {}
2345
2346 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2347 virtual void store(string & buffer) const
2348 {
2349 const Sig_item_u16 signal_id(sid_EVENTS_ARE);
2350 signal_id.store(buffer);
2351 key.store(buffer);
2352 events.store(buffer);
2353 }
2354
2355 /// print this signal on out.
print(ostream & out) const2356 virtual ostream & print(ostream & out) const
2357 {
2358 out << "EVENTS_ARE(";
2359 key.print(out); out << ", ";
2360 events.print(out);
2361 return out << ")" << endl;
2362 }
2363
2364 /// a unique number for this signal
get_sigID() const2365 virtual Signal_id get_sigID() const { return sid_EVENTS_ARE; }
2366
2367 /// the name of this signal
get_sigName() const2368 virtual const char * get_sigName() const { return "EVENTS_ARE"; }
2369
2370 /// return item key of this signal
get__EVENTS_ARE__key() const2371 virtual uint64_t get__EVENTS_ARE__key() const { return key.get_value(); }
2372
2373 /// return item events of this signal
get__EVENTS_ARE__events() const2374 virtual uint32_t get__EVENTS_ARE__events() const { return events.get_value(); }
2375
2376
2377 protected:
2378 Sig_item_x64 key; ///< key
2379 Sig_item_u32 events; ///< events
2380 };
2381
2382 /// APserver request: add an event for \b key
2383 //----------------------------------------------------------------------------
2384 /// The class for signal ADD_EVENT
2385 class ADD_EVENT_c : public Signal_base
2386 {
2387 public:
2388
2389 /// contructor that creates the signal and sends it on TCP socket s
ADD_EVENT_c(int s,Sig_item_x64 _key,Sig_item_u32 _proc,Sig_item_u32 _parent,Sig_item_u32 _grand,Sig_item_u32 _event)2390 ADD_EVENT_c(int s,
2391 Sig_item_x64 _key,
2392 Sig_item_u32 _proc,
2393 Sig_item_u32 _parent,
2394 Sig_item_u32 _grand,
2395 Sig_item_u32 _event)
2396 : key(_key),
2397 proc(_proc),
2398 parent(_parent),
2399 grand(_grand),
2400 event(_event)
2401 { send_TCP(s); }
2402
2403 /// construct (deserialize) this item from a (received) buffer
2404 /// id has already been load()ed.
ADD_EVENT_c(const uint8_t * & buffer)2405 ADD_EVENT_c(const uint8_t * & buffer)
2406 : key(buffer),
2407 proc(buffer),
2408 parent(buffer),
2409 grand(buffer),
2410 event(buffer)
2411 {}
2412
2413 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2414 virtual void store(string & buffer) const
2415 {
2416 const Sig_item_u16 signal_id(sid_ADD_EVENT);
2417 signal_id.store(buffer);
2418 key.store(buffer);
2419 proc.store(buffer);
2420 parent.store(buffer);
2421 grand.store(buffer);
2422 event.store(buffer);
2423 }
2424
2425 /// print this signal on out.
print(ostream & out) const2426 virtual ostream & print(ostream & out) const
2427 {
2428 out << "ADD_EVENT(";
2429 key.print(out); out << ", ";
2430 proc.print(out); out << ", ";
2431 parent.print(out); out << ", ";
2432 grand.print(out); out << ", ";
2433 event.print(out);
2434 return out << ")" << endl;
2435 }
2436
2437 /// a unique number for this signal
get_sigID() const2438 virtual Signal_id get_sigID() const { return sid_ADD_EVENT; }
2439
2440 /// the name of this signal
get_sigName() const2441 virtual const char * get_sigName() const { return "ADD_EVENT"; }
2442
2443 /// return item key of this signal
get__ADD_EVENT__key() const2444 virtual uint64_t get__ADD_EVENT__key() const { return key.get_value(); }
2445
2446 /// return item proc of this signal
get__ADD_EVENT__proc() const2447 virtual uint32_t get__ADD_EVENT__proc() const { return proc.get_value(); }
2448
2449 /// return item parent of this signal
get__ADD_EVENT__parent() const2450 virtual uint32_t get__ADD_EVENT__parent() const { return parent.get_value(); }
2451
2452 /// return item grand of this signal
get__ADD_EVENT__grand() const2453 virtual uint32_t get__ADD_EVENT__grand() const { return grand.get_value(); }
2454
2455 /// return item event of this signal
get__ADD_EVENT__event() const2456 virtual uint32_t get__ADD_EVENT__event() const { return event.get_value(); }
2457
2458
2459 protected:
2460 Sig_item_x64 key; ///< key
2461 Sig_item_u32 proc; ///< proc
2462 Sig_item_u32 parent; ///< parent
2463 Sig_item_u32 grand; ///< grand
2464 Sig_item_u32 event; ///< event
2465 };
2466
2467 /// APserver request: ws-ws SVAR←X
2468 //----------------------------------------------------------------------------
2469 /// The class for signal ASSIGN_WSWS_VAR
2470 class ASSIGN_WSWS_VAR_c : public Signal_base
2471 {
2472 public:
2473
2474 /// contructor that creates the signal and sends it on TCP socket s
ASSIGN_WSWS_VAR_c(int s,Sig_item_x64 _key,Sig_item_string _cdr_value)2475 ASSIGN_WSWS_VAR_c(int s,
2476 Sig_item_x64 _key,
2477 Sig_item_string _cdr_value)
2478 : key(_key),
2479 cdr_value(_cdr_value)
2480 { send_TCP(s); }
2481
2482 /// construct (deserialize) this item from a (received) buffer
2483 /// id has already been load()ed.
ASSIGN_WSWS_VAR_c(const uint8_t * & buffer)2484 ASSIGN_WSWS_VAR_c(const uint8_t * & buffer)
2485 : key(buffer),
2486 cdr_value(buffer)
2487 {}
2488
2489 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2490 virtual void store(string & buffer) const
2491 {
2492 const Sig_item_u16 signal_id(sid_ASSIGN_WSWS_VAR);
2493 signal_id.store(buffer);
2494 key.store(buffer);
2495 cdr_value.store(buffer);
2496 }
2497
2498 /// print this signal on out.
print(ostream & out) const2499 virtual ostream & print(ostream & out) const
2500 {
2501 out << "ASSIGN_WSWS_VAR(";
2502 key.print(out); out << ", ";
2503 cdr_value.print(out);
2504 return out << ")" << endl;
2505 }
2506
2507 /// a unique number for this signal
get_sigID() const2508 virtual Signal_id get_sigID() const { return sid_ASSIGN_WSWS_VAR; }
2509
2510 /// the name of this signal
get_sigName() const2511 virtual const char * get_sigName() const { return "ASSIGN_WSWS_VAR"; }
2512
2513 /// return item key of this signal
get__ASSIGN_WSWS_VAR__key() const2514 virtual uint64_t get__ASSIGN_WSWS_VAR__key() const { return key.get_value(); }
2515
2516 /// return item cdr_value of this signal
get__ASSIGN_WSWS_VAR__cdr_value() const2517 virtual string get__ASSIGN_WSWS_VAR__cdr_value() const { return cdr_value.get_value(); }
2518
2519
2520 protected:
2521 Sig_item_x64 key; ///< key
2522 Sig_item_string cdr_value; ///< cdr_value
2523 };
2524 /// APserver request: X←ws-ws SVAR
2525 //----------------------------------------------------------------------------
2526 /// The class for signal READ_WSWS_VAR
2527 class READ_WSWS_VAR_c : public Signal_base
2528 {
2529 public:
2530
2531 /// contructor that creates the signal and sends it on TCP socket s
READ_WSWS_VAR_c(int s,Sig_item_x64 _key)2532 READ_WSWS_VAR_c(int s,
2533 Sig_item_x64 _key)
2534 : key(_key)
2535 { send_TCP(s); }
2536
2537 /// construct (deserialize) this item from a (received) buffer
2538 /// id has already been load()ed.
READ_WSWS_VAR_c(const uint8_t * & buffer)2539 READ_WSWS_VAR_c(const uint8_t * & buffer)
2540 : key(buffer)
2541 {}
2542
2543 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2544 virtual void store(string & buffer) const
2545 {
2546 const Sig_item_u16 signal_id(sid_READ_WSWS_VAR);
2547 signal_id.store(buffer);
2548 key.store(buffer);
2549 }
2550
2551 /// print this signal on out.
print(ostream & out) const2552 virtual ostream & print(ostream & out) const
2553 {
2554 out << "READ_WSWS_VAR(";
2555 key.print(out);
2556 return out << ")" << endl;
2557 }
2558
2559 /// a unique number for this signal
get_sigID() const2560 virtual Signal_id get_sigID() const { return sid_READ_WSWS_VAR; }
2561
2562 /// the name of this signal
get_sigName() const2563 virtual const char * get_sigName() const { return "READ_WSWS_VAR"; }
2564
2565 /// return item key of this signal
get__READ_WSWS_VAR__key() const2566 virtual uint64_t get__READ_WSWS_VAR__key() const { return key.get_value(); }
2567
2568
2569 protected:
2570 Sig_item_x64 key; ///< key
2571 };
2572 /// APserver result for: X←ws-ws SVAR
2573 //----------------------------------------------------------------------------
2574 /// The class for signal WSWS_VALUE_IS
2575 class WSWS_VALUE_IS_c : public Signal_base
2576 {
2577 public:
2578
2579 /// contructor that creates the signal and sends it on TCP socket s
WSWS_VALUE_IS_c(int s,Sig_item_string _cdr_value)2580 WSWS_VALUE_IS_c(int s,
2581 Sig_item_string _cdr_value)
2582 : cdr_value(_cdr_value)
2583 { send_TCP(s); }
2584
2585 /// construct (deserialize) this item from a (received) buffer
2586 /// id has already been load()ed.
WSWS_VALUE_IS_c(const uint8_t * & buffer)2587 WSWS_VALUE_IS_c(const uint8_t * & buffer)
2588 : cdr_value(buffer)
2589 {}
2590
2591 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2592 virtual void store(string & buffer) const
2593 {
2594 const Sig_item_u16 signal_id(sid_WSWS_VALUE_IS);
2595 signal_id.store(buffer);
2596 cdr_value.store(buffer);
2597 }
2598
2599 /// print this signal on out.
print(ostream & out) const2600 virtual ostream & print(ostream & out) const
2601 {
2602 out << "WSWS_VALUE_IS(";
2603 cdr_value.print(out);
2604 return out << ")" << endl;
2605 }
2606
2607 /// a unique number for this signal
get_sigID() const2608 virtual Signal_id get_sigID() const { return sid_WSWS_VALUE_IS; }
2609
2610 /// the name of this signal
get_sigName() const2611 virtual const char * get_sigName() const { return "WSWS_VALUE_IS"; }
2612
2613 /// return item cdr_value of this signal
get__WSWS_VALUE_IS__cdr_value() const2614 virtual string get__WSWS_VALUE_IS__cdr_value() const { return cdr_value.get_value(); }
2615
2616
2617 protected:
2618 Sig_item_string cdr_value; ///< cdr_value
2619 };
2620
2621 /// APserver request: print the entire database (for command ]SVARS)
2622 //----------------------------------------------------------------------------
2623 /// The class for signal PRINT_SVAR_DB
2624 class PRINT_SVAR_DB_c : public Signal_base
2625 {
2626 public:
2627
2628 /// contructor that creates the signal and sends it on TCP socket s
PRINT_SVAR_DB_c(int s)2629 PRINT_SVAR_DB_c(int s)
2630 { send_TCP(s); }
2631
2632 /// construct (deserialize) this item from a (received) buffer
2633 /// id has already been load()ed.
PRINT_SVAR_DB_c(const uint8_t * & buffer)2634 PRINT_SVAR_DB_c(const uint8_t * & buffer)
2635 {}
2636
2637 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2638 virtual void store(string & buffer) const
2639 {
2640 const Sig_item_u16 signal_id(sid_PRINT_SVAR_DB);
2641 signal_id.store(buffer);
2642 }
2643
2644 /// print this signal on out.
print(ostream & out) const2645 virtual ostream & print(ostream & out) const
2646 {
2647 out << "PRINT_SVAR_DB(";
2648
2649 return out << ")" << endl;
2650 }
2651
2652 /// a unique number for this signal
get_sigID() const2653 virtual Signal_id get_sigID() const { return sid_PRINT_SVAR_DB; }
2654
2655 /// the name of this signal
get_sigName() const2656 virtual const char * get_sigName() const { return "PRINT_SVAR_DB"; }
2657
2658
2659 protected:
2660 };
2661 /// APserver result for: print the entire database
2662 //----------------------------------------------------------------------------
2663 /// The class for signal SVAR_DB_PRINTED
2664 class SVAR_DB_PRINTED_c : public Signal_base
2665 {
2666 public:
2667
2668 /// contructor that creates the signal and sends it on TCP socket s
SVAR_DB_PRINTED_c(int s,Sig_item_string _printout)2669 SVAR_DB_PRINTED_c(int s,
2670 Sig_item_string _printout)
2671 : printout(_printout)
2672 { send_TCP(s); }
2673
2674 /// construct (deserialize) this item from a (received) buffer
2675 /// id has already been load()ed.
SVAR_DB_PRINTED_c(const uint8_t * & buffer)2676 SVAR_DB_PRINTED_c(const uint8_t * & buffer)
2677 : printout(buffer)
2678 {}
2679
2680 /// store (aka. serialize) this signal into a buffer
store(string & buffer) const2681 virtual void store(string & buffer) const
2682 {
2683 const Sig_item_u16 signal_id(sid_SVAR_DB_PRINTED);
2684 signal_id.store(buffer);
2685 printout.store(buffer);
2686 }
2687
2688 /// print this signal on out.
print(ostream & out) const2689 virtual ostream & print(ostream & out) const
2690 {
2691 out << "SVAR_DB_PRINTED(";
2692 printout.print(out);
2693 return out << ")" << endl;
2694 }
2695
2696 /// a unique number for this signal
get_sigID() const2697 virtual Signal_id get_sigID() const { return sid_SVAR_DB_PRINTED; }
2698
2699 /// the name of this signal
get_sigName() const2700 virtual const char * get_sigName() const { return "SVAR_DB_PRINTED"; }
2701
2702 /// return item printout of this signal
get__SVAR_DB_PRINTED__printout() const2703 virtual string get__SVAR_DB_PRINTED__printout() const { return printout.get_value(); }
2704
2705
2706 protected:
2707 Sig_item_string printout; ///< printout
2708 };
2709
2710 //----------------------------------------------------------------------------
2711
2712 /// a union big enough for all signal classes
2713 struct _all_signal_classes_
2714 {
2715
2716 /*
2717 */
2718
2719
2720 /// APserver request: ⎕SVO
2721 char u_MAKE_OFFER[sizeof(MAKE_OFFER_c)];
2722 /// APserver request: ⎕SVR
2723 char u_RETRACT_OFFER[sizeof(RETRACT_OFFER_c)];
2724 /// APserver request: ⎕SVR
2725 char u_RETRACT_VAR[sizeof(RETRACT_VAR_c)];
2726
2727 /// APserver request: set state of shared var \b key
2728 char u_SET_STATE[sizeof(SET_STATE_c)];
2729
2730 /// APserver request: set control of shared var \b key
2731 char u_SET_CONTROL[sizeof(SET_CONTROL_c)];
2732
2733 /// APserver request: X←SVAR
2734 char u_GET_VALUE[sizeof(GET_VALUE_c)];
2735
2736 /// APserver result for: X←SVAR
2737 char u_VALUE_IS[sizeof(VALUE_IS_c)];
2738
2739 /// APserver request: SVAR←X
2740 char u_ASSIGN_VALUE[sizeof(ASSIGN_VALUE_c)];
2741 /// APserver result for: SVAR←X
2742 char u_SVAR_ASSIGNED[sizeof(SVAR_ASSIGNED_c)];
2743
2744 /// APserver request: Can svar key be referenced ?
2745 char u_MAY_USE[sizeof(MAY_USE_c)];
2746
2747 /// APserver request: Can svar key be assigned ?
2748 char u_MAY_SET[sizeof(MAY_SET_c)];
2749
2750 /// APserver request: read SVAR database record from APserver
2751 ///
2752 /// apl/APnnn --> READ_SVAR_RECORD APserver
2753 /// <-- SVAR_RECORD_IS
2754 ///
2755 char u_READ_SVAR_RECORD[sizeof(READ_SVAR_RECORD_c)];
2756 /// APserver result (record) for: read SVAR database record from APserver
2757 char u_SVAR_RECORD_IS[sizeof(SVAR_RECORD_IS_c)];
2758
2759 /// APserver request: is ID registered ?
2760 char u_IS_REGISTERED_ID[sizeof(IS_REGISTERED_ID_c)];
2761
2762 /// APserver result: yes (1) or no (0)
2763 char u_YES_NO[sizeof(YES_NO_c)];
2764
2765 /// APserver request: register processor proc in APserver
2766 char u_REGISTER_PROCESSOR[sizeof(REGISTER_PROCESSOR_c)];
2767
2768 /// APserver request: match offered shared variable or make a new offer
2769 char u_MATCH_OR_MAKE[sizeof(MATCH_OR_MAKE_c)];
2770
2771 /// APserver result for: match or make
2772 char u_MATCH_OR_MAKE_RESULT[sizeof(MATCH_OR_MAKE_RESULT_c)];
2773
2774
2775 /// APserver request: find processor ID that offers \b key
2776 char u_FIND_OFFERING_ID[sizeof(FIND_OFFERING_ID_c)];
2777
2778 /// APserver result for: find processor ID that offers \b key
2779 char u_OFFERING_ID_IS[sizeof(OFFERING_ID_IS_c)];
2780
2781 /// APserver request: get offering processors (⎕SVQ)
2782 char u_GET_OFFERING_PROCS[sizeof(GET_OFFERING_PROCS_c)];
2783
2784 /// APserver result for: get offering processors (⎕SVQ)
2785 char u_OFFERING_PROCS_ARE[sizeof(OFFERING_PROCS_ARE_c)];
2786
2787 /// APserver request: get offered variables (⎕SVQ)
2788 char u_GET_OFFERED_VARS[sizeof(GET_OFFERED_VARS_c)];
2789
2790 /// APserver result for: get offered variables (⎕SVQ)
2791 char u_OFFERED_VARS_ARE[sizeof(OFFERED_VARS_ARE_c)];
2792
2793 /// APserver request: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2794 char u_FIND_PAIRING_KEY[sizeof(FIND_PAIRING_KEY_c)];
2795
2796 /// APserver result for: find pairing key
2797 char u_PAIRING_KEY_IS[sizeof(PAIRING_KEY_IS_c)];
2798
2799 /// APserver result for: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2800 /// get events for one processor (first shared var with an event)
2801 char u_GET_EVENTS[sizeof(GET_EVENTS_c)];
2802
2803 /// APserver request: clear all events for one processor
2804 char u_CLEAR_ALL_EVENTS[sizeof(CLEAR_ALL_EVENTS_c)];
2805
2806
2807 /// APserver result for: clear all events for one processor (first cleared svar
2808 char u_EVENTS_ARE[sizeof(EVENTS_ARE_c)];
2809
2810 /// APserver request: add an event for \b key
2811 char u_ADD_EVENT[sizeof(ADD_EVENT_c)];
2812
2813 /// APserver request: ws-ws SVAR←X
2814 char u_ASSIGN_WSWS_VAR[sizeof(ASSIGN_WSWS_VAR_c)];
2815 /// APserver request: X←ws-ws SVAR
2816 char u_READ_WSWS_VAR[sizeof(READ_WSWS_VAR_c)];
2817 /// APserver result for: X←ws-ws SVAR
2818 char u_WSWS_VALUE_IS[sizeof(WSWS_VALUE_IS_c)];
2819
2820 /// APserver request: print the entire database (for command ]SVARS)
2821 char u_PRINT_SVAR_DB[sizeof(PRINT_SVAR_DB_c)];
2822 /// APserver result for: print the entire database
2823 char u_SVAR_DB_PRINTED[sizeof(SVAR_DB_PRINTED_c)];
2824
2825 };
2826
2827 enum { MAX_SIGNAL_CLASS_SIZE = sizeof(_all_signal_classes_) };
2828
2829 //----------------------------------------------------------------------------
2830 Signal_base *
recv_TCP(int tcp_sock,char * buffer,int bufsize,char * & del,ostream * debug)2831 Signal_base::recv_TCP(int tcp_sock, char * buffer, int bufsize,
2832 char * & del, ostream * debug)
2833 {
2834 if (bufsize < 2*MAX_SIGNAL_CLASS_SIZE)
2835 {
2836 // a too small bufsize happens easily but is hard to debug!
2837 //
2838 cerr << "\n\n*** bufsize is " << bufsize
2839 << " but MUST be at least " << 2*MAX_SIGNAL_CLASS_SIZE
2840 << " in recv_TCP() !!!" << endl;
2841
2842 return 0;
2843 }
2844 ssize_t siglen = 0;
2845 for (;;)
2846 {
2847 errno = 0;
2848 const ssize_t rx_bytes = ::recv(tcp_sock, buffer,
2849 sizeof(uint32_t), MSG_WAITALL);
2850
2851 if (errno == EINTR) continue;
2852
2853 if (rx_bytes != sizeof(uint32_t))
2854 {
2855 // connection was closed by the peer
2856 return 0;
2857 }
2858
2859 break; // got sizeof(uint32_t) length bytes
2860 }
2861 // debug && *debug << "rx_bytes is " << rx_bytes
2862 // << " when reading siglen in in recv_TCP()" << endl;
2863
2864 siglen = ntohl(*reinterpret_cast<uint32_t *>(buffer));
2865 if (siglen == 0) return 0; // close
2866
2867 // debug && *debug << "signal length is " << siglen << " in recv_TCP()" << endl;
2868
2869 // skip MAX_SIGNAL_CLASS_SIZE bytes at the beginning of buffer
2870 //
2871 char * rx_buf = buffer + MAX_SIGNAL_CLASS_SIZE;
2872 bufsize -= MAX_SIGNAL_CLASS_SIZE;
2873
2874 if (siglen > bufsize)
2875 {
2876 // the buffer provided is too small: allocate a bigger one
2877 //
2878 del = new char[siglen];
2879 if (del == 0)
2880 {
2881 cerr << "*** new(" << siglen <<") failed in recv_TCP()" << endl;
2882 return 0;
2883 }
2884 rx_buf = del;
2885 }
2886
2887 for (;;)
2888 {
2889 errno = 0;
2890 const ssize_t rx_bytes = ::recv(tcp_sock, rx_buf,
2891 siglen, MSG_WAITALL);
2892
2893 if (errno == EINTR) continue;
2894
2895 if (rx_bytes != siglen)
2896 {
2897 cerr << "*** got " << rx_bytes
2898 << " when expecting " << siglen << endl;
2899 return 0;
2900 }
2901
2902
2903 break; // got siglen bytes
2904 }
2905
2906 // debug && *debug << "rx_bytes is " << rx_bytes << " in recv_TCP()" << endl;
2907
2908 const uint8_t * b = reinterpret_cast<const uint8_t *>(rx_buf);
2909 Sig_item_u16 signal_id(b);
2910
2911 Signal_base * ret = 0;
2912 switch(signal_id.get_value())
2913 {
2914
2915 /*
2916 */
2917
2918
2919 /// APserver request: ⎕SVO
2920 case sid_MAKE_OFFER: ret = new MAKE_OFFER_c(b); break;
2921 /// APserver request: ⎕SVR
2922 case sid_RETRACT_OFFER: ret = new RETRACT_OFFER_c(b); break;
2923 /// APserver request: ⎕SVR
2924 case sid_RETRACT_VAR: ret = new RETRACT_VAR_c(b); break;
2925
2926 /// APserver request: set state of shared var \b key
2927 case sid_SET_STATE: ret = new SET_STATE_c(b); break;
2928
2929 /// APserver request: set control of shared var \b key
2930 case sid_SET_CONTROL: ret = new SET_CONTROL_c(b); break;
2931
2932 /// APserver request: X←SVAR
2933 case sid_GET_VALUE: ret = new GET_VALUE_c(b); break;
2934
2935 /// APserver result for: X←SVAR
2936 case sid_VALUE_IS: ret = new VALUE_IS_c(b); break;
2937
2938 /// APserver request: SVAR←X
2939 case sid_ASSIGN_VALUE: ret = new ASSIGN_VALUE_c(b); break;
2940 /// APserver result for: SVAR←X
2941 case sid_SVAR_ASSIGNED: ret = new SVAR_ASSIGNED_c(b); break;
2942
2943 /// APserver request: Can svar key be referenced ?
2944 case sid_MAY_USE: ret = new MAY_USE_c(b); break;
2945
2946 /// APserver request: Can svar key be assigned ?
2947 case sid_MAY_SET: ret = new MAY_SET_c(b); break;
2948
2949 /// APserver request: read SVAR database record from APserver
2950 ///
2951 /// apl/APnnn --> READ_SVAR_RECORD APserver
2952 /// <-- SVAR_RECORD_IS
2953 ///
2954 case sid_READ_SVAR_RECORD: ret = new READ_SVAR_RECORD_c(b); break;
2955 /// APserver result (record) for: read SVAR database record from APserver
2956 case sid_SVAR_RECORD_IS: ret = new SVAR_RECORD_IS_c(b); break;
2957
2958 /// APserver request: is ID registered ?
2959 case sid_IS_REGISTERED_ID: ret = new IS_REGISTERED_ID_c(b); break;
2960
2961 /// APserver result: yes (1) or no (0)
2962 case sid_YES_NO: ret = new YES_NO_c(b); break;
2963
2964 /// APserver request: register processor proc in APserver
2965 case sid_REGISTER_PROCESSOR: ret = new REGISTER_PROCESSOR_c(b); break;
2966
2967 /// APserver request: match offered shared variable or make a new offer
2968 case sid_MATCH_OR_MAKE: ret = new MATCH_OR_MAKE_c(b); break;
2969
2970 /// APserver result for: match or make
2971 case sid_MATCH_OR_MAKE_RESULT: ret = new MATCH_OR_MAKE_RESULT_c(b); break;
2972
2973
2974 /// APserver request: find processor ID that offers \b key
2975 case sid_FIND_OFFERING_ID: ret = new FIND_OFFERING_ID_c(b); break;
2976
2977 /// APserver result for: find processor ID that offers \b key
2978 case sid_OFFERING_ID_IS: ret = new OFFERING_ID_IS_c(b); break;
2979
2980 /// APserver request: get offering processors (⎕SVQ)
2981 case sid_GET_OFFERING_PROCS: ret = new GET_OFFERING_PROCS_c(b); break;
2982
2983 /// APserver result for: get offering processors (⎕SVQ)
2984 case sid_OFFERING_PROCS_ARE: ret = new OFFERING_PROCS_ARE_c(b); break;
2985
2986 /// APserver request: get offered variables (⎕SVQ)
2987 case sid_GET_OFFERED_VARS: ret = new GET_OFFERED_VARS_c(b); break;
2988
2989 /// APserver result for: get offered variables (⎕SVQ)
2990 case sid_OFFERED_VARS_ARE: ret = new OFFERED_VARS_ARE_c(b); break;
2991
2992 /// APserver request: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2993 case sid_FIND_PAIRING_KEY: ret = new FIND_PAIRING_KEY_c(b); break;
2994
2995 /// APserver result for: find pairing key
2996 case sid_PAIRING_KEY_IS: ret = new PAIRING_KEY_IS_c(b); break;
2997
2998 /// APserver result for: find pairing key (CTL vs. DAT or Cnnn vs. Dnnn) for AP210
2999 /// get events for one processor (first shared var with an event)
3000 case sid_GET_EVENTS: ret = new GET_EVENTS_c(b); break;
3001
3002 /// APserver request: clear all events for one processor
3003 case sid_CLEAR_ALL_EVENTS: ret = new CLEAR_ALL_EVENTS_c(b); break;
3004
3005
3006 /// APserver result for: clear all events for one processor (first cleared svar
3007 case sid_EVENTS_ARE: ret = new EVENTS_ARE_c(b); break;
3008
3009 /// APserver request: add an event for \b key
3010 case sid_ADD_EVENT: ret = new ADD_EVENT_c(b); break;
3011
3012 /// APserver request: ws-ws SVAR←X
3013 case sid_ASSIGN_WSWS_VAR: ret = new ASSIGN_WSWS_VAR_c(b); break;
3014 /// APserver request: X←ws-ws SVAR
3015 case sid_READ_WSWS_VAR: ret = new READ_WSWS_VAR_c(b); break;
3016 /// APserver result for: X←ws-ws SVAR
3017 case sid_WSWS_VALUE_IS: ret = new WSWS_VALUE_IS_c(b); break;
3018
3019 /// APserver request: print the entire database (for command ]SVARS)
3020 case sid_PRINT_SVAR_DB: ret = new PRINT_SVAR_DB_c(b); break;
3021 /// APserver result for: print the entire database
3022 case sid_SVAR_DB_PRINTED: ret = new SVAR_DB_PRINTED_c(b); break;
3023
3024 default: cerr << "Signal_base::recv_TCP() failed: unknown signal id "
3025 << signal_id.get_value() << endl;
3026 errno = EINVAL;
3027 return 0;
3028 }
3029
3030 debug && ret->print(*debug << "<-- ");
3031
3032 return ret; // invalid id
3033 }
3034 //----------------------------------------------------------------------------
3035