clangmsgbuilder.cc

在LINUX下运行的仿真机器人服务器源代码

	void MsgBuilder::add( Dir* dir )
	    {
		traceAdding< Dir >();
		ItemType tmp;
		tmp.m_item.m_dir = dir;
		tmp.m_type = DIR;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Cond* cond )
	    {
		traceAdding< Cond >();
		ItemType tmp;
		tmp.m_item.m_cond = cond;
		tmp.m_type = COND;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( MsgBuilder::CondList* cond_list )
	    {
		traceAdding< CondList >();
		ItemType tmp;
		tmp.m_item.m_cond_list = cond_list;
		tmp.m_type = CONDLIST;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Token* token )
	    {
		traceAdding< Token >();
		ItemType tmp;
		tmp.m_item.m_token = token;
		tmp.m_type = TOKEN;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Def* def )
	    {
		traceAdding< Def >();
		ItemType tmp;
		tmp.m_item.m_def = def;
		tmp.m_type = DEF;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Region* region )
	    {
		traceAdding< Region >();
		ItemType tmp;
		tmp.m_item.m_region = region;
		tmp.m_type = REG;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Point* point )
	    {
		traceAdding< Point >();
		ItemType tmp;
		tmp.m_item.m_point = point;
		tmp.m_type = POINT;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( UNum* unum )
	    {
		traceAdding< UNum >();
		ItemType tmp;
		tmp.m_item.m_unum = unum;
		tmp.m_type = UNUM;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( BallMoveToken bmt )
	    {
		traceAdding< BallMoveToken >();
		ItemType tmp;
		tmp.m_item.m_bmt = bmt;
		tmp.m_type = BMT;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( UNumSet* unum_set )
	    {
		traceAdding< UNumSet >();
		ItemType tmp;
		tmp.m_item.m_unum_set = unum_set;
		tmp.m_type = UNUMSET;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( std::string* str )
	    {
		traceAdding< std::string >();
		ItemType tmp;
		tmp.m_item.m_str = str;
		tmp.m_type = STR;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( RuleIDList* rid_list )
	    {
		traceAdding< RuleIDList >();
		ItemType tmp;
		tmp.m_item.m_rule_id_list = rid_list;
		tmp.m_type = RIDLIST;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( ActivateRules* act_rules )
	    {
		traceAdding< ActivateRules >();
		ItemType tmp;
		tmp.m_item.m_activate = act_rules;
		tmp.m_type = ACTIVATE;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( Rule* rule )
	    {
		traceAdding< Rule >();
		ItemType tmp;
		tmp.m_item.m_rule = rule;
		tmp.m_type = RULE;
		M_items.push( tmp );
	    }

	void MsgBuilder::add( RuleID rid )
	    {
		traceAdding< BallMoveToken >();
		ItemType tmp;
		tmp.m_item.m_rid = new RuleID( rid );
		tmp.m_type = RID;
		M_items.push( tmp );
	    }


    void
    MsgBuilder::emptyStack()
    {
      while( !M_items.empty() )
        {
	    M_items.top().clear();
            M_items.pop();
        }
    }

    void
    MsgBuilder::clear()
    {
      M_msg.release();
      M_min_ver = (unsigned int)-1;
      M_max_ver = 0;
    }      

    void
    MsgBuilder::onNoItems() const
    {
      throw BuilderErr( __FILE__, __LINE__,
                        "No item on stack." );        
    }
    
    void
    MsgBuilder::onWrongItem() const
    {
      throw BuilderErr( __FILE__, __LINE__,
                        "Wrong item on stack." );        
    }
    
    void
    MsgBuilder::onNotEmpty() const
    {
      throw BuilderErr( __FILE__, __LINE__,
                        "Stack is not empty when it should be." );        
    }
 
    MsgBuilder::MsgBuilder()
      : M_min_ver( (unsigned int)-1 ),
        M_max_ver( 0 )
    {}

    MsgBuilder::~MsgBuilder()
    { emptyStack(); }

    Msg*
    MsgBuilder::getMsg()
    { return M_msg.get(); }
    
    const Msg*
    MsgBuilder::getMsg() const
    { return M_msg.get(); }
    
    std::auto_ptr< Msg >
    MsgBuilder::detatchMsg()
    { return M_msg; }

    
    void
    MsgBuilder::checkItemsEmpty() const
    {
      if( !M_items.empty() )
        onNotEmpty();
    }

    
    void
    MsgBuilder::setMsg( Msg* msg )
    {
      std::auto_ptr< Msg > tmp( msg );
      M_msg = tmp;
      setVer( M_min_ver, M_max_ver );
      checkItemsEmpty();
    }

    
    void
    MsgBuilder::setTime( const int& time )
    {
      if( M_msg.get() != NULL )
        M_msg->setTimeSend( time );
    }
    
    
    void
    MsgBuilder::setSide( const int& side )
    {
      if( M_msg.get() != NULL )
        M_msg->setSide( side );
    }

    void
    MsgBuilder::setTimeRecv( const int& time )
    {
      if( M_msg.get() != NULL )
        M_msg->setTimeRecv( time );
    }      


    
    void
    MsgBuilder::setVer( const unsigned int& min,
                              const unsigned int& max )
    {
      if( min == max )
        {
          // Then the version is restriced to min/max
          if( min < M_max_ver )
            M_min_ver = min;
          else if( min > M_min_ver )
            M_max_ver = min;
          else if( M_max_ver < M_min_ver )
            M_min_ver = M_max_ver = min;
        }
      else
        {
          if( min < M_min_ver )
            M_min_ver = min;
          if( max > M_max_ver )
            M_max_ver = max;
          if( min > max 
              && M_max_ver < M_min_ver 
              && min > M_max_ver 
              && max < M_min_ver )
            {
              M_min_ver = min;
              M_max_ver = max;
            }
        }
      if( M_msg.get() != NULL )
        {
          M_msg->setVer( min, max );
        }
    }

      
    
    void
    MsgBuilder::buildMetaMsg()
    {
      traceBuild< MetaMsg* >();
      MetaMsg* msg( new MetaMsg() );
      if( checkIsItem( META ) )
      {
	  while( isItem( META ) )
	      msg->getTokens().push_front( getMetaToken().release() );
      }  
      setMsg( msg );
    }
      
    
    void
    MsgBuilder::buildMetaTokenVer( const double& ver )
    {
      traceBuild< MetaTokenVer* >();
      add( new MetaTokenVer( ver ) ); 
    }

      
    
    void
    MsgBuilder::buildDefineMsg()
    {
      traceBuild< DefineMsg* >();
      DefineMsg* msg = new DefineMsg();
      if( checkIsItem( DEF ) )
        {
	    while( isItem( DEF ) )
		msg->getDefs().push_front( getDef().release() );
        }
      setMsg( msg );
    }

      
    
    void
    MsgBuilder::buildDefineCond( const std::string& name )
    {
      traceBuild< DefCond* >();
      add( new DefCond( name, checkAndGetCond() ) ); 
    }
      
    
    void
    MsgBuilder::buildDefineDir( const std::string& name )
    {
      traceBuild< DefDir* >();
      add( new DefDir( name, checkAndGetDir() ) ); 
    }
      
    
    void
    MsgBuilder::buildDefineReg( const std::string& name )
    {
      traceBuild< DefReg* >();
      add( new DefReg( name, checkAndGetRegion() ) ); 
    }
      
    
    void
    MsgBuilder::buildDefineAct( const std::string& name )
    { 
      traceBuild< DefAct* >();
      add( new DefAct( name, checkAndGetAction() ) ); 
    }
      
    
    void
    MsgBuilder::buildFreeformMsg( const std::string& str )
    { 
      traceBuild< FreeformMsg* >();
      setMsg( new FreeformMsg( str ) ); 
    }
     
    
    void
    MsgBuilder::buildUnsuppMsg()
    { 
      traceBuild< UnsuppMsg* >();
      setMsg( new UnsuppMsg() ); 
    }
      
    
    void  
    MsgBuilder::buildInfoMsg()
    {
      traceBuild< InfoMsg* >();
      InfoMsg* msg = new InfoMsg();
      if( checkIsItem( TOKEN ) )
        {
	    while( isItem( TOKEN ) )
		msg->getTokens().push_front( getToken().release() );
        }
      setMsg( msg );
    }
      
    
    void
    MsgBuilder::buildAdviceMsg()
    {
      traceBuild< AdviceMsg* >();
      AdviceMsg* msg = new AdviceMsg();
      if( checkIsItem( TOKEN ) )
        {
          while( isItem( TOKEN ) )
            msg->getTokens().push_front( getToken().release() );
        }
      setMsg( msg );
    }
      
    
    void
    MsgBuilder::buildTokenRule( const int& ttl )
    {
      traceBuild< TokRule* >();
      TokRule* token = new TokRule( ttl );
      if( checkIsItem( DIR ) )
        {
          while( isItem( DIR ) )
	      token->getDirs().push_front( getDir().release() );
        }
      token->set( checkAndGetCond() );
      add( token );
    }
      
    
    void
    MsgBuilder::buildTokenClear()
    {
      traceBuild< TokClear* >();
      add( new TokClear() );
    }
 
    
    void
    MsgBuilder::buildActPos()
    {
      traceBuild< ActPos* >();
      add( new ActPos( checkAndGetRegion() ) ); 
    }
      
    
    void
    MsgBuilder::buildActHome()
    {
      traceBuild< ActHome* >();
      add( new ActHome( checkAndGetRegion() ) );
    }
      
    
    void
    MsgBuilder::buildActBallToReg()
    { 
      traceBuild< ActBallToReg* >();
      BallMove bm;
      if( checkIsItem( BMT ) )
        {
          while( isItem( BMT ) )
            bm.addToken( getBMT() );
        }
      std::auto_ptr< Region > reg = checkAndGetRegion(); 
      add( new ActBallToReg( reg, bm ) );
    }
      
    
    void
    MsgBuilder::buildActBallToPlayer()
    {
      traceBuild< ActBallToPlayer* >();
      add( new ActBallToPlayer( *checkAndGetUNumSet() ) );
    }
 
    
    void
    MsgBuilder::buildActMark()
    {
      traceBuild< ActMark* >();
      add( new ActMark( *checkAndGetUNumSet() ) );
    }
      
    
    void
    MsgBuilder::buildActMarkLinePlayer()
    {
      traceBuild< ActMarkLinePlayer* >();
      add( new ActMarkLinePlayer( *checkAndGetUNumSet() ) );
    }
      
    
    void
    MsgBuilder::buildActMarkLineReg()
    {
      traceBuild< ActMarkLineReg* >();
      add( new ActMarkLineReg( checkAndGetRegion() ) ); 
    }

    
    void
    MsgBuilder::buildActOffsideLine()
    {
      traceBuild< ActOffsidesLine* >();
      add( new ActOffsidesLine( checkAndGetRegion() ) ); 
    }
      
    
    void
    MsgBuilder::buildActHetType( const int& type )
    {
      traceBuild< ActHetType* >();
      add( new ActHetType( type ) ); 
    }
      
    
    void
    MsgBuilder::buildActNamed( const std::string& name )
    {
      traceBuild< ActNamed* >();
      add( new ActNamed( name ) ); 
    }
      
    
    void
    MsgBuilder::buildActPassReg()
    {
      traceBuild< ActPassReg* >();
      add( new ActPassReg( checkAndGetRegion() ) ); 
    }
      
    
    void
    MsgBuilder::buildActPassUNum()
    {
      traceBuild< ActPassUNum* >();
      add( new ActPassUNum( *checkAndGetUNumSet() ) ); 
    }
 
    
    void
    MsgBuilder::buildActDribble()
    {
      traceBuild< ActDribble* >();
      add( new ActDribble( checkAndGetRegion() ) ); 
    }
 
    
    void
    MsgBuilder::buildActClear()