clangmsgbuilder.cc

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

// -*-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
  {
      	    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 );
	    }