Fawkes API  Fawkes Development Version
SkillerInterface.cpp
1 
2 /***************************************************************************
3  * SkillerInterface.cpp - Fawkes BlackBoard Interface - SkillerInterface
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/SkillerInterface.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 SkillerInterface <interfaces/SkillerInterface.h>
36  * SkillerInterface Fawkes BlackBoard Interface.
37  *
38  The interface provides access to the skill execution runtime plugin.
39  It provides basic status information about skiller and allows for
40  calling skills via messages. It can also be used to manually restart
41  the Lua interpreter if something is wedged.
42 
43  * @ingroup FawkesInterfaces
44  */
45 
46 
47 
48 /** Constructor */
49 SkillerInterface::SkillerInterface() : Interface()
50 {
51  data_size = sizeof(SkillerInterface_data_t);
52  data_ptr = malloc(data_size);
53  data = (SkillerInterface_data_t *)data_ptr;
54  data_ts = (interface_data_ts_t *)data_ptr;
55  memset(data_ptr, 0, data_size);
56  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
57  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
58  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
59  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
60  add_fieldinfo(IFT_STRING, "skill_string", 1024, data->skill_string);
61  add_fieldinfo(IFT_STRING, "error", 128, data->error);
62  add_fieldinfo(IFT_UINT32, "exclusive_controller", 1, &data->exclusive_controller);
63  add_fieldinfo(IFT_UINT32, "msgid", 1, &data->msgid);
64  add_fieldinfo(IFT_ENUM, "status", 1, &data->status, "SkillStatusEnum", &enum_map_SkillStatusEnum);
65  add_messageinfo("ExecSkillMessage");
66  add_messageinfo("RestartInterpreterMessage");
67  add_messageinfo("StopExecMessage");
68  add_messageinfo("AcquireControlMessage");
69  add_messageinfo("ReleaseControlMessage");
70  unsigned char tmp_hash[] = {0x99, 0x14, 0xe6, 0x2b, 0x7f, 0x3b, 0x80, 0xb, 0xbd, 0x35, 0x10, 0xc0, 0x7e, 0xb5, 0xdc, 0x55};
71  set_hash(tmp_hash);
72 }
73 
74 /** Destructor */
75 SkillerInterface::~SkillerInterface()
76 {
77  free(data_ptr);
78 }
79 /** Convert SkillStatusEnum constant to string.
80  * @param value value to convert to string
81  * @return constant value as string.
82  */
83 const char *
85 {
86  switch (value) {
87  case S_INACTIVE: return "S_INACTIVE";
88  case S_FINAL: return "S_FINAL";
89  case S_RUNNING: return "S_RUNNING";
90  case S_FAILED: return "S_FAILED";
91  default: return "UNKNOWN";
92  }
93 }
94 /* Methods */
95 /** Get skill_string value.
96  *
97  Currently executed skill string, at least the first 1023 bytes of it.
98  Must be properly null-terminated.
99 
100  * @return skill_string value
101  */
102 char *
104 {
105  return data->skill_string;
106 }
107 
108 /** Get maximum length of skill_string value.
109  * @return length of skill_string value, can be length of the array or number of
110  * maximum number of characters for a string
111  */
112 size_t
114 {
115  return 1024;
116 }
117 
118 /** Set skill_string value.
119  *
120  Currently executed skill string, at least the first 1023 bytes of it.
121  Must be properly null-terminated.
122 
123  * @param new_skill_string new skill_string value
124  */
125 void
126 SkillerInterface::set_skill_string(const char * new_skill_string)
127 {
128  strncpy(data->skill_string, new_skill_string, sizeof(data->skill_string));
129  data_changed = true;
130 }
131 
132 /** Get error value.
133  *
134  String describing the error. Can be set by a skill when it fails.
135 
136  * @return error value
137  */
138 char *
140 {
141  return data->error;
142 }
143 
144 /** Get maximum length of error value.
145  * @return length of error value, can be length of the array or number of
146  * maximum number of characters for a string
147  */
148 size_t
150 {
151  return 128;
152 }
153 
154 /** Set error value.
155  *
156  String describing the error. Can be set by a skill when it fails.
157 
158  * @param new_error new error value
159  */
160 void
161 SkillerInterface::set_error(const char * new_error)
162 {
163  strncpy(data->error, new_error, sizeof(data->error));
164  data_changed = true;
165 }
166 
167 /** Get exclusive_controller value.
168  *
169  Instance serial of the exclusive controller of the skiller. If this does not
170  carry your instance serial your exec messages will be ignored. Aquire control with
171  the AquireControlMessage. Make sure you release control before exiting.
172 
173  * @return exclusive_controller value
174  */
175 uint32_t
177 {
178  return data->exclusive_controller;
179 }
180 
181 /** Get maximum length of exclusive_controller value.
182  * @return length of exclusive_controller value, can be length of the array or number of
183  * maximum number of characters for a string
184  */
185 size_t
187 {
188  return 1;
189 }
190 
191 /** Set exclusive_controller value.
192  *
193  Instance serial of the exclusive controller of the skiller. If this does not
194  carry your instance serial your exec messages will be ignored. Aquire control with
195  the AquireControlMessage. Make sure you release control before exiting.
196 
197  * @param new_exclusive_controller new exclusive_controller value
198  */
199 void
200 SkillerInterface::set_exclusive_controller(const uint32_t new_exclusive_controller)
201 {
202  data->exclusive_controller = new_exclusive_controller;
203  data_changed = true;
204 }
205 
206 /** Get msgid value.
207  *
208  The ID of the message that is currently being processed,
209  or 0 if no message is being processed.
210 
211  * @return msgid value
212  */
213 uint32_t
215 {
216  return data->msgid;
217 }
218 
219 /** Get maximum length of msgid value.
220  * @return length of msgid value, can be length of the array or number of
221  * maximum number of characters for a string
222  */
223 size_t
225 {
226  return 1;
227 }
228 
229 /** Set msgid value.
230  *
231  The ID of the message that is currently being processed,
232  or 0 if no message is being processed.
233 
234  * @param new_msgid new msgid value
235  */
236 void
237 SkillerInterface::set_msgid(const uint32_t new_msgid)
238 {
239  data->msgid = new_msgid;
240  data_changed = true;
241 }
242 
243 /** Get status value.
244  *
245  The status of the current skill execution.
246 
247  * @return status value
248  */
251 {
252  return (SkillerInterface::SkillStatusEnum)data->status;
253 }
254 
255 /** Get maximum length of status value.
256  * @return length of status value, can be length of the array or number of
257  * maximum number of characters for a string
258  */
259 size_t
261 {
262  return 1;
263 }
264 
265 /** Set status value.
266  *
267  The status of the current skill execution.
268 
269  * @param new_status new status value
270  */
271 void
273 {
274  data->status = new_status;
275  data_changed = true;
276 }
277 
278 /* =========== message create =========== */
279 Message *
281 {
282  if ( strncmp("ExecSkillMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
283  return new ExecSkillMessage();
284  } else if ( strncmp("RestartInterpreterMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
285  return new RestartInterpreterMessage();
286  } else if ( strncmp("StopExecMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
287  return new StopExecMessage();
288  } else if ( strncmp("AcquireControlMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
289  return new AcquireControlMessage();
290  } else if ( strncmp("ReleaseControlMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
291  return new ReleaseControlMessage();
292  } else {
293  throw UnknownTypeException("The given type '%s' does not match any known "
294  "message type for this interface type.", type);
295  }
296 }
297 
298 
299 /** Copy values from other interface.
300  * @param other other interface to copy values from
301  */
302 void
304 {
305  const SkillerInterface *oi = dynamic_cast<const SkillerInterface *>(other);
306  if (oi == NULL) {
307  throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
308  type(), other->type());
309  }
310  memcpy(data, oi->data, sizeof(SkillerInterface_data_t));
311 }
312 
313 const char *
314 SkillerInterface::enum_tostring(const char *enumtype, int val) const
315 {
316  if (strcmp(enumtype, "SkillStatusEnum") == 0) {
317  return tostring_SkillStatusEnum((SkillStatusEnum)val);
318  }
319  throw UnknownTypeException("Unknown enum type %s", enumtype);
320 }
321 
322 /* =========== messages =========== */
323 /** @class SkillerInterface::ExecSkillMessage <interfaces/SkillerInterface.h>
324  * ExecSkillMessage Fawkes BlackBoard Interface Message.
325  *
326 
327  */
328 
329 
330 /** Constructor with initial values.
331  * @param ini_skill_string initial value for skill_string
332  */
333 SkillerInterface::ExecSkillMessage::ExecSkillMessage(const char * ini_skill_string) : Message("ExecSkillMessage")
334 {
335  data_size = sizeof(ExecSkillMessage_data_t);
336  data_ptr = malloc(data_size);
337  memset(data_ptr, 0, data_size);
338  data = (ExecSkillMessage_data_t *)data_ptr;
340  strncpy(data->skill_string, ini_skill_string, 1024);
341  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
342  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
343  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
344  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
345  add_fieldinfo(IFT_STRING, "skill_string", 1024, data->skill_string);
346 }
347 /** Constructor */
349 {
350  data_size = sizeof(ExecSkillMessage_data_t);
351  data_ptr = malloc(data_size);
352  memset(data_ptr, 0, data_size);
353  data = (ExecSkillMessage_data_t *)data_ptr;
355  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
356  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
357  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
358  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
359  add_fieldinfo(IFT_STRING, "skill_string", 1024, data->skill_string);
360 }
361 
362 /** Destructor */
364 {
365  free(data_ptr);
366 }
367 
368 /** Copy constructor.
369  * @param m message to copy from
370  */
372 {
373  data_size = m->data_size;
374  data_ptr = malloc(data_size);
375  memcpy(data_ptr, m->data_ptr, data_size);
376  data = (ExecSkillMessage_data_t *)data_ptr;
378 }
379 
380 /* Methods */
381 /** Get skill_string value.
382  *
383  Currently executed skill string, at least the first 1023 bytes of it.
384  Must be properly null-terminated.
385 
386  * @return skill_string value
387  */
388 char *
390 {
391  return data->skill_string;
392 }
393 
394 /** Get maximum length of skill_string value.
395  * @return length of skill_string value, can be length of the array or number of
396  * maximum number of characters for a string
397  */
398 size_t
400 {
401  return 1024;
402 }
403 
404 /** Set skill_string value.
405  *
406  Currently executed skill string, at least the first 1023 bytes of it.
407  Must be properly null-terminated.
408 
409  * @param new_skill_string new skill_string value
410  */
411 void
413 {
414  strncpy(data->skill_string, new_skill_string, sizeof(data->skill_string));
415 }
416 
417 /** Clone this message.
418  * Produces a message of the same type as this message and copies the
419  * data to the new message.
420  * @return clone of this message
421  */
422 Message *
424 {
425  return new SkillerInterface::ExecSkillMessage(this);
426 }
427 /** @class SkillerInterface::RestartInterpreterMessage <interfaces/SkillerInterface.h>
428  * RestartInterpreterMessage Fawkes BlackBoard Interface Message.
429  *
430 
431  */
432 
433 
434 /** Constructor */
436 {
437  data_size = sizeof(RestartInterpreterMessage_data_t);
438  data_ptr = malloc(data_size);
439  memset(data_ptr, 0, data_size);
440  data = (RestartInterpreterMessage_data_t *)data_ptr;
442  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
443  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
444  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
445  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
446 }
447 
448 /** Destructor */
450 {
451  free(data_ptr);
452 }
453 
454 /** Copy constructor.
455  * @param m message to copy from
456  */
458 {
459  data_size = m->data_size;
460  data_ptr = malloc(data_size);
461  memcpy(data_ptr, m->data_ptr, data_size);
462  data = (RestartInterpreterMessage_data_t *)data_ptr;
464 }
465 
466 /* Methods */
467 /** Clone this message.
468  * Produces a message of the same type as this message and copies the
469  * data to the new message.
470  * @return clone of this message
471  */
472 Message *
474 {
476 }
477 /** @class SkillerInterface::StopExecMessage <interfaces/SkillerInterface.h>
478  * StopExecMessage Fawkes BlackBoard Interface Message.
479  *
480 
481  */
482 
483 
484 /** Constructor */
486 {
487  data_size = sizeof(StopExecMessage_data_t);
488  data_ptr = malloc(data_size);
489  memset(data_ptr, 0, data_size);
490  data = (StopExecMessage_data_t *)data_ptr;
492  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
493  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
494  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
495  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
496 }
497 
498 /** Destructor */
500 {
501  free(data_ptr);
502 }
503 
504 /** Copy constructor.
505  * @param m message to copy from
506  */
508 {
509  data_size = m->data_size;
510  data_ptr = malloc(data_size);
511  memcpy(data_ptr, m->data_ptr, data_size);
512  data = (StopExecMessage_data_t *)data_ptr;
514 }
515 
516 /* Methods */
517 /** Clone this message.
518  * Produces a message of the same type as this message and copies the
519  * data to the new message.
520  * @return clone of this message
521  */
522 Message *
524 {
525  return new SkillerInterface::StopExecMessage(this);
526 }
527 /** @class SkillerInterface::AcquireControlMessage <interfaces/SkillerInterface.h>
528  * AcquireControlMessage Fawkes BlackBoard Interface Message.
529  *
530 
531  */
532 
533 
534 /** Constructor with initial values.
535  * @param ini_steal_control initial value for steal_control
536  */
537 SkillerInterface::AcquireControlMessage::AcquireControlMessage(const bool ini_steal_control) : Message("AcquireControlMessage")
538 {
539  data_size = sizeof(AcquireControlMessage_data_t);
540  data_ptr = malloc(data_size);
541  memset(data_ptr, 0, data_size);
542  data = (AcquireControlMessage_data_t *)data_ptr;
544  data->steal_control = ini_steal_control;
545  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
546  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
547  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
548  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
549  add_fieldinfo(IFT_BOOL, "steal_control", 1, &data->steal_control);
550 }
551 /** Constructor */
553 {
554  data_size = sizeof(AcquireControlMessage_data_t);
555  data_ptr = malloc(data_size);
556  memset(data_ptr, 0, data_size);
557  data = (AcquireControlMessage_data_t *)data_ptr;
559  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
560  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
561  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
562  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
563  add_fieldinfo(IFT_BOOL, "steal_control", 1, &data->steal_control);
564 }
565 
566 /** Destructor */
568 {
569  free(data_ptr);
570 }
571 
572 /** Copy constructor.
573  * @param m message to copy from
574  */
576 {
577  data_size = m->data_size;
578  data_ptr = malloc(data_size);
579  memcpy(data_ptr, m->data_ptr, data_size);
580  data = (AcquireControlMessage_data_t *)data_ptr;
582 }
583 
584 /* Methods */
585 /** Get steal_control value.
586  *
587  If set to true steal the control from someone else who has it
588  atm. Use this with caution. But sometimes it is necessary to
589  ensure a successful operation, e.g. if the agent tries to
590  acquire control.
591 
592  * @return steal_control value
593  */
594 bool
596 {
597  return data->steal_control;
598 }
599 
600 /** Get maximum length of steal_control value.
601  * @return length of steal_control value, can be length of the array or number of
602  * maximum number of characters for a string
603  */
604 size_t
606 {
607  return 1;
608 }
609 
610 /** Set steal_control value.
611  *
612  If set to true steal the control from someone else who has it
613  atm. Use this with caution. But sometimes it is necessary to
614  ensure a successful operation, e.g. if the agent tries to
615  acquire control.
616 
617  * @param new_steal_control new steal_control value
618  */
619 void
621 {
622  data->steal_control = new_steal_control;
623 }
624 
625 /** Clone this message.
626  * Produces a message of the same type as this message and copies the
627  * data to the new message.
628  * @return clone of this message
629  */
630 Message *
632 {
634 }
635 /** @class SkillerInterface::ReleaseControlMessage <interfaces/SkillerInterface.h>
636  * ReleaseControlMessage Fawkes BlackBoard Interface Message.
637  *
638 
639  */
640 
641 
642 /** Constructor */
644 {
645  data_size = sizeof(ReleaseControlMessage_data_t);
646  data_ptr = malloc(data_size);
647  memset(data_ptr, 0, data_size);
648  data = (ReleaseControlMessage_data_t *)data_ptr;
650  enum_map_SkillStatusEnum[(int)S_INACTIVE] = "S_INACTIVE";
651  enum_map_SkillStatusEnum[(int)S_FINAL] = "S_FINAL";
652  enum_map_SkillStatusEnum[(int)S_RUNNING] = "S_RUNNING";
653  enum_map_SkillStatusEnum[(int)S_FAILED] = "S_FAILED";
654 }
655 
656 /** Destructor */
658 {
659  free(data_ptr);
660 }
661 
662 /** Copy constructor.
663  * @param m message to copy from
664  */
666 {
667  data_size = m->data_size;
668  data_ptr = malloc(data_size);
669  memcpy(data_ptr, m->data_ptr, data_size);
670  data = (ReleaseControlMessage_data_t *)data_ptr;
672 }
673 
674 /* Methods */
675 /** Clone this message.
676  * Produces a message of the same type as this message and copies the
677  * data to the new message.
678  * @return clone of this message
679  */
680 Message *
682 {
684 }
685 /** Check if message is valid and can be enqueued.
686  * @param message Message to check
687  * @return true if the message is valid, false otherwise.
688  */
689 bool
691 {
692  const ExecSkillMessage *m0 = dynamic_cast<const ExecSkillMessage *>(message);
693  if ( m0 != NULL ) {
694  return true;
695  }
696  const RestartInterpreterMessage *m1 = dynamic_cast<const RestartInterpreterMessage *>(message);
697  if ( m1 != NULL ) {
698  return true;
699  }
700  const StopExecMessage *m2 = dynamic_cast<const StopExecMessage *>(message);
701  if ( m2 != NULL ) {
702  return true;
703  }
704  const AcquireControlMessage *m3 = dynamic_cast<const AcquireControlMessage *>(message);
705  if ( m3 != NULL ) {
706  return true;
707  }
708  const ReleaseControlMessage *m4 = dynamic_cast<const ReleaseControlMessage *>(message);
709  if ( m4 != NULL ) {
710  return true;
711  }
712  return false;
713 }
714 
715 /// @cond INTERNALS
716 EXPORT_INTERFACE(SkillerInterface)
717 /// @endcond
718 
719 
720 } // end namespace fawkes
char * skill_string() const
Get skill_string value.
size_t maxlenof_error() const
Get maximum length of error value.
void * data_ptr
Pointer to memory that contains local data.
Definition: message.h:124
virtual Message * clone() const
Clone this message.
Base class for all messages passed through interfaces in Fawkes BlackBoard.
Definition: message.h:44
The skill string has been successfully processed.
void set_steal_control(const bool new_steal_control)
Set steal_control value.
size_t maxlenof_skill_string() const
Get maximum length of skill_string value.
void set_hash(unsigned char *ihash)
Set hash.
Definition: interface.cpp:314
void set_exclusive_controller(const uint32_t new_exclusive_controller)
Set exclusive_controller value.
Fawkes library namespace.
Timestamp data, must be present and first entries for each interface data structs! This leans on time...
Definition: message.h:129
size_t maxlenof_msgid() const
Get maximum length of msgid value.
void set_skill_string(const char *new_skill_string)
Set skill_string value.
char * skill_string() const
Get skill_string value.
StopExecMessage Fawkes BlackBoard Interface Message.
virtual Message * clone() const
Clone this message.
virtual void copy_values(const Interface *other)
Copy values from other interface.
string field
Definition: types.h:47
char * error() const
Get error value.
ReleaseControlMessage Fawkes BlackBoard Interface Message.
SkillStatusEnum
This determines the current status of skill execution.
uint32_t exclusive_controller() const
Get exclusive_controller value.
Base class for all Fawkes BlackBoard interfaces.
Definition: interface.h:79
AcquireControlMessage Fawkes BlackBoard Interface Message.
virtual Message * clone() const
Clone this message.
virtual Message * clone() const
Clone this message.
message_data_ts_t * data_ts
data timestamp aliasing pointer
Definition: message.h:133
unsigned int data_size
Size of memory needed to hold all data.
Definition: message.h:125
size_t maxlenof_exclusive_controller() const
Get maximum length of exclusive_controller value.
void add_messageinfo(const char *name)
Add an entry to the message info list.
Definition: interface.cpp:373
bool data_changed
Indicator if data has changed.
Definition: interface.h:222
void set_error(const char *new_error)
Set error value.
const char * type() const
Get type of interface.
Definition: interface.cpp:651
virtual bool message_valid(const Message *message) const
Check if message is valid and can be enqueued.
virtual Message * clone() const
Clone this message.
virtual const char * enum_tostring(const char *enumtype, int val) const
Convert arbitrary enum value to string.
SkillStatusEnum status() const
Get status value.
ExecSkillMessage Fawkes BlackBoard Interface Message.
size_t maxlenof_skill_string() const
Get maximum length of skill_string value.
size_t maxlenof_status() const
Get maximum length of status value.
RestartInterpreterMessage Fawkes BlackBoard Interface Message.
The execution failed and cannot succeed anymore.
void set_skill_string(const char *new_skill_string)
Set skill_string value.
uint32_t msgid() const
Get msgid value.
SkillerInterface Fawkes BlackBoard Interface.
bool is_steal_control() const
Get steal_control value.
size_t maxlenof_steal_control() const
Get maximum length of steal_control value.
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:436
void set_status(const SkillStatusEnum new_status)
Set status value.
virtual Message * create_message(const char *type) const
Create message based on type name.
boolean field
Definition: types.h:36
const char * tostring_SkillStatusEnum(SkillStatusEnum value) const
Convert SkillStatusEnum constant to string.
The execution is still running.
const char * type() const
Get message type.
Definition: message.cpp:378
void set_msgid(const uint32_t new_msgid)
Set msgid value.
32 bit unsigned integer field
Definition: types.h:42
field with interface specific enum type
Definition: types.h:49