---

/home/pauldt/projects/IDEA/IDEA-ALL/IDEA-DEV/Core/Agent/Includes/MessageDefinitions.hh

Go to the documentation of this file.

// -*- Mode: c++ -*-
//      CVS: $Id: MessageDefinitions.hh,v 1.4 2005/12/30 22:05:32 rijsman Exp $
//      Tag: $name$
//     Info: $CVSROOT/IDEA-DEV/COPYRIGHT

#ifndef MESSAGE_DEFINITION_HEADER_FILE
#define MESSAGE_DEFINITION_HEADER_FILE

#include "MessageHandle.hh"
#include "MessageData.hh"
#include "TokenLocation.hh"
#include "Trace.hh"
#include "Utilities.hh"

namespace IDEA
{
  typedef Message ObjectMessage;
  typedef Message StartMessage;
  typedef Message StatusMessage;
  typedef Message StopMessage;
  typedef Message TelemetryMessage;
  typedef Message ValueMessage;
  typedef Message UserDefinedMessage;
  
  class MessageDataBase:
    public MessageData
  {
  public:
    const TokenLocation& getSourceLocation() const 
    { 
      return m_SourceLocation; 
    }
    const TokenLocation& getTargetLocation() const 
    { 
      return m_TargetLocation; 
    }
    const std::string& getSourceToken() const 
    {
      return m_SourceToken;
    }
    
    Prototype* clone() const 
    { 
      return new MessageDataBase( getType(), 
                                  m_SourceLocation, 
                                  m_TargetLocation, 
                                  m_SourceToken, 
                                  getIdentifier(), 
                                  getSubMessages(), 
                                  getParent() );
    }
  protected:
    MessageDataBase( const Message::Type& type,
                     const std::string& source,
                     const std::string& sourceClass,
                     const std::string& sourceTimeline,
                     const std::string& sourceToken,
                     const std::string& target,
                     const std::string& targetClass,
                     const std::string& targetTimeline,
                     int identifier,
                     const IntSet& subMessages,
                     int parent):
      MessageData( type, identifier, subMessages, parent ),
      m_SourceLocation( source, sourceClass, sourceTimeline ),
      m_TargetLocation( target, targetClass, targetTimeline ),
      m_SourceToken( sourceToken )
    {
    };

    MessageDataBase( const Message::Type& type,
                     const TokenLocation& sourceLocation,
                     const TokenLocation& targetLocation,
                     const std::string& sourceToken,
                     int identifier,
                     const IntSet& subMessages = IntSet(),
                     int parent = -1):
      MessageData( type, identifier, subMessages, parent ),
      m_SourceLocation( sourceLocation ),
      m_TargetLocation( targetLocation ),
      m_SourceToken( sourceToken )
    {
    }
  private:
    MessageDataBase();
    MessageDataBase(const MessageDataBase &);
    MessageDataBase& operator=(const MessageDataBase &);

    TokenLocation m_SourceLocation;
    TokenLocation m_TargetLocation;
    std::string m_SourceToken;
  };

  std::ostream& operator<< ( std::ostream& os, const MessageDataBase& data );

  class ObjectMessageData:
    public MessageDataBase
  {
  public:
    ObjectMessageData( const std::string& source,
                       const std::string& sourceClass,
                       const std::string& sourceTimeline,
                       const std::string& sourceToken,
                       const std::string& target,
                       const std::string& targetClass,
                       const std::string& targetTimeline,
                       const std::string& objectName,
                       const std::string& objectClass,
                       const std::string& objectToken,
                       const std::string& parameters,
                       int identifier = getNextUniqueIdentifier(),
                       const IntSet& subMessages = IntSet(),
                       int parent = -1):
      MessageDataBase( Message::OBJECT, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_ObjectName( objectName ),
      m_ObjectClass( objectClass ),
      m_ObjectToken( objectToken ),
      m_Parameters( parameters )
    {
    }
    const std::string& getObjectName() const 
    { 
      return m_ObjectName; 
    }
    const std::string& getObjectClass() const 
    { 
      return m_ObjectClass; 
    }
    const std::string& getObjectToken() const 
    {
      return m_ObjectToken; 
    }
    const std::string& getParameters() const 
    {
      return m_Parameters; 
    }

    Prototype* clone() const
    {
      return new ObjectMessageData( getSourceLocation(), 
                                    getTargetLocation(), 
                                    getSourceToken(), 
                                    m_ObjectName, 
                                    m_ObjectClass, 
                                    m_ObjectToken, 
                                    m_Parameters,
                                    getIdentifier(),
                                    getSubMessages(),
                                    getParent() );
    }
  private:
    ObjectMessageData( const TokenLocation& sourceLocation,
                       const TokenLocation& targetLocation,
                       const std::string& sourceToken,
                       const std::string& objectName,
                       const std::string& objectClass,
                       const std::string& objectToken,
                       const std::string& parameters,
                       int identifier,
                       const IntSet& subMessages,
                       int parent ):
      MessageDataBase(  Message::OBJECT, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent ),
      m_ObjectName( objectName ),
      m_ObjectClass( objectClass ),
      m_ObjectToken( objectToken ),
      m_Parameters( parameters )
    {
    }
      
    std::string m_ObjectName;
    std::string m_ObjectClass;
    std::string m_ObjectToken;
    std::string m_Parameters;
  };

  class StartMessageData:
    public MessageDataBase
  {
  public:
    StartMessageData( const std::string& source,
                      const std::string& sourceClass,
                      const std::string& sourceTimeline,
                      const std::string& sourceToken,
                      const std::string& target,
                      const std::string& targetClass,
                      const std::string& targetTimeline,
                      int externalToken,
                      const std::string& parameters,
                      const Time& earliestStart,
                      const Time& latestStart,
                      const Time& earliestEnd,
                      const Time& latestEnd,
                      const std::string& comRelay,
                      int identifier = getNextUniqueIdentifier(),
                      const IntSet& subMessages = IntSet(),
                      int parent = -1 ):
      MessageDataBase(  Message::START, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_ExternalTokenId( externalToken ),
      m_Parameters( parameters), 
      m_EarliestStart( earliestStart ),
      m_LatestStart( latestStart ),
      m_EarliestEnd( earliestEnd ),
      m_LatestEnd( latestEnd ),
      m_ComRelay( comRelay )
    {
    }
    int getExternalTokenId() const 
    { 
      return m_ExternalTokenId;
    }
    const std::string& getParameters() const 
    {
      return m_Parameters;
    }
    const Time& getEarliestStart() const 
    { 
      return m_EarliestStart;
    }
    const Time& getLatestStart() const 
    { 
      return m_LatestStart;
    }
    const Time& getEarliestEnd() const 
    { 
      return m_EarliestEnd;
    }
    const Time& getLatestEnd() const 
    { 
      return m_LatestEnd;
    }
    const std::string& getComRelay() const 
    { 
      return m_ComRelay;
    }

    Prototype* clone() const
    {
      return new StartMessageData( getSourceLocation(), 
                                   getTargetLocation(), 
                                   getSourceToken(), 
                                   m_ExternalTokenId,
                                   m_Parameters,
                                   m_EarliestStart,
                                   m_LatestStart,
                                   m_EarliestEnd,
                                   m_LatestEnd,
                                   m_ComRelay,
                                   getIdentifier(),
                                   getSubMessages(),
                                   getParent() );
    }
  private:
    StartMessageData( const TokenLocation& sourceLocation,
                      const TokenLocation& targetLocation,
                      const std::string& sourceToken,
                      int externalToken,
                      const std::string& parameters,
                      const Time& earliestStart,
                      const Time& latestStart,
                      const Time& earliestEnd,
                      const Time& latestEnd,
                      const std::string& comRelay,
                      int identifier,
                      const IntSet& subMessages,
                      int parent ):
      MessageDataBase( Message::START, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent ),
      m_ExternalTokenId( externalToken ),
      m_Parameters( parameters  ),
      m_EarliestStart( earliestStart  ),
      m_LatestStart( latestStart ),
      m_EarliestEnd( earliestEnd ), 
      m_LatestEnd( latestEnd  ),
      m_ComRelay( comRelay )
    {
    }

    int m_ExternalTokenId;
    std::string m_Parameters;
    Time m_EarliestStart;
    Time m_LatestStart;
    Time m_EarliestEnd; 
    Time m_LatestEnd;
    std::string m_ComRelay;
  };

  std::ostream& operator<< ( std::ostream& os, const StartMessageData& data );

  class ValueMessageData:
    public MessageDataBase
  {
  public:
    ValueMessageData( const std::string& source,
                      const std::string& sourceClass,
                      const std::string& sourceTimeline,
                      const std::string& sourceToken,
                      const std::string& target,
                      const std::string& targetClass,
                      const std::string& targetTimeline,
                      int token,
                      const std::string& value,
                      int index,
                      int identifier = getNextUniqueIdentifier(),
                      const IntSet& subMessages = IntSet(),
                      int parent = -1 ):
      MessageDataBase( Message::VALUE, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_ExternalTokenId( token ),
      m_Value( value ),
      m_Index( index )
    {
    }
    int getExternalTokenId() const 
    { 
      return m_ExternalTokenId;
    }
    const std::string& getValue() const 
    { 
      return m_Value; 
    }
    int getIndex() const 
    { 
      return m_Index; 
    }

    Prototype* clone() const
    {
      return new ValueMessageData( getSourceLocation(),
                                   getTargetLocation(),
                                   getSourceToken(),
                                   m_ExternalTokenId,
                                   m_Value,
                                   m_Index, 
                                   getIdentifier(),
                                   getSubMessages(),
                                   getParent()  );
    }
  private:
    ValueMessageData( const TokenLocation& sourceLocation,
                      const TokenLocation& targetLocation,
                      const std::string& sourceToken,
                      int token,
                      const std::string& value,
                      int index,
                      int identifier,
                      const IntSet& subMessages,
                      int parent ):
      MessageDataBase( Message::VALUE, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent  ),
      m_ExternalTokenId( token ),
      m_Value( value ),
      m_Index( index )
    {
    }

    int m_ExternalTokenId;
    std::string m_Value;
    int m_Index;
  };

  std::ostream& operator<< ( std::ostream& os, const ValueMessageData& data );


  class StatusMessageData:
    public MessageDataBase
  {
  public:
    StatusMessageData( const std::string& source,
                       const std::string& sourceClass,
                       const std::string& sourceTimeline,
                       const std::string& sourceToken,
                       const std::string& target,
                       const std::string& targetClass,
                       const std::string& targetTimeline,
                       int token, 
                       const std::string& value,
                       int identifier = getNextUniqueIdentifier(),
                       const IntSet& subMessages = IntSet(),
                       int parent = -1 ):
      MessageDataBase( Message::STATUS, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_ExternalTokenId( token ),
      m_Value( value )
    {
    }
  
    int getExternalTokenId() const 
    { 
      return m_ExternalTokenId;
    }
    const std::string& getValue() const 
    { 
      return m_Value; 
    }
    Prototype* clone() const
    {
      return new StatusMessageData( getSourceLocation(),
                                    getTargetLocation(),
                                    getSourceToken(),
                                    m_ExternalTokenId,
                                    m_Value, 
                                    getIdentifier(),
                                    getSubMessages(),
                                    getParent()  );
    }
  private:
    StatusMessageData( const TokenLocation& sourceLocation,
                       const TokenLocation& targetLocation,
                       const std::string& sourceToken,
                       int token,
                       const std::string& value,
                       int identifier,
                       const IntSet& subMessages,
                       int parent):
      MessageDataBase( Message::STATUS, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent ),
      m_ExternalTokenId( token ),
      m_Value( value )
    {
    }

    int m_ExternalTokenId;
    std::string m_Value;
  };

  std::ostream& operator<< ( std::ostream& os, const StatusMessageData& data );

  class StopMessageData:
    public MessageDataBase
  {
  public:
    StopMessageData( const std::string& source,
                     const std::string& sourceClass,
                     const std::string& sourceTimeline,
                     const std::string& sourceToken,
                     const std::string& target,
                     const std::string& targetClass,
                     const std::string& targetTimeline,
                     int token, 
                     const std::string& value,
                     int identifier = getNextUniqueIdentifier(),
                     const IntSet& subMessages = IntSet(),
                     int parent = -1 ):
      MessageDataBase( Message::STOP, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_ExternalTokenId( token ),
      m_Value( value )
    {
    }
  
    int getExternalTokenId() const 
    { 
      return m_ExternalTokenId;
    }
    const std::string& getValue() const 
    { 
      return m_Value; 
    }
    Prototype* clone() const
    {
      return new StopMessageData( getSourceLocation(),
                                  getTargetLocation(),
                                  getSourceToken(),
                                  m_ExternalTokenId,
                                  m_Value, 
                                  getIdentifier(),
                                  getSubMessages(),
                                  getParent() );
    }
  private:
    StopMessageData( const TokenLocation& sourceLocation,
                     const TokenLocation& targetLocation,
                     const std::string& sourceToken,
                     int token,
                     const std::string& value,
                     int identifier,
                     const IntSet& subMessages,
                     int parent ):
      MessageDataBase( Message::STOP, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent ),
      m_ExternalTokenId( token ),
      m_Value( value )
    {
    }

    int m_ExternalTokenId;
    std::string m_Value;
  };

  std::ostream& operator<< ( std::ostream& os, const StopMessageData& data );

  class TelemetryMessageData:
    public MessageDataBase
  {
  public:
    TelemetryMessageData( const std::string& source,
                          const std::string& sourceClass,
                          const std::string& sourceTimeline,
                          const std::string& sourceToken,
                          const std::string& target,
                          const std::string& targetClass,
                          const std::string& targetTimeline,
                          const std::string& value,
                          int index,
                          int identifier = getNextUniqueIdentifier(),
                          const IntSet& subMessages = IntSet(),
                          int parent = -1 ):
      MessageDataBase( Message::TELEMETRY, source, sourceClass, sourceTimeline, sourceToken, target, targetClass, targetTimeline, identifier, subMessages, parent ),
      m_Value( value ),
      m_Index( index )
    {
    }
    const std::string& getValue() const 
    { 
      return m_Value; 
    }
    int getIndex() const 
    { 
      return m_Index; 
    }
    
    Prototype* clone() const
    {
      return new TelemetryMessageData( getSourceLocation(),
                                       getTargetLocation(),
                                       getSourceToken(),
                                       m_Value,
                                       m_Index, 
                                       getIdentifier(),
                                       getSubMessages(),
                                       getParent()  );
    }
  private:
    TelemetryMessageData( const TokenLocation& sourceLocation,
                          const TokenLocation& targetLocation,
                          const std::string& sourceToken,
                          const std::string& value,
                          int index, 
                          int identifier,
                          const IntSet& subMessages,
                          int parent ):
      MessageDataBase( Message::TELEMETRY, sourceLocation, targetLocation, sourceToken, identifier, subMessages, parent ),
      m_Value( value ),
      m_Index( index )
    {
    }

    std::string m_Value;
    int m_Index;
  };

  std::ostream& operator<< ( std::ostream& os, const TelemetryMessageData& data );

} //namespace IDEA

#endif // MESSAGE_DEFINITION_HEADER_FILE

---

Contact information © IDEA