cond.h

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

      clearPlayers()
      { M_players.clear(); }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondBallOwner( *this ) ); }

    private:
      bool M_our_side;
      UNumSet M_players;
    };



    class CondPlayMode
      : public Cond
    {
    public:
      static const char* MODE_STRINGS[];

      CondPlayMode()
        : Cond(),
          M_pm( PM_None )
      {}

      CondPlayMode( const PlayMode& pm )
        : Cond(),
          M_pm( pm )
      {}

      ~CondPlayMode()
      {}

      std::ostream&
      print( std::ostream& out ) const
      { return out << "(playm " << MODE_STRINGS[ M_pm ] << ")"; }

      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return out << line_header << "is play mode '"
                   << MODE_STRINGS[ M_pm ] << "'" << std::endl; }

      bool
      eval( const Context& context ) const
      { return context.lookup( *this ); }
  
      /* class specific stuff */
      PlayMode 
      getPlayMode() const
      { return M_pm; }

      void
      setPlayMode( const PlayMode& pm)
      { M_pm = pm; }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondPlayMode( *this ) ); }

    private:
      PlayMode M_pm;
    };

    class CondAnd
      : public Cond
    {
    public:
	typedef std::list< Cond* > Storage;
	
      CondAnd()
        : Cond()
      {}

      CondAnd( const Storage& conds ) 
        : Cond(),
          m_conds( conds )
      {
      }

      virtual
      ~CondAnd()
      {
	  for( Storage::iterator i = m_conds.begin();
	       i != m_conds.end(); ++i )
	      delete *i;
	  m_conds.clear();
      }

      std::ostream&
      print( std::ostream& out ) const;

      std::ostream& 
      printPretty( std::ostream& out, const std::string& line_header ) const;

      bool
      eval( const Context& context ) const;

      const Storage& 
      getConds() const 
      { return m_conds; }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      virtual
      std::auto_ptr< Cond >
      deepCopy() const
      {
	  Storage new_conds;
	  for( Storage::const_iterator i = m_conds.begin();
	       i != m_conds.end(); ++i )
	      new_conds.push_back( (*i)->deepCopy().release() );
	  return std::auto_ptr< Cond >( new CondAnd( new_conds ) ); 
      }

    private:
	Storage m_conds;
	
    };


    class CondOr
      : public Cond
    {
    public:
 	typedef std::list< Cond* > Storage;
 
      CondOr() 
        : Cond()
      {}

      CondOr( const Storage& conds ) 
        : Cond(),
          m_conds( conds )
      {}

      virtual
      ~CondOr()
      {	  
	  for( Storage::iterator i = m_conds.begin();
	       i != m_conds.end(); ++i )
	      delete *i;
	  m_conds.clear();
      }

      std::ostream&
      print( std::ostream& out ) const;

      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const;

      bool
      eval( const Context& context ) const;

      const Storage&
      getConds() const 
      { return m_conds; }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      virtual
      std::auto_ptr< Cond >
      deepCopy() const
      {
	  Storage new_conds;
	  for( Storage::const_iterator i = m_conds.begin();
	       i != m_conds.end(); ++i )
	      new_conds.push_back( (*i)->deepCopy().release() );
	  return std::auto_ptr< Cond >( new CondOr( new_conds ) ); 
      }

    private:
	Storage m_conds;
    };


    class CondNot
      : public Cond
    {
    public:

      CondNot()
        : Cond()
      {}

      CondNot( std::auto_ptr< Cond > cond ) 
        : Cond(),
          m_cond( cond )
      {}

      virtual
      ~CondNot()
      {}

      std::ostream& 
      print( std::ostream& out ) const 
      { 
        out << "(not ";
        if( getCond() == NULL )
          out << "(null)\n";
        else
          out << *getCond();
        return out << ")";
      }

      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { 
        out << line_header << "not " << std::endl;
        if( getCond() == NULL )
          out << line_header << " (null)\n";
        else
          getCond()->printPretty( out, line_header + " +" );
        return out;
      }

      bool
      eval( const Context& context ) const
      {
        if( getCond() == NULL )
          throw util::NullErr( __FILE__, __LINE__, 
                               "Null condition in CondNot\n" );
        else
	    return !( getCond()->eval( context ) );
      }
  
      const Cond*
      getCond() const
      { return m_cond.get(); }

      std::auto_ptr< Cond >
      detachCond()
      { return m_cond; }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      virtual
      std::auto_ptr< Cond >
      deepCopy() const
      {
	  if( m_cond.get() != NULL )
	      return std::auto_ptr< Cond >( new CondNot( m_cond->deepCopy() ) ); 
	  else
	      return std::auto_ptr< Cond >( new CondNot() ); 
      }

    private:
	std::auto_ptr< Cond > m_cond;
    };


    class CondNamed
      : public Cond
    {
    public:
      CondNamed() 
        : Cond()
      {}
  
      CondNamed( const std::string& name ) 
        : Cond(),
          M_name( name )
      {}
  
      ~CondNamed()
      {}

      std::ostream&
      print( std::ostream& out ) const
      { return out << "\"" << M_name << "\""; }

      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return out << line_header << "cond named \"" 
                   << M_name << "\"" << std::endl; }
  
      bool
      eval( const Context& context ) const 
      { return context.lookup ( *this ); }

      /* class specific */
      std::string& 
      getName()
      { return M_name; }

      const std::string& 
      getName() const
      { return M_name; }

      void
      setName( const std::string& name )
      { M_name = name; }
 
//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondNamed( *this ) ); }

    private:
      std::string M_name;
    };

    template< typename VALUE >
    class CondComp
      : public Cond
    {
    private:
      const util::CompOp* M_comp;
      VALUE M_value;

    public:
      CondComp( const VALUE& value, const util::CompOp& comp )
        : M_comp( &comp ),
          M_value( value )
      {}

      ~CondComp()
      {}

      VALUE
      getValue() const
      { return M_value; }

      VALUE
      setValue( const VALUE& value )
      { return M_value = value; }

      const util::CompOp&
      getComp() const
      { return *M_comp; }

      const util::CompOp&
      setComp( const util::CompOp& comp )
      { return *(M_comp = &comp); }      
    };

    class CondTime
      : public CondComp< int >
    {
    public:
      CondTime( const int& value, const util::CompOp& comp )
        : CondComp< int >( value, comp )
      {}

      ~CondTime()
      {}

      virtual
      std::ostream&
      print( std::ostream& out ) const
      { return out << "(time " << getComp() << " " << getValue() << ")"; }

      virtual
      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return print( out << line_header ); }

      virtual
      bool 
      eval( const Context& context ) const
      { return context.lookup( *this ); }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondTime( *this ) ); }
    };


    class CondOppGoal
      : public CondComp< int >
    {
    public:
      CondOppGoal( const int& value, const util::CompOp& comp )
        : CondComp< int >( value, comp )
      {}

      ~CondOppGoal()
      {}

      virtual
      std::ostream&
      print( std::ostream& out ) const
      { return out << "(opp_goals " << getComp() << " " << getValue() << ")"; }

      virtual
      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return print( out << line_header ); }

      virtual
      bool 
      eval( const Context& context ) const
      { return context.lookup( *this ); }

 //      virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondOppGoal( *this ) ); }
    };

    class CondOurGoal
      : public CondComp< int >
    {
    public:
      CondOurGoal( const int& value, const util::CompOp& comp )
        : CondComp< int >( value, comp )
      {}

      ~CondOurGoal()
      {}

      virtual
      std::ostream&
      print( std::ostream& out ) const
      { return out << "(our_goals " << getComp() << " " << getValue() << ")"; }

      virtual
      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return print( out << line_header ); }

      virtual
      bool 
      eval( const Context& context ) const
      { return context.lookup( *this ); }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondOurGoal( *this ) ); }
    };

    class CondGoalDiff
      : public CondComp< int >
    {
    public:
      CondGoalDiff( const int& value, const util::CompOp& comp )
        : CondComp< int >( value, comp )
      {}

      ~CondGoalDiff()
      {}

      virtual
      std::ostream&
      print( std::ostream& out ) const
      { return out << "(goal_diff " << getComp() << " " << getValue() << ")"; }

      virtual
      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return print( out << line_header ); }

      virtual
      bool 
      eval( const Context& context ) const
      { return context.lookup( *this ); }

 //      virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondGoalDiff( *this ) ); }
    };

    
    class CondUNum
      : public Cond
    {
    public:
     CondUNum()
        : Cond(),
          M_unum(),
          M_set()
      {}

     CondUNum( const UNum& unum )
        : Cond(),
          M_unum( unum ),
          M_set()
      {}

      CondUNum( const UNum& unum, const UNumSet& players )
        : Cond(),
          M_unum( unum ),
          M_set( players )
      {}

      ~CondUNum()
      {}

      virtual
      std::ostream&
      print( std::ostream& out ) const
      { return out << "(unum " << M_unum << " " << M_set << ")"; }

      virtual
      std::ostream&
      printPretty( std::ostream& out, const std::string& line_header ) const
      { return print( out << line_header ); }

      virtual
      bool 
      eval( const Context& context ) const
      { return context.lookup( *this ); }

//       virtual
//       void
//       accept( Visitor& v )
//       { v.startVisit( this ); }

//       virtual
//       void
//       accept( ConstVisitor& v ) const
//       { v.startVisit( this ); }

      std::auto_ptr< Cond >
      deepCopy() const
      { return std::auto_ptr< Cond >( new CondUNum( *this ) ); }

      UNum&
      setUNum( const UNum& unum )
      { return M_unum = unum; }

      UNum
      getUNum() const
      { return M_unum; }
      
      UNumSet&
      setUNum( const UNumSet& uset )
      { return M_set = uset; }

      UNumSet&
      getUNumSet()
      { return M_set; }
      
      const UNumSet&
      getUNumSet() const
      { return M_set; }
      
      UNum
      addUNum( const UNum& unum )
      { M_set.add( unum ); return unum; }

    private:
      UNum M_unum;
      UNumSet M_set;
    };
  }
}

#endif