MAK RTIspy API Documentation for HLA 1516: fedTimeFactory.h Source File

Go to the documentation of this file.
00001 /*********************************************************************
00002 ** Copyright (c) 2003 MaK Technologies, Inc.
00003 ** All rights reserved.
00004 *********************************************************************/
00005 /*********************************************************************
00006 ** $RCSfile: fedTimeFactory.h,v $ $Revision: 1.10 $ $State: Exp $
00007 *********************************************************************/
00008 
00011 
00012 #ifndef DtDtLogicalTimeFactory_H_
00013 #define DtDtLogicalTimeFactory_H_
00014 
00015 
00016 #include "rtiMsConfig.h"
00017 
00018 #ifdef DtIFSPEC1516
00019 
00020 #include <memory>
00021 #include <RTI/VariableLengthData.h>
00022 #include <RTI/LogicalTime.h>
00023 #include <RTI/LogicalTimeFactory.h>
00024 #include <RTI/LogicalTimeInterval.h>
00025 
00026 class DT_DLL_LRC DtLogicalTimeFactory
00027 {
00028 public:
00029 
00031    DtLogicalTimeFactory(
00032       std::auto_ptr<rti1516::LogicalTimeFactory> logicalTimeFactoryVal,
00033       std::string const & implementationNameVal);
00034 
00036    virtual ~DtLogicalTimeFactory();
00037 
00039    virtual std::string const & implementationName();
00040 
00042    rti1516::LogicalTime const & initial() const;
00043 
00045    rti1516::LogicalTime const & final() const;
00046 
00048    rti1516::LogicalTimeInterval const & zero () const;
00049 
00051    rti1516::LogicalTimeInterval const & epsilon () const;
00052 
00053    virtual
00054    std::auto_ptr< rti1516::LogicalTime >
00055    makeInitial();
00056 
00057    virtual
00058    std::auto_ptr< rti1516::LogicalTime >
00059    decode(rti1516::VariableLengthData const & VariableLengthData);
00060 
00061    virtual
00062    std::auto_ptr< rti1516::LogicalTime >
00063    decode(void* buffer, unsigned long bufferSize);
00064 
00065    virtual 
00066    std::auto_ptr< rti1516::LogicalTimeInterval >
00067    makeZero();
00068 
00069    virtual 
00070    std::auto_ptr< rti1516::LogicalTimeInterval >
00071    makeEpsilon();
00072 
00073    virtual
00074    std::auto_ptr< rti1516::LogicalTimeInterval >
00075    decodeInterval(rti1516::VariableLengthData const & VariableLengthData);
00076 
00077    virtual
00078    std::auto_ptr< rti1516::LogicalTimeInterval >
00079    decodeInterval(void* buffer, unsigned long bufferSize);
00080 
00081 protected:
00082 
00083    std::string myImplementationName;
00084    std::auto_ptr<rti1516::LogicalTimeFactory> myLogicalTimeFactory;
00085    std::auto_ptr<rti1516::LogicalTime> myInitial;
00086    std::auto_ptr<rti1516::LogicalTime> myFinal;
00087    std::auto_ptr<rti1516::LogicalTimeInterval> myZero;
00088    std::auto_ptr<rti1516::LogicalTimeInterval> myEpsilon;
00089 };
00090 
00093 const char* printableString(rti1516::LogicalTime const & time);
00094 
00097 const char* printableString(rti1516::LogicalTimeInterval const & interval);
00098 
00099 #elif defined(DtIFSPEC1516E)
00100 
00101 #include <memory>
00102 #include <RTI/VariableLengthData.h>
00103 #include <RTI/LogicalTime.h>
00104 #include <RTI/LogicalTimeFactory.h>
00105 #include <RTI/LogicalTimeInterval.h>
00106 
00107 class DT_DLL_LRC DtLogicalTimeFactory
00108 {
00109 public:
00110 
00112     DtLogicalTimeFactory(
00113         std::auto_ptr<rti1516e::LogicalTimeFactory> logicalTimeFactoryVal,
00114         std::string const & implementationNameVal);
00115 
00117     virtual ~DtLogicalTimeFactory();
00118 
00120     virtual std::string const & implementationName();
00121 
00123     rti1516e::LogicalTime const & initial() const;
00124 
00126     rti1516e::LogicalTime const & final() const;
00127 
00129     rti1516e::LogicalTimeInterval const & zero () const;
00130 
00132     rti1516e::LogicalTimeInterval const & epsilon () const;
00133 
00134     virtual
00135         std::auto_ptr< rti1516e::LogicalTime >
00136         makeInitial();
00137 
00138     virtual
00139         std::auto_ptr< rti1516e::LogicalTime >
00140         decode(rti1516e::VariableLengthData const & VariableLengthData);
00141 
00142     virtual
00143         std::auto_ptr< rti1516e::LogicalTime >
00144         decode(void* buffer, unsigned long bufferSize);
00145 
00146     virtual 
00147         std::auto_ptr< rti1516e::LogicalTimeInterval >
00148         makeZero();
00149 
00150     virtual 
00151         std::auto_ptr< rti1516e::LogicalTimeInterval >
00152         makeEpsilon();
00153 
00154     virtual
00155         std::auto_ptr< rti1516e::LogicalTimeInterval >
00156         decodeInterval(rti1516e::VariableLengthData const & VariableLengthData);
00157 
00158     virtual
00159         std::auto_ptr< rti1516e::LogicalTimeInterval >
00160         decodeInterval(void* buffer, unsigned long bufferSize);
00161 
00162 protected:
00163 
00164     std::string myImplementationName;
00165     std::auto_ptr<rti1516e::LogicalTimeFactory> myLogicalTimeFactory;
00166     std::auto_ptr<rti1516e::LogicalTime> myInitial;
00167     std::auto_ptr<rti1516e::LogicalTime> myFinal;
00168     std::auto_ptr<rti1516e::LogicalTimeInterval> myZero;
00169     std::auto_ptr<rti1516e::LogicalTimeInterval> myEpsilon;
00170 };
00171 
00174 const char* printableString(rti1516e::LogicalTime const & time);
00175 
00178 const char* printableString(rti1516e::LogicalTimeInterval const & interval);
00179 
00180 
00181 #else //! !DtIFSPEC1516
00182 
00183 #ifdef DtIFSPEC13DLC
00184 #include "RTI13.h"
00185 #define RTI rti13
00186 #else
00187 #include "RTI.hh"
00188 #endif
00189 #include <memory>
00190 
00191 class DT_DLL_LRC DtLogicalTimeFactory
00192 {
00193 public:
00194 
00196    DtLogicalTimeFactory(RTI::FedTimeFactory* logicalTimeFactory);
00197 
00199    virtual ~DtLogicalTimeFactory();
00200 
00202    RTI::FedTime const & initial() const;
00203 
00205    RTI::FedTime const & final() const;
00206 
00208    RTI::FedTime const & zero () const;
00209 
00211    RTI::FedTime const & epsilon () const;
00212 
00213    virtual
00214    std::auto_ptr< RTI::FedTime >
00215    makeInitial();
00216 
00217    virtual
00218    std::auto_ptr< RTI::FedTime >
00219    decode(const char* VariableLengthData);
00220 
00221    virtual 
00222    std::auto_ptr< RTI::FedTime >
00223    makeZero();
00224     
00225    virtual 
00226    std::auto_ptr< RTI::FedTime >
00227    makeEpsilon();
00228     
00229    virtual
00230    std::auto_ptr< RTI::FedTime >
00231    decodeInterval(const char* VariableLengthData);
00232 
00233 
00234 
00235 protected:
00236 
00237    RTI::FedTimeFactory* myLogicalTimeFactory;
00238    std::auto_ptr<RTI::FedTime> myInitial;
00239    std::auto_ptr<RTI::FedTime> myFinal;
00240    std::auto_ptr<RTI::FedTime> myZero;
00241    std::auto_ptr<RTI::FedTime> myEpsilon;
00242 };
00243 
00246 const char* printableString(RTI::FedTime const & time);
00247 
00248 #endif //! DtIFSPEC1516
00249 #endif //! DtDtLogicalTimeFactory_H_
00250