baseIntDesc13.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef baseIntDesc13_H_
#define baseIntDesc13_H_

#if DtHLA & !DtHLA_1516

#include <lgrSim/lgrSim.h>

#include "baseHlaClass.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 DtBaseHlaClass<DtBaseParamDesc>
   {
   public:
      DtBaseInterClassDesc( const DtString& className,
         DtBaseInterClassDesc* baseClass, DtLgrHlaHandle handle);

      DtBaseInterClassDesc( const DtString& className,
         const DtString& baseClassName, DtLgrHlaHandle hand);

      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 );

      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);
      }
   }

}

#endif   
#endif