---

/home/pauldt/projects/IDEA/IDEA-ALL/IDEA-DEV/Core/PlanServer/Includes/PslDatabaseImpl.hh

Go to the documentation of this file.

// -*- Mode: C++ -*-
//      CVS: $Id: PslDatabaseImpl.hh,v 1.15 2005/12/30 22:15:00 rijsman Exp $
//      Tag: $name$
//     Info: $CVSROOT/IDEA-DEV/COPYRIGHT
#ifndef PLANSERVER_DATABASE_IMPL_HEADER_
#define PLANSERVER_DATABASE_IMPL_HEADER_

#include "PslConstantTypes.hh"
#include "PslContainers.hh"
#include "PslDataTypes.hh"
#include "PslTrueFalseVariable.hh"

#include "ThreadTools.hh"
#include "TimeBasics.hh"
#include "TokenLocation.hh"
#include "Utilities.hh"

namespace IDEA
{
  class PslConstant;
  class PslConstantImpl;
  class PslDatabase;
  class PslLabelSet;
  class PslModelManager;
  class PslObject;
  class PslObjectImpl;
  class PslObjectClass;
  class PslPredicate;
  class PslTimeline;
  class PslToken;
  class PslTokenImpl;
  class PslVariable;
  class PslVariableImpl;
  class PslOutputFilter;

  class PslDatabaseImpl
  {
    friend class PslDatabase;
  public:
    virtual ~PslDatabaseImpl();

    void resetContent();

    const std::string& getAgentName() const;

    void setAgentName( const std::string& name );


    const PslToken* createToken( const PslDatabase* database,
                                 const PslTimeline* timeline, 
                                 const PslPredicate* predicate,
                                 const Time& earliestStart,
                                 const Time& latestStart,
                                 const Time& earliestEnd,
                                 const Time& latestEnd,
                                 unsigned int externalTokenId,
                                 const TokenLocation& source,
                                 const std::string& comRelayName);

    const PslToken* getToken( int uid );
    void removeToken( const PslTokenImpl* token );
    void removeVariable( const PslVariable* var );

    PslConstant* createConstant( const std::string& name, double value, const PslConstantType& type );
    PslObject* createObject( const PslDatabase* database, const PslObjectClass* objectClass, const std::string& objectName );
    const PslVariable* createVariable( const PslDatabase* database, int lb, int ub, const std::string& name );
    const PslVariable* createVariable( const PslDatabase* database, int value, const std::string& name );
    const PslVariable* createVariable( const PslDatabase* database, const PslDataType& type, const std::string& name );
    const PslVariable* createVariable( const PslDatabase* database, double lb, double ub, const std::string& name );
    const PslVariable* createVariable( const PslDatabase* database, double value, const std::string& name );
    const PslVariable* createVariable( const PslDatabase* database, const PslLabelSet* ls, const std::string& name );

    const PslVariable* createBoolVariable( const PslDatabase* database, const std::string& name );
    const PslVariable* getVariable( int key ); 
    PslConstant* getConstant( const std::string& name );
    const PslModelManager* getModelManager();
    const std::string& getName() const;
    PslObject* getObject( const std::string& name );
    const PslObjectList getObjects();
    const PslVariable* getTimeVariable();
    void setTime( const Time& time );
    void setPendingMessages( bool value );
    const PslTrueFalseVariable* getPendingMessageVariable() const;
    const Time getTime();
    void lock( const std::string& location );
    void unLock( const std::string& location );
    virtual void print( std::ostream& os );
    void setPrintFilter(PslOutputFilter* filter, bool deleteInstance );
    virtual bool isConsistent() = 0;
    virtual void setActiveUpdate() = 0;
    virtual void setPassiveUpdate() = 0;

    virtual int externalize( const PslToken* token );
    const PslToken* getExternalizedToken( int id );
  protected:
    PslDatabaseImpl( const PslModelManager* modelManager, 
                     const std::string& agentName,
                     const std::string& name );
    const PslToken* addToken( PslTokenImpl* impl );
    const PslVariable* addVariable( PslVariableImpl* impl );
  private:
    virtual void archive( const Time& t ) = 0;
    virtual const Time getTimeExtended();
    void initialize( const PslDatabase* database );
    virtual void initializeExtended( const PslDatabase* database );
    void createTimeVariable( const PslDatabase* database );
    void createPendingMessagesVariable( const PslDatabase* database );

    typedef std::map< std::string, PslConstant* > String2Constant;

    String2Constant m_Constants;

    typedef std::map< std::string, PslObject* > String2Object;
    
    String2Object m_Objects;

    const PslModelManager* m_ModelManager;
    std::string m_Name;
    std::string m_AgentName;

    typedef std::map< int, PslVariable* > Int2PslVariable;

    Int2PslVariable m_Variables;

    typedef std::map< int, PslToken* > Int2PslToken;
    
    Int2PslToken m_Tokens;

//     typedef std::map< int, PslConstraint* > Int2PslConstraint;

//     Int2PslConstraint m_Constraints;

    const PslVariable* m_TimeVariable;
    PslTrueFalseVariable* m_PendingMessageVariable;
    RecursiveThreadMutex m_Mutex;
    bool m_DeleteFilter;
    PslOutputFilter* m_PrintFilter;
  };
}

#endif // PLANSERVER_DATABASE_IMPL_HEADER_

---

Contact information © IDEA