fedTimeFactory.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2003 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: fedTimeFactory.h,v $ $Revision: 1.10 $ $State: Exp $
*********************************************************************/


#ifndef DtDtLogicalTimeFactory_H_
#define DtDtLogicalTimeFactory_H_


#include "rtiMsConfig.h"

#ifdef DtIFSPEC1516

#include <memory>
#include <RTI/VariableLengthData.h>
#include <RTI/LogicalTime.h>
#include <RTI/LogicalTimeFactory.h>
#include <RTI/LogicalTimeInterval.h>

class DT_DLL_LRC DtLogicalTimeFactory
{
public:

   DtLogicalTimeFactory(
      std::auto_ptr<rti1516::LogicalTimeFactory> logicalTimeFactoryVal,
      std::string const & implementationNameVal);

   virtual ~DtLogicalTimeFactory();

   virtual std::string const & implementationName();

   rti1516::LogicalTime const & initial() const;

   rti1516::LogicalTime const & final() const;

   rti1516::LogicalTimeInterval const & zero () const;

   rti1516::LogicalTimeInterval const & epsilon () const;

   virtual
   std::auto_ptr< rti1516::LogicalTime >
   makeInitial();

   virtual
   std::auto_ptr< rti1516::LogicalTime >
   decode(rti1516::VariableLengthData const & VariableLengthData);

   virtual
   std::auto_ptr< rti1516::LogicalTime >
   decode(void* buffer, unsigned long bufferSize);

   virtual 
   std::auto_ptr< rti1516::LogicalTimeInterval >
   makeZero();

   virtual 
   std::auto_ptr< rti1516::LogicalTimeInterval >
   makeEpsilon();

   virtual
   std::auto_ptr< rti1516::LogicalTimeInterval >
   decodeInterval(rti1516::VariableLengthData const & VariableLengthData);

   virtual
   std::auto_ptr< rti1516::LogicalTimeInterval >
   decodeInterval(void* buffer, unsigned long bufferSize);

protected:

   std::string myImplementationName;
   std::auto_ptr<rti1516::LogicalTimeFactory> myLogicalTimeFactory;
   std::auto_ptr<rti1516::LogicalTime> myInitial;
   std::auto_ptr<rti1516::LogicalTime> myFinal;
   std::auto_ptr<rti1516::LogicalTimeInterval> myZero;
   std::auto_ptr<rti1516::LogicalTimeInterval> myEpsilon;
};

const char* printableString(rti1516::LogicalTime const & time);

const char* printableString(rti1516::LogicalTimeInterval const & interval);

#elif defined(DtIFSPEC1516E)

#include <memory>
#include <RTI/VariableLengthData.h>
#include <RTI/LogicalTime.h>
#include <RTI/LogicalTimeFactory.h>
#include <RTI/LogicalTimeInterval.h>

class DT_DLL_LRC DtLogicalTimeFactory
{
public:

    DtLogicalTimeFactory(
        std::auto_ptr<rti1516e::LogicalTimeFactory> logicalTimeFactoryVal,
        std::string const & implementationNameVal);

    virtual ~DtLogicalTimeFactory();

    virtual std::string const & implementationName();

    rti1516e::LogicalTime const & initial() const;

    rti1516e::LogicalTime const & final() const;

    rti1516e::LogicalTimeInterval const & zero () const;

    rti1516e::LogicalTimeInterval const & epsilon () const;

    virtual
        std::auto_ptr< rti1516e::LogicalTime >
        makeInitial();

    virtual
        std::auto_ptr< rti1516e::LogicalTime >
        decode(rti1516e::VariableLengthData const & VariableLengthData);

    virtual
        std::auto_ptr< rti1516e::LogicalTime >
        decode(void* buffer, unsigned long bufferSize);

    virtual 
        std::auto_ptr< rti1516e::LogicalTimeInterval >
        makeZero();

    virtual 
        std::auto_ptr< rti1516e::LogicalTimeInterval >
        makeEpsilon();

    virtual
        std::auto_ptr< rti1516e::LogicalTimeInterval >
        decodeInterval(rti1516e::VariableLengthData const & VariableLengthData);

    virtual
        std::auto_ptr< rti1516e::LogicalTimeInterval >
        decodeInterval(void* buffer, unsigned long bufferSize);

protected:

    std::string myImplementationName;
    std::auto_ptr<rti1516e::LogicalTimeFactory> myLogicalTimeFactory;
    std::auto_ptr<rti1516e::LogicalTime> myInitial;
    std::auto_ptr<rti1516e::LogicalTime> myFinal;
    std::auto_ptr<rti1516e::LogicalTimeInterval> myZero;
    std::auto_ptr<rti1516e::LogicalTimeInterval> myEpsilon;
};

const char* printableString(rti1516e::LogicalTime const & time);

const char* printableString(rti1516e::LogicalTimeInterval const & interval);


#else 

#ifdef DtIFSPEC13DLC
#include "RTI13.h"
#define RTI rti13
#else
#include "RTI.hh"
#endif
#include <memory>

class DT_DLL_LRC DtLogicalTimeFactory
{
public:

   DtLogicalTimeFactory(RTI::FedTimeFactory* logicalTimeFactory);

   virtual ~DtLogicalTimeFactory();

   RTI::FedTime const & initial() const;

   RTI::FedTime const & final() const;

   RTI::FedTime const & zero () const;

   RTI::FedTime const & epsilon () const;

   virtual
   std::auto_ptr< RTI::FedTime >
   makeInitial();

   virtual
   std::auto_ptr< RTI::FedTime >
   decode(const char* VariableLengthData);

   virtual 
   std::auto_ptr< RTI::FedTime >
   makeZero();
    
   virtual 
   std::auto_ptr< RTI::FedTime >
   makeEpsilon();
    
   virtual
   std::auto_ptr< RTI::FedTime >
   decodeInterval(const char* VariableLengthData);



protected:

   RTI::FedTimeFactory* myLogicalTimeFactory;
   std::auto_ptr<RTI::FedTime> myInitial;
   std::auto_ptr<RTI::FedTime> myFinal;
   std::auto_ptr<RTI::FedTime> myZero;
   std::auto_ptr<RTI::FedTime> myEpsilon;
};

const char* printableString(RTI::FedTime const & time);

#endif 
#endif