Fawkes API  Fawkes Development Version
SkillerDebugInterface.cpp
1 
2 /***************************************************************************
3  * SkillerDebugInterface.cpp - Fawkes BlackBoard Interface - SkillerDebugInterface
4  *
5  * Templated created: Thu Oct 12 10:49:19 2006
6  * Copyright 2008 Tim Niemueller
7  *
8  ****************************************************************************/
9 
10 /* This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version. A runtime exception applies to
14  * this software (see LICENSE.GPL_WRE file mentioned below for details).
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU Library General Public License for more details.
20  *
21  * Read the full text in the LICENSE.GPL_WRE file in the doc directory.
22  */
23 
24 #include <interfaces/SkillerDebugInterface.h>
25 
26 #include <core/exceptions/software.h>
27 
28 #include <map>
29 #include <string>
30 #include <cstring>
31 #include <cstdlib>
32 
33 namespace fawkes {
34 
35 /** @class SkillerDebugInterface <interfaces/SkillerDebugInterface.h>
36  * SkillerDebugInterface Fawkes BlackBoard Interface.
37  *
38  This interface provides internal skiller data that should allow for
39  easier debugging of skills and the skiller in general. The most notable
40  feature is a graph representation in the dot language of the available
41  skills (and highlighting for the currently active skill).
42 
43  * @ingroup FawkesInterfaces
44  */
45 
46 
47 
48 /** Constructor */
49 SkillerDebugInterface::SkillerDebugInterface() : Interface()
50 {
51  data_size = sizeof(SkillerDebugInterface_data_t);
52  data_ptr = malloc(data_size);
53  data = (SkillerDebugInterface_data_t *)data_ptr;
54  data_ts = (interface_data_ts_t *)data_ptr;
55  memset(data_ptr, 0, data_size);
56  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
57  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
58  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
59  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
60  add_fieldinfo(IFT_STRING, "graph_fsm", 32, data->graph_fsm);
61  add_fieldinfo(IFT_STRING, "graph", 8192, data->graph);
62  add_fieldinfo(IFT_ENUM, "graph_dir", 1, &data->graph_dir, "GraphDirectionEnum", &enum_map_GraphDirectionEnum);
63  add_fieldinfo(IFT_BOOL, "graph_colored", 1, &data->graph_colored);
64  add_messageinfo("SetGraphMessage");
65  add_messageinfo("SetGraphDirectionMessage");
66  add_messageinfo("SetGraphColoredMessage");
67  unsigned char tmp_hash[] = {0xcf, 0x3d, 0x2f, 0xf8, 0x80, 0x6e, 0x8f, 0xf4, 0x81, 0xa6, 0x7f, 0xd9, 0xb0, 0x29, 0xfc, 0x62};
68  set_hash(tmp_hash);
69 }
70 
71 /** Destructor */
72 SkillerDebugInterface::~SkillerDebugInterface()
73 {
74  free(data_ptr);
75 }
76 /** Convert GraphDirectionEnum constant to string.
77  * @param value value to convert to string
78  * @return constant value as string.
79  */
80 const char *
81 SkillerDebugInterface::tostring_GraphDirectionEnum(GraphDirectionEnum value) const
82 {
83  switch (value) {
84  case GD_TOP_BOTTOM: return "GD_TOP_BOTTOM";
85  case GD_BOTTOM_TOP: return "GD_BOTTOM_TOP";
86  case GD_LEFT_RIGHT: return "GD_LEFT_RIGHT";
87  case GD_RIGHT_LEFT: return "GD_RIGHT_LEFT";
88  default: return "UNKNOWN";
89  }
90 }
91 /* Methods */
92 /** Get graph_fsm value.
93  *
94  The finite state machine (FSM) the current graph has been updated for.
95 
96  * @return graph_fsm value
97  */
98 char *
99 SkillerDebugInterface::graph_fsm() const
100 {
101  return data->graph_fsm;
102 }
103 
104 /** Get maximum length of graph_fsm value.
105  * @return length of graph_fsm value, can be length of the array or number of
106  * maximum number of characters for a string
107  */
108 size_t
109 SkillerDebugInterface::maxlenof_graph_fsm() const
110 {
111  return 32;
112 }
113 
114 /** Set graph_fsm value.
115  *
116  The finite state machine (FSM) the current graph has been updated for.
117 
118  * @param new_graph_fsm new graph_fsm value
119  */
120 void
121 SkillerDebugInterface::set_graph_fsm(const char * new_graph_fsm)
122 {
123  strncpy(data->graph_fsm, new_graph_fsm, sizeof(data->graph_fsm)-1);
124  data->graph_fsm[sizeof(data->graph_fsm)-1] = 0;
125  data_changed = true;
126 }
127 
128 /** Get graph value.
129  *
130  The selected graph in a dot string representation.
131 
132  * @return graph value
133  */
134 char *
135 SkillerDebugInterface::graph() const
136 {
137  return data->graph;
138 }
139 
140 /** Get maximum length of graph value.
141  * @return length of graph value, can be length of the array or number of
142  * maximum number of characters for a string
143  */
144 size_t
145 SkillerDebugInterface::maxlenof_graph() const
146 {
147  return 8192;
148 }
149 
150 /** Set graph value.
151  *
152  The selected graph in a dot string representation.
153 
154  * @param new_graph new graph value
155  */
156 void
157 SkillerDebugInterface::set_graph(const char * new_graph)
158 {
159  strncpy(data->graph, new_graph, sizeof(data->graph)-1);
160  data->graph[sizeof(data->graph)-1] = 0;
161  data_changed = true;
162 }
163 
164 /** Get graph_dir value.
165  *
166  Primary direction of current graph.
167 
168  * @return graph_dir value
169  */
171 SkillerDebugInterface::graph_dir() const
172 {
173  return (SkillerDebugInterface::GraphDirectionEnum)data->graph_dir;
174 }
175 
176 /** Get maximum length of graph_dir value.
177  * @return length of graph_dir value, can be length of the array or number of
178  * maximum number of characters for a string
179  */
180 size_t
181 SkillerDebugInterface::maxlenof_graph_dir() const
182 {
183  return 1;
184 }
185 
186 /** Set graph_dir value.
187  *
188  Primary direction of current graph.
189 
190  * @param new_graph_dir new graph_dir value
191  */
192 void
193 SkillerDebugInterface::set_graph_dir(const GraphDirectionEnum new_graph_dir)
194 {
195  data->graph_dir = new_graph_dir;
196  data_changed = true;
197 }
198 
199 /** Get graph_colored value.
200  *
201  True if the graph is colored, false otherwise.
202 
203  * @return graph_colored value
204  */
205 bool
206 SkillerDebugInterface::is_graph_colored() const
207 {
208  return data->graph_colored;
209 }
210 
211 /** Get maximum length of graph_colored value.
212  * @return length of graph_colored value, can be length of the array or number of
213  * maximum number of characters for a string
214  */
215 size_t
216 SkillerDebugInterface::maxlenof_graph_colored() const
217 {
218  return 1;
219 }
220 
221 /** Set graph_colored value.
222  *
223  True if the graph is colored, false otherwise.
224 
225  * @param new_graph_colored new graph_colored value
226  */
227 void
228 SkillerDebugInterface::set_graph_colored(const bool new_graph_colored)
229 {
230  data->graph_colored = new_graph_colored;
231  data_changed = true;
232 }
233 
234 /* =========== message create =========== */
235 Message *
236 SkillerDebugInterface::create_message(const char *type) const
237 {
238  if ( strncmp("SetGraphMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
239  return new SetGraphMessage();
240  } else if ( strncmp("SetGraphDirectionMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
241  return new SetGraphDirectionMessage();
242  } else if ( strncmp("SetGraphColoredMessage", type, INTERFACE_MESSAGE_TYPE_SIZE_ - 1) == 0 ) {
243  return new SetGraphColoredMessage();
244  } else {
245  throw UnknownTypeException("The given type '%s' does not match any known "
246  "message type for this interface type.", type);
247  }
248 }
249 
250 
251 /** Copy values from other interface.
252  * @param other other interface to copy values from
253  */
254 void
255 SkillerDebugInterface::copy_values(const Interface *other)
256 {
257  const SkillerDebugInterface *oi = dynamic_cast<const SkillerDebugInterface *>(other);
258  if (oi == NULL) {
259  throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
260  type(), other->type());
261  }
262  memcpy(data, oi->data, sizeof(SkillerDebugInterface_data_t));
263 }
264 
265 const char *
266 SkillerDebugInterface::enum_tostring(const char *enumtype, int val) const
267 {
268  if (strcmp(enumtype, "GraphDirectionEnum") == 0) {
269  return tostring_GraphDirectionEnum((GraphDirectionEnum)val);
270  }
271  throw UnknownTypeException("Unknown enum type %s", enumtype);
272 }
273 
274 /* =========== messages =========== */
275 /** @class SkillerDebugInterface::SetGraphMessage <interfaces/SkillerDebugInterface.h>
276  * SetGraphMessage Fawkes BlackBoard Interface Message.
277  *
278 
279  */
280 
281 
282 /** Constructor with initial values.
283  * @param ini_graph_fsm initial value for graph_fsm
284  */
285 SkillerDebugInterface::SetGraphMessage::SetGraphMessage(const char * ini_graph_fsm) : Message("SetGraphMessage")
286 {
287  data_size = sizeof(SetGraphMessage_data_t);
288  data_ptr = malloc(data_size);
289  memset(data_ptr, 0, data_size);
290  data = (SetGraphMessage_data_t *)data_ptr;
292  strncpy(data->graph_fsm, ini_graph_fsm, 32-1);
293  data->graph_fsm[32-1] = 0;
294  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
295  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
296  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
297  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
298  add_fieldinfo(IFT_STRING, "graph_fsm", 32, data->graph_fsm);
299 }
300 /** Constructor */
302 {
303  data_size = sizeof(SetGraphMessage_data_t);
304  data_ptr = malloc(data_size);
305  memset(data_ptr, 0, data_size);
306  data = (SetGraphMessage_data_t *)data_ptr;
308  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
309  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
310  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
311  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
312  add_fieldinfo(IFT_STRING, "graph_fsm", 32, data->graph_fsm);
313 }
314 
315 /** Destructor */
317 {
318  free(data_ptr);
319 }
320 
321 /** Copy constructor.
322  * @param m message to copy from
323  */
325 {
326  data_size = m->data_size;
327  data_ptr = malloc(data_size);
328  memcpy(data_ptr, m->data_ptr, data_size);
329  data = (SetGraphMessage_data_t *)data_ptr;
331 }
332 
333 /* Methods */
334 /** Get graph_fsm value.
335  *
336  The finite state machine (FSM) the current graph has been updated for.
337 
338  * @return graph_fsm value
339  */
340 char *
342 {
343  return data->graph_fsm;
344 }
345 
346 /** Get maximum length of graph_fsm value.
347  * @return length of graph_fsm value, can be length of the array or number of
348  * maximum number of characters for a string
349  */
350 size_t
352 {
353  return 32;
354 }
355 
356 /** Set graph_fsm value.
357  *
358  The finite state machine (FSM) the current graph has been updated for.
359 
360  * @param new_graph_fsm new graph_fsm value
361  */
362 void
364 {
365  strncpy(data->graph_fsm, new_graph_fsm, sizeof(data->graph_fsm)-1);
366  data->graph_fsm[sizeof(data->graph_fsm)-1] = 0;
367 }
368 
369 /** Clone this message.
370  * Produces a message of the same type as this message and copies the
371  * data to the new message.
372  * @return clone of this message
373  */
374 Message *
376 {
378 }
379 /** @class SkillerDebugInterface::SetGraphDirectionMessage <interfaces/SkillerDebugInterface.h>
380  * SetGraphDirectionMessage Fawkes BlackBoard Interface Message.
381  *
382 
383  */
384 
385 
386 /** Constructor with initial values.
387  * @param ini_graph_dir initial value for graph_dir
388  */
390 {
391  data_size = sizeof(SetGraphDirectionMessage_data_t);
392  data_ptr = malloc(data_size);
393  memset(data_ptr, 0, data_size);
394  data = (SetGraphDirectionMessage_data_t *)data_ptr;
396  data->graph_dir = ini_graph_dir;
397  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
398  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
399  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
400  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
401  add_fieldinfo(IFT_ENUM, "graph_dir", 1, &data->graph_dir, "GraphDirectionEnum", &enum_map_GraphDirectionEnum);
402 }
403 /** Constructor */
405 {
406  data_size = sizeof(SetGraphDirectionMessage_data_t);
407  data_ptr = malloc(data_size);
408  memset(data_ptr, 0, data_size);
409  data = (SetGraphDirectionMessage_data_t *)data_ptr;
411  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
412  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
413  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
414  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
415  add_fieldinfo(IFT_ENUM, "graph_dir", 1, &data->graph_dir, "GraphDirectionEnum", &enum_map_GraphDirectionEnum);
416 }
417 
418 /** Destructor */
420 {
421  free(data_ptr);
422 }
423 
424 /** Copy constructor.
425  * @param m message to copy from
426  */
428 {
429  data_size = m->data_size;
430  data_ptr = malloc(data_size);
431  memcpy(data_ptr, m->data_ptr, data_size);
432  data = (SetGraphDirectionMessage_data_t *)data_ptr;
434 }
435 
436 /* Methods */
437 /** Get graph_dir value.
438  *
439  Primary direction of current graph.
440 
441  * @return graph_dir value
442  */
445 {
446  return (SkillerDebugInterface::GraphDirectionEnum)data->graph_dir;
447 }
448 
449 /** Get maximum length of graph_dir value.
450  * @return length of graph_dir value, can be length of the array or number of
451  * maximum number of characters for a string
452  */
453 size_t
455 {
456  return 1;
457 }
458 
459 /** Set graph_dir value.
460  *
461  Primary direction of current graph.
462 
463  * @param new_graph_dir new graph_dir value
464  */
465 void
467 {
468  data->graph_dir = new_graph_dir;
469 }
470 
471 /** Clone this message.
472  * Produces a message of the same type as this message and copies the
473  * data to the new message.
474  * @return clone of this message
475  */
476 Message *
478 {
480 }
481 /** @class SkillerDebugInterface::SetGraphColoredMessage <interfaces/SkillerDebugInterface.h>
482  * SetGraphColoredMessage Fawkes BlackBoard Interface Message.
483  *
484 
485  */
486 
487 
488 /** Constructor with initial values.
489  * @param ini_graph_colored initial value for graph_colored
490  */
491 SkillerDebugInterface::SetGraphColoredMessage::SetGraphColoredMessage(const bool ini_graph_colored) : Message("SetGraphColoredMessage")
492 {
493  data_size = sizeof(SetGraphColoredMessage_data_t);
494  data_ptr = malloc(data_size);
495  memset(data_ptr, 0, data_size);
496  data = (SetGraphColoredMessage_data_t *)data_ptr;
498  data->graph_colored = ini_graph_colored;
499  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
500  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
501  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
502  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
503  add_fieldinfo(IFT_BOOL, "graph_colored", 1, &data->graph_colored);
504 }
505 /** Constructor */
507 {
508  data_size = sizeof(SetGraphColoredMessage_data_t);
509  data_ptr = malloc(data_size);
510  memset(data_ptr, 0, data_size);
511  data = (SetGraphColoredMessage_data_t *)data_ptr;
513  enum_map_GraphDirectionEnum[(int)GD_TOP_BOTTOM] = "GD_TOP_BOTTOM";
514  enum_map_GraphDirectionEnum[(int)GD_BOTTOM_TOP] = "GD_BOTTOM_TOP";
515  enum_map_GraphDirectionEnum[(int)GD_LEFT_RIGHT] = "GD_LEFT_RIGHT";
516  enum_map_GraphDirectionEnum[(int)GD_RIGHT_LEFT] = "GD_RIGHT_LEFT";
517  add_fieldinfo(IFT_BOOL, "graph_colored", 1, &data->graph_colored);
518 }
519 
520 /** Destructor */
522 {
523  free(data_ptr);
524 }
525 
526 /** Copy constructor.
527  * @param m message to copy from
528  */
530 {
531  data_size = m->data_size;
532  data_ptr = malloc(data_size);
533  memcpy(data_ptr, m->data_ptr, data_size);
534  data = (SetGraphColoredMessage_data_t *)data_ptr;
536 }
537 
538 /* Methods */
539 /** Get graph_colored value.
540  *
541  True if the graph is colored, false otherwise.
542 
543  * @return graph_colored value
544  */
545 bool
547 {
548  return data->graph_colored;
549 }
550 
551 /** Get maximum length of graph_colored value.
552  * @return length of graph_colored value, can be length of the array or number of
553  * maximum number of characters for a string
554  */
555 size_t
557 {
558  return 1;
559 }
560 
561 /** Set graph_colored value.
562  *
563  True if the graph is colored, false otherwise.
564 
565  * @param new_graph_colored new graph_colored value
566  */
567 void
569 {
570  data->graph_colored = new_graph_colored;
571 }
572 
573 /** Clone this message.
574  * Produces a message of the same type as this message and copies the
575  * data to the new message.
576  * @return clone of this message
577  */
578 Message *
580 {
582 }
583 /** Check if message is valid and can be enqueued.
584  * @param message Message to check
585  * @return true if the message is valid, false otherwise.
586  */
587 bool
588 SkillerDebugInterface::message_valid(const Message *message) const
589 {
590  const SetGraphMessage *m0 = dynamic_cast<const SetGraphMessage *>(message);
591  if ( m0 != NULL ) {
592  return true;
593  }
594  const SetGraphDirectionMessage *m1 = dynamic_cast<const SetGraphDirectionMessage *>(message);
595  if ( m1 != NULL ) {
596  return true;
597  }
598  const SetGraphColoredMessage *m2 = dynamic_cast<const SetGraphColoredMessage *>(message);
599  if ( m2 != NULL ) {
600  return true;
601  }
602  return false;
603 }
604 
605 /// @cond INTERNALS
606 EXPORT_INTERFACE(SkillerDebugInterface)
607 /// @endcond
608 
609 
610 } // end namespace fawkes
fawkes::Interface::data_ptr
void * data_ptr
Definition: interface.h:224
fawkes::SkillerDebugInterface::SetGraphMessage::set_graph_fsm
void set_graph_fsm(const char *new_graph_fsm)
Set graph_fsm value.
Definition: SkillerDebugInterface.cpp:369
fawkes::SkillerDebugInterface::SetGraphColoredMessage::set_graph_colored
void set_graph_colored(const bool new_graph_colored)
Set graph_colored value.
Definition: SkillerDebugInterface.cpp:574
fawkes::Message
Definition: message.h:41
fawkes::SkillerDebugInterface::SetGraphMessage::SetGraphMessage
SetGraphMessage()
Constructor.
Definition: SkillerDebugInterface.cpp:307
fawkes::Message::data_ptr
void * data_ptr
Definition: message.h:125
fawkes::IFT_BOOL
@ IFT_BOOL
boolean field
Definition: types.h:51
fawkes::IFT_ENUM
@ IFT_ENUM
field with interface specific enum type
Definition: types.h:64
fawkes::Message::data_ts
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:135
fawkes::SkillerDebugInterface::SetGraphColoredMessage::clone
virtual Message * clone() const
Clone this message.
Definition: SkillerDebugInterface.cpp:585
fawkes::Interface::add_fieldinfo
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the field info list.
Definition: interface.cpp:341
fawkes::Interface::data_ts
interface_data_ts_t * data_ts
Definition: interface.h:228
fawkes::SkillerDebugInterface::SetGraphColoredMessage::is_graph_colored
bool is_graph_colored() const
Get graph_colored value.
Definition: SkillerDebugInterface.cpp:552
fawkes::SkillerDebugInterface::GraphDirectionEnum
GraphDirectionEnum
Primary direction of the graph.
Definition: SkillerDebugInterface.h:54
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::graph_dir
GraphDirectionEnum graph_dir() const
Get graph_dir value.
Definition: SkillerDebugInterface.cpp:450
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::~SetGraphDirectionMessage
~SetGraphDirectionMessage()
Destructor.
Definition: SkillerDebugInterface.cpp:425
fawkes::Message::message_data_ts_t
Timestamp data, must be present and first entries for each interface data structs!...
Definition: message.h:130
fawkes::SkillerDebugInterface::SetGraphColoredMessage::SetGraphColoredMessage
SetGraphColoredMessage()
Constructor.
Definition: SkillerDebugInterface.cpp:512
fawkes::SkillerDebugInterface::SetGraphMessage::~SetGraphMessage
~SetGraphMessage()
Destructor.
Definition: SkillerDebugInterface.cpp:322
fawkes::SkillerDebugInterface::GD_TOP_BOTTOM
@ GD_TOP_BOTTOM
From top to bottom.
Definition: SkillerDebugInterface.h:61
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::set_graph_dir
void set_graph_dir(const GraphDirectionEnum new_graph_dir)
Set graph_dir value.
Definition: SkillerDebugInterface.cpp:472
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::SetGraphDirectionMessage
SetGraphDirectionMessage()
Constructor.
Definition: SkillerDebugInterface.cpp:410
fawkes::SkillerDebugInterface::SetGraphColoredMessage::~SetGraphColoredMessage
~SetGraphColoredMessage()
Destructor.
Definition: SkillerDebugInterface.cpp:527
fawkes
fawkes::SkillerDebugInterface::SetGraphMessage::graph_fsm
char * graph_fsm() const
Get graph_fsm value.
Definition: SkillerDebugInterface.cpp:347
fawkes::SkillerDebugInterface::SetGraphMessage
Definition: SkillerDebugInterface.h:86
fawkes::Message::data_size
unsigned int data_size
Definition: message.h:126
fawkes::SkillerDebugInterface::GD_BOTTOM_TOP
@ GD_BOTTOM_TOP
From bottom to top.
Definition: SkillerDebugInterface.h:62
fawkes::SkillerDebugInterface::SetGraphMessage::maxlenof_graph_fsm
size_t maxlenof_graph_fsm() const
Get maximum length of graph_fsm value.
Definition: SkillerDebugInterface.cpp:357
fawkes::SkillerDebugInterface::SetGraphMessage::clone
virtual Message * clone() const
Clone this message.
Definition: SkillerDebugInterface.cpp:381
fawkes::Message::add_fieldinfo
void add_fieldinfo(interface_fieldtype_t type, const char *name, size_t length, void *value, const char *enumtype=0, const interface_enum_map_t *enum_map=0)
Add an entry to the info list.
Definition: message.cpp:406
fawkes::Interface::data_size
unsigned int data_size
Definition: interface.h:225
fawkes::IFT_STRING
@ IFT_STRING
string field
Definition: types.h:62
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::maxlenof_graph_dir
size_t maxlenof_graph_dir() const
Get maximum length of graph_dir value.
Definition: SkillerDebugInterface.cpp:460
fawkes::SkillerDebugInterface::GD_RIGHT_LEFT
@ GD_RIGHT_LEFT
From left to right.
Definition: SkillerDebugInterface.h:64
fawkes::SkillerDebugInterface::SetGraphDirectionMessage
Definition: SkillerDebugInterface.h:114
fawkes::SkillerDebugInterface::SetGraphColoredMessage
Definition: SkillerDebugInterface.h:142
fawkes::SkillerDebugInterface::SetGraphDirectionMessage::clone
virtual Message * clone() const
Clone this message.
Definition: SkillerDebugInterface.cpp:483
fawkes::SkillerDebugInterface::message_valid
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
Definition: SkillerDebugInterface.cpp:594
fawkes::SkillerDebugInterface::SetGraphColoredMessage::maxlenof_graph_colored
size_t maxlenof_graph_colored() const
Get maximum length of graph_colored value.
Definition: SkillerDebugInterface.cpp:562
fawkes::SkillerDebugInterface::GD_LEFT_RIGHT
@ GD_LEFT_RIGHT
From left to right.
Definition: SkillerDebugInterface.h:63