cond.h

2009 ROBOCUP 仿真2DSERVER 源码

    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;
      }

private:
    PlayMode M_pm;
};


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

private:
    CondAnd()
        : Cond()
      { }

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

    virtual
    ~CondAnd();

    virtual
    std::auto_ptr< Cond > deepCopy() const;

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

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

    virtual
    bool eval( const Context & context ) const;

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

private:
	Storage M_conds;

};


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

private:
    CondOr()
        : Cond()
      { }

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

    virtual
    ~CondOr();

    virtual
    std::auto_ptr< Cond > deepCopy() const;

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

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

    virtual
    bool eval( const Context & context ) const;

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

private:
	Storage M_conds;
};


class CondNot
    : public Cond {
public:

    CondNot()
        : Cond()
      { }

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

    virtual
    ~CondNot()
      { }

    virtual
    std::auto_ptr< Cond > deepCopy() const;

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

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

    virtual
    bool eval( const Context & context ) const;

    const Cond * getCond() const
      {
          return M_cond.get();
      }

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

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


class CondNamed
    : public Cond {
private:
    CondNamed()
        : Cond()
      { }

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

    ~CondNamed()
      {}

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

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

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

    virtual
    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;
//       }

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::auto_ptr< Cond > deepCopy() const
      {
          return std::auto_ptr< Cond >( new CondTime( *this ) );
      }

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

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

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


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

    ~CondOppGoal()
      { }

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

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

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

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

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

    ~CondOurGoal()
      { }

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

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

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

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

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

    ~CondGoalDiff()
      { }

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

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

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

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


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

public:
    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::auto_ptr< Cond > deepCopy() const
      {
          return std::auto_ptr< Cond >( new CondUNum( *this ) );
      }

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

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

    virtual
    bool eval( const Context & context ) const
      {
          return context.lookup( *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