baseIntDesc1516.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef baseIntDesc1516_H_
#define baseIntDesc1516_H_

#if DtHLA
#if DtHLA_1516

#include <lgrSim/lgrSim.h>

#include "baseHla1516Class.h"
#include "baseParam.h"

#include <vl/rtiCompatibility.h>
#include <vl/rtiNamespace.h>

class DtString;
class DtInterClassDesc;

namespace MAKLogger
{
   class DtLgrOnlineFomDesc;

   class DT_DLL_LGRSIM DtBaseInterClassDesc : public DtBaseHla1516Class<DtBaseParamDesc>
   {
   public:
      DtBaseInterClassDesc( const DtString& className,
         DtBaseInterClassDesc* baseClass, DtLgrHlaHandle handle,
         const void* handCode, int codeSize );

      DtBaseInterClassDesc( const DtString& className,
         const DtString& baseClassName, DtLgrHlaHandle hand,
         const void* handCode, int codeSize );

      DtBaseInterClassDesc( char*& bfr, int& bsz );

      virtual ~DtBaseInterClassDesc();

      DtBaseInterClassDesc( const DtBaseInterClassDesc& src );

      DtBaseInterClassDesc& operator=( const DtBaseInterClassDesc& src );

      RTI::InteractionClassHandle rtiHandle(const DtLgrOnlineFomDesc& fomDesc) const;

      inline bool isBaseClass() const;

      inline void setIsBaseClass(bool);

      inline bool isSubscribedTo() const;

      inline void setIsSubscribedTo( bool onOff );

      inline bool isFilteredClass() const;

      inline void setIsFilteredClass( bool onOff );

      inline DtLgrFomTransportType transportType() const;

      inline void setTransportType(DtLgrFomTransportType type);

      inline DtLgrFomOrderType orderType() const;

      inline void setOrderType(DtLgrFomOrderType type);


      int  serialize( char*& bfr, int& bsz ) const;

   protected:
      void resetAll();
      int  unserializeParameters( char* bfr, int bsz, int num );

   };

   inline bool DtBaseInterClassDesc::isBaseClass() const
   {
      return ( ( flags() & DtLgrFomDesc_IsBaseClass ) != 0 );
   }

   inline void DtBaseInterClassDesc::setIsBaseClass(bool isBaseClass)
   {
      if(isBaseClass)
      {
         setFlags(flags() | DtLgrFomDesc_IsBaseClass);
      }
      else
      {
         setFlags(flags() & ~DtLgrFomDesc_IsBaseClass);
      }
   }


   inline bool DtBaseInterClassDesc::isSubscribedTo() const
   {
      return ( ( flags() & DtLgrFomDesc_IsSubscribed ) != 0 );
   }


   inline void DtBaseInterClassDesc::setIsSubscribedTo( bool onOff )
   {
      if(onOff)
      {
         setFlags(flags() | DtLgrFomDesc_IsSubscribed);
      }
      else
      {
         setFlags(flags() & ~DtLgrFomDesc_IsSubscribed);
      }
   }


   inline bool DtBaseInterClassDesc::isFilteredClass() const
   {
      return ( ( flags() & DtLgrFomDesc_IsFiltered ) != 0 );
   }


   inline void DtBaseInterClassDesc::setIsFilteredClass( bool onOff )
   {
      if(onOff)
      {
         setFlags(flags() | DtLgrFomDesc_IsFiltered);
      }
      else
      {
         setFlags(flags() & ~DtLgrFomDesc_IsFiltered);
      }
   }


   inline DtLgrFomTransportType DtBaseInterClassDesc::transportType() const
   {
      if ( ( flags() & DtLgrFomDesc_Reliable ) != 0 )
      {
         return DtLgr_Reliable;
      }
      else
      {
         return DtLgr_BestEffort;
      }
   }

   inline void DtBaseInterClassDesc::setTransportType(DtLgrFomTransportType type)
   {
      if(type == DtLgr_Reliable)
      {
         setFlags(flags() | DtLgrFomDesc_Reliable);
      }
      else
      {
         setFlags(flags() & ~DtLgrFomDesc_Reliable);
      }
   }

   inline DtLgrFomOrderType DtBaseInterClassDesc::orderType() const
   {
      if ( ( flags() & DtLgrFomDesc_TimeStamp ) != 0 )
      {
         return DtLgr_TimeStamp;
      }
      else
      {
         return DtLgr_Receive;
      }
   }

   inline void DtBaseInterClassDesc::setOrderType(DtLgrFomOrderType type)
   {
      if(type == DtLgr_TimeStamp)
      {
         setFlags(flags() | DtLgrFomDesc_TimeStamp);
      }
      else
      {
         setFlags(flags() & ~DtLgrFomDesc_TimeStamp);
      }
   }

}

#endif   
#endif   

#endif