00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef __INTERFACES_SKILLERINTERFACE_H_
00025 #define __INTERFACES_SKILLERINTERFACE_H_
00026
00027 #include <interface/interface.h>
00028 #include <interface/message.h>
00029 #include <interface/field_iterator.h>
00030
00031 namespace fawkes {
00032
00033 class SkillerInterface : public Interface
00034 {
00035
00036 INTERFACE_MGMT_FRIENDS(SkillerInterface)
00037
00038 public:
00039
00040
00041
00042
00043
00044 typedef enum {
00045 S_INACTIVE ,
00046 S_FINAL ,
00047 S_RUNNING ,
00048 S_FAILED
00049 } SkillStatusEnum;
00050 const char * tostring_SkillStatusEnum(SkillStatusEnum value) const;
00051
00052 private:
00053 #pragma pack(push,4)
00054
00055 typedef struct {
00056 int64_t timestamp_sec;
00057 int64_t timestamp_usec;
00058 char skill_string[1024];
00059
00060
00061
00062 char error[128];
00063
00064
00065 uint32_t exclusive_controller;
00066
00067
00068
00069
00070 SkillStatusEnum status;
00071
00072
00073 bool continuous;
00074
00075
00076
00077 } SkillerInterface_data_t;
00078 #pragma pack(pop)
00079
00080 SkillerInterface_data_t *data;
00081
00082 public:
00083
00084 class ExecSkillMessage : public Message
00085 {
00086 private:
00087 #pragma pack(push,4)
00088
00089 typedef struct {
00090 int64_t timestamp_sec;
00091 int64_t timestamp_usec;
00092 char skill_string[1024];
00093
00094
00095
00096 } ExecSkillMessage_data_t;
00097 #pragma pack(pop)
00098
00099 ExecSkillMessage_data_t *data;
00100
00101 public:
00102 ExecSkillMessage(const char * ini_skill_string);
00103 ExecSkillMessage();
00104 ~ExecSkillMessage();
00105
00106 ExecSkillMessage(const ExecSkillMessage *m);
00107
00108 char * skill_string() const;
00109 void set_skill_string(const char * new_skill_string);
00110 size_t maxlenof_skill_string() const;
00111 virtual Message * clone() const;
00112 };
00113
00114 class ExecSkillContinuousMessage : public Message
00115 {
00116 private:
00117 #pragma pack(push,4)
00118
00119 typedef struct {
00120 int64_t timestamp_sec;
00121 int64_t timestamp_usec;
00122 char skill_string[1024];
00123
00124
00125
00126 } ExecSkillContinuousMessage_data_t;
00127 #pragma pack(pop)
00128
00129 ExecSkillContinuousMessage_data_t *data;
00130
00131 public:
00132 ExecSkillContinuousMessage(const char * ini_skill_string);
00133 ExecSkillContinuousMessage();
00134 ~ExecSkillContinuousMessage();
00135
00136 ExecSkillContinuousMessage(const ExecSkillContinuousMessage *m);
00137
00138 char * skill_string() const;
00139 void set_skill_string(const char * new_skill_string);
00140 size_t maxlenof_skill_string() const;
00141 virtual Message * clone() const;
00142 };
00143
00144 class RestartInterpreterMessage : public Message
00145 {
00146 private:
00147 #pragma pack(push,4)
00148
00149 typedef struct {
00150 int64_t timestamp_sec;
00151 int64_t timestamp_usec;
00152 } RestartInterpreterMessage_data_t;
00153 #pragma pack(pop)
00154
00155 RestartInterpreterMessage_data_t *data;
00156
00157 public:
00158 RestartInterpreterMessage();
00159 ~RestartInterpreterMessage();
00160
00161 RestartInterpreterMessage(const RestartInterpreterMessage *m);
00162
00163 virtual Message * clone() const;
00164 };
00165
00166 class StopExecMessage : public Message
00167 {
00168 private:
00169 #pragma pack(push,4)
00170
00171 typedef struct {
00172 int64_t timestamp_sec;
00173 int64_t timestamp_usec;
00174 } StopExecMessage_data_t;
00175 #pragma pack(pop)
00176
00177 StopExecMessage_data_t *data;
00178
00179 public:
00180 StopExecMessage();
00181 ~StopExecMessage();
00182
00183 StopExecMessage(const StopExecMessage *m);
00184
00185 virtual Message * clone() const;
00186 };
00187
00188 class AcquireControlMessage : public Message
00189 {
00190 private:
00191 #pragma pack(push,4)
00192
00193 typedef struct {
00194 int64_t timestamp_sec;
00195 int64_t timestamp_usec;
00196 } AcquireControlMessage_data_t;
00197 #pragma pack(pop)
00198
00199 AcquireControlMessage_data_t *data;
00200
00201 public:
00202 AcquireControlMessage();
00203 ~AcquireControlMessage();
00204
00205 AcquireControlMessage(const AcquireControlMessage *m);
00206
00207 virtual Message * clone() const;
00208 };
00209
00210 class ReleaseControlMessage : public Message
00211 {
00212 private:
00213 #pragma pack(push,4)
00214
00215 typedef struct {
00216 int64_t timestamp_sec;
00217 int64_t timestamp_usec;
00218 } ReleaseControlMessage_data_t;
00219 #pragma pack(pop)
00220
00221 ReleaseControlMessage_data_t *data;
00222
00223 public:
00224 ReleaseControlMessage();
00225 ~ReleaseControlMessage();
00226
00227 ReleaseControlMessage(const ReleaseControlMessage *m);
00228
00229 virtual Message * clone() const;
00230 };
00231
00232 virtual bool message_valid(const Message *message) const;
00233 private:
00234 SkillerInterface();
00235 ~SkillerInterface();
00236
00237 public:
00238
00239 char * skill_string() const;
00240 void set_skill_string(const char * new_skill_string);
00241 size_t maxlenof_skill_string() const;
00242 char * error() const;
00243 void set_error(const char * new_error);
00244 size_t maxlenof_error() const;
00245 uint32_t exclusive_controller() const;
00246 void set_exclusive_controller(const uint32_t new_exclusive_controller);
00247 size_t maxlenof_exclusive_controller() const;
00248 SkillStatusEnum status() const;
00249 void set_status(const SkillStatusEnum new_status);
00250 size_t maxlenof_status() const;
00251 bool is_continuous() const;
00252 void set_continuous(const bool new_continuous);
00253 size_t maxlenof_continuous() const;
00254 virtual Message * create_message(const char *type) const;
00255
00256 virtual void copy_values(const Interface *other);
00257 virtual const char * enum_tostring(const char *enumtype, int val) const;
00258
00259 };
00260
00261 }
00262
00263 #endif