patch.h

Go to the documentation of this file.

//********************************************************************
// Copyright (c) 2006 MaK Technologies, Inc.
// All rights reserved.
//********************************************************************
#if DtHLA

#include <stdio.h>
#include <vl/entityStateRepository.h>
#include <vlutil/vlString.h>
#include <vl/platformEncoder.h>
#include <vl/platformDecoder.h>
#include <vl/fomMapper.h>
#include <vl/stateEncoderFactory.h>
#include <vl/stateDecoderFactory.h>
#include <vl/fom.h>
#include <vlpi/entityTypes.h>

class DtF18EntityStateRep : public DtEntityStateRepository
{
public:
   DtF18EntityStateRep() : DtEntityStateRepository(),
                                 myAttrib("")

   { printf("\n===================\n"
            "Constructing DtF18EntityStateRep\n"
            "=====================\n"); }

   virtual ~DtF18EntityStateRep() {}

private:

   DtF18EntityStateRep(const DtF18EntityStateRep& orig);

   DtF18EntityStateRep& operator=(const DtF18EntityStateRep& orig);

public:

   virtual void setF18Attribute(const DtString & val) { myAttrib = val;}
   virtual DtString f18Attribute() const { return myAttrib;}

   static DtF18EntityStateRep* create() { return new DtF18EntityStateRep; };


protected:

   DtString myAttrib;

};

class DtF18EntityDecoder : public DtPlatformDecoder
{
public:
   DtF18EntityDecoder( DtExerciseConn* exConn,
                      DtObjClassDesc* classDesc):
      DtPlatformDecoder(exConn, classDesc)
   {
      addDecoder("SpecialF18Attribute", 
                 (DtAttributeDecoder) decodeSpecialF18Attribute);
   }

   virtual ~DtF18EntityDecoder(){}

protected:

   static void decodeSpecialF18Attribute(DtF18EntityStateRep* stateRep,
                                         const RTI::AttributeHandleValuePairSet& attrs,
                                         int pairSetIndex)
   {
      RTI::ULong length = attrs.getValueLength(pairSetIndex);
      // if there is nothing in there, we can exit safely
      if (length == 0) return;

      char* buffer = DtDecodingBuffer(length+1);
      attrs.getValue(pairSetIndex, buffer, length);
      buffer[length] = '\0';

      stateRep->setF18Attribute(buffer);
   }

};

class DtF18EntityEncoder : public DtPlatformEncoder
{
public:
   DtF18EntityEncoder( DtExerciseConn* exConn,
                      DtObjClassDesc* classDesc):
      // By calling the base class ctor all the needed encoders and checkers are registered
      DtPlatformEncoder(exConn, classDesc)
   {
      // Register our encoder functions for all the attributes we need.
      addEncoder("SpecialF18Attribute",
                 (DtAttributeEncoder) encodeSpecialF18Attribute);
      addChecker("SpecialF18Attribute",
                 (DtAttributeChecker) needSpecialF18Attribute);
   }
   virtual ~DtF18EntityEncoder() {}

protected:

   static bool needSpecialF18Attribute( const DtF18EntityStateRep& stateRep,
                                        const DtF18EntityStateRep& asSeenByRemote)
   {
      return(stateRep.f18Attribute() != asSeenByRemote.f18Attribute());
   }

   static void encodeSpecialF18Attribute( const DtF18EntityStateRep& stateRep,
                                          RTI::AttributeHandleValuePairSet* avList,
                                          RTI::AttributeHandle attrHandle)
   {  
      // This is easy, they are not all this easy. The point of this example
      // is not to show how to encode/decode complex data types. 
      avList->add(attrHandle, 
                  stateRep.f18Attribute().c_str(), 
                  stateRep.f18Attribute().size());
   }

};

// Some useful macros for adding the encoders/decoders
#define DtADD_ENCODER(className, derivedEnc) \
{ \
   DtObjClassDesc* classDesc = exConn.fom()->objClassByName(#className); \
   if (classDesc) \
   { \
      exConn.fomMapper()->stateEncoderFactory()->addEncoder( \
         classDesc->handle(), new derivedEnc(&exConn, classDesc)); \
   } \
   else \
   { \
      DtWarn("Can't add encoder for object class %s: Not in FOM.\n", #className); \
   } \
} 

#define DtADD_DECODER(className, derivedDec) \
{ \
   DtObjClassDesc* classDesc = exConn.fom()->objClassByName(#className); \
   if (classDesc) \
   { \
      exConn.fomMapper()->stateDecoderFactory()->addDecoder( \
         classDesc->handle(), new derivedDec(&exConn, classDesc)); \
   } \
   else \
   { \
      DtWarn("Can't add decoder for object class %s: Not in FOM.\n", #className); \
   } \
} 

char* DtF18EntityChooser( const char* vrlinkClassName,
                          DtExerciseConn* exConn,
                          void *usr)
{
   printf("=========\n");
   printf(" In Class Chooser, deciding which entity Type to publish\n");
   printf("=========\n");

   // For Entities, the usr data is always of DtEntityType. This is just
   // the way it is. 
   
   DtEntityType& type = *((DtEntityType*) usr);

   if (type.subCategory() == DtF18)
   {
      printf("Choosing F18 Type, we will use the new class!\n");
      // Return the FOM OBJECT CLASS name 
      return "BaseEntity.PhysicalEntity.Platform.Aircraft.F18";
   }

   // If this is not the right type, let the default chooser decide
   return(DtRprFomMapper::dfltEntityClassChooser(vrlinkClassName,
                                                 exConn, usr));
}


#endif