clangmsgbuilder.cpp

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

// -*-c++-*-

/***************************************************************************
                               clangmsgbuilder.cc
                      Class for building a clang message
                             -------------------
    begin                : 25-FEB-2002
    copyright            : (C) 2002 by The RoboCup Soccer Server
                           Maintenance Group.
    email                : [e-mail]
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU LGPL as published by the Free Software  *
 *   Foundation; either version 2 of the License, or (at your option) any  *
 *   later version.                                                        *
 *                                                                         *
 ***************************************************************************/

#include "clangmsgbuilder.h"
#include "region.h"
#include "clangmsg.h"
#include "clangmetamsg.h"
#include "clangfreeformmsg.h"
#include "clangunsuppmsg.h"
#include "clangrulemsg.h"
#include "clangdelmsg.h"
#include "clanginfomsg.h"
#include "clangadvicemsg.h"
#include "clangdefmsg.h"
#include "coach_lang_comp.h"
#include "rule.h"


namespace rcss {
namespace clang {


template< typename X >
inline
void
traceBuild()
{
#ifdef DEBUG
    std::cout << "Building: " << typeid( X ).name() << std::endl;
#endif
}

template< typename X >
inline
void
traceRemoving()
{
#ifdef DEBUG
    std::cout << "Removing: " << typeid( X ).name() << std::endl;
#endif
}

template< typename X >
inline
void
traceAdding()
{
#ifdef DEBUG
    std::cout << "Adding: " << typeid( X ).name() << std::endl;
#endif
}


void
MsgBuilder::ItemType::clear()
{
    switch ( m_type ) {
    case NONE:
        break;
    case META:
        delete m_item.m_meta_token;
        break;
    case ACTION:
        delete m_item.m_action;
        break;
    case DIR:
        delete m_item.m_dir;
        break;
    case COND:
        delete m_item.m_cond;
        break;
    case CONDLIST:
        delete m_item.m_cond_list;
        break;
    case TOKEN:
        delete m_item.m_token;
        break;
    case DEF:
        delete m_item.m_def;
        break;
    case REG:
        delete m_item.m_region;
        break;
    case POINT:
        delete m_item.m_point;
        break;
    case UNUM:
        delete m_item.m_unum;
        break;
    case BMT:
        break;
    case UNUMSET:
        delete m_item.m_unum_set;
        break;
    case STR:
        delete m_item.m_str;
        break;
    case RIDLIST:
        delete m_item.m_rule_id_list;
        break;
    case ACTIVATE:
        delete m_item.m_activate;
        break;
    case RULE:
        delete m_item.m_rule;
        break;
    case RID:
        break;
    }
}

std::auto_ptr< MetaToken >
MsgBuilder::getMetaToken()
{
    traceRemoving< MetaToken >();
    std::auto_ptr< MetaToken > rval( M_items.top().m_item.m_meta_token );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Action >
MsgBuilder::getAction()
{
    traceRemoving< Action >();
    std::auto_ptr< Action > rval( M_items.top().m_item.m_action );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}

std::auto_ptr< Dir >
MsgBuilder::getDir()
{
    traceRemoving< Dir >();
    std::auto_ptr< Dir > rval( M_items.top().m_item.m_dir );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Cond >
MsgBuilder::getCond()
{
    traceRemoving< Cond >();
    std::auto_ptr< Cond > rval( M_items.top().m_item.m_cond );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< MsgBuilder::CondList >
MsgBuilder::getCondList()
{
    traceRemoving< CondList >();
    std::auto_ptr< CondList > rval( M_items.top().m_item.m_cond_list );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Token >
MsgBuilder::getToken()
{
    traceRemoving< Token >();
    std::auto_ptr< Token > rval( M_items.top().m_item.m_token );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Def >
MsgBuilder::getDef()
{
    traceRemoving< Def >();
    std::auto_ptr< Def > rval( M_items.top().m_item.m_def );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Region >
MsgBuilder::getRegion()
{
    traceRemoving< Region >();
    std::auto_ptr< Region > rval( M_items.top().m_item.m_region );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Point >
MsgBuilder::getPoint()
{
    traceRemoving< Point >();
    std::auto_ptr< Point > rval( M_items.top().m_item.m_point );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< UNum >
MsgBuilder::getUNum()
{
    traceRemoving< UNum >();
    std::auto_ptr< UNum > rval( M_items.top().m_item.m_unum );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


BallMoveToken
MsgBuilder::getBMT()
{
    traceRemoving< BallMoveToken >();
    BallMoveToken rval( M_items.top().m_item.m_bmt );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< UNumSet >
MsgBuilder::getUNumSet()
{
    traceRemoving< UNumSet >();
    std::auto_ptr< UNumSet > rval( M_items.top().m_item.m_unum_set );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< std::string >
MsgBuilder::getStr()
{
    traceRemoving< std::string >();
    std::auto_ptr< std::string > rval( M_items.top().m_item.m_str );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< RuleIDList >
MsgBuilder::getRIDList()
{
    traceRemoving< RuleIDList >();
    std::auto_ptr< RuleIDList > rval( M_items.top().m_item.m_rule_id_list );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< ActivateRules >
MsgBuilder::getActivateRules()
{
    traceRemoving< ActivateRules >();
    std::auto_ptr< ActivateRules > rval( M_items.top().m_item.m_activate );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}


std::auto_ptr< Rule >
MsgBuilder::getRule()
{
    traceRemoving< Rule >();
    std::auto_ptr< Rule > rval( M_items.top().m_item.m_rule );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}

std::auto_ptr< RuleID >
MsgBuilder::getRID()
{
    traceRemoving< RuleID >();
    std::auto_ptr< RuleID > rval( M_items.top().m_item.m_rid );
    //M_items.top().clear();
    M_items.pop();
    return rval;
}

bool
MsgBuilder::isItem( Types type ) const
{
    return ( ! M_items.empty()
             && M_items.top().m_type == type );
}

bool
MsgBuilder::checkIsItem( Types type ) const
{
    if ( !M_items.empty() )
    {
        if ( M_items.top().m_type == type )
        {
            return true;
        }
        else
        {
            onWrongItem();
        }
    }
    else
    {
        onNoItems();
    }
    return false;
}


std::auto_ptr< MetaToken >
MsgBuilder::checkAndGetMetaToken()
{
    if ( checkIsItem( META ) )
    {
        return getMetaToken();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< MetaToken >();
}


std::auto_ptr< Action >
MsgBuilder::checkAndGetAction()
{
    if ( checkIsItem( ACTION ) )
    {
        return getAction();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Action >();
}

std::auto_ptr< Dir >
MsgBuilder::checkAndGetDir()
{
    if ( checkIsItem( DIR ) )
    {
        return getDir();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Dir >();
}


std::auto_ptr< Cond >
MsgBuilder::checkAndGetCond()
{
    if ( checkIsItem( COND ) )
    {
        return getCond();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Cond >();
}


std::auto_ptr< MsgBuilder::CondList >
MsgBuilder::checkAndGetCondList()
{
    if ( checkIsItem( CONDLIST ) )
    {
        return getCondList();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< CondList >( new CondList() );
}


std::auto_ptr< Token >
MsgBuilder::checkAndGetToken()
{
    if ( checkIsItem( TOKEN ) )
    {
        return getToken();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Token >();
}


std::auto_ptr< Def >
MsgBuilder::checkAndGetDef()
{
    if ( checkIsItem( DEF ) )
    {
        return getDef();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Def >();
}


std::auto_ptr< Region >
MsgBuilder::checkAndGetRegion()
{
    if ( checkIsItem( REG ) )
    {
        return getRegion();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Region >();
}


std::auto_ptr< Point >
MsgBuilder::checkAndGetPoint()
{
    if ( checkIsItem( POINT ) )
    {
        return getPoint();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Point >();
}


std::auto_ptr< UNum >
MsgBuilder::checkAndGetUNum()
{
    if ( checkIsItem( UNUM ) )
    {
        return getUNum();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< UNum >( new UNum() );
}


BallMoveToken
MsgBuilder::checkAndGetBMT()
{
    if ( checkIsItem( BMT ) )
    {
        return getBMT();
    }
    // no need for error handling as this is done by checkIsItem()
    return BallMoveToken();
}


std::auto_ptr< UNumSet >
MsgBuilder::checkAndGetUNumSet()
{
    if ( checkIsItem( UNUMSET ) )
    {
        return getUNumSet();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< UNumSet >( new UNumSet() );
}


std::auto_ptr< std::string >
MsgBuilder::checkAndGetStr()
{
    if ( checkIsItem( STR ) )
    {
        return getStr();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< std::string >( new std::string() );
}


std::auto_ptr< RuleIDList >
MsgBuilder::checkAndGetRIDList()
{
    if ( checkIsItem( RIDLIST ) )
    {
        return getRIDList();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< RuleIDList >();
}


std::auto_ptr< ActivateRules >
MsgBuilder::checkAndGetActivateRules()
{
    if ( checkIsItem( ACTIVATE ) )
    {
        return getActivateRules();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< ActivateRules >();
}


std::auto_ptr< Rule >
MsgBuilder::checkAndGetRule()
{
    if ( checkIsItem( RULE ) )
    {
        return getRule();
    }
    // no need for error handling as this is done by checkIsItem()
    return std::auto_ptr< Rule >();
}

RuleID
MsgBuilder::checkAndGetRID()
{
    if ( checkIsItem( RID ) )
    {
        return *getRID();
    }
    // no need for error handling as this is done by checkIsItem()
    return RuleID();
}

void MsgBuilder::add( MetaToken * meta )
{
    traceAdding< MetaToken >();
    ItemType tmp;
    tmp.m_item.m_meta_token = meta;
    tmp.m_type = META;
    M_items.push( tmp );
}

void MsgBuilder::add( Action * action )
{
    traceAdding< Action >();
    ItemType tmp;
    tmp.m_item.m_action = action;
    tmp.m_type = ACTION;
    M_items.push( tmp );
}