main() { vector<FSM::SEAEdge> eventArray; for(unsigned i=0; eventsExpected[i].eventId!=-1; i++) { eventArray.push_back(eventsExpected[i]); } FSM::SEAFSM fsm(eventArray); fsm.print(); int evtId; while(1) { cout << "eventId(-1 means end): "; cin >> evtId; if(evtId == -1) { break; } fsm.processEvent(evtId); } if(!fsm.isInFinalState()) { list<int> nextPossibleEvents = fsm.suggestNextEvents(); list<int>::const_iterator cit= nextPossibleEvents.begin(); cout << "Next possible events:" << endl; for( ; cit!=nextPossibleEvents.end(); cit++) { cout << "eventId:" << *cit << endl; } } }
int main(int argc, char *argv[]) { list<int> finalStates; finalStates.push_back(5); finalStates.push_back(4); FSM::GraphFSM fsm(stateTransitions,finalStates); fsm.print(); int evtId; while(1) { cout << "eventId(-1 means end): "; cin >> evtId; if(evtId == -1) { break; } fsm.processEvent(evtId); } if(!fsm.isInFinalState()) { list<int> nextPossibleEvents = fsm.suggestNextEvents(); list<int>::const_iterator cit= nextPossibleEvents.begin(); cout << "Next possible events:" << endl; for( ; cit!=nextPossibleEvents.end(); cit++) { cout << "eventId:" << *cit << endl; } } return 0; }
static void listenTimeout(void *arg) { bcm_p2p_discovery_t *disc = (bcm_p2p_discovery_t *)arg; WL_TRACE(("listenTimeout callback\n")); fsm(disc, EVENT_LISTEN_TIMEOUT); }
/** * @brief Main entry point. */ int main (void) { event_t evt; /* Disable watchdog timer since it doesn't always get reset on restart. */ wdt_disable(); /* Initialize the MCU. */ init(); /* Online. */ printf( "Exocore Apollo online...\n" ); /* Start fsm. */ fsm_start(); for (;;) { /* Atomic test to see if has anything to do. */ cli(); /* Handle events. */ while (event_poll(&evt)) { sei(); /* Reenable interrupts. */ fsm( &evt ); cli(); /* Disable for next check. */ } /* Atomic sleep as specified on the documentation. */ sleep_enable(); sei(); sleep_cpu(); sleep_disable(); } }
SIPTransaction::Ptr SIPTransaction::findBranch(const SIPMessage::Ptr& pRequest) { // // Only a parent transaction can have branches // if(!isParent()) return SIPTransaction::Ptr(); OSS::mutex_critic_sec_lock lock(_branchesMutex); SIPTransaction::Ptr foundBranch; std::string branch = pRequest->getToTag(); if (branch.empty()) return SIPTransaction::Ptr(); Branches::iterator pBranch = _branches.find(branch); // // Branch is non-existent. Create a new one and attach a new FSM to it // if (pBranch == _branches.end()) { foundBranch = SIPTransaction::Ptr(new SIPTransaction(shared_from_this())); _owner->onAttachFSM(foundBranch); foundBranch->fsm()->setRequest(fsm()->getRequest()); foundBranch->_owner = _owner; foundBranch->_responseTU = _responseTU; _branches[branch] = foundBranch; } else { foundBranch = pBranch->second; } return foundBranch; }
TEST(TlMatrix_RLHD_file, constructer_by_existed) { TlMatrix_RLHD sm(100); { sm(3, 17) = 51.0; sm(0, 28) = -1.0; sm.save(mat_path); } TlMatrix_RLHD_file fsm(mat_path); }
static void start_discovery_handler(bcm_p2p_discovery_t *disc, int reqLength, bcm_p2p_discovery_req_t *req, void *rspNull) { (void)rspNull; if (disc == 0 || reqLength != sizeof(bcm_p2p_discovery_req_t) || req == 0) { WL_ERROR(("invalid parameter\n")); return; } WL_TRACE(("start_discovery_handler\n")); fsm(disc, EVENT_START_DISCOVERY); }
void NavigationState::execute( float timeElapsed ) { if ( !m_waitingForQueryResults && m_uic->isKeyPressed( VK_LBUTTON ) ) { TamySceneWidget& sceneWidget = fsm().getSceneWidget(); // issue an object selection command sceneWidget.localToViewport( sceneWidget.getMousePos(), m_queryPos ); sceneWidget.queryScene( *this ); m_waitingForQueryResults = true; } }
static void start_ext_listen_handler(bcm_p2p_discovery_t *disc, int reqLength, bcm_p2p_discovery_req_t *req, void *rspNull) { (void)rspNull; if (disc == 0 || reqLength != sizeof(bcm_p2p_discovery_req_t) || req == 0) { WL_ERROR(("invalid parameter\n")); return; } WL_TRACE(("start_ext_listen_handler %d %d\n", req->startExtListen.listenOnTimeout, req->startExtListen.listenOffTimeout)); disc->extListenOnTimeout = req->startExtListen.listenOnTimeout; disc->extListenOffTimeout = req->startExtListen.listenOffTimeout; fsm(disc, EVENT_START_EXT_LISTEN); }
TEST(TlMatrix_RLHD_file, get) { TlMatrix_RLHD sm(100); sm(3, 17) = 51.0; sm(0, 28) = -1.0; sm.save(mat_path); TlMatrix_RLHD_file fsm(mat_path); EXPECT_DOUBLE_EQ(0.0, fsm.get(0, 0)); EXPECT_DOUBLE_EQ(0.0, fsm.get(0, 99)); EXPECT_DOUBLE_EQ(0.0, fsm.get(99, 0)); EXPECT_DOUBLE_EQ(0.0, fsm.get(99, 99)); EXPECT_DOUBLE_EQ(51.0, fsm.get(3, 17)); EXPECT_DOUBLE_EQ(-1.0, fsm.get(0, 28)); }
TEST(TlMatrix_RLHD_file, constructer) { { cleanup(); TlMatrix_RLHD_file fsm(mat_path, 100); } { TlMatrix_RLHD a; a.load(mat_path); EXPECT_EQ(100, a.getNumOfRows()); EXPECT_EQ(100, a.getNumOfCols()); for (int r = 0; r < 100; ++r) { for (int c = 0; c <= r; ++c) { EXPECT_DOUBLE_EQ(0.0, a.get(r, c)); } } } }
bool uri<StringT>::parse (typename string_type::const_iterator first , typename string_type::const_iterator last) { typedef uri_grammar<StringT> grammar_type; typedef typename grammar_type::fsm_type fsm_type; // Initialize grammar's static members static grammar_type grammar; _d.clear(); fsm_type fsm(grammar.p_uri_tr, & _d); typename fsm_type::result_type r = fsm.exec(0, first, last); if (r.first && r.second == last) return true; return false; }
int sc_main(int ac, char **av) { sc_signal<bool> handshake ("HS"); sc_signal<bool> found; sc_signal<char> stream ("ST"); sc_clock clk("Clock", 20, SC_NS, 0.5, 0.0, SC_NS); counter cnt("COUNTER", clk, found); fsm_recognizer fsm("Recog", clk, stream, handshake, found); stimgen chargen("TESTB", clk, stream, handshake); // initialize signals - ali handshake = false; found = false; sc_start(); return 0; }
/** * ==================================================================== * get_direction fn: * assigns state based on sentinel var and calls the fsm to determine * direction. This function calls back to Java with an int * (direction) which will allow java to broadcast the input to other * apps. * ==================================================================== * authors(s): Stephan Greto-McGrath * ==================================================================== */ void get_direction(char buf1[8], char buf2[8], JNIEnv *newEnv, jobject obj, jmethodID mid){ if (sentinel != true) { /* we already have a prev state */ previousState = currentState; currentState = concantenate(atoi(buf1), atoi(buf2)); /* In case poll returns constantly, this statement below * ensures that we only consider a change in state. * Unnecessary if poll() is working properly with interrupts */ if (previousState != currentState) { int direction = fsm(currentState, previousState); LOGD("direction: %d\n", direction); /* call back to java to broadcast state change*/ (*newEnv)->CallVoidMethod(newEnv, obj, mid, (jint)direction); } } else { /* just starting -> need prev state */ currentState = concantenate(atoi(buf1), atoi(buf2)); sentinel = false; } }
TEST(TlMatrix_RLHD_file, set) { cleanup(); { TlMatrix_RLHD_file fsm(mat_path, 100); fsm.set(3, 17, 51.0); fsm.set(0, 28, -1.0); } TlMatrix_RLHD sm; sm.load(mat_path); EXPECT_EQ(100, sm.getNumOfRows()); EXPECT_EQ(100, sm.getNumOfCols()); EXPECT_DOUBLE_EQ(0.0, sm(0, 0)); EXPECT_DOUBLE_EQ(0.0, sm(0, 99)); EXPECT_DOUBLE_EQ(0.0, sm(99, 0)); EXPECT_DOUBLE_EQ(0.0, sm(99, 99)); EXPECT_DOUBLE_EQ(51.0, sm(3, 17)); EXPECT_DOUBLE_EQ(-1.0, sm(0, 28)); }
bool parse (json & result, string const & s) { user_context userContext; notification nx; parse_context ctx = { & userContext , & nx , true // isBeginJson , string() // memberName , stack<string>() // objects , stack<string>() // arrays; , on_begin_json , on_end_json , on_begin_object , on_end_object , on_begin_array , on_end_array , on_null_value , on_boolean_value , on_number_value , on_string_value }; userContext.ptr_stack.push(& result); fsm::fsm<string> fsm(json_fsm, & ctx); fsm::fsm<string>::result_type r = fsm.exec(s.cbegin(), s.cend()); if (r.first && r.second == s.cend()) { ; } else { result.clear(); return false; } return true; }
void NavigationState::commitSelectdEntities( const Array< Entity* >& selectedEntities ) { SelectionManager& selectionMgr = fsm().getSceneEditor().getSelectionMgr(); uint count = selectedEntities.size(); bool somethingSelected = false; for( uint i = 0; i < count; ++i ) { // we want the manipulator to select only the scene nodes it can actually manipulate afterwards Entity* entity = selectedEntities[i]; if ( entity ) { // got a node to select selectionMgr.selectEntity( *entity ); somethingSelected = true; break; } } if ( !somethingSelected ) { selectionMgr.resetSelection(); } }
TEST(TlMatrix_RLHD_file, add) { { TlMatrix_RLHD sm(100); sm(3, 17) = 51.0; sm(0, 28) = -1.0; sm.save(mat_path); } { TlMatrix_RLHD_file fsm(mat_path); fsm.add(3, 17, 12.3); } TlMatrix_RLHD sm; sm.load(mat_path); EXPECT_EQ(100, sm.getNumOfRows()); EXPECT_EQ(100, sm.getNumOfCols()); EXPECT_DOUBLE_EQ(0.0, sm(0, 0)); EXPECT_DOUBLE_EQ(0.0, sm(0, 99)); EXPECT_DOUBLE_EQ(0.0, sm(99, 0)); EXPECT_DOUBLE_EQ(0.0, sm(99, 99)); EXPECT_DOUBLE_EQ(63.3, sm(3, 17)); EXPECT_DOUBLE_EQ(-1.0, sm(0, 28)); }
bool Abnf::parse(const String & abnf, AbnfRuleList & rulelist) { CWT_UNUSED(abnf); AbnfParseContext ctx = { & rulelist , Stack<AbnfElement *>() , 10 // numValBase , 0 // numValMin , 0 // numValMax }; /* AbnfContext abnfContext; abnfContext.isIncrementalAlternation = false; */ /* AbnfParseContext ctx = { & abnfContext , String() , {CWT_INT_MIN, CWT_INT_MIN} , api }; */ Fsm<String> fsm(rulelist_fsm, & ctx); String s(abnf); if (!s.endsWith(String::EndOfLine)) s.append(String::EndOfLine); if (fsm.exec(0, s.begin(), s.end()) >= 0) { return true; } return false; }
static void create_handler(bcm_p2p_discovery_t *discNull, int reqLength, bcm_p2p_discovery_req_t *req, void *rspData) { bcm_p2p_discovery_t *disc; create_rsp_t *rsp = (create_rsp_t *)rspData; (void)discNull; if (reqLength != sizeof(bcm_p2p_discovery_req_t) || req == 0 || rspData == 0) { WL_ERROR(("invalid parameter\n")); return; } WL_TRACE(("create_handler\n")); #ifndef BCMDRIVER /* seed the random generator */ srand((unsigned)time(NULL)); #endif /* BCMDRIVER */ rsp->disc = 0; disc = &gDisc; memset(disc, 0, sizeof(*disc)); disc->drv = req->create.drv; disc->listenChannel = req->create.listenChannel; /* initialize social channels */ disc->socialChannel[0] = 1; disc->socialChannel[1] = 6; disc->socialChannel[2] = 11; #ifdef BCM_P2P_DISCOVERY_CREATE_DISCOVERY_BSSCFG /* disable P2P discovery - to ensure bsscfg does not exist */ wl_p2p_disc(disc->drv, FALSE); /* enable P2P discovery */ wl_p2p_disc(disc->drv, TRUE); #endif /* BCM_P2P_DISCOVERY_CREATE_DISCOVERY_BSSCFG */ if (wl_p2p_dev(disc->drv, &disc->bsscfgIndex) < 0) { WL_ERROR(("failed to get bsscfg index\n")); } WL_P2PO(("bsscfg index=%d\n", disc->bsscfgIndex)); #ifdef BCM_P2P_DISCOVERY_ADD_DELETE_IES wl_cur_etheraddr(disc->drv, disc->bsscfgIndex, &disc->addr); WL_PRMAC("discovery MAC address", &disc->addr); #endif /* BCM_P2P_DISCOVERY_ADD_DELETE_IES */ #ifdef BCM_P2P_DISCOVERY_ADD_DELETE_IES addIes(disc); #endif /* BCM_P2P_DISCOVERY_ADD_DELETE_IES */ /* create timers */ disc->listenTimer = tmrCreate( #ifndef BCMDRIVER dsp(), #else disc->drv, #endif /* BCMDRIVER */ listenTimeout, disc, "listenTimer"); if (disc->listenTimer == 0) { WL_ERROR(("failed to create timer\n")); goto fail; } /* reset state machine */ fsm(disc, EVENT_RESET); /* return created instance */ rsp->disc = disc; return; fail: memset(disc, 0, sizeof(*disc)); }
int main(int argc, char *argv[]) { argumentNumberMessage(argc); fsm(argv[1]); return 0; }
void NavigationState::setResult( const Array< Entity* >& foundEntities ) { m_waitingForQueryResults = false; // analyze the found entities and determine what ( if any ) spatial entities were found, // and whether a gizmo axis was selected GizmoAxis* selectedGizmoAxis = NULL; Array< Entity* > selectedEntities; { uint count = foundEntities.size(); for ( uint i = 0; i < count; ++i ) { Entity* foundEntity = foundEntities[i]; if ( !foundEntity ) { continue; } // first a quick test to see if the selected entity is a gizmo axis if ( foundEntity->isA< GizmoAxis >() ) { ASSERT_MSG( selectedGizmoAxis == NULL, "Only one scene with gizmo is allowed with this query listener, and here we've found the second gizmo axis already" ); // yup - memorize it and go to the next one selectedGizmoAxis = DynamicCast< GizmoAxis >( foundEntity ); // and go to the next item on the list continue; } // next - determine if the entity is a spatial entity { Entity* spatialEntityCandidate = foundEntity; while( spatialEntityCandidate && !spatialEntityCandidate->isA< SpatialEntity >() ) { // find a parent of the entity that's a node spatialEntityCandidate = spatialEntityCandidate->getParent(); } if ( spatialEntityCandidate != NULL ) { // we found it SpatialEntity* node = DynamicCast< SpatialEntity >( spatialEntityCandidate ); selectedEntities.push_back( node ); } } } } if ( selectedGizmoAxis && m_uic->isKeyPressed( VK_LBUTTON ) ) { // if a gizmo axis was selected ( and the selection button is still pressed ) then it means we want to manipulate the selected object. // At this point we're no longer interested in any other selected objects ASSERT_MSG( fsm().areNodesSelected(), "There are no selected nodes, and yet we managed to select a manipulation gizmo somehow. Check it!" ); transitionTo< GizmoNodeManipulationState >().setGizmoAxis( *selectedGizmoAxis ); } else { // analyze the selected spatial entities SelectionManager& selectionMgr = fsm().getSceneEditor().getSelectionMgr(); const std::vector< Entity* >& currentlySelectedEntities = selectionMgr.getSelectedEntities(); // if both selections were exactly the same ( meaning that we clicked on one of the previously selected // vehicles, then instead of committing the selection, transition to a planar node movement mode if ( CollectionUtils::containsAll( currentlySelectedEntities, selectedEntities ) ) { transitionTo< PlanarNodeManipulationState >(); } else { // the selection has changed - commit the nnew one commitSelectdEntities( selectedEntities ); } } }
void NavigationState::deactivate() { fsm().setController( NULL ); }
void NavigationState::activate() { fsm().setController( new CameraMovementController() ); }
int main(int cc, char **vv) { int ch, disco; char *pname, *pidfile, *p, *q, *ta, *kw, *v; isc_opt_t *op; FILE *fd; size_t n; op = &opvals; iscsidev = "/dev/"ISCSIDEV; fd = NULL; pname = vv[0]; if ((pname = basename(pname)) == NULL) err(1, "basename"); kw = ta = 0; disco = 0; pidfile = NULL; /* | check for driver & controller version match */ n = 0; #define VERSION_OID_S "net.iscsi_initiator.driver_version" if (sysctlbyname(VERSION_OID_S, 0, &n, 0, 0) != 0) { if (errno == ENOENT) errx(1, "sysctlbyname(\"" VERSION_OID_S "\") " "failed; is the iscsi driver loaded?"); err(1, "sysctlbyname(\"" VERSION_OID_S "\")"); } v = malloc(n+1); if (v == NULL) err(1, "malloc"); if (sysctlbyname(VERSION_OID_S, v, &n, 0, 0) != 0) err(1, "sysctlbyname"); if (strncmp(version, v, 3) != 0) errx(1, "versions mismatch"); while((ch = getopt(cc, vv, OPTIONS)) != -1) { switch(ch) { case 'v': vflag++; break; case 'c': fd = fopen(optarg, "r"); if (fd == NULL) err(1, "fopen(\"%s\")", optarg); break; case 'd': disco = 1; break; case 't': ta = optarg; break; case 'n': kw = optarg; break; case 'p': pidfile = optarg; break; default: usage(pname); } } if(fd == NULL) fd = fopen("/etc/iscsi.conf", "r"); if(fd != NULL) { parseConfig(fd, kw, op); fclose(fd); } cc -= optind; vv += optind; if(cc > 0) { if(vflag) printf("adding '%s'\n", *vv); parseArgs(cc, vv, op); } if(ta) op->targetAddress = ta; if(op->targetAddress == NULL) { warnx("no target specified!"); usage(pname); } q = op->targetAddress; if(*q == '[' && (q = strchr(q, ']')) != NULL) { *q++ = '\0'; op->targetAddress++; } else q = op->targetAddress; if((p = strchr(q, ':')) != NULL) { *p++ = 0; op->port = atoi(p); p = strchr(p, ','); } if(p || ((p = strchr(q, ',')) != NULL)) { *p++ = 0; op->targetPortalGroupTag = atoi(p); } if(op->initiatorName == 0) { char hostname[MAXHOSTNAMELEN]; if(op->iqn) { if(gethostname(hostname, sizeof(hostname)) == 0) asprintf(&op->initiatorName, "%s:%s", op->iqn, hostname); else asprintf(&op->initiatorName, "%s:%d", op->iqn, (int)time(0) & 0xff); // XXX: } else { if(gethostname(hostname, sizeof(hostname)) == 0) asprintf(&op->initiatorName, "%s", hostname); else asprintf(&op->initiatorName, "%d", (int)time(0) & 0xff); // XXX: } } if(disco) { op->sessionType = "Discovery"; op->targetName = 0; } op->pidfile = pidfile; fsm(op); exit(0); }
int main(int cc, char **vv) { int ch, disco; char *pname, *p, *q, *ta, *kw; isc_opt_t *op; FILE *fd; /* Try to load iscsi_initiator module before starting its operation */ if (modfind(INITIATORMOD) < 0) { if (kldload(INITIATORMOD) < 0 || modfind(INITIATORMOD) < 0) { perror(INITIATORMOD ": Error while handling kernel module"); return 1; } } op = &opvals; iscsidev = "/dev/"ISCSIDEV; fd = NULL; pname = vv[0]; if((p = strrchr(pname, '/')) != NULL) pname = p + 1; kw = ta = NULL; disco = 0; while((ch = getopt(cc, vv, OPTIONS)) != -1) { switch(ch) { case 'v': vflag++; break; case 'c': fd = fopen(optarg, "r"); if(fd == NULL) { perror(optarg); exit(1); } break; case 'd': disco = 1; break; case 't': ta = optarg; break; case 'n': kw = optarg; break; default: badu: fprintf(stderr, "Usage: %s %s\n", pname, USAGE); exit(1); } } if(fd == NULL) fd = fopen("/etc/iscsi.conf", "r"); if(fd != NULL) { parseConfig(fd, kw, op); fclose(fd); } cc -= optind; vv += optind; if(cc > 0) { if(vflag) printf("adding '%s'\n", *vv); parseArgs(cc, vv, op); } if(ta) op->targetAddress = ta; if(op->targetAddress == NULL) { fprintf(stderr, "No target!\n"); goto badu; } q = op->targetAddress; if(*q == '[' && (q = strchr(q, ']')) != NULL) { *q++ = '\0'; op->targetAddress++; } else q = op->targetAddress; if((p = strchr(q, ':')) != NULL) { *p++ = 0; op->port = atoi(p); p = strchr(p, ','); } if(p || ((p = strchr(q, ',')) != NULL)) { *p++ = 0; op->targetPortalGroupTag = atoi(p); } if(op->initiatorName == 0) { char hostname[256]; if(op->iqn) { if(gethostname(hostname, sizeof(hostname)) == 0) asprintf(&op->initiatorName, "%s:%s", op->iqn, hostname); else asprintf(&op->initiatorName, "%s:%d", op->iqn, (int)time(0) & 0xff); // XXX: } else { if(gethostname(hostname, sizeof(hostname)) == 0) asprintf(&op->initiatorName, "%s", hostname); else asprintf(&op->initiatorName, "%d", (int)time(0) & 0xff); // XXX: } } if(disco) { op->sessionType = "Discovery"; op->targetName = 0; } fsm(op); exit(0); }
void ParseFormatNotation(const std::string& notation, FormatTokensVisitor& visitor) { ParseFSM fsm(visitor); CreateFormatGrammar()->Analyse(notation, fsm); }
void bcm_p2p_discovery_process_wlan_event(void * context, uint32 eventType, wl_event_msg_t *wlEvent, uint8 *data, uint32 length) { bcm_p2p_discovery_t *disc = &gDisc; (void)context; #ifndef BCMDBG_ESCAN (void)data; (void)length; #endif #ifdef BCMDBG { int i; char *event_name = "UNKNOWN"; for (i = 0; i < bcmevent_names_size; i++) if (bcmevent_names[i].event == eventType) event_name = (char *)bcmevent_names[i].name; WL_P2PO(("WLAN event %s (%d)\n", event_name, eventType)); } #endif /* BCMDBG */ if (eventType == WLC_E_ESCAN_RESULT) { if (wlEvent->status == WLC_E_STATUS_PARTIAL) { #ifdef BCMDBG_ESCAN wl_escan_result_t *escan_data = (wl_escan_result_t *)data; if (length >= sizeof(*escan_data)) { wl_bss_info_t *bi = &escan_data->bss_info[0]; bcm_decode_probe_response_t pr; struct ether_addr *addr; if (!bcm_decode_ie_probe_response(bi, &pr)) { return; } /* default address */ addr = &bi->BSSID; /* P2P not supported */ if (!pr.isP2P) { char ssidbuf[4*32+1]; wl_format_ssid(ssidbuf, bi->SSID, bi->SSID_len); dbg(" AP %-20.20s %s %d\n", ssidbuf, wl_ether_etoa(addr), pr.channel); return; } if (pr.isP2PDeviceInfoDecoded) { /* use device address */ addr = &pr.p2pDeviceInfo.deviceAddress; dbg("P2P %-20.20s %s %d\n", pr.p2pDeviceInfo.deviceName, wl_ether_etoa(addr), pr.channel); } } #endif /* BCMDBG_ESCAN */ } else if (wlEvent->status == WLC_E_STATUS_SUCCESS) { WL_P2PO(("WLC_E_ESCAN_RESULT status=WLC_E_STATUS_SUCCESS\n")); fsm(disc, EVENT_SCAN_COMPLETE); } else { WL_P2PO(("WLC_E_ESCAN_RESULT status=%d\n", wlEvent->status)); /* escan may have failed/restarted but keep state machine running */ fsm(disc, EVENT_SCAN_COMPLETE); } } }
void STest::init(const std::vector<Pattern>& pats) { std::unique_ptr<PatternHandle,void(*)(PatternHandle*)> pat( lg_create_pattern(), lg_destroy_pattern ); PMap = std::unique_ptr<PatternMapHandle,void(*)(PatternMapHandle*)>( lg_create_pattern_map(pats.size()), lg_destroy_pattern_map ); std::unique_ptr<FSMHandle,void(*)(FSMHandle*)> fsm( lg_create_fsm(0), lg_destroy_fsm ); LG_KeyOptions keyOpts; size_t i = 0, numErrors = 0; for (const Pattern& p : pats) { LG_Error* err = nullptr; keyOpts.CaseInsensitive = p.CaseInsensitive; keyOpts.FixedString = p.FixedString; lg_parse_pattern(pat.get(), p.Expression.c_str(), &keyOpts, &err); if (!err) { lg_add_pattern( fsm.get(), PMap.get(), pat.get(), p.Encoding.c_str(), &err ); if (!err) { // pack the user pattern number into the void*, oh the horror LG_PatternInfo* pinfo = lg_pattern_info(PMap.get(), i - numErrors); pinfo->UserData = reinterpret_cast<void*>(i); } } if (err) { lg_free_error(err); ++numErrors; } ++i; } LG_ProgramOptions progOpts{1}; Prog = std::unique_ptr<ProgramHandle,void(*)(ProgramHandle*)>( lg_create_program(fsm.get(), &progOpts), lg_destroy_program ); if (Prog) { LG_ContextOptions ctxOpts; Ctx = std::unique_ptr<ContextHandle,void(*)(ContextHandle*)>( lg_create_context(Prog.get(), &ctxOpts), lg_destroy_context ); } }
int main() { std::string input ("0110100010010001101001000111110010011001"); std::for_each(input.begin(), input.end(), fsm()); std::cout <<"\n"; }