AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

history.h

Go to the documentation of this file.

#ifndef ____________animal_history_hpp_____________
#define ____________animal_history_hpp_____________
 
#include <list> 

namespace animal {

  template<class Position, class Velocity>
  class History
  {
    struct Key {
        double time;          
        Position position;    
        Velocity velocity;   
        
        Key(double t, Position p, Velocity v)
            : time(t)
            , position(p)
            , velocity(v)
        {} 
        
        Key(){}
    };
    
    typedef std::list< Key > List;         
    typename List::iterator cursor;        
    bool record;                           
    bool replay;                           
    
  public:
    History( double t, Position p, Velocity v, bool record = false )
      : record(record)
      , replay(false)
    {
      state_list.push_back( Key(t,p,v) );
      cursor = state_list.begin();
    }
    
    virtual ~History(){}
    
    void push_back( double t, Position p, Velocity v ){     
        if( isRecording() ){
            typename List::iterator c = cursor;
            c++;
            state_list.erase( c, state_list.end() );            
            state_list.push_back( Key(t,p,v) );
            cursor++;
        }
    }
    
    void reset(){ cursor = state_list.begin(); }
    
    void operator ++ () { 
        if( isReplaying() ){
            //cerr<<"history++, t= "<< cursor->first << " to ";
            cursor++;
            if( cursor==state_list.end() ) { 
                cursor--; 
                //cerr<<"END "; 
            }
            //cerr<< cursor->first << endl;
        }
    }
    
    void operator -- () { 
        if( isReplaying() ){
            if( cursor!=state_list.begin() ) {
                cursor--; 
            }
        }
    }
    
    double t() const { return cursor->time; }
    
    void copyStateTo( Position* p, Velocity* v ) const { 
        *p = cursor->position; 
        *v = cursor->velocity;
    }
    
    void toggleRecord( bool b ){ 
        record = b; 
        if( record ) 
            replay = false; 
    }
    bool isRecording() const { return record; }
    
    void toggleReplay( bool b ){ 
        replay = b; 
        if( replay ) 
            record = false; 
    }

    bool isReplaying() const { return replay; }
    
    virtual void write( std::ostream& out ) const = 0;
    
    virtual void read( std::istream& in ) = 0;

protected:
    List state_list;   


    
  };



  template<class Position, class Velocity>
  class HistoryS: public History<Position,Velocity>
  {

    public:
    
    typedef History<Position,Velocity> Parent;  
    typedef typename Parent::List List;                  
    
    HistoryS( double t, Position p, Velocity v, bool record = false )
      : History<Position,Velocity>(t,p,v,record)
    {}
    
    virtual void write( std::ostream& out ) const {
        typename List::const_iterator i, iend;
        for( i=this->state_list.begin(), iend=this->state_list.end(); i!=iend; ++i ){ 
            out << (*i).time << "\t" << (*i).position << "\t" << (*i).velocity << endl;
        }   
    }
    
    virtual void read( std::istream& in )
    {
        this->reset();
        this->toggleRecord(true);
        typename List::value_type key; 
        while( in >> key.time ){
            in >> key.position >> key.velocity;
            push_back( key.time, key.position, key.velocity );
        }
        if( !this->state_list.empty() )
            this->state_list.erase(this->state_list.begin()); // avoid duplication of time 0
        this->reset();
     }


  };


  template<class Position,class Velocity>
  class HistoryV: public History<Position,Velocity>
  {

  public:
  
    typedef History<Position,Velocity> Parent;  
    typedef typename Parent::List List;                  
    
    HistoryV( double t, Position p, Velocity v, bool record = false )
      : History<Position,Velocity>(t,p,v,record)
    {}
    
    virtual void write( std::ostream& out ) const {
        typename List::const_iterator i, iend;
        for( i=this->state_list.begin(), iend=this->state_list.end(); i!=iend; ++i ){ 
            out << (*i).time << "\t" << v_output((*i).position) << "\t" << v_output((*i).velocity) << endl;
        }   
    }
    
    virtual void read( std::istream& in )
    {
      this->reset();
      this->toggleRecord(true);
      typename List::value_type key; 
      while( in >> key.time ){
        key.position.resize( this->state_list.begin()->position.size() );
        key.velocity.resize( this->state_list.begin()->velocity.size() );
        in >> v_input(key.position);
        in >> v_input(key.velocity);
        push_back( key.time, key.position, key.velocity );
      }
      if( !this->state_list.empty() )
            this->state_list.erase(this->state_list.begin()); // avoid duplication of time 0
      this->reset();
    }

  };

}//animal

#endif

---