自学教程：C++ states函数代码示例

void initVideo(void){	/* We need access to DS hardware */	FeOS_DirectMode();	vramSetPrimaryBanks (VRAM_A_LCD, VRAM_B_LCD, VRAM_C_SUB_BG_0x06200000, VRAM_D_LCD);	/* Init video engine for the SUB_SCREEN */	videoSetModeSub(MODE_5_2D);	vramSetBankI(VRAM_I_SUB_SPRITE);	oamEnable(states(SUB_SCREEN));	oamInit(states(SUB_SCREEN), SpriteMapping_1D_128, false);	/* Init video engine for the MAIN_SCREEN */	init3D();}

void CursorDropdown::onStateDeactivate(StateEvent* event){    if (!_deactivated)    {        auto game = Game::getInstance();        auto mouse = game->mouse();        // workaround to get rid of cursor disappearing issues        std::vector<unsigned int> icons;        while (mouse->states()->size() > _initialMouseStack)        {            icons.push_back(mouse->state());            mouse->popState();        }        if (icons.size() > 0)        {            icons.pop_back(); // remove empty icon from CursorDropdown state            // place only new icons back in stack            for (auto it = icons.rbegin(); it != icons.rend(); it++)            {                mouse->pushState(*it);            }        }        mouse->setX(_initialX);        mouse->setY(_initialY);        _deactivated = true;    }}

void Game::Gameplay_Draw(){	for (unsigned int i = 0; i < m_gameObjects.size(); i++)	{		m_gameObjects[i]->Render(m_renderer, m_currentCam);		if (m_gameObjects[i]->GetObjectType() == "SphereEnemy")		{			if (static_cast <SphereEnemy*> (m_gameObjects[i])->Bullets[0]->getState() == 0)			static_cast <SphereEnemy*> (m_gameObjects[i])->Bullets[0]->Render(m_renderer,m_currentCam);		}	}	for (unsigned int i = 0; i < m_player->Bullets.size(); i++)	{		if (m_player->Bullets[i]->getState() == 0)		m_player->Bullets[i]->Render(m_renderer,m_currentCam);	}	//When we want to draw 2D objects we need to do it within the Begin and End calls of the Sprite Batch	CommonStates states(m_renderer->GetDevice());	m_spriteBatch->Begin(SpriteSortMode_Deferred, states.NonPremultiplied());	m_arial->DrawString(m_spriteBatch, L"Lives:", Vector2(150, 100));	std::wstring health_string = std::to_wstring(m_player->getHealth());	m_arial->DrawString(m_spriteBatch, &health_string[0], Vector2(200, 100));	m_arial->DrawString(m_spriteBatch, L"Score:", Vector2(150, 150));	std::wstring score_string = std::to_wstring(m_player->getScore());	m_arial->DrawString(m_spriteBatch, &score_string[0], Vector2(200, 150));	if (m_player->reloading)	{		m_arial->DrawString(m_spriteBatch, L"Reload Timer:", Vector2(750, 100));		std::wstring reloadTime_string = std::to_wstring(m_player->reloadCounter);		m_arial->DrawString(m_spriteBatch, &reloadTime_string[0], Vector2(850, 100));	}	m_arial->DrawString(m_spriteBatch, L"Current Weapon:", Vector2(450, 100));	std::wstring currentWeapon = m_player->enumToString(m_player->currentWeapon);	const wchar_t* widecstr = currentWeapon.c_str();	m_arial->DrawString(m_spriteBatch,widecstr, Vector2(580, 100));	m_arial->DrawString(m_spriteBatch, L"Ammo:", Vector2(450, 150));	std::wstring ammo_string = std::to_wstring(m_player->Bullets.size() - m_player->shotsCounter);	m_arial->DrawString(m_spriteBatch, &ammo_string[0], Vector2(505, 150));	m_arial->DrawString(m_spriteBatch, L"/", Vector2(523, 150));	std::wstring maxAmmo_string = std::to_wstring(m_player->Bullets.size());	m_arial->DrawString(m_spriteBatch, &maxAmmo_string[0], Vector2(530, 150));	//m_button->Render();		//The Button rendering needs to be done within the Begin and End calls of the SpriteBatch	m_spriteBatch->End();}

TEST(WebKit2, ResizeWindowAfterCrash){    WKRetainPtr<WKContextRef> context(AdoptWK, WKContextCreate());    TestStatesData states(context.get());    WKPageLoaderClientV0 loaderClient;    memset(&loaderClient, 0, sizeof(loaderClient));    loaderClient.base.version = 0;    loaderClient.base.clientInfo = &states;    loaderClient.didFinishLoadForFrame = didFinishLoad;    loaderClient.processDidCrash = didCrash;    WKPageSetPageLoaderClient(states.webView.page(), &loaderClient.base);    WKRetainPtr<WKURLRef> url = adoptWK(WKURLCreateWithUTF8CString("about:blank"));    // Load a blank page and next kills WebProcess.    WKPageLoadURL(states.webView.page(), url.get());    Util::run(&states.firstLoad);    WKPageTerminate(states.webView.page());    // Let's try load a page and see what happens.    WKPageLoadURL(states.webView.page(), url.get());    Util::run(&states.resizeAfterCrash);}

int main() {  typedef ColinearityKinematicConstraintT<colinearityKinematic::PhiTheta> ColinearityConstraint;  { ColinearityConstraint cc; std::cout << " cc " << cc.numberOfEquations() << std::endl;}   typedef CombinedKinematicConstraintT<std::tuple<ColinearityConstraint,VertexKinematicConstraintT>, 2> CKC;  CKC ckc(std::make_tuple(ColinearityConstraint(),VertexKinematicConstraintT()));  std::cout << CKC::nTrk << " " << CKC::nDim             << " " << ckc.numberOfEquations()             << std::endl;  std::vector<KinematicState> states(2);  const GlobalPoint point;  const GlobalVector mf;  ckc.init(states,point,mf);  CKC::valueType v = ckc.value();  CKC::parametersDerivativeType pad =  ckc.parametersDerivative();  CKC::positionDerivativeType pod = ckc.positionDerivative();  std::cout << v(0) << " " << pad(0,0) << " " << pod(0,0) << std::endl;  KinematicConstrainedVertexFitterT<CKC::nTrk,CKC::nDim> kinefit(0);  return 0;}

 void countoccur(){     for(int i = 0; i < sz; ++i){ occur[i] = 1 - isclone[i]; }     vii states(sz);     for(int i = 0; i < sz; ++i){ states[i] = ii(len[i],i); }     sort(states.begin(), states.end());     for(int i = size(states)-1; i >= 0; --i){ int v = states[i].second;         if(link[v] != -1) { occur[link[v]] += occur[v]; } } }

std::vector<typename state_type<Domain>::type> random(const Domain& dom, unsigned int n) {	std::vector<typename state_type<Domain>::type> states(n);	for(std::size_t i=0; i<states.size(); i++) {		states[i] = random(dom);	}	return states;}

void CritterDialog::_selectAnswer(size_t i){    if (i >= _answers.size()) throw Exception("No answer with number " + std::to_string(i));    auto game = Game::getInstance();    auto dialog = dynamic_cast<CritterInteract*>(game->states()->at(game->states()->size() - 2));    // @todo optimize    int newOffset = dialog->script()->script()->procedures()->at(_functions.at(i))->bodyOffset();    int oldOffset = dialog->script()->programCounter() - 2;    deleteAnswers();    dialog->script()->dataStack()->push(0); // arguments counter;    dialog->script()->returnStack()->push(oldOffset); // return adrress    dialog->script()->setProgramCounter(newOffset);    dialog->script()->run();}

    void undo() const override    {        auto& scenar = m_scenarioPath.find();        auto& globalEvent = scenar.event(m_destinationEventId);        Deserializer<DataStream> s{m_serializedEvent};        auto recreatedEvent = new EventModel{s, &scenar};        auto states_in_event = recreatedEvent->states();        // we remove and re-add states in recreated event        // to ensure correct parentship between elements.        for(auto stateId : states_in_event)        {            recreatedEvent->removeState(stateId);            globalEvent.removeState(stateId);        }        for(auto stateId : states_in_event)        {            recreatedEvent->addState(stateId);            scenar.states.at(stateId).setEventId(m_movingEventId);        }        scenar.events.add(recreatedEvent);        if(recreatedEvent->timeNode() != globalEvent.timeNode())        {            auto& tn = scenar.timeNode(globalEvent.timeNode());            tn.addEvent(m_movingEventId);            m_mergeTimeNodesCommand->undo();        }        updateEventExtent(m_destinationEventId, scenar);    }

static void nrn_state(_NrnThread* _nt, _Memb_list* _ml, int _type) { double _break, _save;double* _p; Datum* _ppvar; Datum* _thread;Node *_nd; double _v; int* _ni; int _iml, _cntml;#if CACHEVEC    _ni = _ml->_nodeindices;#endif_cntml = _ml->_nodecount;_thread = _ml->_thread;for (_iml = 0; _iml < _cntml; ++_iml) { _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml]; _nd = _ml->_nodelist[_iml];#if CACHEVEC  if (use_cachevec) {    _v = VEC_V(_ni[_iml]);  }else#endif  {    _nd = _ml->_nodelist[_iml];    _v = NODEV(_nd);  } _break = t + .5*dt; _save = t; v=_v;{  ek = _ion_ek; { { for (; t < _break; t += dt) {   states(_p, _ppvar, _thread, _nt);  }} t = _save; } }}}

intfm<Label>::is_deterministic() const{	int		j;	set<state>	all_states;	set<Label>	alphabet;	fm<Label>	t;	// if more than one start state, it's not deterministic	if (start_states.size() != 1)		return 0;	// collect alphabet and states	labels(alphabet);	states(all_states);	// for every state, check for all instructions	for (int i=0; i<all_states.size(); ++i)		for (j=0; j<alphabet.size(); ++j)		{			select(alphabet[j], all_states[i], SOURCE, t);			if (t.size() > 1)				return 0;		}	return 1;}

static void nrn_state(_NrnThread* _nt, _Memb_list* _ml, int _type){ double _break, _save;Node *_nd; double _v; int* _ni; int _iml, _cntml;#if CACHEVEC    _ni = _ml->_nodeindices;#endif_cntml = _ml->_nodecount;for (_iml = 0; _iml < _cntml; ++_iml) { _p = _ml->_data[_iml]; _ppvar = _ml->_pdata[_iml]; _nd = _ml->_nodelist[_iml];#if CACHEVEC  if (use_cachevec) {    _v = VEC_V(_ni[_iml]);  }else#endif  {    _nd = _ml->_nodelist[_iml];    _v = NODEV(_nd);  } _break = t + .5*dt; _save = t; v=_v;{  ek = _ion_ek; { { for (; t < _break; t += dt) { error =  states(); if(error){fprintf(stderr,"at line 64 in file KA_i1.mod:/n  SOLVE states METHOD cnexp/n"); nrn_complain(_p); abort_run(error);} }} t = _save; } }}}

 //!Generate a hit table from a multiple traceback paths //! Hit table is 2D table describing how many times a state was called at a particular position in the sequence heatTable* multiTraceback::get_hit_table(){     if (table!=NULL){         delete table;     }          //Over the lenght of the sequence     model* hmm = ((*pathAccess[0]).first).getModel();     size_t sequenceSize=((*pathAccess[0]).first).size();     size_t stateSize=hmm->state_size();               std::vector<int> states(stateSize,0);     table = new heatTable(sequenceSize,states);          std::map<traceback_path,int>::iterator it;          for( it =paths.begin(); it!=paths.end();it++){         int count = (*it).second;         for(size_t position=0;position<sequenceSize;position++){             int tbState=(*it).first[position];             (*table)[position][tbState]+=count;         }     }     return table; }

 virtual WhichFstComposeSpecials whichInputFstComposeSpecials() const {   WhichFstComposeSpecials r;   for (StateIdInterval states(possiblyInputTerminalLabeledStates()); states.first < states.second;        ++states.first)     r.check(inputLabel(states.first));   return r; }

std::vector<int>galleryd::queue::status(item_t &items, const std::string &category){    std::vector<int> states (items.size());    // build sql statement    auto stmt = category.empty()        ? query_status_(items)        : query_status_with_category_(items, category);    // insert all found items into a map    std::map<std::string, int> lookup;    for(auto&& row : stmt)        lookup.emplace(row.as_string(0), row.as_int(1));    // build array with state-values for each item in the request.    // if the item doesn't exist, the value is '0'.    std::map<std::string, int>::const_iterator iter, end = lookup.end();    for(size_t i = 0, e = items.size(); i < e; ++i)    {        iter      = lookup.find(items[i]);        states[i] = iter == end ? 0 : iter->second;    }    return states;}

void ompl::base::SpaceInformation::samplesPerSecond(double &uniform, double &near, double &gaussian,                                                    unsigned int attempts) const{    StateSamplerPtr ss = allocStateSampler();    std::vector<State *> states(attempts + 1);    allocStates(states);    time::point start = time::now();    for (unsigned int i = 0; i < attempts; ++i)        ss->sampleUniform(states[i]);    uniform = (double)attempts / time::seconds(time::now() - start);    double d = getMaximumExtent() / 10.0;    ss->sampleUniform(states[attempts]);    start = time::now();    for (unsigned int i = 1; i <= attempts; ++i)        ss->sampleUniformNear(states[i - 1], states[i], d);    near = (double)attempts / time::seconds(time::now() - start);    start = time::now();    for (unsigned int i = 1; i <= attempts; ++i)        ss->sampleGaussian(states[i - 1], states[i], d);    gaussian = (double)attempts / time::seconds(time::now() - start);    freeStates(states);}

std::vector<state> sa_init(size_t &size, size_t &last) {    std::vector<state> states(1);    size = last = 0;    states[0].len = 0;    states[0].link = -1;    ++size;    return states;}

TEST(stateset, orthonormalization_highmem) {	RNG rng(RNG::produce_random_seed());	const DataLayout dl(16, 16, 1.0);	StateSet states(8, dl, HighMem);	states.init_to_gaussian_noise(rng);	states.orthonormalize();	EXPECT_LT(states.how_orthonormal(), 16*machine_epsilon);}

static void add_rules(StateMachinePtr sm, BindingsPtr bindings, NodePtr root) {   if (root->get_op() == Op::sm_rules) {      add_rules(sm, bindings, root->get_operand(0));      root = root->get_operand(1);   }   assert(root->get_op() == Op::sm_rule);   if (root->size() == 1) {      // handler      root = root->get_operand(0);      assert(root->get_op() == Op::ON);      assert(root->get_operand(0)->get_op() == Op::CLOSE);      root = root->get_operand(1);      assert(root->get_op() == Op::sm_handler);      if (root->size() == 1) {	 StateSet states;	 sm->add_close_handler(states, root->get_operand(0));      } else {	 StateSet states(sm->get_nofstates());	 get_states(sm, root->get_operand(0), states);	 sm->add_close_handler(states, root->get_operand(1));      }   } else {      // regular rule      NodePtr smcond = root->get_operand(0);      StateMachineRulePtr rule;      NodePtr node_expr;      if (smcond->size() == 2) {	 NodePtr tree_expr = smcond->get_operand(0);	 NodeTypeSet nodetypes(nof_node_types(bindings));	 get_node_expression(bindings, smcond->get_operand(1),	    nodetypes, node_expr);	 rule = std::make_shared<StateMachineRule>(sm,		  tree_expr, nodetypes, bindings->get_rules());      } else {	 if (smcond->get_operand(0)->get_op() == Op::cfg_node_expression) {	    NodeTypeSet nodetypes(nof_node_types(bindings));	    get_node_expression(bindings, smcond->get_operand(0),	       nodetypes, node_expr);	    rule = std::make_shared<StateMachineRule>(sm,	       nodetypes, bindings->get_rules());	 } else {	    NodePtr tree_expr = smcond->get_operand(0);	    rule = std::make_shared<StateMachineRule>(sm,	       tree_expr, bindings->get_rules());	 }      }      if (node_expr) {	 rule->add_node_condition(node_expr);      }      if (root->get_operand(1)->get_op() == Op::sm_block) {	 NodePtr smblock = root->get_operand(1);	 rule->add_alternative(create_alternative(sm, smblock));      } else {	 add_alternatives(sm, rule, bindings, root->get_operand(1));      }      sm->add_rule(rule);   }}

void Level::Impl::checkWinMission(){  auto city = game->city();  auto& conditions = city->victoryConditions();  int culture = city->culture();  int prosperity = city->prosperity();  int favour = city->states().favor;  int peace = city->peace();  int population = city->states().population;  bool success = conditions.isSuccess(culture, prosperity, favour, peace, population);  if (success)  {    events::dispatch<ScriptFunc>("OnMissionWin");    steamapi::missionWin(conditions.name());  }}

// We don't care about things below.// They will look the same all timevoid Engine::loop(){    while( core->isOpen() )    {        events();        states();        // After timer ...    }}

void RenderTheme::adjustRepaintRect(const RenderObject& renderer, FloatRect& rect){#if USE(NEW_THEME)    ControlStates states(extractControlStatesForRenderer(renderer));    m_theme->inflateControlPaintRect(renderer.style().appearance(), states, rect, renderer.style().effectiveZoom());#else    UNUSED_PARAM(renderer);    UNUSED_PARAM(rect);#endif}

    Perturb7(const vd::DynamicsInit& init, const vd::InitEventList& events) :        vf::Statechart(init, events)    {        states(this) << A;        transition(this, A, A) << after(5.)                               << send(&Perturb7::out);        initialState(A);    }