lib/misc/state-machine/ico_StateMachine_CWrapper.cpp

   1 /*
   2  * Copyright (c) 2013 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Contact:
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the License){}
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an AS IS BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18 #include <vector>
  19 #include <iostream>
  20 #include <string>
  21 #include <vector>
  22 #include <fstream>
  23
  24 #include "CicoEvent.h"
  25 #include "CicoEventInfo.h"
  26 #include "CicoStateAction.h"
  27 #include "CicoStateCore.h"
  28 #include "CicoState.h"
  29 #include "CicoHistoryState.h"
  30 #include "CicoFinalState.h"
  31 #include "CicoStateMachine.h"
  32 #include "CicoStateMachineCreator.h"
  33 #include "ico_StateMachine_CWrapper.h"
  34 #include "CicoStateInternal.h"
  35
  36 /**
  37  * stateMachine C Wrapper functions
  38  */
  39
  40 static std::vector<CicoStateCore*>  stateObjects;
  41 static std::vector<CicoEventInfo*>  evInfObjects;
  42 static std::vector<void*>           callbackFnc;
  43
  44 StateMachineCWrapperErr_E sttmerr;
  45
  46
  47 /**
  48  * @brief GCOpKind
  49  * @      Definitions used in the function ico_sttm_addTransitionGCI ,
  50  * @      ico_sttm_addTransitionGCD , ico_sttm_addTransitionGCS
  51  * @      ico_sttm_addGCI , ico_sttm_addGCD , ico_sttm_addGCS
  52  */
  53 const char* GCOpKind[] = {
  54     "",
  55     DEFJGCE_EQ,     // "="   Guard condition is equal to
  56     DEFJGCE_NE,     // "!="  Guard condition is not equal to
  57     DEFJGCE_LT,     // "<"   Guard condition is less than
  58     DEFJGCE_LE,     // "<="  Guard condition is less than or equal
  59     DEFJGCE_GT,     // ">"   Guard condition is greater than
  60     DEFJGCE_GE,     // ">="  Guard condition is greater than or equal
  61     DEFJGCE_IN,     // "in"  Guard condition is the state of the state-object
  62     DEFJGCE_NOT,    // "not" Guard condition is the state of the state-object
  63 };
  64
  65 /**
  66  * @brief getID2ObjSTT
  67  * @      c-wrapper local ID to CicoStateCore pointer
  68  * @param id c-wrapper local ID
  69  * @return not 0:get success
  70  * @       0:get faile
  71  */
  72 CicoStateCore* getID2ObjSTT(int id)
  73 {
  74     int sz = stateObjects.size();
  75     if ((1 > id) || (id > sz)) {
  76         return (CicoStateCore*)0;
  77     }
  78     return stateObjects[(id-1)];
  79 }
  80
  81
  82 /**
  83  * @brief getID2ObjSTTX
  84  * @      c-wrapper local ID to CicoStateCore pointer
  85  * @param id c-wrapper local ID
  86  * @return not 0:get success
  87  * @       0:get faile
  88  */
  89 extern "C" void* getID2ObjSTTX(int id)
  90 {
  91     return (void*)getID2ObjSTT(id);
  92 }
  93
  94 /**
  95  * @brief getObjSTT2ID
  96  * @      CicoStateCore pointer to c-wrapper local ID
  97  * @param stt
  98  * @return not 0:get success(c-wrapper local ID)
  99  * @       0:get faile
 100  */
 101 int getObjSTT2ID(const CicoStateCore* stt)
 102 {
 103     int r = 0;
 104     int sz = stateObjects.size();
 105     for (int i=0; i<sz; i++) {
 106         if (stt == stateObjects[i]) {
 107             r = i+1;
 108             break;                      // break of for i<sz
 109         }
 110     }
 111     return r;
 112 }
 113
 114 /**
 115  * @brief getID2ObjEV
 116  * @      c-wrapper local ID to CicoEventInfo pointer
 117  * @param id c-wrapper local ID
 118  * @return not 0:CicoEventInfo pointer
 119  * @       0:get faile
 120  */
 121 CicoEventInfo*  getID2ObjEV(int id)
 122 {
 123     int sz = evInfObjects.size();
 124     if ((1 > id) || (id > sz)) {
 125         return (CicoEventInfo*)0;
 126     }
 127     return evInfObjects[(id-1)];
 128 }
 129
 130 /**
 131  * @brief supplementName
 132  * @      supplement name
 133  * @param name
 134  * @return supplement name
 135  */
 136 const char* supplementName(const char* name)
 137 {
 138     static const char* emptychar = "";
 139     if ((char*)0 == name) {
 140         return emptychar;
 141     }
 142     return name;
 143 }
 144
 145 /* Registration system */
 146 /**
 147  * @brief Create an stateMachine-object and state-object with the specified file
 148  * @param file faile path pseudo-json
 149  * @return not 0:stateMachine-object Id no.(c-wrapper local ID)
 150  * @       0:create error
 151  */
 152 extern "C" int ico_sttm_createStateMachineFile(const char* file)
 153 {
 154     sttmerr = STTMNOERROR;
 155     CicoStateMachineCreator csmc;
 156     CicoStateMachine* csm = csmc.createFile(file);
 157     if ((CicoStateMachine*)0 == csm) {
 158         sttmerr = STTMCREATEERR;
 159         _DBG("ico_sttm_createStateMachineFile %s", csmc.getError().c_str());
 160         return 0;
 161     }
 162     csm->getObjects(stateObjects);
 163     int r = 0;
 164     int sz = stateObjects.size();
 165     for (int i = 0; i < sz; i++) {
 166         if (stateObjects[i] == csm) {   // match object pointer
 167             r = i+1;                    // get return value
 168             break;                      // break of for i<sz
 169         }
 170     }
 171     return r;
 172 }
 173
 174
 175 /**
 176  * @brief Create an stateMachine-object and state-object with the specified text
 177  * @param buff text pseudo-json
 178  * @return not 0:stateMachine-object ID no.(c-wrapper local ID)
 179  * @       0:create error
 180  */
 181 extern "C" int ico_sttm_createStateMachineText(const char* buff)
 182 {
 183     sttmerr = STTMNOERROR;
 184     CicoStateMachineCreator csmc;
 185     CicoStateMachine* csm = csmc.create(buff);
 186     if ((CicoStateMachine*)0 == csm) {
 187         sttmerr = STTMCREATEERR;
 188         _DBG("ico_sttm_createStateMachineText %s", csmc.getError().c_str());
 189         return 0;
 190     }
 191     csm->getObjects(stateObjects);      // get all state-objects
 192     int r = 0;                          //
 193     int sz = stateObjects.size();       //
 194     for (int i = 0; i < sz; i++) {      //
 195         if (stateObjects[i] == csm) {   // match object pointer
 196             r = i+1;                    // get return value
 197             break;                      // break of for i<sz
 198         }
 199     }
 200     return r;
 201 }
 202
 203 /**
 204  * @brief Create stateMachine-object
 205  * @param name stateMachine-object name (Option)
 206  * @param value stateMachine-object ID no.
 207  * @return not 0:stateMachine-object ID no.(c-wrapper local ID)
 208  * @       0:create error
 209  */
 210 extern "C" int ico_sttm_createStateMachine(const char* name, int value)
 211 {
 212     sttmerr = STTMNOERROR;
 213     CicoStateMachine* csm;
 214     const char* sname = supplementName(name);
 215     csm = new CicoStateMachine(sname, value);
 216     if ((CicoStateMachine*)0 == csm) {
 217         sttmerr = STTMNEWERR;
 218         _ERR("ico_sttm_createStateMachine \"%s\", %d", sname, value);
 219         return 0;
 220     }
 221     stateObjects.push_back(csm);
 222     return stateObjects.size();
 223 }
 224
 225 /**
 226  * @brief Create state-object
 227  * @param parent parent ID no.(c-wrapper local ID)
 228  * @param name state-object name (Option)
 229  * @param value state-object ID no.
 230  * @return not 0:state-object ID no.(c-wrapper local ID)
 231  * @       0:create faile
 232  */
 233 extern "C" int ico_sttm_createState(int parent, const char* name, int value)
 234 {
 235     sttmerr = STTMNOERROR;
 236     const char* sname = supplementName(name);
 237     CicoStateCore* cscParent = getID2ObjSTT(parent); // ID to state-object
 238     if ((CicoStateCore*)0 == cscParent) {
 239         sttmerr = STTMNOTFIND;
 240         _DBG("ico_sttm_createState >>%d<<, \"%s\", %d", parent, sname,value);
 241         return 0;
 242     }
 243     CicoState* cs = (CicoState*)0;
 244     if (cscParent->isStateMachine()) {
 245         cs = new CicoState(sname, value, (CicoStateMachine*)cscParent);
 246     }
 247     else if (cscParent->isState()) {
 248         cs = new CicoState(sname, value, (CicoState*)cscParent);
 249     }
 250     if ((CicoState*)0 == cs) {
 251         sttmerr = STTMNEWERR;
 252         _ERR("ico_sttm_createState %d(%s:%d:%d), \"%s\", %d",
 253              parent, cscParent->getName().c_str(), cscParent->getValue(),
 254              (int)cscParent->getType(), sname, value);
 255         return 0;
 256     }
 257     stateObjects.push_back(cs);
 258     return stateObjects.size();
 259 }
 260
 261 /**
 262  * @brief Create historyState-object
 263  * @param parent parent ID no.(c-wrapper local ID)
 264  * @param name historyState-object name (Option)
 265  * @param value historyState-object ID no.
 266  * @return not 0:historyState-object ID no.(c-wrapper local ID)
 267  * @       0:create error
 268  */
 269 extern "C" int ico_sttm_createHState(int parent, const char* name, int value,
 270                                  HISTORY_TYPE_E typ)
 271 {
 272     sttmerr = STTMNOERROR;
 273     const char* sname = supplementName(name);
 274     CicoStateCore* cscParent = getID2ObjSTT(parent); // ID to state-object
 275     if ((CicoStateCore*)0 == cscParent) {
 276         sttmerr = STTMNOTFIND;
 277         _DBG("ico_sttm_createHState >>%d<<, \"%s\", %d, %d", parent, sname, value, (int)typ);
 278         return 0;
 279     }
 280     CicoHistoryState* chs = (CicoHistoryState*)0;
 281     if (cscParent->isStateMachine()) {
 282         chs = new CicoHistoryState(sname, value, (CicoStateMachine*)cscParent);
 283     }
 284     else if (cscParent->isState()) {
 285         chs = new CicoHistoryState(sname, value, (CicoState*)cscParent);
 286     }
 287     if ((CicoHistoryState*)0 == chs) {
 288         sttmerr = STTMNEWERR;
 289         _ERR("ico_sttm_createHState >>%d(%s:%d:%d)<<, \"%s\", %d, %d",
 290              parent, cscParent->getName().c_str(), cscParent->getValue(),
 291              (int)cscParent->getType(), sname, value, (int)typ);
 292         return 0;
 293     }
 294     if (E_SHALLOW == typ) {
 295         chs->setHistoryType(CicoHistoryState::Shallow);
 296     }
 297     else if (E_DEEP == typ) {
 298         chs->setHistoryType(CicoHistoryState::Deep);
 299     }
 300     else {
 301         sttmerr = STTMPARAMERR;
 302         _DBG("ico_sttm_createHState %d(%s:%d:%d), \"%s\", %d,>>%d<<",
 303              parent, cscParent->getName().c_str(), cscParent->getValue(),
 304              (int)cscParent->getType(), sname, value, (int)typ);
 305         delete chs;
 306         return 0;
 307     }
 308     stateObjects.push_back((CicoStateCore*)chs);
 309     return stateObjects.size();
 310 }
 311
 312 /**
 313  * @brief Create finalState-object
 314  * @param parent parent ID no.(c-wrapper local ID)
 315  * @param name finalState-object name (Option)
 316  * @param value finalState-object ID no.
 317  * @return not 0:finalState-object ID no.(c-wrapper local ID)
 318  * @       0:create error
 319  */
 320 extern "C" int ico_sttm_createFState(int parent, const char* name, int value)
 321 {
 322     sttmerr = STTMNOERROR;
 323     const char* sname = supplementName(name);
 324     CicoStateCore* cscParent = getID2ObjSTT(parent); // ID to state-object
 325     if ((CicoStateCore*)0 == cscParent) {
 326         sttmerr = STTMNOTFIND;
 327         _DBG("ico_sttm_createFState >>%d<<, \"%s\", %d", parent, sname, value);
 328         return 0;
 329     }
 330     CicoFinalState* cfs = (CicoFinalState*)0;
 331     if (cscParent->isStateMachine()) {
 332         cfs = new CicoFinalState(sname, value, (CicoStateMachine*)cscParent);
 333     }
 334     else if (cscParent->isState()) {
 335         cfs = new CicoFinalState(sname, value, (CicoState*)cscParent);
 336     }
 337     if ((CicoFinalState*)0 == cfs) {
 338         sttmerr = STTMNEWERR;
 339         _ERR("ico_sttm_createFState >>%d(%s:%d:%d)<<, \"%s\", %d",
 340              parent, cscParent->getName().c_str(), cscParent->getValue(),
 341              (int)cscParent->getType(), sname, value);
 342         return 0;
 343     }
 344     stateObjects.push_back((CicoStateCore*)cfs);
 345     return stateObjects.size();
 346 }
 347
 348 /**
 349  * @brief Registration of transition events
 350  * @param sCWId ID no. to be registered(c-wrapper local ID)
 351  * @param trCWId of transition destination(c-wrapper local ID)
 352  * @param evi Registration event
 353  * @param fname function name of the caller
 354  * @return not 0:ID no. of the event to register(c-wrapper local ID)
 355  * @       0:added error
 356  */
 357 int ico_sttm_addTransitionX(int sCWId, int trCWId, CicoEventInfo& evi,
 358                       const char* fname)
 359 {
 360     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
 361     if ((CicoStateCore*)0 == cscTarget) {
 362         sttmerr = STTMNOTFIND;
 363         _DBG("%s >>%d<<, \"%s\", %d, ..., %d",
 364              fname, sCWId, evi.getName().c_str(), (int)evi.getEV(),
 365              trCWId);
 366         return 0;
 367     }
 368     CicoStateCore* cscTrans = getID2ObjSTT(trCWId); // ID to state-object
 369     if ((CicoStateCore*)0 == cscTrans) {
 370         sttmerr = STTMNOTFIND;
 371         _DBG("%s %d, \"%s\", %d, ...,>>%d<<",
 372              fname, sCWId, evi.getName().c_str(), (int)evi.getEV(),
 373              trCWId);
 374         return 0;
 375     }
 376     if (false == cscTarget->isState()) {
 377         sttmerr = STTMTYPEMISMATCH;
 378         _DBG("%s >>%d(%s:%d:%d)<<, \"%s\", %d, ..., %d",
 379              fname, sCWId, cscTarget->getName().c_str(),
 380              cscTarget->getValue(), (int)cscTarget->getType(),
 381              evi.getName().c_str(), (int)evi.getEV(), trCWId);
 382         return 0;
 383     }
 384     CicoState* csTgt = (CicoState*)cscTarget;
 385     if (true == cscTrans->isState()) {
 386         csTgt->addTransition(evi, (CicoState*)cscTrans);
 387     }
 388     else if (true == cscTrans->isFinalState()) {
 389         csTgt->addTransition(evi, (CicoFinalState*)cscTrans);
 390     }
 391     else if (true == cscTrans->isHistoryState()) {
 392         csTgt->addTransition(evi, (CicoHistoryState*)cscTrans);
 393     }
 394     else {
 395         sttmerr = STTMTYPEMISMATCH;
 396         _DBG("%s %d, \"%s\", %d, ...,>>%d(%s:%d:%d)<<",
 397              fname, sCWId, evi.getName().c_str(), (int)evi.getEV(),
 398              trCWId, cscTarget->getName().c_str(),
 399              cscTarget->getValue(), (int)cscTarget->getType());
 400         return 0;
 401     }
 402     const CicoEventInfo* t = csTgt->getEventInfo(evi.getName(), evi.getEV());
 403     evInfObjects.push_back((CicoEventInfo*)t);
 404     return evInfObjects.size();
 405 }
 406
 407 /**
 408  * @brief Registration of transition events
 409  * @param sCWId ID no. to be registered(c-wrapper local ID)
 410  * @param name event name
 411  * @param ev event no.(Use the 1000-65535)
 412  * @param trCWId of transition destination(c-wrapper local ID)
 413  * @return not 0:ID no. of the event to register(c-wrapper local ID)
 414  * @       0:added error
 415  */
 416 extern "C" int ico_sttm_addTransition(int sCWId,
 417                                       const char* evname, unsigned short ev,
 418                                       int trCWId)
 419 {
 420     sttmerr = STTMNOERROR;
 421     const char* sname = supplementName(evname);
 422     CicoEventInfo evi(sname, ev);
 423     int r = ico_sttm_addTransitionX(sCWId, trCWId, evi, "ico_sttm_addTransition");
 424     return r;
 425 }
 426
 427
 428 /**
 429  * @brief Registration of transition events
 430  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
 431  * @param value value is state-object identification number
 432  * @param name state-object Identification name
 433  * @param evname event name
 434  * @param ev event no.(Use the 1000-65535)
 435  * @param trVal state-object identification value destination
 436  * @param namTrns state-object Identification name destination
 437  * @return not 0:ID no. of the event to register(c-wrapper local ID)
 438  * @       0:added error
 439  */
 440 extern "C" int ico_sttm_addTransition_V_(int smCWId, int value,
 441                                          const char* evname, unsigned short ev,
 442                                          int trCWId)
 443 {
 444     sttmerr = STTMNOERROR;
 445     int id = ico_sttm_retrieveSVal(smCWId, value);
 446     if (0 == id) {
 447         sttmerr = STTMNOTFIND;
 448         _DBG("ico_sttm_addTransition_VV >>%d<<,>>%d<<, %s,%d, %d", smCWId,
 449              value, evname, ev, trCWId);
 450         return 0;
 451     }
 452     return ico_sttm_addTransition(id, evname, ev, trCWId);
 453 }
 454
 455 extern "C" int ico_sttm_addTransition_VV(int smCWId, int value,
 456                                          const char* evname, unsigned short ev,
 457                                          int trVal)
 458 {
 459     sttmerr = STTMNOERROR;
 460     int idT = ico_sttm_retrieveSVal(smCWId, trVal);
 461     if (0 == idT) {
 462         sttmerr = STTMNOTFIND;
 463         _DBG("ico_sttm_addTransition_VV >>%d<<, %d, %s,%d,>>%d<<", smCWId,
 464              value, evname, ev, trVal);
 465         return 0;
 466     }
 467     return ico_sttm_addTransition_V_(smCWId, value, evname, ev, idT);
 468 }
 469
 470 extern "C" int ico_sttm_addTransitionVVV(int smVal, int value,
 471                                          const char* evname, unsigned short ev,
 472                                          int trVal)
 473 {
 474     sttmerr = STTMNOERROR;
 475     int id = ico_sttm_retrieveMVal(smVal);
 476     if (0 == id) {
 477         sttmerr = STTMNOTFIND;
 478         _DBG("ico_sttm_addTransitionVVV >>%d<<, %d, %s,%d, %d", smVal,
 479              value, evname, ev, trVal);
 480         return 0;
 481     }
 482     return ico_sttm_addTransition_VV(id, value, evname, ev, trVal);
 483 }
 484
 485 extern "C" int ico_sttm_addTransition_N_(int smCWId, const char* name,
 486                                          const char* evname, unsigned short ev,
 487                                          int trCWId)
 488 {
 489     sttmerr = STTMNOERROR;
 490     int id = ico_sttm_retrivevSName(smCWId, name);
 491     if (0 == id) {
 492         sttmerr = STTMNOTFIND;
 493         _DBG("ico_sttm_addTransitionVVV >>%d<<,>>%s<<, %s,%d,%d", smCWId,
 494              name, evname, ev, trCWId);
 495         return 0;
 496     }
 497     return ico_sttm_addTransition(id, evname, ev, trCWId);
 498
 499
 500 }
 501 extern "C" int ico_sttm_addTransition_NN(int smCWId, const char* name,
 502                                          const char* evname, unsigned short ev,
 503                                          const char* trNm)
 504 {
 505     sttmerr = STTMNOERROR;
 506     int idT = ico_sttm_retrivevSName(smCWId, trNm);
 507     if (0 == idT) {
 508         sttmerr = STTMNOTFIND;
 509         _DBG("ico_sttm_addTransitionVVV >>%d<<, %s, %s,%d,>>%s<<", smCWId,
 510              name, evname, ev, trNm);
 511         return 0;
 512     }
 513     return ico_sttm_addTransition_N_(smCWId, name, evname, ev, idT);
 514 }
 515
 516 extern "C" int ico_sttm_addTransitionNNN(const char* smNm, const char* name,
 517                                          const char* evname, unsigned short ev,
 518                                          const char* trNm)
 519 {
 520     int id = ico_sttm_retrieveMName(smNm);
 521     if (0 == id) {
 522         sttmerr = STTMNOTFIND;
 523         _DBG("ico_sttm_addTransitionNNN >>%s<<, %s, %s, %d, %s", smNm,
 524              name, evname, ev, trNm);
 525         return 0;
 526     }
 527     return ico_sttm_addTransition_NN(id, name, evname, ev, trNm);
 528 }
 529
 530 /**
 531  * @brief Registration of transition events
 532  * @param sCWId ID no. to be registered(c-wrapper local ID)
 533  * @param name event name
 534  * @param ev event no.(Use the 1000-65535)
 535  * @param gce operator of guard condition
 536  * @param gcv Comparison value of guard condition
 537  * @param trCWId destination(c-wrapper local ID)
 538  * @return not 0:ID no. of the event to register(c-wrapper local event-ID)
 539  * @       0:added error
 540  */
 541 extern "C" int ico_sttm_addTransitionGCI(int sCWId,
 542                                          const char* evname, unsigned short ev,
 543                                          GC_OP_KIND_E gce, int gcv, int trCWId)
 544 {
 545     sttmerr = STTMNOERROR;
 546     const char* sname = supplementName(evname);
 547     CicoEventInfo evi(sname, ev, GCOpKind[gce], gcv);
 548     int r = ico_sttm_addTransitionX(sCWId, trCWId, evi, "ico_sttm_addTransitionGCI");
 549     return r;
 550 }
 551
 552 extern "C" int ico_sttm_addTransitionGCD(int sCWId,
 553                                          const char* evname, unsigned short ev,
 554                                          GC_OP_KIND_E gce, double gcv,
 555                                          int trCWId)
 556 {
 557     sttmerr = STTMNOERROR;
 558     const char* sname = supplementName(evname);
 559     CicoEventInfo evi(sname, ev, GCOpKind[gce], gcv);
 560     int r = ico_sttm_addTransitionX(sCWId, trCWId, evi, "ico_sttm_addTransitionGCD");
 561     return r;
 562 }
 563
 564 extern "C" int ico_sttm_addTransitionGCS(int sCWId,
 565                                          const char* evname, unsigned short ev,
 566                                          GC_OP_KIND_E gce, const char* gcv,
 567                                          int trCWId)
 568 {
 569     sttmerr = STTMNOERROR;
 570     const char* sname = supplementName(evname);
 571     CicoEventInfo evi(sname, ev, GCOpKind[gce], gcv);
 572     int r = ico_sttm_addTransitionX(sCWId, trCWId, evi, "ico_sttm_addTransitionGCS");
 573     return r;
 574 }
 575
 576
 577 /**
 578  * @brief Registration of transition events
 579  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
 580  * @param value value is state-object identification number
 581  * @param evname event name
 582  * @param ev event no.(Use the 1000-65535)
 583  * @param gce operator of guard condition
 584  * @param gcv Comparison value of guard condition
 585  * @param trCWId destination(c-wrapper local ID)
 586  * @return not 0:ID no. of the event to register(c-wrapper local event-ID)
 587  * @       0:added error
 588  */
 589 extern "C" int ico_sttm_addTransGCI_V_(int smCWId, int value,
 590                           const char* evname, unsigned short ev,
 591                           GC_OP_KIND_E gce, int gcv,
 592                           int trCWId)
 593 {
 594
 595     sttmerr = STTMNOERROR;
 596     int id = ico_sttm_retrieveSVal(smCWId, value);
 597     if (0 == id) {
 598         sttmerr = STTMNOTFIND;
 599         _ERR("ico_sttm_addTransGCI_V_ >>%d<<,>>%d<<, %s, %d, %d, %d, %d",
 600               smCWId, value, evname, ev, (int)gce, gcv, trCWId);
 601         return 0;
 602     }
 603     return ico_sttm_addTransitionGCI(id, evname, ev, gce, gcv, trCWId);
 604 }
 605
 606 extern "C" int ico_sttm_addTransGCD_V_(int smCWId, int value,
 607                           const char* evname, unsigned short ev,
 608                           GC_OP_KIND_E gce, double gcv,
 609                           int trCWId)
 610 {
 611     sttmerr = STTMNOERROR;
 612     int id = ico_sttm_retrieveSVal(smCWId, value);
 613     if (0 == id) {
 614         sttmerr = STTMNOTFIND;
 615         _ERR("ico_sttm_addTransGCD_V_ >>%d<<,>>%d<<, %s, %d, %d, %f, %d",
 616               smCWId, value, evname, ev, (int)gce, gcv, trCWId);
 617         return 0;
 618     }
 619     return ico_sttm_addTransitionGCD(id, evname, ev, gce, gcv, trCWId);
 620 }
 621
 622 extern "C" int ico_sttm_addTransGCS_V_(int smCWId, int value,
 623                           const char* evname, unsigned short ev,
 624                           GC_OP_KIND_E gce, const char* gcv,
 625                           int trCWId)
 626 {
 627     sttmerr = STTMNOERROR;
 628     int id = ico_sttm_retrieveSVal(smCWId, value);
 629     if (0 == id) {
 630         sttmerr = STTMNOTFIND;
 631         _ERR("ico_sttm_addTransGCD_V_ >>%d<<,>>%d<<, %s, %d, %d, %s, %d",
 632               smCWId, value, evname, ev, (int)gce, gcv, trCWId);
 633         return 0;
 634     }
 635     return ico_sttm_addTransitionGCS(id, evname, ev, gce, gcv, trCWId);
 636 }
 637
 638 /**
 639  * @brief Registration of transition events
 640  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
 641  * @param value value is state-object identification number
 642  * @param evname event name
 643  * @param ev event no.(Use the 1000-65535)
 644  * @param gce operator of guard condition
 645  * @param gcv Comparison value of guard condition
 646  * @param trVl value is state-object identification number transition, destination
 647  * @return not 0:ID no. of the event to register(c-wrapper local event-ID)
 648  * @       0:added error
 649  */
 650 extern "C" int ico_sttm_addTransGCI_VV(int smCWId, int value,
 651                                        const char* evname, unsigned short ev,
 652                                        GC_OP_KIND_E gce, int gcv,
 653                                        int trVl)
 654 {
 655     sttmerr = STTMNOERROR;
 656     int idT = ico_sttm_retrieveSVal(smCWId, trVl);
 657     if (0 == idT) {
 658         sttmerr = STTMNOTFIND;
 659         _ERR("ico_sttm_addTransGCI_VV >>%d<<, %d, %s, %d, %d, %d,>>%d<<",
 660               smCWId, value, evname, ev, (int)gce, gcv, trVl);
 661         return 0;
 662     }
 663     return ico_sttm_addTransGCI_V_(smCWId, value, evname, ev, gce, gcv, idT);
 664 }
 665
 666 extern "C" int ico_sttm_addTransGCD_VV(int smCWId, int value,
 667                                        const char* evname, unsigned short ev,
 668                                        GC_OP_KIND_E gce, double gcv,
 669                                        int trVl)
 670 {
 671     sttmerr = STTMNOERROR;
 672     int idT = ico_sttm_retrieveSVal(smCWId, trVl);
 673     if (0 == idT) {
 674         sttmerr = STTMNOTFIND;
 675         _ERR("ico_sttm_addTransGCD_VV >>%d<<, %d, %s, %d, %d, %f,>>%d<<",
 676               smCWId, value, evname, ev, (int)gce, gcv, trVl);
 677         return 0;
 678     }
 679     return ico_sttm_addTransGCD_V_(smCWId, value, evname, ev, gce, gcv, idT);
 680 }
 681
 682 extern "C" int ico_sttm_addTransGCS_VV(int smCWId, int value,
 683                                        const char* evname, unsigned short ev,
 684                                        GC_OP_KIND_E gce, const char* gcv,
 685                                        int trVl)
 686 {
 687     sttmerr = STTMNOERROR;
 688     int idT = ico_sttm_retrieveSVal(smCWId, trVl);
 689     if (0 == idT) {
 690         sttmerr = STTMNOTFIND;
 691         _ERR("ico_sttm_addTransGCS_VV >>%d<<, %d, %s, %d, %d, %s,>>%d<<",
 692               smCWId, value, evname, ev, (int)gce, gcv, trVl);
 693         return 0;
 694     }
 695     return ico_sttm_addTransGCS_V_(smCWId, value, evname, ev, gce, gcv, idT);
 696 }
 697
 698
 699
 700 extern "C" int ico_sttm_addTransGCIVVV(int smVal, int value,
 701                                        const char* evname, unsigned short ev,
 702                                        GC_OP_KIND_E gce, int gcv,
 703                                        int trVl)
 704 {
 705     sttmerr = STTMNOERROR;
 706     int id = ico_sttm_retrieveMVal(smVal);
 707     if (0 == id) {
 708         sttmerr = STTMNOTFIND;
 709         _DBG("ico_sttm_addTransGCIVVV >>%d<<, %d, %s, %d, %d, %d, %d", smVal,
 710              value, evname, ev, gce, gcv, trVl);
 711         return 0;
 712     }
 713     return ico_sttm_addTransGCI_VV(id, value, evname, ev, gce, gcv, trVl);
 714 }
 715
 716 extern "C" int ico_sttm_addTransGCDVVV(int smVal, int value,
 717                                        const char* evname, unsigned short ev,
 718                                        GC_OP_KIND_E gce, double gcv,
 719                                        int trVl)
 720 {
 721     sttmerr = STTMNOERROR;
 722     int id = ico_sttm_retrieveMVal(smVal);
 723     if (0 == id) {
 724         sttmerr = STTMNOTFIND;
 725         _DBG("ico_sttm_addTransGCIVVV >>%d<<, %d, %s, %d, %d, %f, %d", smVal,
 726              value, evname, ev, gce, gcv, trVl);
 727         return 0;
 728     }
 729     return ico_sttm_addTransGCD_VV(id, value, evname, ev, gce, gcv, trVl);
 730 }
 731
 732 extern "C" int ico_sttm_addTransGCSVVV(int smVal, int value,
 733                                        const char* evname, unsigned short ev,
 734                                        GC_OP_KIND_E gce, const char* gcv,
 735                                        int trVl)
 736 {
 737     sttmerr = STTMNOERROR;
 738     int id = ico_sttm_retrieveMVal(smVal);
 739     if (0 == id) {
 740         sttmerr = STTMNOTFIND;
 741         _DBG("ico_sttm_addTransGCSVVV >>%d<<, %d, %s, %d, %d, %s, %d", smVal,
 742              value, evname, ev, gce, gcv, trVl);
 743         return 0;
 744     }
 745     return ico_sttm_addTransGCS_VV(id, value, evname, ev, gce, gcv, trVl);
 746 }
 747
 748 /**
 749  * @brief Registration of transition events
 750  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
 751  * @param name  name is state-object Identification name
 752  * @param evname event name
 753  * @param ev event no.(Use the 1000-65535)
 754  * @param gce operator of guard condition
 755  * @param gcv Comparison value of guard condition
 756  * @param transition destination(c-wrapper local ID)
 757  * @return not 0:ID no. of the event to register(c-wrapper local event-ID)
 758  * @       0:added error
 759  */
 760 extern "C" int ico_sttm_addTransGCI_N_(int smCWId, const char* name,
 761                                        const char* evname, unsigned short ev,
 762                                        GC_OP_KIND_E gce, int gcv,
 763                                        int trCWId)
 764 {
 765     sttmerr = STTMNOERROR;
 766     int id = ico_sttm_retrivevSName(smCWId, name);
 767     if (0 == id) {
 768         sttmerr = STTMNOTFIND;
 769         _DBG("ico_sttm_addTransGCI_N_ >>%d<<, %s, %s, %d, %d, %d, %d", smCWId,
 770              name, evname, ev, gce, gcv, trCWId);
 771         return 0;
 772     }
 773     return ico_sttm_addTransitionGCI(id, evname, ev, gce, gcv, trCWId);
 774 }
 775
 776 extern "C" int ico_sttm_addTransGCD_N_(int smCWId, const char* name,
 777                                        const char* evname, unsigned short ev,
 778                                        GC_OP_KIND_E gce, double gcv,
 779                                        int trCWId)
 780 {
 781     sttmerr = STTMNOERROR;
 782     int id = ico_sttm_retrivevSName(smCWId, name);
 783     if (0 == id) {
 784         sttmerr = STTMNOTFIND;
 785         _DBG("ico_sttm_addTransGCD_N_ >>%d<<, %s, %s, %d, %d, %f, %d", smCWId,
 786              name, evname, ev, gce, gcv, trCWId);
 787         return 0;
 788     }
 789     return ico_sttm_addTransitionGCD(id, evname, ev, gce, gcv, trCWId);
 790 }
 791
 792 extern "C" int ico_sttm_addTransGCS_N_(int smCWId, const char* name,
 793                                        const char* evname, unsigned short ev,
 794                                        GC_OP_KIND_E gce, const char* gcv,
 795                                        int trCWId)
 796 {
 797     sttmerr = STTMNOERROR;
 798     int id = ico_sttm_retrivevSName(smCWId, name);
 799     if (0 == id) {
 800         sttmerr = STTMNOTFIND;
 801         _DBG("ico_sttm_addTransGCD_N_ >>%d<<, %s, %s, %d, %d, %s, %d", smCWId,
 802              name, evname, ev, gce, gcv, trCWId);
 803         return 0;
 804     }
 805     return ico_sttm_addTransitionGCS(id, evname, ev, gce, gcv, trCWId);
 806 }
 807
 808 /**
 809  * @brief Registration of transition events
 810  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
 811  * @param name name is state-object Identification name
 812  * @param evname event name
 813  * @param ev event no.(Use the 1000-65535)
 814  * @param gce operator of guard condition
 815  * @param gcv Comparison value of guard condition
 816  * @param trNm name is state-object Identification name destination
 817  * @return not 0:ID no. of the event to register(c-wrapper local event-ID)
 818  * @       0:added error
 819  */
 820 extern "C" int ico_sttm_addTransGCI_NN(int smCWId, const char* name,
 821                                        const char* evname, unsigned short ev,
 822                                        GC_OP_KIND_E gce, int gcv,
 823                                        const char* trNm)
 824 {
 825     sttmerr = STTMNOERROR;
 826     int idT = ico_sttm_retrivevSName(smCWId, trNm);
 827     if (0 == idT) {
 828         sttmerr = STTMNOTFIND;
 829         _DBG("ico_sttm_addTransGCI_NN >>%d<<, %s, %s, %d, %d, %d,>>%s<<", smCWId,
 830              name, evname, ev, gce, gcv, trNm);
 831         return 0;
 832     }
 833     return ico_sttm_addTransGCI_N_(smCWId, name, evname, ev, gce, gcv, idT);
 834 }
 835
 836 extern "C" int ico_sttm_addTransGCD_NN(int smCWId, const char* name,
 837                                        const char* evname, unsigned short ev,
 838                                        GC_OP_KIND_E gce, double gcv,
 839                                        const char* trNm)
 840 {
 841     sttmerr = STTMNOERROR;
 842     int idT = ico_sttm_retrivevSName(smCWId, trNm);
 843     if (0 == idT) {
 844         sttmerr = STTMNOTFIND;
 845         _DBG("ico_sttm_addTransGCD_NN >>%d<<, %s, %s, %d, %d, %f,>>%s<<", smCWId,
 846              name, evname, ev, gce, gcv, trNm);
 847         return 0;
 848     }
 849     return ico_sttm_addTransGCD_N_(smCWId, name, evname, ev, gce, gcv, idT);
 850 }
 851
 852 extern "C" int ico_sttm_addTransGCS_NN(int smCWId, const char* name,
 853                                        const char* evname, unsigned short ev,
 854                                        GC_OP_KIND_E gce, const char* gcv,
 855                                        const char* trNm)
 856 {
 857     sttmerr = STTMNOERROR;
 858     int idT = ico_sttm_retrivevSName(smCWId, trNm);
 859     if (0 == idT) {
 860         sttmerr = STTMNOTFIND;
 861         _DBG("ico_sttm_addTransGCS_NN >>%d<<, %s, %s, %d, %d, %s,>>%s<<", smCWId,
 862              name, evname, ev, gce, gcv, trNm);
 863         return 0;
 864     }
 865     return ico_sttm_addTransGCS_N_(smCWId, name, evname, ev, gce, gcv, idT);
 866 }
 867
 868 extern "C" int ico_sttm_addTransGCINNN(const char* smNm, const char* name,
 869                                        const char* evname, unsigned short ev,
 870                                        GC_OP_KIND_E gce, int gcv,
 871                                        const char* trNm)
 872 {
 873     sttmerr = STTMNOERROR;
 874     int id = ico_sttm_retrieveMName(smNm);
 875     if (0 == id) {
 876         _DBG("ico_sttm_addTransGCINNN >>%s<<, %s, %s, %d, %d, %d, %s", smNm,
 877              name, evname, ev, gce, gcv, trNm);
 878         return 0;
 879     }
 880     return ico_sttm_addTransGCI_NN(id, name, evname, ev, gce, gcv, trNm);
 881 }
 882
 883 extern "C" int ico_sttm_addTransGCDNNN(const char* smNm, const char* name,
 884                                        const char* evname, unsigned short ev,
 885                                        GC_OP_KIND_E gce, double gcv,
 886                                        const char* trNm)
 887 {
 888     sttmerr = STTMNOERROR;
 889     int id = ico_sttm_retrieveMName(smNm);
 890     if (0 == id) {
 891         _DBG("ico_sttm_addTransGCDNNN >>%s<<, %s, %s, %d, %d, %f, %s", smNm,
 892              name, evname, ev, gce, gcv, trNm);
 893         return 0;
 894     }
 895     return ico_sttm_addTransGCD_NN(id, name, evname, ev, gce, gcv, trNm);
 896 }
 897
 898 extern "C" int ico_sttm_addTransGCSNNN(const char* smNm, const char* name,
 899                                        const char* evname, unsigned short ev,
 900                                        GC_OP_KIND_E gce, const char* gcv,
 901                                        const char* trNm)
 902 {
 903     sttmerr = STTMNOERROR;
 904     int id = ico_sttm_retrieveMName(smNm);
 905     if (0 == id) {
 906         _DBG("ico_sttm_addTransGCSNNN >>%s<<, %s, %s, %d, %d, %s, %s", smNm,
 907              name, evname, ev, gce, gcv, trNm);
 908         return 0;
 909     }
 910     return ico_sttm_addTransGCS_NN(id, name, evname, ev, gce, gcv, trNm);
 911 }
 912
 913
 914 /**
 915  * @brief add guard condition
 916  * @param evi register target
 917  * @param j logical operator
 918  * @param gce operator of guard condition
 919  * @param gcv Comparison value of guard condition
 920  * @return true:Success
 921  * @       false:added failure
 922  */
 923 bool addGC(CicoEventInfo* evi, GC_JOIN_E j, GC_OP_KIND_E gce, int gcv)
 924 {
 925     if (E_GC_AND == j) {
 926         return evi->addAndGurdCondition(GCOpKind[gce], gcv);
 927     }
 928     else if (E_GC_OR == j) {
 929         return evi->addOrGurdCondition(GCOpKind[gce], gcv);
 930     }
 931     return false;
 932 }
 933
 934
 935 bool addGC(CicoEventInfo* evi, GC_JOIN_E j, GC_OP_KIND_E gce, double gcv)
 936 {
 937     if (E_GC_AND == j) {
 938         return evi->addAndGurdCondition(GCOpKind[gce], gcv);
 939     }
 940     else if (E_GC_OR == j) {
 941         return evi->addOrGurdCondition(GCOpKind[gce], gcv);
 942     }
 943     return false;
 944 }
 945
 946
 947 bool addGC(CicoEventInfo* evi, GC_JOIN_E j, GC_OP_KIND_E gce, const char* gcv)
 948 {
 949     if (E_GC_AND == j) {
 950         return evi->addAndGurdCondition(GCOpKind[gce], gcv);
 951     }
 952     else if (E_GC_OR == j) {
 953         return evi->addOrGurdCondition(GCOpKind[gce], gcv);
 954     }
 955     return false;
 956 }
 957
 958 /**
 959  * @brief add guard condition
 960  * @param evId ID no. to be registered(c-wrapper local event-ID)
 961  * @param j logical operator
 962  * @param gce operator of guard condition
 963  * @param gcv Comparison value of guard condition
 964  * @return not 0:Success
 965  * @       0:added failure
 966  */
 967 extern "C" int ico_sttm_addGCI(int evId, GC_JOIN_E j, GC_OP_KIND_E gce, int gcv)
 968 {
 969     sttmerr = STTMNOERROR;
 970     CicoEventInfo* eviTarget = getID2ObjEV(evId);
 971     if ((CicoEventInfo*)0 == eviTarget) {
 972         sttmerr = STTMEVNOTFIND;
 973         _DBG("ico_sttm_addGCI >>%d<<,%d, %d, %d",evId, (int)j, (int)gce, gcv);
 974         return 0;
 975     }
 976     if (false == addGC(eviTarget, j, gce, gcv)) {
 977         sttmerr = STTMPARAMERR;
 978         _DBG("ico_sttm_addGCI ,>>%d<<, %d, %d, %d",evId, (int)j, (int)gce, gcv);
 979     }
 980     return evId;
 981 }
 982
 983 extern "C" int ico_sttm_addGCD(int evId, GC_JOIN_E j, GC_OP_KIND_E gce, double gcv)
 984 {
 985     sttmerr = STTMNOERROR;
 986     CicoEventInfo* eviTarget = getID2ObjEV(evId);
 987     if ((CicoEventInfo*)0 == eviTarget) {
 988         sttmerr = STTMEVNOTFIND;
 989         _DBG("ico_sttm_addGCD >>%d<<,%d, %d, %f",evId, (int)j, (int)gce, gcv);
 990         return 0;
 991     }
 992     if (false == addGC(eviTarget, j, gce, gcv)) {
 993         sttmerr = STTMPARAMERR;
 994         _DBG("ico_sttm_addGCD %d,>>%d<<, %d, %f",evId, (int)j, (int)gce, gcv);
 995         return 0;
 996     }
 997     return evId;
 998 }
 999
1000 extern "C" int ico_sttm_addGCS(int evId, GC_JOIN_E j, GC_OP_KIND_E gce,
1001                                 const char* gcv)
1002 {
1003     sttmerr = STTMNOERROR;
1004     if ((char*)0==gcv) {
1005         sttmerr = STTMEVNOTFIND;
1006         _DBG("ico_sttm_addGCS %d,%d, %d,>>nill<<",evId, (int)j, (int)gce);
1007         return 0;
1008     }
1009     CicoEventInfo* eviTarget = getID2ObjEV(evId);
1010     if ((CicoEventInfo*)0 == eviTarget) {
1011         sttmerr = STTMNOTFIND;
1012         _DBG("ico_sttm_addGCS >>%d<<,%d, %d, \"%s\"",evId, (int)j, (int)gce,
1013              gcv);
1014         return 0;
1015     }
1016     if (false == addGC(eviTarget, j, gce, gcv)) {
1017         sttmerr = STTMPARAMERR;
1018         _DBG("ico_sttm_addGCS %d,>>%d<<, %d, \"%s\"",evId, (int)j, (int)gce, gcv);
1019         return 0;
1020     }
1021     return evId;
1022 }
1023
1024 /**
1025  * @brief ico_sttm_getStateMachineX
1026  * @param smCWId stateMachine-object ID
1027  * @param fname calling function Name
1028  * @return not 0:get success 0:get fail
1029  */
1030 CicoStateMachine* ico_sttm_getStateMachineX(int smCWId, const char* fname)
1031 {
1032     CicoStateCore* cscTarget = getID2ObjSTT(smCWId); // ID to state-object
1033     if ((CicoStateCore*)0 == cscTarget) {
1034         sttmerr = STTMNOTFIND;
1035         _DBG("%s >>%d<<",fname, smCWId);
1036         return (CicoStateMachine*)0;
1037     }
1038     if (false == cscTarget->isStateMachine()) {
1039         sttmerr = STTMTYPEMISMATCH;
1040         _DBG("%s >>%d(%s:%d:%d)<<", fname, smCWId,
1041              cscTarget->getName().c_str(), cscTarget->getValue(),
1042              (int)cscTarget->getType());
1043         return (CicoStateMachine*)0;
1044     }
1045     return (CicoStateMachine*)cscTarget;
1046 }
1047
1048 /**
1049  * @brief add guard condition
1050  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
1051  * @param evname event name
1052  * @param ev event no.(Use the 1000-65535)
1053  * @param j logical operator
1054  * @param gce operator of guard condition
1055  * @param gcv Comparison value of guard condition
1056  * @return not 0:Success
1057  * @       0:added failure
1058  */
1059
1060 CicoStateCore* getStateObject(int smCWId, int value, const char* fnc)
1061 {
1062     CicoStateMachine* csm;
1063     csm = ico_sttm_getStateMachineX(smCWId, fnc);
1064     if ((CicoStateMachine*)0 == csm) {
1065         sttmerr = STTMNOTFIND;
1066         _DBG("%s>>%d<<, %d", fnc, smCWId, value);
1067         return 0;
1068     }
1069     const CicoStateCore* csc = csm->getState(value);
1070     if ((CicoStateCore*)0 == csc) {
1071         sttmerr = STTMPARAMERR;
1072         _DBG("%s %d,>>%d<<", fnc, smCWId, value);
1073         return 0;
1074     }
1075     return (CicoStateCore*)csc;
1076 }
1077
1078
1079 CicoStateCore* getStateObject(int smCWId, const char* name, const char* fnc)
1080 {
1081     CicoStateMachine* csm;
1082     csm = ico_sttm_getStateMachineX(smCWId, fnc);
1083     if ((CicoStateMachine*)0 == csm) {
1084         sttmerr = STTMNOTFIND;
1085         _DBG("%s>>%d<<, %s", fnc, smCWId, name);
1086         return 0;
1087     }
1088     const CicoStateCore* csc = csm->getState(name);
1089     if ((CicoStateCore*)0 == csc) {
1090         sttmerr = STTMPARAMERR;
1091         _DBG("%s %d,>>%s<<", fnc, smCWId, name);
1092         return 0;
1093     }
1094     return (CicoStateCore*)csc;
1095 }
1096
1097
1098 CicoEventInfo* getEventInfoV(int smCWId, int value,
1099                              const char* evname, unsigned short ev,
1100                              const char* fnc)
1101 {
1102     CicoStateCore* csc;
1103     csc = getStateObject(smCWId, value, fnc);
1104     if ((CicoStateCore*)0 == csc) {
1105         return 0;
1106     }
1107     const CicoEventInfo* t = csc->getEventInfo(evname, ev);
1108     if ((CicoEventInfo*)0 == t) {
1109         sttmerr = STTMPARAMERR;
1110         _DBG("%s %d, %d,>>%s, %d<<", fnc, smCWId, value, evname, ev);
1111         return 0;
1112     }
1113     return (CicoEventInfo*)t;
1114 }
1115
1116
1117 CicoEventInfo* getEventInfoN(int smCWId, const char* name,
1118                              const char* evname, unsigned short ev,
1119                              const char* fnc)
1120 {
1121     CicoStateCore* csc;
1122     csc = getStateObject(smCWId, name, fnc);
1123     if ((CicoStateCore*)0 == csc) {
1124         return 0;
1125     }
1126     const CicoEventInfo* t = csc->getEventInfo(evname, ev);
1127     if ((CicoEventInfo*)0 == t) {
1128         sttmerr = STTMPARAMERR;
1129         _DBG("%s %d, %s,>>%s, %d<<", fnc, smCWId, name, evname, ev);
1130         return 0;
1131     }
1132     return (CicoEventInfo*)t;
1133 }
1134
1135
1136 /**
1137  * @brief add guard condition
1138  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
1139  * @param value value is state-object identification number
1140  * @param evname event name
1141  * @param ev event no.(Use the 1000-65535)
1142  * @param j logical operator
1143  * @param gce operator of guard condition
1144  * @param gcv Comparison value of guard condition
1145  * @return not 0:Success
1146  * @       0:added failure
1147  */
1148 extern "C" int ico_sttm_addGCI_V(int smCWId, int value,
1149                                  const char* evname, unsigned short ev,
1150                                  GC_JOIN_E j, GC_OP_KIND_E gc, int gcv)
1151 {
1152     sttmerr = STTMNOERROR;
1153     const char* fnc = "ico_sttm_addGCI_V";
1154     CicoEventInfo* t;
1155     t = getEventInfoV(smCWId, value, evname, ev, fnc);
1156     if ((CicoEventInfo*)0 == t) {
1157         return 0;
1158     }
1159     if (false == addGC(t, j, gc, gcv)) {
1160         sttmerr = STTMPARAMERR;
1161         _DBG("%s %d, %d, %s, %d, >> %d, %d, %d<<", fnc, smCWId, value,
1162              evname, ev, (int)j, (int)gc, gcv);
1163         return 0;
1164     }
1165     return 1;
1166 }
1167
1168
1169 extern "C" int ico_sttm_addGCD_V(int smCWId, int value,
1170                                  const char* evname, unsigned short ev,
1171                                  GC_JOIN_E j, GC_OP_KIND_E gc, double gcv)
1172 {
1173     sttmerr = STTMNOERROR;
1174     const char* fnc = "ico_sttm_addGCD_V";
1175     CicoEventInfo* t;
1176     t = getEventInfoV(smCWId, value, evname, ev, fnc);
1177     if ((CicoEventInfo*)0 == t) {
1178         return 0;
1179     }
1180     if (false == addGC(t, j, gc, gcv)) {
1181         sttmerr = STTMPARAMERR;
1182         _DBG("%s %d, %d, %s, %d, >> %d, %d, %f<<", fnc, smCWId, value,
1183              evname, ev, (int)j, (int)gc, gcv);
1184         return 0;
1185     }
1186     return 1;
1187 }
1188
1189 extern "C" int ico_sttm_addGCS_V(int smCWId, int value,
1190                                  const char* evname, unsigned short ev,
1191                                  GC_JOIN_E j, GC_OP_KIND_E gc, const char* gcv)
1192 {
1193     sttmerr = STTMNOERROR;
1194     const char* fnc = "ico_sttm_addGCS_V";
1195     CicoEventInfo* t;
1196     t = getEventInfoV(smCWId, value, evname, ev, fnc);
1197     if ((CicoEventInfo*)0 == t) {
1198         return 0;
1199     }
1200     if (false == addGC(t, j, gc, gcv)) {
1201         sttmerr = STTMPARAMERR;
1202         _DBG("%s %d, %d, %s, %d, >> %d, %d, %s<<", fnc, smCWId, value,
1203              evname, ev, (int)j, (int)gc, gcv);
1204         return 0;
1205     }
1206     return 1;
1207 }
1208
1209 /**
1210  * @brief add guard condition
1211  * @param smVal value is stateMachine-object identification number
1212  * @param value value is state-object identification number
1213  * @param evname event name
1214  * @param ev event no.(Use the 1000-65535)
1215  * @param j logical operator
1216  * @param gce operator of guard condition
1217  * @param gcv Comparison value of guard condition
1218  * @return not 0:Success
1219  * @       0:added failure
1220  */
1221 extern "C" int ico_sttm_addGCIVV(int smVal, int value,
1222                                  const char* evname, unsigned short ev,
1223                                  GC_JOIN_E j, GC_OP_KIND_E gc, int gcv)
1224 {
1225     sttmerr = STTMNOERROR;
1226     int id = ico_sttm_retrieveMVal(smVal);
1227     if (0 == id) {
1228         sttmerr = STTMNOTFIND;
1229         _DBG("ico_sttm_addGCIVV >>%d<<, %d, %s, %d, %d, %d, %d", smVal,
1230              value, evname, ev, j, gc, gcv);
1231         return 0;
1232     }
1233     return ico_sttm_addGCI_V(id, value, evname, ev, j, gc, gcv);
1234 }
1235
1236 extern "C" int ico_sttm_addGCDVV(int smVal, int value,
1237                                  const char* evname, unsigned short ev,
1238                                  GC_JOIN_E j, GC_OP_KIND_E gc, double gcv)
1239 {
1240     sttmerr = STTMNOERROR;
1241     int id = ico_sttm_retrieveMVal(smVal);
1242     if (0 == id) {
1243         sttmerr = STTMNOTFIND;
1244         _DBG("ico_sttm_addGCDVV >>%d<<, %d, %s, %d, %d, %d, %f", smVal,
1245              value, evname, ev, j, gc, gcv);
1246         return 0;
1247     }
1248     return ico_sttm_addGCD_V(id, value, evname, ev, j, gc, gcv);
1249 }
1250
1251 extern "C" int ico_sttm_addGCSVV(int smVal, int value,
1252                                  const char* evname, unsigned short ev,
1253                                  GC_JOIN_E j, GC_OP_KIND_E gc, const char* gcv)
1254 {
1255     sttmerr = STTMNOERROR;
1256     int id = ico_sttm_retrieveMVal(smVal);
1257     if (0 == id) {
1258         sttmerr = STTMNOTFIND;
1259         _DBG("ico_sttm_addGCSVV >>%d<<, %d, %s, %d, %d, %d, %s", smVal,
1260              value, evname, ev, j, gc, gcv);
1261         return 0;
1262     }
1263     return ico_sttm_addGCS_V(id, value, evname, ev, j, gc, gcv);
1264 }
1265
1266
1267 /**
1268  * @brief add guard condition
1269  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
1270  * @param name  name is state-object Identification name
1271  * @param evname event name
1272  * @param ev event no.(Use the 1000-65535)
1273  * @param j logical operator
1274  * @param gce operator of guard condition
1275  * @param gcv Comparison value of guard condition
1276  * @return not 0:Success
1277  * @       0:added failure
1278  */
1279 extern "C" int ico_sttm_addGCI_N(int smCWId, const char* name,
1280                                  const char* evname, unsigned short ev,
1281                                  GC_JOIN_E j, GC_OP_KIND_E gc, int gcv)
1282 {
1283     sttmerr = STTMNOERROR;
1284     const char* fnc = "ico_sttm_addGCI_N";
1285     CicoEventInfo* t;
1286     t = getEventInfoN(smCWId, name, evname, ev, fnc);
1287     if ((CicoEventInfo*)0 == t) {
1288         return 0;
1289     }
1290     if (false == addGC(t, j, gc, gcv)) {
1291         sttmerr = STTMPARAMERR;
1292         _DBG("%s %d, %s, %s, %d, >> %d, %d, %d<<", fnc, smCWId, name,
1293              evname, ev, (int)j, (int)gc, gcv);
1294         return 0;
1295     }
1296     return 1;
1297 }
1298
1299 extern "C" int ico_sttm_addGCD_N(int smCWId, const char* name,
1300                                  const char* evname, unsigned short ev,
1301                                  GC_JOIN_E j, GC_OP_KIND_E gc, double gcv)
1302 {
1303     sttmerr = STTMNOERROR;
1304     const char* fnc = "ico_sttm_addGCD_N";
1305     CicoEventInfo* t;
1306     t = getEventInfoN(smCWId, name, evname, ev, fnc);
1307     if ((CicoEventInfo*)0 == t) {
1308         return 0;
1309     }
1310     if (false == addGC(t, j, gc, gcv)) {
1311         sttmerr = STTMPARAMERR;
1312         _DBG("%s %d, %s, %s, %d, >> %d, %d, %f<<", fnc, smCWId, name,
1313              evname, ev, (int)j, (int)gc, gcv);
1314         return 0;
1315     }
1316     return 1;
1317 }
1318
1319
1320 extern "C" int ico_sttm_addGCS_N(int smCWId, const char* name,
1321                                  const char* evname, unsigned short ev,
1322                                  GC_JOIN_E j, GC_OP_KIND_E gc, const char* gcv)
1323 {
1324     sttmerr = STTMNOERROR;
1325     const char* fnc = "ico_sttm_addGCS_N";
1326     CicoEventInfo* t;
1327     t = getEventInfoN(smCWId, name, evname, ev, fnc);
1328     if ((CicoEventInfo*)0 == t) {
1329         return 0;
1330     }
1331     if (false == addGC(t, j, gc, gcv)) {
1332         sttmerr = STTMPARAMERR;
1333         _DBG("%s %d, %s, %s, %d, >> %d, %d, %s<<", fnc, smCWId, name,
1334              evname, ev, (int)j, (int)gc, gcv);
1335         return 0;
1336     }
1337     return 1;
1338 }
1339
1340 /**
1341  * @brief add guard condition
1342  * @param smNm stateMachine-object Identification name
1343  * @param name  name is state-object Identification name
1344  * @param evname event name
1345  * @param ev event no.(Use the 1000-65535)
1346  * @param j logical operator
1347  * @param gce operator of guard condition
1348  * @param gcv Comparison value of guard condition
1349  * @return not 0:Success
1350  * @       0:added failure
1351  */
1352 extern "C" int ico_sttm_addGCINN(const char* smNm, const char* name,
1353                                  const char* evname, unsigned short ev,
1354                                  GC_JOIN_E j, GC_OP_KIND_E gc, int gcv)
1355 {
1356     sttmerr = STTMNOERROR;
1357     int id = ico_sttm_retrieveMName(smNm);
1358     if (0 == id) {
1359         sttmerr = STTMNOTFIND;
1360         _DBG("ico_sttm_addGCINN >>%s<<, %s, %s, %d, %d, %d, %d", smNm,
1361              name, evname, ev, j,  gc, gcv);
1362         return 0;
1363     }
1364     return ico_sttm_addGCI_N(id, name, evname, ev, j,  gc, gcv);
1365 }
1366
1367 extern "C" int ico_sttm_addGCDNN(const char* smNm, const char* name,
1368                                  const char* evname, unsigned short ev,
1369                                  GC_JOIN_E j, GC_OP_KIND_E gc, double gcv)
1370 {
1371     sttmerr = STTMNOERROR;
1372     int id = ico_sttm_retrieveMName(smNm);
1373     if (0 == id) {
1374         sttmerr = STTMNOTFIND;
1375         _DBG("ico_sttm_addGCDNN >>%s<<, %s, %s, %d, %d, %d, %f", smNm,
1376              name, evname, ev, j,  gc, gcv);
1377         return 0;
1378     }
1379     return ico_sttm_addGCD_N(id, name, evname, ev, j,  gc, gcv);
1380 }
1381
1382 extern "C" int ico_sttm_addGCSNN(const char* smNm, const char* name,
1383                                  const char* evname, unsigned short ev,
1384                                  GC_JOIN_E j, GC_OP_KIND_E gc, const char* gcv)
1385 {
1386     sttmerr = STTMNOERROR;
1387     int id = ico_sttm_retrieveMName(smNm);
1388     if (0 == id) {
1389         sttmerr = STTMNOTFIND;
1390         _DBG("ico_sttm_addGCSNN >>%s<<, %s, %s, %d, %d, %d, %s", smNm,
1391              name, evname, ev, j,  gc, gcv);
1392         return 0;
1393     }
1394     return ico_sttm_addGCS_N(id, name, evname, ev, j,  gc, gcv);
1395 }
1396
1397 /**
1398  * @brief callback call entryAction/exitAction/doAction
1399  * @param ev callback function parameter(trigger event)
1400  * @param sCWId callback function parameter
1401  * @param fnc callback function
1402  */
1403 extern "C" {
1404     void callbackActionC(st_event* ev, int sCWId, void* vfnc)
1405     {
1406         void (*fnc)(st_event*, int) = (void (*)(st_event*, int))vfnc;
1407         fnc(ev, sCWId);
1408     }
1409 }
1410
1411 /**
1412  * @breif callback action for c++
1413  * @param ev trigger event
1414  * @param state-objects the action occurred
1415  */
1416 void callbackActionCPP(const CicoEvent& ev, const CicoStateCore* stt, int vec)
1417 {
1418     int sz = callbackFnc.size();
1419     if ((1 > vec) || (sz < vec)) {
1420         return;
1421     }
1422
1423     int sCWId = getObjSTT2ID(stt);
1424     if (0 == sCWId) {                   // state-objects outside the control
1425         return;                         //
1426     }
1427
1428     st_event stev;
1429     stev.ev = ev.getEV();
1430
1431     CicoEvent::E_TOV tov = ev.getVTG();
1432     if ( CicoEvent::EEvtGCInt == tov) {
1433         stev.uk = E_NUMBER;
1434         stev.u.i = ev.getGCVi();
1435     }
1436     else if (CicoEvent::EEvtGCDouble == tov) {
1437         stev.uk = E_DOUBLE;
1438         stev.u.d = ev.getGCVd();
1439     }
1440     else if (CicoEvent::EEvtGCStr == tov) {
1441         stev.uk = E_STRING;
1442         stev.u.s = ev.getGCVs().c_str();
1443     }
1444     else {
1445         stev.uk = E_NONE;
1446     }
1447     stev.v = ev.getAdVal();
1448
1449     callbackActionC(&stev, sCWId, callbackFnc[vec-1]);
1450     return;
1451 }
1452
1453 #ifndef CWAPPERCALLBACKACTION_H
1454 #define CWAPPERCALLBACKACTION_H
1455 /**
1456  * C Wrapper call back CicoStateAction
1457  */
1458 class CicoCWrapperCallbackAction :public CicoStateAction
1459 {
1460 public:
1461     CicoCWrapperCallbackAction();
1462     // entry-Action
1463     void onEnttry(const CicoEvent& ev, const CicoState* stt, int addval);
1464     void onEnttry(const CicoEvent& ev, const CicoFinalState* stt, int addval);
1465     void onEnttry(const CicoEvent& ev, const CicoHistoryState* stt,
1466                   int addval);
1467     // exit-Action
1468     void onExit(const CicoEvent& ev, const CicoState* stt, int addval);
1469     void onExit(const CicoEvent& ev, const CicoHistoryState* stt, int addval);
1470
1471     // doAction
1472     void onDo(const CicoEvent& ev, const CicoState* stt, int addval);
1473 };
1474 #endif  // CWAPPERCALLBACKACTION_H
1475
1476 /**
1477  * @brief cnstractor
1478  */
1479 CicoCWrapperCallbackAction::CicoCWrapperCallbackAction()
1480 {
1481 }
1482
1483 /**
1484  * @brief entry Action callback
1485  * @param ev trigger event data
1486  * @param stt entery state-object
1487  * @param addval Additional information
1488  */
1489 void CicoCWrapperCallbackAction::onEnttry(const CicoEvent& ev,
1490                                           const CicoState* stt, int addval)
1491 {
1492     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1493 }
1494
1495 void CicoCWrapperCallbackAction::onEnttry(const CicoEvent& ev,
1496                                           const CicoFinalState* stt, int addval)
1497 {
1498     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1499 }
1500
1501 void CicoCWrapperCallbackAction::onEnttry(const CicoEvent& ev,
1502                                           const CicoHistoryState* stt, int addval)
1503 {
1504     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1505 }
1506
1507 /**
1508  * @brief exit Action callback
1509  * @param ev trigger event data
1510  * @param stt exit state-object
1511  * @param addval Additional information
1512  */
1513 void CicoCWrapperCallbackAction::onExit(const CicoEvent& ev,
1514                                         const CicoState* stt, int addval)
1515 {
1516     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1517 }
1518
1519 void CicoCWrapperCallbackAction::onExit(const CicoEvent& ev,
1520                                         const CicoHistoryState* stt, int addval)
1521 {
1522     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1523 }
1524
1525 /**
1526  * @brief do Action callback
1527  * @param ev trigger event data
1528  * @param stt active state-object
1529  * @param addval Additional information
1530  */
1531 void CicoCWrapperCallbackAction::onDo(const CicoEvent& ev,
1532                                       const CicoState* stt, int addval)
1533 {
1534     callbackActionCPP(ev, (CicoStateCore*)stt, addval);
1535 }
1536
1537 /**
1538  * Declaration of the class CicoCWrapperCallbackAction
1539  */
1540 CicoCWrapperCallbackAction cWprActn;
1541
1542
1543 /* registration entry-Action,exit-Action,do-action callback */
1544 /**
1545  * @brief Callback registration
1546  * @param sCWId ID no. to be registered(c-wrapper local ID)
1547  * @param fanc callback function
1548  * @return not 0:Success
1549  * @       0:Failure
1550  */
1551 extern "C" int ico_sttm_addEntryAction(int sCWId, void (*fnc)(st_event*, int))
1552 {
1553     sttmerr = STTMNOERROR;
1554     CicoStateCore* csc = getID2ObjSTT(sCWId); // ID to state-object
1555     if ((CicoStateCore*)0 == csc) {
1556         sttmerr = STTMNOTFIND;
1557         _DBG("ico_sttm_addEntryAction >>%d<<, fnc", sCWId);
1558         return 0;
1559     }
1560     if (0 == fnc) {
1561         sttmerr = STTMPARAMERR;
1562         _DBG("ico_sttm_addEntryAction %d,>>fnc(0x0)<<", sCWId);
1563         return 0;
1564     }
1565
1566     callbackFnc.push_back((void*)fnc);
1567     int addval = callbackFnc.size();
1568
1569     if (true == csc->isState()) {
1570         CicoState* cs = (CicoState*)csc;
1571         cs->addEntryAction((CicoStateAction*)&cWprActn, addval);
1572     }
1573     else if (true == csc->isFinalState()) {
1574         CicoFinalState* cfs = (CicoFinalState*)csc;
1575         cfs->addEntryAction((CicoStateAction*)&cWprActn, addval);
1576     }
1577     else if (true == csc->isHistoryState()) {
1578         CicoHistoryState* chs = (CicoHistoryState*)csc;
1579         chs->addEntryAction((CicoStateAction*)&cWprActn, addval);
1580     }
1581     else {
1582         sttmerr = STTMTYPEMISMATCH;
1583         _DBG("ico_sttm_addEntryAction >>%d(%s:%d:%d)<<,fnc", sCWId,
1584              csc->getName().c_str(), csc->getValue(), (int)csc->getType());
1585         return 0;
1586     }
1587     return sCWId;
1588 }
1589
1590
1591 extern "C" int ico_sttm_addExitAction(int sCWId, void (*fnc)(st_event*, int))
1592 {
1593     sttmerr = STTMNOERROR;
1594     CicoStateCore* csc = getID2ObjSTT(sCWId); // ID to state-object
1595     if ((CicoStateCore*)0 == csc) {
1596         sttmerr = STTMNOTFIND;
1597         _DBG("ico_sttm_addExitAction >>%d<<, fnc", sCWId);
1598         return 0;
1599     }
1600     if (0 == fnc) {
1601         sttmerr = STTMPARAMERR;
1602         _DBG("ico_sttm_addExitAction %d,>>fnc(0x0)<<", sCWId);
1603         return 0;
1604     }
1605
1606     callbackFnc.push_back((void*)fnc);
1607     int addval = callbackFnc.size();
1608
1609     if (true == csc->isState()) {
1610         CicoState* cs = (CicoState*)csc;
1611         cs->addExitAction((CicoStateAction*)&cWprActn, addval);
1612     }
1613     else if (true == csc->isHistoryState()) {
1614         CicoHistoryState* chs = (CicoHistoryState*)csc;
1615         chs->addExitAction((CicoStateAction*)&cWprActn, addval);
1616     }
1617     else {
1618         sttmerr = STTMTYPEMISMATCH;
1619         _DBG("ico_sttm_addExitAction >>%d(%s:%d:%d)<<,fnc", sCWId,
1620              csc->getName().c_str(), csc->getValue(), (int)csc->getType());
1621         return 0;
1622     }
1623     return sCWId;
1624 }
1625
1626
1627 extern "C" int ico_sttm_addDoAction(int sCWId, void (*fnc)(st_event*, int))
1628 {
1629     sttmerr = STTMNOERROR;
1630     CicoStateCore* csc = getID2ObjSTT(sCWId); // ID to state-object
1631     if ((CicoStateCore*)0 == csc) {
1632         sttmerr = STTMNOTFIND;
1633         _DBG("ico_sttm_addDoAction >>%d<<, fnc", sCWId);
1634         return 0;
1635     }
1636     if (0 == fnc) {
1637         sttmerr = STTMPARAMERR;
1638         _DBG("ico_sttm_addDoAction %d,>>fnc(0x0)<<", sCWId);
1639         return 0;
1640     }
1641
1642     callbackFnc.push_back((void*)fnc);
1643     int addval = callbackFnc.size();
1644
1645     if (true == csc->isState()) {
1646         CicoState* cs = (CicoState*)csc;
1647         cs->addDoAction((CicoStateAction*)&cWprActn, addval);
1648     }
1649     else {
1650         sttmerr = STTMTYPEMISMATCH;
1651         _DBG("ico_sttm_addDoAction >>%d(%s:%d:%d)<<,fnc", sCWId,
1652              csc->getName().c_str(), csc->getValue(), (int)csc->getType());
1653         return 0;
1654     }
1655     return sCWId;
1656 }
1657
1658 /**
1659  * @brief Callback registration
1660  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
1661  * @param value value is state-object identification number
1662  * @param fanc callback function
1663  * @return not 0:Success
1664  * @       0:added Failure
1665  */
1666 extern "C" int ico_sttm_addEntryAction_V(int smCWId, int value,
1667                                          void (*fnc)(st_event* ev, int sCWId))
1668 {
1669     sttmerr = STTMNOERROR;
1670     int lid = ico_sttm_retrieveSVal(smCWId, value);
1671     if (0 == lid) {
1672         sttmerr = STTMNOTFIND;
1673         _DBG("ico_sttm_addEntryAction_V >>%d<<,>>%d<<, .", smCWId, value);
1674         return 0;
1675     }
1676     return ico_sttm_addEntryAction(lid, fnc);
1677 }
1678
1679 extern "C" int ico_sttm_addExitAction_V(int smCWId, int value,
1680                                         void (*fnc)(st_event* ev, int sCWId))
1681 {
1682     sttmerr = STTMNOERROR;
1683     int lid = ico_sttm_retrieveSVal(smCWId, value);
1684     if (0 == lid) {
1685         sttmerr = STTMNOTFIND;
1686         _DBG("ico_sttm_addExitAction_V >>%d<<,>>%d<<, .", smCWId, value);
1687         return 0;
1688     }
1689     return ico_sttm_addExitAction(lid, fnc);
1690 }
1691
1692 extern "C" int ico_sttm_addDoAction_V(int smCWId, int value,
1693                                       void (*fnc)(st_event* ev, int sCWId))
1694 {
1695     sttmerr = STTMNOERROR;
1696     int lid = ico_sttm_retrieveSVal(smCWId, value);
1697     if (0 == lid) {
1698         sttmerr = STTMNOTFIND;
1699         _DBG("ico_sttm_addDoAction_V >>%d<<,>>%d<<, .", smCWId, value);
1700         return 0;
1701     }
1702     return ico_sttm_addDoAction(lid, fnc);
1703 }
1704
1705 /**
1706  * @brief Callback registration
1707  * @param smVal value is stateMachine-object identification number
1708  * @param value value is state-object identification number
1709  * @param fanc callback function
1710  * @return not 0:Success
1711  * @       0:added Failure
1712  */
1713 extern "C" int ico_sttm_addEntryActionVV(int smVal, int value,
1714                                          void (*fnc)(st_event* ev, int sCWId))
1715 {
1716     sttmerr = STTMNOERROR;
1717     int id = ico_sttm_retrieveMVal(smVal);
1718     if (0 == id) {
1719         sttmerr = STTMNOTFIND;
1720         _DBG("ico_sttm_addEntryActionVV >>%d<<, %d, .", smVal, value);
1721         return 0;
1722     }
1723     return ico_sttm_addEntryAction_V(id, value, fnc);
1724 }
1725
1726 extern "C" int ico_sttm_addExitActionVV(int smVal, int value,
1727                                         void (*fnc)(st_event* ev, int sCWId))
1728 {
1729     sttmerr = STTMNOERROR;
1730     int id = ico_sttm_retrieveMVal(smVal);
1731     if (0 == id) {
1732         sttmerr = STTMNOTFIND;
1733         _DBG("ico_sttm_addExitActionVV >>%d<<, %d, .", smVal, value);
1734         return 0;
1735     }
1736     return ico_sttm_addExitAction_V(id, value, fnc);
1737 }
1738
1739 extern "C" int ico_sttm_addDoActionVV(int smVal, int value,
1740                                       void (*fnc)(st_event* ev, int sCWId))
1741 {
1742     sttmerr = STTMNOERROR;
1743     int id = ico_sttm_retrieveMVal(smVal);
1744     if (0 == id) {
1745         sttmerr = STTMNOTFIND;
1746         _DBG("ico_sttm_addDoActionVV >>%d<<, %d, .", smVal, value);
1747         return 0;
1748     }
1749     return ico_sttm_addDoAction_V(id, value, fnc);
1750 }
1751
1752
1753 /**
1754  * @brief Callback registration
1755  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
1756  * @param name  name is state-object Identification name
1757  * @param fanc callback function
1758  * @return not 0:Success
1759  * @       0:added Failure
1760  */
1761 extern "C" int ico_sttm_addEntryAction_N(int smCWId, const char* name,
1762                                          void (*fnc)(st_event* ev, int sCWId))
1763 {
1764     int lid = ico_sttm_retrivevSName(smCWId, name);
1765     if (0 == lid) {
1766         sttmerr = STTMNOTFIND;
1767         _DBG("ico_sttm_addEntryAction_N >>%d<<,>>%s<<, .", smCWId, name);
1768         return 0;
1769     }
1770     return ico_sttm_addEntryAction(lid, fnc);
1771 }
1772
1773 extern "C" int ico_sttm_addExitAction_N(int smCWId, const char* name,
1774                                         void (*fnc)(st_event* ev, int sCWId))
1775 {
1776     int lid = ico_sttm_retrivevSName(smCWId, name);
1777     if (0 == lid) {
1778         sttmerr = STTMNOTFIND;
1779         _DBG("ico_sttm_addExitAction_N >>%d<<,>>%s<<, .", smCWId, name);
1780         return 0;
1781     }
1782     return ico_sttm_addExitAction(lid, fnc);
1783 }
1784
1785 extern "C" int ico_sttm_addDoAction_N(int smCWId, const char* name,
1786                                       void (*fnc)(st_event* ev, int sCWId))
1787 {
1788     int lid = ico_sttm_retrivevSName(smCWId, name);
1789     if (0 == lid) {
1790         sttmerr = STTMNOTFIND;
1791         _DBG("ico_sttm_addDoAction_N >>%d<<,>>%s<<, .", smCWId, name);
1792         return 0;
1793     }
1794     return ico_sttm_addDoAction(lid, fnc);
1795 }
1796
1797 /**
1798  * @brief Callback registration
1799  * @param smNm stateMachine-object Identification name
1800  * @param name  name is state-object Identification name
1801  * @param fanc callback function
1802  * @return not 0:Success
1803  * @       0:added Failure
1804  */
1805 extern "C" int ico_sttm_addEntryActionNN(const char* smNm, const char* name,
1806                                          void (*fnc)(st_event* ev, int sCWId))
1807 {
1808     sttmerr = STTMNOERROR;
1809     int id = ico_sttm_retrieveMName(smNm);
1810     if (0 == id) {
1811         sttmerr = STTMNOTFIND;
1812         _DBG("ico_sttm_addEntryActionNN >>%s<<, %s, .", smNm, name);
1813         return 0;
1814     }
1815     return ico_sttm_addEntryAction_N(id, name, fnc);
1816 }
1817
1818 extern "C" int ico_sttm_addExitActionNN(const char* smNm, const char* name,
1819                                         void (*fnc)(st_event* ev, int sCWId))
1820 {
1821     sttmerr = STTMNOERROR;
1822     int id = ico_sttm_retrieveMName(smNm);
1823     if (0 == id) {
1824         sttmerr = STTMNOTFIND;
1825         _DBG("ico_sttm_addExitActionNN >>%s<<, %s, .", smNm, name);
1826         return 0;
1827     }
1828     return ico_sttm_addExitAction_N(id, name, fnc);
1829 }
1830
1831 extern "C" int ico_sttm_addDoActionNN(const char* smNm, const char* name,
1832                                       void (*fnc)(st_event* ev, int sCWId))
1833 {
1834     sttmerr = STTMNOERROR;
1835     int id = ico_sttm_retrieveMName(smNm);
1836     if (0 == id) {
1837         sttmerr = STTMNOTFIND;
1838         _DBG("ico_sttm_addDoActionNN >>%s<<, %s, .", smNm, name);
1839         return 0;
1840     }
1841     return ico_sttm_addDoAction_N(id, name, fnc);
1842 }
1843
1844
1845 /**
1846  * @brief Registration at the time of termination detection transition destination
1847  * @param sCWId ID no. to be registered(c-wrapper local ID)
1848  * @param trCWId finish transition destination(c-wrapper local ID)
1849  * @return not 0:Success
1850  * @       0:set Failure
1851  */
1852 extern "C" int ico_sttm_setFinishTransition(int sCWId, int trCWId)
1853 {
1854     sttmerr = STTMNOERROR;
1855     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
1856     if ((CicoStateCore*)0 == cscTarget) {
1857         sttmerr = STTMNOTFIND;
1858         _DBG("ico_sttm_setFinishTransition >>%d<<, %d", sCWId, trCWId);
1859         return 0;
1860     }
1861     CicoStateCore* cscTrans = getID2ObjSTT(trCWId); // ID to state-object
1862     if ((CicoStateCore*)0 == cscTrans) {
1863         sttmerr = STTMNOTFIND;
1864         _DBG("ico_sttm_setFinishTransition %d,>>%d<<", sCWId, trCWId);
1865         return 0;
1866     }
1867     if (false == cscTarget->isState()) {
1868         sttmerr = STTMTYPEMISMATCH;
1869         _DBG("ico_sttm_setFinishTransition >>%d(%s:%d:%d)<<, %d", sCWId,
1870              cscTarget->getName().c_str(), cscTarget->getValue(),
1871              (int)cscTarget->getType(), trCWId);
1872         return 0;
1873     }
1874     CicoState* cs = (CicoState*) cscTarget;
1875     if (true == cscTrans->isState()) {
1876         cs->setFinishTransition((CicoState*)cscTrans);
1877     }
1878     else if (true == cscTrans->isFinalState()) {
1879         cs->setFinishTransition((CicoFinalState*)cscTrans);
1880     }
1881     else if (true == cscTrans->isHistoryState()) {
1882         cs->setFinishTransition((CicoHistoryState*)cscTrans);
1883     }
1884     else {
1885         sttmerr = STTMTYPEMISMATCH;
1886         _DBG("ico_sttm_setFinishTransition %d,>>%d(%s:%d:%d)<<", sCWId,
1887              trCWId, cscTarget->getName().c_str(),
1888              cscTarget->getValue(), (int)cscTarget->getType());
1889         return 0;
1890     }
1891     return sCWId;
1892 }
1893
1894 /**
1895  * @brief Registration at the time of termination detection transition destination
1896  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
1897  * @param smVal value is stateMachine-object identification number
1898  * @param value value is state-object identification number
1899  * @param trCWId finish transition destination(c-wrapper local ID)
1900  * @param trVl value is state-object identification number transition destination
1901  * @return not 0:Success
1902  * @       0:set Failure
1903  */
1904 extern "C" int ico_sttm_setFinishTransition_V_(int smCWId, int value,
1905                                                int trCWId)
1906 {
1907     sttmerr = STTMNOERROR;
1908     int id = ico_sttm_retrieveSVal(smCWId, value);
1909     if (0 == id) {
1910         _DBG("ico_sttm_setFinishTransition_V_ >> %d, %d<<, %d",smCWId, value, trCWId);
1911         return 0;
1912     }
1913     return ico_sttm_setFinishTransition(id, trCWId);
1914 }
1915
1916 extern "C" int ico_sttm_setFinishTransition_VV(int smCWId, int value,
1917                                                int trVl)
1918 {
1919     sttmerr = STTMNOERROR;
1920     int idT = ico_sttm_retrieveSVal(smCWId, trVl);
1921     if (0 == idT) {
1922         sttmerr = STTMNOTFIND;
1923         _DBG("ico_sttm_setFinishTransition_VV >>%d<<, %d,>>%d<<",smCWId, value, trVl);
1924         return 0;
1925     }
1926     return ico_sttm_setFinishTransition_V_(smCWId, value, idT);
1927 }
1928
1929 extern "C" int ico_sttm_setFinishTransitionVVV(int smVal, int value, int trVl)
1930 {
1931     sttmerr = STTMNOERROR;
1932     int id = ico_sttm_retrieveMVal(smVal);
1933     if (0 == id) {
1934         sttmerr = STTMNOTFIND;
1935         _DBG("ico_sttm_setFinishTransitionVVV >>%d<<, %d, %d", smVal,
1936              value, trVl);
1937         return 0;
1938     }
1939     return ico_sttm_setFinishTransition_VV(id, value, trVl);
1940 }
1941
1942
1943 /**
1944  * @brief Registration at the time of termination detection transition destination
1945  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
1946  * @param name  name is state-object Identification name
1947  * @param trCWId finish transition destination(c-wrapper local ID)
1948  * @return not 0:Success
1949  * @       0:set Failure
1950  */
1951 extern "C" int ico_sttm_setFinishTransition_N_(int smCWId, const char* name,
1952                                                int trCWId)
1953 {
1954     sttmerr = STTMNOERROR;
1955     int id = ico_sttm_retrivevSName(smCWId, name);
1956     if (0 == id) {
1957         sttmerr = STTMNOTFIND;
1958         _DBG("ico_sttm_setFinishTransition_N_ >>%d, %s<<, %d",smCWId, name, trCWId);
1959         return 0;
1960     }
1961     return ico_sttm_setFinishTransition(id, trCWId);
1962 }
1963
1964 extern "C" int ico_sttm_setFinishTransition_NN(int smCWId, const char* name,
1965                                                const char* trNm)
1966 {
1967     sttmerr = STTMNOERROR;
1968     int idT = ico_sttm_retrivevSName(smCWId, trNm);
1969     if (0 == idT) {
1970         sttmerr = STTMNOTFIND;
1971         _DBG("ico_sttm_setFinishTransition_NN >>%d<<, %s,>>%s<<",smCWId,
1972              name, trNm);
1973         return 0;
1974     }
1975     return ico_sttm_setFinishTransition_N_(smCWId, name, idT);
1976 }
1977
1978 extern "C" int ico_sttm_setFinishTransitionNNN(const char* smNm,
1979                                                const char* name,
1980                                                const char* trNm)
1981 {
1982     sttmerr = STTMNOERROR;
1983     int id = ico_sttm_retrieveMName(smNm);
1984     if (0 == id) {
1985         sttmerr = STTMNOTFIND;
1986         _DBG("ico_sttm_setFinishTransitionNNN >>%s<<, %s, %s", smNm, name,
1987              trNm);
1988         return 0;
1989     }
1990     return ico_sttm_setFinishTransition_NN(id, name, trNm);
1991
1992 }
1993
1994
1995 /**
1996  * @brief Registration of default history state-objectss
1997  * @param sCWId ID no. to be registered(c-wrapper local ID)
1998  * @param dfCWId  default transition destination(c-wrapper local ID)
1999  * @return not 0:Success
2000  * @       0:added Failure
2001  */
2002 extern "C" int ico_sttm_addDefault(int sCWId, int dfCWId)
2003 {
2004     sttmerr = STTMNOERROR;
2005     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
2006     if ((CicoStateCore*)0 == cscTarget) {
2007         sttmerr = STTMNOTFIND;
2008         _DBG("ico_sttm_addDefault >>%d<<, %d", sCWId, dfCWId);
2009         return 0;
2010     }
2011     CicoStateCore* cscDef = getID2ObjSTT(dfCWId); // ID to state-object
2012     if ((CicoStateCore*)0 == cscDef) {
2013         sttmerr = STTMNOTFIND;
2014         _DBG("ico_sttm_addDefault %d,>>%d<<", sCWId, dfCWId);
2015         return 0;
2016     }
2017     if (false == cscTarget->isHistoryState()) {
2018         sttmerr = STTMTYPEMISMATCH;
2019         _DBG("ico_sttm_addDefault >>%d(%s:%d:%d)<<, %d", sCWId,
2020              cscTarget->getName().c_str(), cscTarget->getValue(),
2021              (int)cscTarget->getType(), dfCWId);
2022         return 0;
2023     }
2024     CicoHistoryState* chs = (CicoHistoryState*) cscTarget;
2025     if (true == cscDef->isState()) {
2026         chs->addDefaultState((CicoState*)cscDef);
2027     }
2028     else {
2029         sttmerr = STTMTYPEMISMATCH;
2030         _DBG("ico_sttm_addDefault %d,>>%d(%s:%d:%d)<<", sCWId,
2031              dfCWId, cscTarget->getName().c_str(),
2032              cscTarget->getValue(), (int)cscTarget->getType());
2033         return 0;
2034     }
2035     return sCWId;
2036 }
2037
2038 /**
2039  * @brief Registration of default history state-objectss
2040  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
2041  * @param value value is state-object identification number
2042  * @param dfCWId  default transition destination(c-wrapper local ID)
2043  * @param dfVal value is state-object identification number
2044  * @return not 0:Success
2045  * @       0:added Failure
2046  */
2047 extern "C" int ico_sttm_addDefault_V_(int smCWId, int value, int dfCWId)
2048 {
2049     sttmerr = STTMNOERROR;
2050     int id = ico_sttm_retrieveSVal(smCWId, value);
2051     if (0 == id) {
2052         sttmerr = STTMNOTFIND;
2053         _DBG("ico_sttm_addDefaultV >>%d, %d<<, %d", smCWId, value, dfCWId);
2054         return 0;
2055     }
2056     return ico_sttm_addDefault(id, dfCWId);
2057 }
2058
2059 extern "C" int ico_sttm_addDefault_VV(int smCWId, int value, int dfVal)
2060 {
2061     sttmerr = STTMNOERROR;
2062     int dfCWId = ico_sttm_retrieveSVal(smCWId, dfVal);
2063     if (0 == dfCWId) {
2064         sttmerr = STTMNOTFIND;
2065         _DBG("ico_sttm_addDefaultVV >>%d<<, %d,>>%d<<", smCWId, value, dfVal);
2066         return 0;
2067     }
2068     return ico_sttm_addDefault_V_(smCWId, value, dfCWId);
2069 }
2070
2071 extern "C" int ico_sttm_addDefaultVVV(int smVal, int value, int dfVal)
2072 {
2073     sttmerr = STTMNOERROR;
2074     int id = ico_sttm_retrieveMVal(smVal);
2075     if (0 == id) {
2076         sttmerr = STTMNOTFIND;
2077         _DBG("ico_sttm_addDefaultVVV >>%d<<, %d,>>%d<<", smVal, value,
2078              dfVal);
2079         return 0;
2080     }
2081     return ico_sttm_addDefault_VV(id, value, dfVal);
2082 }
2083
2084 /**
2085  * @brief Registration of default history state-objectss
2086  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
2087  * @param name  name is state-object Identification name
2088  * @param dfCWId  default transition destination(c-wrapper local ID)
2089  * @param dfNm  name is state-object Identification name
2090  * @return not 0:Success
2091  * @       0:added Failure
2092  */
2093 extern "C" int ico_sttm_addDefault_N_(int smCWId, const char* name, int dfCWId)
2094 {
2095     sttmerr = STTMNOERROR;
2096     int id = ico_sttm_retrivevSName(smCWId, name);
2097     if (0 == id) {
2098         sttmerr = STTMNOTFIND;
2099         _DBG("ico_sttm_addDefault_N_ >>%d, %s<<, %d",smCWId, name, dfCWId);
2100         return 0;
2101     }
2102     return ico_sttm_addDefault(id, dfCWId);
2103 }
2104
2105 extern "C" int ico_sttm_addDefault_NN(int smCWId, const char* name, const char* dfNm)
2106 {
2107     sttmerr = STTMNOERROR;
2108     int idD = ico_sttm_retrivevSName(smCWId, dfNm);
2109     if (0 == idD) {
2110         sttmerr = STTMNOTFIND;
2111         _DBG("ico_sttm_addDefault_NN >>%d<<, %s,>>%s<<", smCWId, name, dfNm);
2112         return 0;
2113     }
2114     return ico_sttm_addDefault_N_(smCWId, name, idD);
2115 }
2116
2117 extern "C" int ico_sttm_addDefaultNNN(const char* smNm, const char* name,
2118                                       const char* dfNm)
2119 {
2120     sttmerr = STTMNOERROR;
2121     int id = ico_sttm_retrieveMName(smNm);
2122     if (0 == id) {
2123         sttmerr = STTMNOTFIND;
2124         _DBG("ico_sttm_addDefaultNNN >>%s<<, %s, %s", smNm, name, dfNm);
2125         return 0;
2126     }
2127     return ico_sttm_addDefault_NN(id, name, dfNm);
2128 }
2129
2130 /**
2131  * @breif Registration of start position state-objects
2132  * @param ID stateMachine-object/state-object ID no.(c-wrapper local ID)
2133  * @param sCWId start position state-object ID no.(c-wrapper local ID)
2134  * @return not 0:Success
2135  * @       0:add failure
2136  */
2137 extern "C" int ico_sttm_addStartPosition(int CWId, int sCWId)
2138 {
2139     sttmerr = STTMNOERROR;
2140     CicoStateCore* cscTarget = getID2ObjSTT(CWId); // ID to state-object
2141     if ((CicoStateCore*)0 == cscTarget) {
2142         sttmerr = STTMNOTFIND;
2143         _DBG("ico_sttm_setStartPosition >>%d<<, %d", CWId, sCWId);
2144         return 0;
2145     }
2146     CicoStateCore* cscIni = getID2ObjSTT(sCWId); // ID to state-object
2147     if ((CicoStateCore*)0 == cscIni) {
2148         sttmerr = STTMNOTFIND;
2149         _DBG("ico_sttm_setStartPosition %d,>>%d<<", CWId, sCWId);
2150         return 0;
2151     }
2152     CicoState* cs = (CicoState*)0;
2153     CicoHistoryState* chs = (CicoHistoryState*)0;
2154     if (true == cscIni->isState()) {
2155         cs = (CicoState*)cscIni;
2156     }
2157     else if (true == cscIni->isHistoryState()) {
2158         chs = (CicoHistoryState*)cscIni;
2159     }
2160     else {
2161         sttmerr = STTMTYPEMISMATCH;
2162         _DBG("ico_sttm_setStartPosition %d,>>%d(%s:%d:%d)<<", CWId, sCWId,
2163              cscIni->getName().c_str(), cscIni->getValue(),
2164              (int)cscIni->getType());
2165         return 0;
2166     }
2167     if (true == cscTarget->isStateMachine()) {
2168         CicoStateMachine* csm = (CicoStateMachine*)cscTarget;
2169         if ((CicoState*)0 != cs) {
2170             csm->addInitState(cs);
2171         }
2172         else {
2173             csm->addInitState(chs);
2174         }
2175     }
2176     else if (true == cscTarget->isState()) {
2177         CicoState* csT = (CicoState*)cscTarget;
2178         if ((CicoState*)0 != cs) {
2179             csT->addInitState(cs);
2180         }
2181         else {
2182             csT->addInitState(chs);
2183         }
2184     }
2185     else {
2186         sttmerr = STTMTYPEMISMATCH;
2187         _DBG("ico_sttm_setStartPosition >>%d(%s:%d:%d)<<, %d", CWId,
2188              cscTarget->getName().c_str(), cscTarget->getValue(),
2189              (int)cscTarget->getType(), sCWId);
2190         return 0;
2191     }
2192     return CWId;
2193 }
2194
2195
2196
2197 /**
2198  * @breif Registration of start position state-objects
2199  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
2200  * @param smVal value is stateMachine-object identification number
2201  * @param value value is state-object identification number
2202  * @param sCWId start position state-object ID no.(c-wrapper local ID)
2203  * @param value spVal is state-object identification number
2204  * @return not 0:Success
2205  * @       0:set failure
2206  */
2207 extern "C" int ico_sttm_addStartPosition_V_(int smCWId, int value, int sCWId)
2208 {
2209     sttmerr = STTMNOERROR;
2210     int id = ico_sttm_retrieveSVal(smCWId, value);
2211     if (0 == id) {
2212         sttmerr = STTMNOTFIND;
2213         _DBG("ico_sttm_addStartPosition_V_ >>%d, %d<<, %d",smCWId, value, sCWId);
2214         return 0;
2215     }
2216     return ico_sttm_addStartPosition(id, sCWId);
2217 }
2218
2219
2220 extern "C" int ico_sttm_addStartPosition_VV(int smCWId, const int value, int spVal)
2221 {
2222     sttmerr = STTMNOERROR;
2223     int idSP = ico_sttm_retrieveSVal(smCWId, spVal);
2224     if (0 == idSP) {
2225         sttmerr = STTMNOTFIND;
2226         _DBG("ico_sttm_addStartPosition_VV >>%d<<, %d,>>%d<<",smCWId, value, spVal);
2227         return 0;
2228     }
2229     return ico_sttm_addStartPosition_V_(smCWId, value, idSP);
2230 }
2231
2232 extern "C" int ico_sttm_addStartPositionVVV(int smVal, int value, int spVal)
2233 {
2234     sttmerr = STTMNOERROR;
2235     int id = ico_sttm_retrieveMVal(smVal);
2236     if (0 == id) {
2237         sttmerr = STTMNOTFIND;
2238         _DBG("ico_sttm_addStartPositionVVV >>%d<<, %d, %d", smVal, value,
2239              spVal);
2240         return 0;
2241     }
2242     return ico_sttm_addStartPosition_VV(id, value, spVal);
2243 }
2244
2245 extern "C" int ico_sttm_addStartPositionSMVV(int smVal, int spVal)
2246 {
2247     sttmerr = STTMNOERROR;
2248     int id = ico_sttm_retrieveMVal(smVal);
2249     if (0 == id) {
2250         sttmerr = STTMNOTFIND;
2251         _DBG("ico_sttm_addStartPositionSMVV >>%d<<, %d", smVal, spVal);
2252         return 0;
2253     }
2254     int idSP = ico_sttm_retrieveSVal(id, spVal);
2255     if (0 == idSP) {
2256         sttmerr = STTMNOTFIND;
2257         _DBG("ico_sttm_addStartPositionSMVV %d,>>%d<<",smVal, spVal);
2258         return 0;
2259     }
2260     return ico_sttm_addStartPosition(id, idSP);
2261 }
2262
2263
2264 /**
2265  * @breif Registration of start position state-objects
2266  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
2267  * @param name  name is state-object Identification name
2268  * @param sCWId start position state-object ID no.(c-wrapper local ID)
2269  * @param name  spNm is state-object Identification name
2270  * @return not 0:Success
2271  * @       0:set failure
2272  */
2273 extern "C" int ico_sttm_addStartPosition_N_(int smCWId, const char* name, int sCWId)
2274 {
2275     sttmerr = STTMNOERROR;
2276     int id = ico_sttm_retrivevSName(smCWId, name);
2277     if (0 == id) {
2278         sttmerr = STTMNOTFIND;
2279         _DBG("ico_sttm_addStartPosition_N_ >>%d, %s<<, %d",smCWId, name, sCWId);
2280         return 0;
2281     }
2282     return ico_sttm_addStartPosition(id, sCWId);
2283 }
2284
2285 extern "C" int ico_sttm_addStartPosition_NN(int smCWId, const char* name,
2286                                             const char*  spNm)
2287 {
2288     sttmerr = STTMNOERROR;
2289     int idSP = ico_sttm_retrivevSName(smCWId, spNm);
2290     if (0 == idSP) {
2291         sttmerr = STTMNOTFIND;
2292         _DBG("ico_sttm_addStartPosition_NN >>%d<<, %s,>>%s<<",smCWId, name,
2293              spNm);
2294         return 0;
2295     }
2296     return ico_sttm_addStartPosition_N_(smCWId, name, idSP);
2297 }
2298
2299 extern "C" int ico_sttm_addStartPositionNNN(const char* smNm, const char* name,
2300                                             const char* spNm)
2301 {
2302     sttmerr = STTMNOERROR;
2303     int id = ico_sttm_retrieveMName(smNm);
2304     if (0 == id) {
2305         sttmerr = STTMNOTFIND;
2306         _DBG("ico_sttm_addStartPositionNNN >>%s<<, %s, %s", smNm, name,
2307              spNm);
2308         return 0;
2309     }
2310     return ico_sttm_addStartPosition_NN(id, name, spNm);
2311 }
2312
2313 extern "C" int ico_sttm_addStartPositionSMNN(const char* smNm, const char* spNm)
2314 {
2315     sttmerr = STTMNOERROR;
2316     int id = ico_sttm_retrieveMName(smNm);
2317     if (0 == id) {
2318         sttmerr = STTMNOTFIND;
2319         _DBG("ico_sttm_addStartPositionSMNN >>%s<<, %s", smNm, spNm);
2320         return 0;
2321     }
2322     int idSP = ico_sttm_retrivevSName(id, spNm);
2323     if (0 == idSP) {
2324         sttmerr = STTMNOTFIND;
2325         _DBG("ico_sttm_addStartPositionSMNN %s,>>%s<<",smNm, spNm);
2326         return 0;
2327     }
2328     return ico_sttm_addStartPosition(id, idSP);
2329 }
2330
2331
2332 /* Operational system */
2333 /**
2334  * @breif start stateMachine
2335  * @param smCWId stateMachine-object ID no. to be registered(c-wrapper local ID)
2336  * @param smVal value is stateMachine-object identification number
2337  * @param smNm stateMachine-object Identification name
2338  * @return not 0:Success
2339  * @       0:start Failure
2340  */
2341 extern "C" int ico_sttm_start(int smCWId)
2342 {
2343     sttmerr = STTMNOERROR;
2344     CicoStateMachine* csm = ico_sttm_getStateMachineX(smCWId, "ico_sttm_start");
2345     if ((CicoStateMachine*)0 == csm) {
2346         return 0;
2347     }
2348     return csm->start()? smCWId:0;
2349 }
2350
2351
2352
2353 extern "C" int ico_sttm_startV(int smVal)
2354 {
2355     sttmerr = STTMNOERROR;
2356     int id = ico_sttm_retrieveMVal(smVal);
2357     if (0 == id) {
2358         sttmerr = STTMNOTFIND;
2359         _DBG("ico_sttm_startV >>%d<<", smVal);
2360         return 0;
2361     }
2362     return ico_sttm_start(id);
2363 }
2364
2365 extern "C" int ico_sttm_startN(const char* smNm)
2366 {
2367     sttmerr = STTMNOERROR;
2368     int id = ico_sttm_retrieveMName(smNm);
2369     if (0 == id) {
2370         sttmerr = STTMNOTFIND;
2371         _DBG("ico_sttm_startN >>%s<<", smNm);
2372         return 0;
2373     }
2374     return ico_sttm_start(id);
2375 }
2376
2377 /**
2378  * @breif stop stateMachine
2379  * @param smCWId stateMachine-object ID no. to be registered(c-wrapper local ID)
2380  * @param smVal value is stateMachine-object identification number
2381  * @param smNm stateMachine-object Identification name
2382  * @return not 0:Success
2383  * @       0:stop Failure
2384  */
2385 extern "C" int ico_sttm_stop(int smCWId)
2386 {
2387     sttmerr = STTMNOERROR;
2388     CicoStateMachine* csm = ico_sttm_getStateMachineX(smCWId, "ico_sttm_stop");
2389     if ((CicoStateMachine*)0 == csm) {
2390         return 0;
2391     }
2392     return csm->stop()? smCWId:0;
2393 }
2394
2395 extern "C" int ico_sttm_stopV(int smVal)
2396 {
2397     sttmerr = STTMNOERROR;
2398     int id = ico_sttm_retrieveMVal(smVal);
2399     if (0 == id) {
2400         sttmerr = STTMNOTFIND;
2401         _DBG("ico_sttm_stopV >>%d<<", smVal);
2402         return 0;
2403     }
2404     return ico_sttm_stop(id);
2405 }
2406
2407 extern "C" int ico_sttm_stopN(const char* smNm)
2408 {
2409     sttmerr = STTMNOERROR;
2410     int id = ico_sttm_retrieveMName(smNm);
2411     if (0 == id) {
2412         sttmerr = STTMNOTFIND;
2413         _DBG("ico_sttm_stopN >>%s<<", smNm);
2414         return 0;
2415     }
2416     return ico_sttm_stop(id);
2417 }
2418
2419 bool ico_sttm_eventX(int smCWId, CicoEvent& ev, const char* fname)
2420 {
2421     CicoStateMachine* csm = ico_sttm_getStateMachineX(smCWId, fname);
2422     if ((CicoStateMachine*)0 == csm) {
2423         return 0;
2424     }
2425     return csm->eventEntry(ev);
2426 }
2427
2428 /**
2429  * @brief Issue an event
2430  * @param smCWId stateMachine-object ID no. to be registered(c-wrapper local ID)
2431  * @param smVal value is stateMachine-object identification number
2432  * @param smNm stateMachine-object Identification name
2433  * @param ev event No.(Use the 1000-65535)
2434  * @param gcv Comparison value of guard condition
2435  * @param info Additional information user
2436  * @return not 0:Success on Transition
2437  * @       0: none Transition
2438  */
2439 extern "C" int ico_sttm_event(int smCWId, unsigned short ev, void* info)
2440 {
2441     sttmerr = STTMNOERROR;
2442     CicoEvent oev(ev, info);
2443     return ico_sttm_eventX(smCWId, oev, "ico_sttm_event")? smCWId:0;
2444 }
2445
2446 extern "C" int ico_sttm_eventGCI(int smCWId, unsigned short ev, int gcv, void* info)
2447 {
2448     sttmerr = STTMNOERROR;
2449     CicoEvent oev(ev, gcv, info);
2450     return ico_sttm_eventX(smCWId, oev, "ico_sttm_eventGCI")? smCWId:0;
2451 }
2452
2453 extern "C" int ico_sttm_eventGCD(int smCWId, unsigned short ev, double gcv, void* info)
2454 {
2455     sttmerr = STTMNOERROR;
2456     CicoEvent oev(ev, gcv, info);
2457     return ico_sttm_eventX(smCWId, oev, "ico_sttm_eventGCD")? smCWId:0;
2458 }
2459
2460 extern "C" int ico_sttm_eventGCS(int smCWId, unsigned short ev, const char* gcv, void* info)
2461 {
2462     sttmerr = STTMNOERROR;
2463     CicoEvent oev(ev, gcv, info);
2464     return ico_sttm_eventX(smCWId, oev, "ico_sttm_eventGCS")? smCWId:0;
2465 }
2466
2467 extern "C" int ico_sttm_eventV(int smVal, unsigned short ev, void* info)
2468 {
2469     sttmerr = STTMNOERROR;
2470     int id = ico_sttm_retrieveMVal(smVal);
2471     if (0 == id) {
2472         sttmerr = STTMNOTFIND;
2473         _DBG("ico_sttm_eventV >>%d<<, %d, .", smVal, ev);
2474         return 0;
2475     }
2476     return ico_sttm_event(id, ev, info);
2477 }
2478
2479 extern "C" int ico_sttm_eventGCIV(int smVal, unsigned short ev, int gcv,
2480                                   void* info)
2481 {
2482     sttmerr = STTMNOERROR;
2483     int id = ico_sttm_retrieveMVal(smVal);
2484     if (0 == id) {
2485         sttmerr = STTMNOTFIND;
2486         _DBG("ico_sttm_eventGCIV >>%d<<, %d, %d, .", smVal, ev, gcv);
2487         return 0;
2488     }
2489     return ico_sttm_eventGCI(id, ev, gcv, info);
2490 }
2491
2492 extern "C" int ico_sttm_eventGCDV(int smVal, unsigned short ev, double gcv,
2493                                   void* info)
2494 {
2495     sttmerr = STTMNOERROR;
2496     int id = ico_sttm_retrieveMVal(smVal);
2497     if (0 == id) {
2498         sttmerr = STTMNOTFIND;
2499         _DBG("ico_sttm_eventGCDV >>%d<<, %d, %f, .", smVal, ev, gcv);
2500         return 0;
2501     }
2502     return ico_sttm_eventGCD(id, ev, gcv, info);
2503 }
2504
2505 extern "C" int ico_sttm_eventGCSV(int smVal, unsigned short ev,
2506                                   const char* gcv, void* info)
2507 {
2508     sttmerr = STTMNOERROR;
2509     int id = ico_sttm_retrieveMVal(smVal);
2510     if (0 == id) {
2511         sttmerr = STTMNOTFIND;
2512         _DBG("ico_sttm_eventGCSV >>%d<<, %d, %s, .", smVal, ev, gcv);
2513         return 0;
2514     }
2515     return ico_sttm_eventGCS(id, ev, gcv, info);
2516 }
2517
2518 extern "C" int ico_sttm_eventN(const char* smNm, unsigned short ev, void* info)
2519 {
2520     sttmerr = STTMNOERROR;
2521     int id = ico_sttm_retrieveMName(smNm);
2522     if (0 == id) {
2523         sttmerr = STTMNOTFIND;
2524         _DBG("ico_sttm_eventN >>%s<<, %d, .", smNm, ev);
2525         return 0;
2526     }
2527     return ico_sttm_event(id, ev, info);
2528 }
2529
2530 extern "C" int ico_sttm_eventGCIN(const char* smNm, unsigned short ev, int gcv,
2531                                   void* info)
2532 {
2533     sttmerr = STTMNOERROR;
2534     int id = ico_sttm_retrieveMName(smNm);
2535     if (0 == id) {
2536         sttmerr = STTMNOTFIND;
2537         _DBG("ico_sttm_eventGCIN >>%s<<, %d, %d, .", smNm, ev, gcv);
2538         return 0;
2539     }
2540     return ico_sttm_eventGCI(id, ev, gcv, info);
2541 }
2542
2543 extern "C" int ico_sttm_eventGCDN(const char* smNm, unsigned short ev, double gcv,
2544                                   void* info)
2545 {
2546     sttmerr = STTMNOERROR;
2547     int id = ico_sttm_retrieveMName(smNm);
2548     if (0 == id) {
2549         sttmerr = STTMNOTFIND;
2550         _DBG("ico_sttm_eventGCDN >>%s<<, %d, %f, .", smNm, ev, gcv);
2551         return 0;
2552     }
2553     return ico_sttm_eventGCD(id, ev, gcv, info);
2554 }
2555
2556 extern "C" int ico_sttm_eventGCSN(const char* smNm, unsigned short ev, const char* gcv,
2557                        void* info)
2558 {
2559     sttmerr = STTMNOERROR;
2560     int id = ico_sttm_retrieveMName(smNm);
2561     if (0 == id) {
2562         sttmerr = STTMNOTFIND;
2563         _DBG("ico_sttm_eventGCSN >>%s<<, %d, %s, .", smNm, ev, gcv);
2564         return 0;
2565     }
2566     return ico_sttm_eventGCS(id, ev, gcv, info);
2567 }
2568
2569
2570
2571 bool ico_sttm_eventTestX(int smCWId, CicoEvent& ev, const char* fname)
2572 {
2573     CicoStateMachine* csm = ico_sttm_getStateMachineX(smCWId, fname);
2574     if ((CicoStateMachine*)0 == csm) {
2575         return 0;
2576     }
2577     return csm->eventTest(ev);
2578 }
2579
2580 /**
2581  * @brief Test of the transition
2582  * @param smCWId stateMachine-object ID no. to be registered(c-wrapper local ID)
2583  * @param smVal value is stateMachine-object identification number
2584  * @param smNm stateMachine-object Identification name
2585  * @param ev event No.(Use the 1000-65535)
2586  * @param gcv Comparison value of guard condition
2587  * @param info Additional information user
2588  * @return not 0:Success on Transition
2589  * @       0: none Transition
2590  */
2591 extern "C" int ico_sttm_eventTest(int smCWId, unsigned short ev)
2592 {
2593     sttmerr = STTMNOERROR;
2594     CicoEvent oev(ev);
2595     return ico_sttm_eventTestX(smCWId, oev, "ico_sttm_eventTest")? smCWId:0;
2596 }
2597
2598 extern "C" int ico_sttm_eventTestGCI(int smCWId, unsigned short ev, int gcv)
2599 {
2600     sttmerr = STTMNOERROR;
2601     CicoEvent oev(ev, gcv);
2602     return ico_sttm_eventTestX(smCWId, oev, "ico_sttm_eventTestGCI")? smCWId:0;
2603 }
2604
2605 extern "C" int ico_sttm_eventTestGCD(int smCWId, unsigned short ev, double gcv)
2606 {
2607     sttmerr = STTMNOERROR;
2608     CicoEvent oev(ev, gcv);
2609     return ico_sttm_eventTestX(smCWId, oev, "ico_sttm_eventTestGCD")? smCWId:0;
2610 }
2611
2612 extern "C" int ico_sttm_eventTestGCS(int smCWId, unsigned short ev, const char* gcv)
2613 {
2614     sttmerr = STTMNOERROR;
2615     CicoEvent oev(ev, gcv);
2616     return ico_sttm_eventTestX(smCWId, oev, "ico_sttm_eventTestGCS")? smCWId:0;
2617 }
2618
2619 extern "C" int ico_sttm_eventTestV(int smVal, unsigned short ev)
2620 {
2621     sttmerr = STTMNOERROR;
2622     int id = ico_sttm_retrieveMVal(smVal);
2623     if (0 == id) {
2624         sttmerr = STTMNOTFIND;
2625         _DBG("ico_sttm_eventTestV >>%d<<, %d, .", smVal, ev);
2626         return 0;
2627     }
2628     return ico_sttm_eventTest(id, ev);
2629 }
2630
2631 extern "C" int ico_sttm_eventTestGCIV(int smVal, unsigned short ev, int gcv)
2632 {
2633     sttmerr = STTMNOERROR;
2634     int id = ico_sttm_retrieveMVal(smVal);
2635     if (0 == id) {
2636         sttmerr = STTMNOTFIND;
2637         _DBG("ico_sttm_eventGCIV >>%d<<, %d, %d, .", smVal, ev, gcv);
2638         return 0;
2639     }
2640     return ico_sttm_eventTestGCI(id, ev, gcv);
2641 }
2642
2643 extern "C" int ico_sttm_eventTestGCDV(int smVal, unsigned short ev, double gcv)
2644 {
2645     sttmerr = STTMNOERROR;
2646     int id = ico_sttm_retrieveMVal(smVal);
2647     if (0 == id) {
2648         sttmerr = STTMNOTFIND;
2649         _DBG("ico_sttm_eventTestGCDV >>%d<<, %d, %f, .", smVal, ev, gcv);
2650         return 0;
2651     }
2652     return ico_sttm_eventTestGCD(id, ev, gcv);
2653 }
2654
2655 extern "C" int ico_sttm_eventTestGCSV(int smVal, unsigned short ev, const char* gcv)
2656 {
2657     sttmerr = STTMNOERROR;
2658     int id = ico_sttm_retrieveMVal(smVal);
2659     if (0 == id) {
2660         sttmerr = STTMNOTFIND;
2661         _DBG("ico_sttm_eventTestGCSV >>%d<<, %d, %s, .", smVal, ev, gcv);
2662         return 0;
2663     }
2664     return ico_sttm_eventTestGCS(id, ev, gcv);
2665 }
2666
2667 extern "C" int ico_sttm_eventTestN(const char* smNm, unsigned short ev)
2668 {
2669     sttmerr = STTMNOERROR;
2670     int id = ico_sttm_retrieveMName(smNm);
2671     if (0 == id) {
2672         sttmerr = STTMNOTFIND;
2673         _DBG("ico_sttm_eventTestN >>%s<<, %d, .", smNm, ev);
2674         return 0;
2675     }
2676     return ico_sttm_eventTest(id, ev);
2677 }
2678
2679 extern "C" int ico_sttm_eventTestGCIN(const char* smNm, unsigned short ev, int gcv)
2680 {
2681     sttmerr = STTMNOERROR;
2682     int id = ico_sttm_retrieveMName(smNm);
2683     if (0 == id) {
2684         sttmerr = STTMNOTFIND;
2685         _DBG("ico_sttm_eventTestGCIN >>%s<<, %d, %d, .", smNm, ev, gcv);
2686         return 0;
2687     }
2688     return ico_sttm_eventTestGCI(id, ev, gcv);
2689 }
2690
2691 extern "C" int ico_sttm_eventTestGCDN(const char* smNm, unsigned short ev, double gcv)
2692 {
2693     sttmerr = STTMNOERROR;
2694     int id = ico_sttm_retrieveMName(smNm);
2695     if (0 == id) {
2696         sttmerr = STTMNOTFIND;
2697         _DBG("ico_sttm_eventTestGCDN >>%s<<, %d, %f, .", smNm, ev, gcv);
2698         return 0;
2699     }
2700     return ico_sttm_eventTestGCD(id, ev, gcv);
2701 }
2702
2703 extern "C" int ico_sttm_eventTestGCSN(const char* smNm, unsigned short ev,
2704                            const char* gcv)
2705 {
2706     sttmerr = STTMNOERROR;
2707     int id = ico_sttm_retrieveMName(smNm);
2708     if (0 == id) {
2709         sttmerr = STTMNOTFIND;
2710         _DBG("ico_sttm_eventTestGCSN >>%s<<, %d, %s, .", smNm, ev, gcv);
2711         return 0;
2712     }
2713     return ico_sttm_eventTestGCS(id, ev, gcv);
2714 }
2715
2716 /**
2717  * @brief retrieve stateMachine-object
2718  * @param value/name  stateMachine-object ID no. / name
2719  * @return not 0:stateMachine-object ID no.(c-wrapper local ID)
2720  * @       0:not find
2721  */
2722 extern "C" int ico_sttm_retrieveMVal(int value)
2723 {
2724     sttmerr = STTMNOERROR;
2725     int r = 0;
2726     int sz = stateObjects.size();
2727     for (int i = 0; i< sz; i++) {
2728         if (true == stateObjects[i]->isStateMachine()) {
2729             if (value == stateObjects[i]->getValue() ) {
2730                 r = i+1;
2731                 break;                  // break of for i<sz
2732             }
2733         }
2734     }
2735     return r;
2736 }
2737
2738 extern "C" int ico_sttm_retrieveMName(const char* name)
2739 {
2740     sttmerr = STTMNOERROR;
2741     std::string oname(name);
2742     int r = 0;
2743     int sz = stateObjects.size();
2744     for (int i = 0; i< sz; i++) {
2745         if (true == stateObjects[i]->isStateMachine()) {
2746             if (oname == stateObjects[i]->getName()) {
2747                 r = i+1;
2748                 break;                  // break of for i<sz
2749             }
2750         }
2751     }
2752     return r;
2753 }
2754
2755 /**
2756  * @brief retrieve state-object(state/historyState/finalState)
2757  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
2758  * @param value/name  state(state/historyState/finalState)-object ID no. / name
2759  * @return not 0:state-object ID no.(c-wrapper local ID)
2760  * @       0:not find
2761  */
2762 extern "C" int ico_sttm_retrieveSVal(int smCWId, int value)
2763 {
2764     sttmerr = STTMNOERROR;
2765     CicoStateMachine* csm;
2766     csm = ico_sttm_getStateMachineX(smCWId, "ico_sttm_retrieveSVal");
2767     if ((CicoStateMachine*)0 == csm) {
2768         return 0;
2769     }
2770     const CicoStateCore* csc = csm->getState(value);
2771     if ((CicoStateCore*)0 == csc) {
2772         _DBG("ico_sttm_retrieveSVal %d, >>%d<<", smCWId, value);
2773         return 0;
2774     }
2775     return getObjSTT2ID(csc);
2776 }
2777
2778 extern "C" int ico_sttm_retrivevSName(int smCWId, const char* name)
2779 {
2780     sttmerr = STTMNOERROR;
2781     CicoStateMachine* csm;
2782     csm = ico_sttm_getStateMachineX(smCWId, "ico_sttm_retrivevSName");
2783     if ((CicoStateMachine*)0 == csm) {
2784         return 0;
2785     }
2786     const CicoStateCore* csc = csm->getState(name);
2787     if ((CicoStateCore*)0 == csc) {
2788         _DBG("ico_sttm_retrivevSName %d, >>%s<<", smCWId, name);
2789         return 0;
2790     }
2791     return getObjSTT2ID(csc);
2792 }
2793
2794
2795 /**
2796  * @brief object check
2797  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
2798  * @return not 0:stateMachine-object
2799  * @           0:no stateMachine-object
2800  */
2801 extern "C" int ico_sttm_isStateMachine(int smCWId)
2802 {
2803     sttmerr = STTMNOERROR;
2804     CicoStateCore* cscTarget = getID2ObjSTT(smCWId); // ID to state-object
2805     if ((CicoStateCore*)0 == cscTarget) {
2806         sttmerr = STTMNOTFIND;
2807         _DBG("ico_sttm_isStateMachine >>%d<<", smCWId);
2808         return 0;
2809     }
2810     return cscTarget->isStateMachine()? smCWId:0;
2811 }
2812
2813 /**
2814  * @brief object check
2815  * @param sCWId state-object ID no.(c-wrapper local ID)
2816  * @return not 0:state-object
2817  * @       0:no state-object
2818  */
2819 extern "C" int ico_sttm_isState(int sCWId)
2820 {
2821     sttmerr = STTMNOERROR;
2822     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
2823     if ((CicoStateCore*)0 == cscTarget) {
2824         sttmerr = STTMNOTFIND;
2825         _DBG("ico_sttm_isState >>%d<<", sCWId);
2826         return 0;
2827     }
2828     return cscTarget->isState()? sCWId:0;
2829 }
2830
2831
2832 /**
2833  * @brief object check
2834  * @param sCWId historyState-object ID no.(c-wrapper local ID)
2835  * @return not 0:state-object
2836  * @       0:no state-object
2837  */
2838 extern "C" int ico_sttm_isHistoryState(int sCWId)
2839 {
2840     sttmerr = STTMNOERROR;
2841     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
2842     if ((CicoStateCore*)0 == cscTarget) {
2843         sttmerr = STTMNOTFIND;
2844         _DBG("ico_sttm_isHistoryState >>%d<<", sCWId);
2845         return 0;
2846     }
2847     return cscTarget->isHistoryState()? sCWId:0;
2848 }
2849
2850
2851 /**
2852  * @brief object check
2853  * @param sCWId finalState-object ID no.(c-wrapper local ID)
2854  * @return not 0:state-object
2855  * @       0:no state-object
2856  */
2857 extern "C" int ico_sttm_isFinalState(int sCWId)
2858 {
2859     sttmerr = STTMNOERROR;
2860     CicoStateCore* cscTarget = getID2ObjSTT(sCWId); // ID to state-object
2861     if ((CicoStateCore*)0 == cscTarget) {
2862         sttmerr = STTMNOTFIND;
2863         _DBG("ico_sttm_isFinalState >>%d<<", sCWId);
2864         return 0;
2865     }
2866     return cscTarget->isFinalState()? sCWId:0;
2867 }
2868
2869 /**
2870  * @brief get state-object running
2871  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
2872  * @param X[] Enter the active state-objects(c-wrapper local ID) or value or name
2873  * @param size of array sCWIds or values or names
2874  * @param value true:get value false:get c-wrapper ID
2875  * @param p top or all or bottom get position is getCurrentState parameter
2876  * @param fname call function name
2877  * @return Number of registered X
2878  * @       -1:size over
2879  */
2880 int ico_sttm_getActiveStateX(int smCWId, int X[], size_t arysz, bool value,
2881                              CicoStateCore::E_GetPolicy p, const char* fname)
2882 {
2883     CicoStateMachine* csm;
2884     csm = ico_sttm_getStateMachineX(smCWId, fname);
2885     if ((CicoStateMachine*)0 == csm) {
2886         return 0;
2887     }
2888     std::vector<const CicoState*> stt;
2889     if (false == csm->getCurrentState(stt, p)) {
2890         _DBG("%s NO ACTIVE STATEMACHINE(\"%s\":%d)",fname,
2891              csm->getName().c_str(), csm->getValue());
2892         return 0;
2893     }
2894     int r = 0;
2895     int sz = stt.size();
2896     for (int i = 0; i < sz; i++) {
2897         if ( r >= (int)arysz ) {
2898             r = -1;
2899             break;                      // break of for i<sz
2900         }
2901         if (true == value) {
2902             X[r] = stt[i]->getValue();  // set state-object value
2903             r++;
2904         }
2905         else {
2906             X[r] = getObjSTT2ID(stt[i]); // set state-object C-wrapper local ID
2907             if (0 != X[r]) {
2908                 r++;
2909             }
2910         }
2911     }
2912     if (0 == r) {
2913         sttmerr = STTMNOTFIND;
2914         _DBG("%s get size %d -> %d",fname, sz, r);
2915         return 0;
2916     }
2917     return r;
2918 }
2919 int ico_sttm_getActiveState_NX(int smCWId, const char* X[], size_t arysz,
2920                              CicoStateCore::E_GetPolicy p, const char* fname)
2921 {
2922     CicoStateMachine* csm;
2923     csm = ico_sttm_getStateMachineX(smCWId, fname);
2924     if ((CicoStateMachine*)0 == csm) {
2925         return 0;
2926     }
2927     std::vector<const CicoState*> stt;
2928     if (false == csm->getCurrentState(stt, p)) {
2929         _DBG("%s NO ACTIVE STATEMACHINE(\"%s\":%d)",fname,
2930              csm->getName().c_str(), csm->getValue());
2931         return 0;
2932     }
2933     int r = 0;
2934     int sz = stt.size();
2935     for (int i = 0; i < sz; i++) {
2936         if ( r >= (int)arysz ) {
2937             r = -1;
2938             break;                      // break of for i<sz
2939         }
2940         X[r] = stt[i]->getName().c_str(); // set state-object name
2941         r++;
2942     }
2943     if (0 == r) {
2944         sttmerr = STTMNOTFIND;
2945         _DBG("%s get size %d -> %d",fname, sz, r);
2946         return 0;
2947     }
2948     return r;
2949 }
2950
2951
2952 /**
2953  * @brief get state-object running true
2954  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
2955  * @param sCWIds[] Enter the active state-objects(c-wrapper local ID)
2956  * @param values[] Enter the active state-objects value
2957  * @param names[] Enter the active state-objects names
2958  * @param size of array sCWIds or values or names
2959  * @return Number of registered sCWIds
2960  * @       -1:size over
2961  */
2962 extern "C" int ico_sttm_getActiveState(int smCWId, int sCWIds[], size_t sz)
2963 {
2964     sttmerr = STTMNOERROR;
2965     return ico_sttm_getActiveStateX(smCWId, sCWIds, sz, false,
2966                                     CicoStateCore::ELvlBttm,
2967                                     "ico_sttm_getActiveState");
2968 }
2969
2970 extern "C" int ico_sttm_getActiveState_V(int smCWId, int values[], size_t sz)
2971 {
2972     sttmerr = STTMNOERROR;
2973     return ico_sttm_getActiveStateX(smCWId, values, sz, true,
2974                                     CicoStateCore::ELvlBttm,
2975                                     "ico_sttm_getActiveState_V");
2976 }
2977
2978 extern "C" int ico_sttm_getActiveStateVV(int smVal, int values[], size_t sz)
2979 {
2980     sttmerr = STTMNOERROR;
2981     int id = ico_sttm_retrieveMVal(smVal);
2982     if (0 == id) {
2983         sttmerr = STTMNOTFIND;
2984         _DBG("ico_sttm_getActiveStateVV >>%d<<, ., %d", smVal, sz);
2985         return 0;
2986     }
2987     return ico_sttm_getActiveStateX(id, values, sz, true,
2988                                     CicoStateCore::ELvlBttm,
2989                                     "ico_sttm_getActiveStateVV");
2990 }
2991
2992 extern "C" int ico_sttm_getActiveState_N(int smCWId, const char* names[],
2993                                            size_t sz)
2994 {
2995     sttmerr = STTMNOERROR;
2996     return ico_sttm_getActiveState_NX(smCWId, names, sz,
2997                                     CicoStateCore::ELvlBttm,
2998                                     "ico_sttm_getActiveState_N");
2999 }
3000
3001 extern "C" int ico_sttm_getActiveStateNN(const char* smNm, const char* names[],
3002                                          size_t sz)
3003 {
3004     sttmerr = STTMNOERROR;
3005     int id = ico_sttm_retrieveMName(smNm);
3006     if (0 == id) {
3007         sttmerr = STTMNOTFIND;
3008         _DBG("ico_sttm_getActiveStateNN >>%s<<, ., %d", smNm, sz);
3009         return 0;
3010     }
3011     return ico_sttm_getActiveState_NX(id, names, sz,
3012                                     CicoStateCore::ELvlBttm,
3013                                     "ico_sttm_getActiveStateNN");
3014 }
3015
3016 /**
3017  * @brief get state-object running directly under
3018  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
3019  * @param sCWIds[] Enter the active state-objects(c-wrapper local ID)
3020  * @param values[] Enter the active state-objects value
3021  * @param names[] Enter the active state-objects names
3022  * @param size of array sCWIds or values or names
3023  * @return Number of registered sCWIds
3024  * @       -1:size over
3025  */
3026 extern "C" int ico_sttm_getActiveStateDirectlyUnder(int smCWId, int sCWIds[],
3027                                                     size_t sz)
3028 {
3029     sttmerr = STTMNOERROR;
3030     return ico_sttm_getActiveStateX(smCWId, sCWIds, sz, false,
3031                                     CicoStateCore::ELvlTop,
3032                                     "ico_sttm_getActiveStateDirectlyUnder");
3033 }
3034 extern "C" int ico_sttm_getActiveStateDirectlyUnder_V(int smCWId,
3035                                                          int values[],
3036                                                          size_t sz)
3037 {
3038     sttmerr = STTMNOERROR;
3039     return ico_sttm_getActiveStateX(smCWId, values, sz, true,
3040                                     CicoStateCore::ELvlTop,
3041                                     "ico_sttm_getActiveStateDirectlyUnder_V");
3042 }
3043
3044 extern "C" int ico_sttm_getActiveStateDirectlyUnderVV(int smVal, int values[],
3045                                            size_t sz)
3046 {
3047     sttmerr = STTMNOERROR;
3048     int id = ico_sttm_retrieveMVal(smVal);
3049     if (0 == id) {
3050         sttmerr = STTMNOTFIND;
3051         _DBG("ico_sttm_getActiveStateDirectlyUnderVV >>%d<<, ., %d",
3052              smVal, sz);
3053         return 0;
3054     }
3055     return ico_sttm_getActiveStateX(id, values, sz, true,
3056                                     CicoStateCore::ELvlTop,
3057                                     "ico_sttm_getActiveStateDirectlyUnderVV");
3058 }
3059
3060 extern "C" int ico_sttm_getActiveStateDirectlyUnder_N(int smCWId,
3061                                                         const char* names[],
3062                                                         size_t sz)
3063 {
3064     sttmerr = STTMNOERROR;
3065     return ico_sttm_getActiveState_NX(smCWId, names, sz,
3066                                     CicoStateCore::ELvlTop,
3067                                     "ico_sttm_getActiveStateDirectlyUnder_N");
3068 }
3069
3070 extern "C" int ico_sttm_getActiveStateDirectlyUnderNN(const char* smNm,
3071                                                       const char* names[],
3072                                                       size_t sz)
3073 {
3074     sttmerr = STTMNOERROR;
3075     int id = ico_sttm_retrieveMName(smNm);
3076     if (0 == id) {
3077         sttmerr = STTMNOTFIND;
3078         _DBG("ico_sttm_getActiveStateDirectlyUnderNN >>%s<<, ., %d", smNm, sz);
3079         return 0;
3080     }
3081     return ico_sttm_getActiveState_NX(id, names, sz,
3082                                     CicoStateCore::ELvlTop,
3083                                     "ico_sttm_getActiveStateDirectlyUnderNN");
3084 }
3085
3086 /**
3087  * @brief get state-object running all
3088  * @param smCWId stateMachine-object ID no.(c-wrapper local ID)
3089  * @param smVal value is stateMachine-object identification number
3090  * @param smNm stateMachine-object Identification name
3091  * @param sCWIds[] Enter the active state-objects(c-wrapper local ID)
3092  * @param values[] Enter the active state-objects value
3093  * @param names[] Enter the active state-objects names
3094  * @param size of array sCWIds or values or names
3095  * @return Number of registered sCWIds
3096  * @       -1:size over
3097  */
3098 extern "C" int ico_sttm_getActiveStateAll(int smCWId, int sCWIds[], size_t sz)
3099 {
3100     sttmerr = STTMNOERROR;
3101     return ico_sttm_getActiveStateX(smCWId, sCWIds, sz, false,
3102                                     CicoStateCore::ELvlAll,
3103                                     "ico_sttm_getActiveStateAll");
3104 }
3105
3106 extern "C" int ico_sttm_getActiveStateAll_V(int smCWId, int values[],
3107                                             size_t sz)
3108 {
3109     sttmerr = STTMNOERROR;
3110     return ico_sttm_getActiveStateX(smCWId, values, sz, true,
3111                                     CicoStateCore::ELvlAll,
3112                                     "ico_sttm_getActiveStateAll_V");
3113 }
3114
3115 extern "C" int ico_sttm_getActiveStateAllVV(int smVal, int values[],
3116                                             size_t sz)
3117 {
3118     sttmerr = STTMNOERROR;
3119     int id = ico_sttm_retrieveMVal(smVal);
3120     if (0 == id) {
3121         sttmerr = STTMNOTFIND;
3122         _DBG("ico_sttm_getActiveStateAllVV >>%d<<, ., %d", smVal, sz);
3123         return 0;
3124     }
3125     return ico_sttm_getActiveStateX(id, values, sz, true,
3126                                     CicoStateCore::ELvlAll,
3127                                     "ico_sttm_getActiveStateAllVV");
3128 }
3129
3130 extern "C" int ico_sttm_getActiveStateAll_N(int smCWId, const char* names[],
3131                                               size_t sz)
3132 {
3133     sttmerr = STTMNOERROR;
3134     return ico_sttm_getActiveState_NX(smCWId, names, sz,
3135                                     CicoStateCore::ELvlAll,
3136                                     "ico_sttm_getActiveStateAll_N");
3137 }
3138
3139 extern "C" int ico_sttm_getActiveStateAllNN(const char* smNm,
3140                                             const char* names[], size_t sz)
3141 {
3142     sttmerr = STTMNOERROR;
3143     int id = ico_sttm_retrieveMName(smNm);
3144     if (0 == id) {
3145         sttmerr = STTMNOTFIND;
3146         _DBG("ico_sttm_getActiveStateAllNN >>%s<<, ., %d", smNm, sz);
3147         return 0;
3148     }
3149     return ico_sttm_getActiveState_NX(id, names, sz,
3150                                     CicoStateCore::ELvlAll,
3151                                     "ico_sttm_getActiveStateAllNN");
3152 }
3153
3154 /**
3155  * @brief get name value
3156  * @param CWId stateMachine-object/state-object ID no.(c-wrapper local ID)
3157  * @return name
3158  */
3159 extern "C" const char* ico_sttm_getName(int CWId)
3160 {
3161     sttmerr = STTMNOERROR;
3162     CicoStateCore* cscTarget = getID2ObjSTT(CWId); // CWId to state-object
3163     if ((CicoStateCore*)0 == cscTarget) {
3164         sttmerr = STTMNOTFIND;
3165         _DBG("ico_sttm_getName >>%d<<", CWId);
3166         return 0;
3167     }
3168     return cscTarget->getName().c_str();
3169 }
3170
3171 /**
3172  * @brief get value
3173  * @param CWId stateMachine-object/state-object ID no.(c-wrapper local ID)
3174  * @return value
3175  */
3176 extern "C" int ico_sttm_getValue(int CWId)
3177 {
3178     sttmerr = STTMNOERROR;
3179     CicoStateCore* cscTarget = getID2ObjSTT(CWId); // ID to state-object
3180     if ((CicoStateCore*)0 == cscTarget) {
3181         sttmerr = STTMNOTFIND;
3182         _DBG("ico_sttm_getValue >>%d<<", CWId);
3183         return 0;
3184     }
3185     return cscTarget->getValue();
3186 }
3187
3188 /**
3189  * @brief get error code
3190  * @return error code
3191  */
3192 StateMachineCWrapperErr_E ico_sttm_errcode()
3193 {
3194     return sttmerr;
3195 }
3196
3197 /**
3198  * @breif get operation state
3199  * @param smCWId ID no. to eb registered stateMachine-object(c-wrapper local ID)
3200  * @param sCWId ID no. to be registered(c-wrapper local ID)
3201  * @param value value is state-object identification number
3202  * @param name  name is state-object Identification name
3203  * @return OPERATION_STATE_E
3204  */
3205 extern "C" OPERATION_STATE_E ico_sttm_isActiveSttM(int smCWId)
3206 {
3207     return ico_sttm_isActiveStt(smCWId);
3208 }
3209
3210 /**
3211  *
3212  */
3213 extern "C" OPERATION_STATE_E ico_sttm_isActiveStt(int sCWId)
3214 {
3215     sttmerr = STTMNOERROR;
3216     int sz = stateObjects.size();
3217     if ((0 < sCWId) && (sCWId <= sz)) {
3218         if (true == stateObjects[sCWId-1]->isActive()) {
3219             return E_STT_ACTIVE;
3220         }
3221     }
3222     else {
3223         sttmerr = STTMPARAMERR;
3224     }
3225     return E_STT_INACTIVE;
3226 }
3227
3228 extern "C" OPERATION_STATE_E ico_sttm_isActive_V(int smCWId, int value)
3229 {
3230     sttmerr = STTMNOERROR;
3231     int lid = ico_sttm_retrieveSVal(smCWId, value);
3232     if (0 != lid) {
3233         return ico_sttm_isActiveStt(lid);
3234     }
3235     else {
3236         sttmerr = STTMNOTFIND;
3237     }
3238     return E_STT_INACTIVE;
3239 }
3240
3241 extern "C" OPERATION_STATE_E ico_sttm_isActiveVV(int smVal, int value)
3242 {
3243     sttmerr = STTMNOERROR;
3244     int id = ico_sttm_retrieveMVal(smVal);
3245     if (0 == id) {
3246         sttmerr = STTMNOTFIND;
3247         _DBG("ico_sttm_isActiveVV >>%d<<, %d", smVal, value);
3248         return E_STT_INACTIVE;
3249     }
3250     return ico_sttm_isActive_V(id, value);
3251 }
3252
3253 extern "C" OPERATION_STATE_E ico_sttm_isActive_N(int smCWId, const char* name)
3254 {
3255     sttmerr = STTMNOERROR;
3256     int lid = ico_sttm_retrivevSName(smCWId, name);
3257     if (0 != lid) {
3258         return ico_sttm_isActiveStt(lid);
3259     }
3260     else {
3261         sttmerr = STTMNOTFIND;
3262     }
3263     return E_STT_INACTIVE;
3264 }
3265
3266 extern "C" OPERATION_STATE_E ico_sttm_isActiveNN(const char* smNm,
3267                                                  const char* name)
3268 {
3269     sttmerr = STTMNOERROR;
3270     int id = ico_sttm_retrieveMName(smNm);
3271     if (0 == id) {
3272         sttmerr = STTMNOTFIND;
3273         _DBG("ico_sttm_isActiveNN >>%s<<, %s", smNm, name);
3274         return E_STT_INACTIVE;
3275     }
3276     return ico_sttm_isActive_N(id, name);
3277 }