trilobot.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008 Jakub Filak <xfilak01@stud.fit.vutbr.cz>
 *
 * This file is part of rob08
 *
 * rob08 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * rob08 is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with rob08.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef __TRILOBOT_H__
#define __TRILOBOT_H__

#include "scanner.h"
#include "DateTime.h"
#include "physics.h"

#include "simulator.h"

#include <boost/shared_ptr.hpp>

#ifndef BUILDING_DOX
// system includes, alphabetically sorted
# include <iostream>
#endif

class IWriter;

class IExporter;

class World;

class IAnswer 
{
  public: 
    void Write( IWriter& output ) {
      ImplWrite( output );
    }

    virtual ~IAnswer() {}

  protected:
    virtual void ImplWrite( IWriter& output ) =0;
};

typedef boost::shared_ptr<IAnswer> IAnswerPtr;

class AckAnswer : public IAnswer
{
  protected:
    virtual void ImplWrite( IWriter& output );
};

template<class DT> class Answer : public IAnswer
{
  public: 
    Answer( const DT& value )
      : m_value( value )
    {}

    virtual ~Answer(){}

  protected:
    DT m_value;
};

class ICommand //: public ISerializable
{
  public:
    typedef EToken CodeType;

    CodeType Code() {
      return ImplCode();
    }
    
    const Token::TArgVector& Data() const
      { return ImplData(); }

    bool Handled() {
      return ImplHandled();
    }

    ICommand& Handled( bool value ) {
      ImplHandled( value );
      return *this;
    }

    IAnswerPtr Answer() {
      return ImplAnswer();
    }
    
    ICommand& Answer( IAnswerPtr answer ) {
      ImplAnswer( answer );
      return *this;
    }
    
    const DateTime& Stamp() {
      return ImplStamp();
    }

    virtual ~ICommand() {}

  protected:
    virtual CodeType ImplCode() const =0;
    virtual const Token::TArgVector& ImplData() const =0;
    virtual bool ImplHandled() const =0;
    virtual void ImplHandled( bool ) =0;
    virtual IAnswerPtr ImplAnswer() const =0;
    virtual void ImplAnswer( IAnswerPtr ) =0;
    virtual const DateTime& ImplStamp() const =0;
};

typedef ICommand* ICommandPtr;

class TokenCommand : public ICommand
{
  public:
    TokenCommand( const Token& );

    virtual ~TokenCommand();
  protected:  
    virtual CodeType ImplCode() const;
    virtual const Token::TArgVector& ImplData() const;
    virtual bool ImplHandled() const;
    virtual void ImplHandled( bool value );
    virtual IAnswerPtr ImplAnswer() const;
    virtual void ImplAnswer( IAnswerPtr answer );
    virtual const DateTime& ImplStamp() const;

  private:
    TokenCommand( const TokenCommand& );
    TokenCommand& operator=( TokenCommand& );

    struct Members;
    Members* pimpl;
};

class Trilobot;
typedef Trilobot* TrilobotPtr;

class IComponent : public virtual IMovingObject
{
  public:
    std::string Id() const {
      return ImplId();
    }

    IComponent& Handle( ICommand& command ) {
      ImplHandle( command );
      return *this;
    }

    virtual ~IComponent() {}

  protected:
    virtual std::string ImplId() const =0;
    virtual void ImplHandle( ICommand& command ) =0;
};

class BaseComponent : public virtual IComponent 
{
  protected:  
    BaseComponent( const char* id, TrilobotPtr robot );

    virtual std::string ImplId() const;

    TrilobotPtr Robot() const;

    BaseComponent& SaveCurrentState( StatePtr );
    BaseComponent& SaveNextState( StatePtr );
    StatePtr GetCurrentState( const DateTime& now );

    virtual ~BaseComponent();

  protected:
    virtual void ImplSerialize( std::ostream& );  
    virtual void ImplDeserialize( std::istream& );

  private:
    struct Members;
    Members* pimpl;
};

class SimpleComponent : public BaseComponent, public BaseMovingObject
{
  protected:
    SimpleComponent( const char* id, TrilobotPtr robot );
    virtual void ImplSerialize( std::ostream& );  
    virtual void ImplDeserialize( std::istream& );
};

class IDriveObserver
{
  public:
    void DrivePropertyChange( const DateTime& stamp, double runTime )
    { ImplDrivePropertyChange( stamp, runTime ); }

    virtual ~IDriveObserver() {};

  protected:
    virtual void ImplDrivePropertyChange( const DateTime&, double runTime ) =0;
};

class IDrive
{
  public:
    double Distance() { 
      DateTime now( DateTime::Now() );
      return ImplDistance( now ); 
    }

    double Distance( const DateTime& stamp )
    { return ImplDistance( stamp ); }

    IDrive& Halt() { 
      DateTime now( DateTime::Now());
      ImplHalt( now );
      return *this;
    }

    IDrive& Halt( const DateTime& at ) { 
      ImplHalt( at );
      return *this;
    }

    IDrive& AddObserver( IDriveObserver* observer ) { 
      ImplAddObserver( observer );
      return *this;
    }
    
    virtual ~IDrive() {}
    
  protected:
    virtual double ImplDistance( const DateTime& ) =0;
    virtual void ImplHalt( const DateTime& ) =0;
    virtual void ImplAddObserver( IDriveObserver* observer ) =0;
};

class Drive;

class Compass : public IComponent
{
  public:
    enum ECourse { NORTH=0, NORTH_EAST, EAST, SOUTH_EAST, SOUTH, SOUTH_WEST, WEST, NORTH_WEST };

    Compass( Trilobot* const robot );
    
    ECourse Course( DateTime at = DateTime::Now() );
    unsigned CourseAngle( DateTime at = DateTime::Now() );

    virtual ~Compass();

  protected:
    virtual std::string ImplId() const;
    virtual void ImplHandle( ICommand& command ); 

    virtual struct Position ImplPosition( const DateTime& );
    virtual double ImplSize(const DateTime&);

    // Returns from trilobot
    virtual double ImplSpeed(const DateTime&);
    // Returns from trilobot
    virtual double ImplRadius(const DateTime&);

    // Nothig to serialize 
    virtual void ImplSerialize( std::ostream& ) {}
    // and nothing to deserialize
    virtual void ImplDeserialize( std::istream& ) {}

  private:
    unsigned Angle( DateTime at = DateTime::Now() );

    struct Members;
    Members* pimpl;
};

class SoundSensor : public IComponent
{
  public:
    SoundSensor( Trilobot* const robot );
    
    unsigned char SoundLevel( DateTime at = DateTime::Now() );

    virtual ~SoundSensor();

  protected:
    virtual std::string ImplId() const;
    virtual void ImplHandle( ICommand& command ); 

    virtual struct Position ImplPosition( const DateTime& );
    virtual double ImplSize(const DateTime&);

    // Returns from trilobot
    virtual double ImplSpeed(const DateTime&);
    // Returns from trilobot
    virtual double ImplRadius(const DateTime&);

    // Nothig to serialize 
    virtual void ImplSerialize( std::ostream& ) {}
    // and nothing to deserialize
    virtual void ImplDeserialize( std::istream& ) {}

  private:
    unsigned char ComputeSoundLevel( DateTime at );

    struct Members;
    Members* pimpl;
};

class Trilobot :  public BaseComponent, public IDriveObserver
{
  public:
    Trilobot( World * const world, IExporter* const exporter );

    IDrive& Drive() const;
    World* GetWorld() const;
    IExporter* GetExporter();

    ~Trilobot();
    
  protected:

    void ImplHandle( ICommand& command );
    
    virtual struct Position ImplPosition( const DateTime& ) ;
    virtual double ImplSize(const DateTime&) ;
    virtual double ImplSpeed(const DateTime&) ;
    virtual double ImplRadius(const DateTime&) ;

    virtual void ImplSerialize( std::ostream& );
    virtual void ImplDeserialize( std::istream& );

    virtual void ImplDrivePropertyChange( const DateTime&, double runTime );

  private:
    StatePtr GetState( const DateTime& at );  

    typedef STD_VECTOR(IComponent*) ComponentContainer;

    struct Members;
    
    Members* pimpl;
};

#endif

---