logicalTimeIntervalImplUnsignedInteger.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2005 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: logicalTimeIntervalImplUnsignedInteger.h,v $ $Revision: 1.3 $ $State: Exp $
*******************************************************************************/

#ifndef RTI_LogicalTimeIntervalImplUnsignedInteger_H_
#define RTI_LogicalTimeIntervalImplUnsignedInteger_H_

#include <RTI/LogicalTimeInterval.h>

#if VMS
#include <limits>
#define MAXUINT64       numeric_limits<unsigned long long>::max()
#else
#define MAXUINT64       18446744073709551615ULL
#endif

#define POSITIVE_INFINITY (MAXUINT64)
#define EPSILON (1)

#if DT_HAVE_64BIT_LONGS

typedef unsigned long DtLtU64;

#else
#ifdef _WIN32

typedef unsigned _int64 DtLtU64;

#else

typedef unsigned long long DtLtU64;

#endif
#endif

class RTI_EXPORT_FEDTIME LogicalTimeIntervalImplUnsignedInteger
   : public rti1516::LogicalTimeInterval
{
public:
   static std::wstring theImplementationName;

public:

   // Constructors
   LogicalTimeIntervalImplUnsignedInteger();
   LogicalTimeIntervalImplUnsignedInteger(const DtLtU64&);
   LogicalTimeIntervalImplUnsignedInteger(rti1516::LogicalTimeInterval const &);
   LogicalTimeIntervalImplUnsignedInteger(const LogicalTimeIntervalImplUnsignedInteger&);

   // Destructor
   virtual ~LogicalTimeIntervalImplUnsignedInteger()
   throw ();

   // Basic accessors/mutators
   virtual void setZero();
   virtual bool isZero() const;

   virtual void setEpsilon();
   virtual bool isEpsilon() const;

   // Assignment
   virtual
   rti1516::LogicalTimeInterval&
   operator= (rti1516::LogicalTimeInterval const & value)
      throw (
         rti1516::InvalidLogicalTimeInterval);

    // Set self to the difference between two LogicalTimes
    virtual
    void
    setToDifference(rti1516::LogicalTime const & minuend,
      rti1516::LogicalTime const& subtrahend)
      throw (rti1516::InvalidLogicalTime);
   
   virtual
   rti1516::LogicalTimeInterval&
   operator+= (rti1516::LogicalTimeInterval const & addend)
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   rti1516::LogicalTimeInterval&
   operator-= (rti1516::LogicalTimeInterval const & subtrahend)
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   bool
   operator> (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   bool
   operator< (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   bool
   operator== (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   bool
   operator>= (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual
   bool
   operator<= (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   // Generates an encoded value that can be used to send
   // LogicalTimeIntervals to other federates in updates or interactions
   virtual rti1516::VariableLengthData encode() const;

   // Alternate encode for directly filling a buffer
   virtual unsigned long encodedLength() const;
   virtual unsigned long encode(void* buffer, unsigned long bufferSize) const
       throw (rti1516::CouldNotEncode);

   // Decode encodedValue into self
   virtual void decode(rti1516::VariableLengthData const & encodedValue)
      throw (
         rti1516::InternalError,
         rti1516::CouldNotDecode);

   // Alternate decode that reads directly from a buffer
   virtual void decode(void* buffer, unsigned long bufferSize)
      throw (
         rti1516::InternalError,
         rti1516::CouldNotDecode);

   virtual std::wstring toString() const;

   // Returns the name of the implementation, as needed by
   // createFederationExecution.
   virtual std::wstring implementationName() const;

public:
   //-----------------------------------------------------------------
   // Implementation functions
   //-----------------------------------------------------------------
   virtual DtLtU64 getInterval() const;

   //-----------------------------------------------------------------
   // Implementation operators
   //-----------------------------------------------------------------
   virtual bool operator== (const DtLtU64&) const
   throw (rti1516::InvalidLogicalTimeInterval);

   virtual bool operator!= (rti1516::LogicalTimeInterval const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual bool operator!= (LogicalTimeIntervalImplUnsignedInteger const & value) const
      throw (
         rti1516::InvalidLogicalTimeInterval);

   virtual bool operator!= (const DtLtU64&) const
   throw (rti1516::InvalidLogicalTimeInterval);

   virtual LogicalTimeIntervalImplUnsignedInteger& operator= (
      const LogicalTimeIntervalImplUnsignedInteger& value)
   throw (rti1516::InvalidLogicalTimeInterval);

   virtual rti1516::LogicalTimeInterval& operator= (const DtLtU64&)
   throw (rti1516::InvalidLogicalTimeInterval);

   virtual rti1516::LogicalTimeInterval& operator+= (const DtLtU64&)
   throw (rti1516::InvalidLogicalTimeInterval);

   virtual rti1516::LogicalTimeInterval& operator-= (const DtLtU64&)
   throw (rti1516::InvalidLogicalTimeInterval);

private:
   //-----------------------------------------------------------------
   // Implementation member variables
   //-----------------------------------------------------------------
   DtLtU64 myInterval;
   DtLtU64 myZero;
   DtLtU64 myEpsilon;
   DtLtU64 myPositiveInfinity;
};

#endif // RTI_LogicalTimeIntervalImplUnsignedInteger_H_