clangmsgbuilder.cpp

来自「2009 ROBOCUP 仿真2DSERVER 源码」· C++ 代码 · 共 1,678 行 · 第 1/3 页

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 ),
      M_freeform_msg_size( 128 )
{

}

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::setFreeformMsgSize( const unsigned int len )
{
    M_freeform_msg_size = len;
}

unsigned int
MsgBuilder::freeformMsgSize() const
{
    return M_freeform_msg_size;
}


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 * >();