handleCreator.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2024 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/

#ifndef handleCreator_H_
#define handleCreator_H_


#include "rtiApiTypes.h"

#include <rtiutil/internalTypes.h>
#include <vlutil/vlFedTarget.h>

#pragma warning(disable : 4302)

#if defined(DtIFSPEC13)


#define DEFINE_HANDLE_MAKER(HandleKind) \
inline RTI::HandleKind make##HandleKind(Dt##HandleKind handle) \
{                                                              \
   return (RTI::HandleKind)(handle);                           \
}                                                              \
                                                               \
inline Dt##HandleKind make##HandleKind##Impl(                  \
   const RTI::HandleKind& handle)                              \
{                                                              \
   return (Dt##HandleKind)(handle);                            \
}

DEFINE_HANDLE_MAKER(FederateHandle)
DEFINE_HANDLE_MAKER(ObjectClassHandle)
DEFINE_HANDLE_MAKER(InteractionClassHandle)
DEFINE_HANDLE_MAKER(AttributeHandle)
DEFINE_HANDLE_MAKER(ParameterHandle)
DEFINE_HANDLE_MAKER(DimensionHandle)

inline RTI::ObjectHandle makeObjectInstanceHandle(DtObjectInstanceHandle handle)
{
   return (RTI::ObjectHandle)(handle);
}

inline DtObjectInstanceHandle makeObjectInstanceHandleImpl(const RTI::ObjectHandle& handle)
{
   return (DtObjectInstanceHandle)(handle);
}

#else

#include "handleImpl.h"
#include <vlutil/vlFedTarget.h>

namespace RTI_API
{


#define DEFINE_HANDLE_CLASS_FRIEND(HandleKind)                                \
                                                                              \
class HandleKind##Friend                                                      \
{                                                                             \
public:                                                                       \
   HandleKind##Friend();                                                      \
   static RTI_API::HandleKind HandleKind(Dt##HandleKind handleValue);         \
   static RTI_API::HandleKind HandleKind(                                     \
      RTI_API::VariableLengthData const & encodedValue);                      \
   static HandleKind##Implementation const* getImplementation(                \
      RTI_API::HandleKind const& handle);                                     \
   static HandleKind##Implementation* getImplementation(                      \
      RTI_API::HandleKind& handle);                                           \
};                                                                            \
                                                                              \
inline HandleKind##Friend::HandleKind##Friend()                               \
{                                                                             \
}                                                                             \
                                                                              \
inline RTI_API::HandleKind HandleKind##Friend::HandleKind(                    \
   Dt##HandleKind handleValue)                                                \
{                                                                             \
   return RTI_API::HandleKind((HandleKind##Implementation*)handleValue);      \
}                                                                             \
                                                                              \
inline RTI_API::HandleKind HandleKind##Friend::HandleKind(                    \
   RTI_API::VariableLengthData const & encodedValue)                          \
{                                                                             \
   return RTI_API::HandleKind(encodedValue);                                  \
}                                                                             \
                                                                              \
inline HandleKind##Implementation const *                                     \
HandleKind##Friend::getImplementation(RTI_API::HandleKind const& handle)      \
{                                                                             \
   return handle.getImplementation();                                         \
}                                                                             \
                                                                              \
inline HandleKind##Implementation*                                            \
HandleKind##Friend::getImplementation(RTI_API::HandleKind & handle)           \
{                                                                             \
   return handle.getImplementation();                                         \
}

#define DEFINE_FILL_HANDLE_SET_IMPL(HandleKind)                               \
                                                                              \
inline void fill##HandleKind##SetImpl(                                        \
   RTI_API::HandleKind##Set const & rtiHandleSet,                             \
   Dt##HandleKind##StdSet & internHandleSet)                                  \
{                                                                             \
   for (RTI_API::HandleKind##Set::const_iterator iter = rtiHandleSet.begin(); \
      iter != rtiHandleSet.end();                                             \
      iter++)                                                                 \
   {                                                                          \
      internHandleSet.insert(make##HandleKind##Impl(*iter));                  \
   }                                                                          \
}

DEFINE_HANDLE_CLASS_FRIEND(FederateHandle)
DEFINE_HANDLE_CLASS_FRIEND(ObjectClassHandle)
DEFINE_HANDLE_CLASS_FRIEND(InteractionClassHandle)
DEFINE_HANDLE_CLASS_FRIEND(ObjectInstanceHandle)
DEFINE_HANDLE_CLASS_FRIEND(AttributeHandle)
DEFINE_HANDLE_CLASS_FRIEND(ParameterHandle)
DEFINE_HANDLE_CLASS_FRIEND(DimensionHandle)
DEFINE_HANDLE_CLASS_FRIEND(RegionHandle)
#if !defined(DtIFSPEC1516) && !defined(DtIFSPEC1516E)
DEFINE_HANDLE_CLASS_FRIEND(TransportationTypeHandle)
#endif

class MessageRetractionHandleFriend
{
public:
   MessageRetractionHandleFriend();
   static RTI_API::MessageRetractionHandle MessageRetractionHandle(DtMessageRetractionHandle handleValue);
   static RTI_API::MessageRetractionHandle MessageRetractionHandle(RTI_API::VariableLengthData const & encodedValue);
   static MessageRetractionHandleImplementation const* getImplementation(RTI_API::MessageRetractionHandle const& handle);
   static MessageRetractionHandleImplementation* getImplementation(RTI_API::MessageRetractionHandle& handle);
};

inline MessageRetractionHandleFriend::MessageRetractionHandleFriend()
{
}

inline RTI_API::MessageRetractionHandle MessageRetractionHandleFriend::MessageRetractionHandle(
   DtMessageRetractionHandle handleValue)
{
   return RTI_API::MessageRetractionHandle((MessageRetractionHandleImplementation*)&handleValue);
}

inline RTI_API::MessageRetractionHandle MessageRetractionHandleFriend::MessageRetractionHandle(
   RTI_API::VariableLengthData const & encodedValue)
{
   return RTI_API::MessageRetractionHandle(encodedValue);
}

inline MessageRetractionHandleImplementation const * MessageRetractionHandleFriend::getImplementation(
   RTI_API::MessageRetractionHandle const& handle)
{
   return handle.getImplementation();
}

inline MessageRetractionHandleImplementation* MessageRetractionHandleFriend::getImplementation(
   RTI_API::MessageRetractionHandle & handle)
{
   return handle.getImplementation();
}

};

// These maker macros are defined outside of the namespace to be compatible with those for HLA 1.3
// which encapsulates namespace using a class which can't be amended.
#define DEFINE_HANDLE_MAKERS(HandleKind)                                         \
                                                                                 \
inline RTI_API::HandleKind make##HandleKind(                                     \
   RTI_API::VariableLengthData const & encodedValue)                             \
{                                                                                \
   return RTI_API::HandleKind##Friend::HandleKind(encodedValue);                 \
}                                                                                \
                                                                                 \
inline Dt##HandleKind make##HandleKind##Impl(const RTI_API::HandleKind& handle)  \
{                                                                                \
   return (Dt##HandleKind)RTI_API::HandleKind##Friend::getImplementation(handle);\
}                                                                                \
                                                                                 \
inline RTI_API::HandleKind make##HandleKind(Dt##HandleKind handle)               \
{                                                                                \
   return RTI_API::HandleKind##Friend::HandleKind(handle);                       \
}

DEFINE_HANDLE_MAKERS(FederateHandle)
DEFINE_HANDLE_MAKERS(ObjectClassHandle)
DEFINE_HANDLE_MAKERS(InteractionClassHandle)
DEFINE_HANDLE_MAKERS(ObjectInstanceHandle)
DEFINE_HANDLE_MAKERS(AttributeHandle)
DEFINE_HANDLE_MAKERS(ParameterHandle)
DEFINE_HANDLE_MAKERS(DimensionHandle)
DEFINE_HANDLE_MAKERS(RegionHandle)

inline RTI_API::MessageRetractionHandle makeMessageRetractionHandle(RTI_API::VariableLengthData const & encodedValue)
{
   return RTI_API::MessageRetractionHandleFriend::MessageRetractionHandle(encodedValue);
}

inline DtMessageRetractionHandle makeMessageRetractionHandleImpl(RTI_API::MessageRetractionHandle handle)
{
   return RTI_API::MessageRetractionHandleFriend::getImplementation(handle)->value();
}

inline RTI_API::MessageRetractionHandle makeMessageRetractionHandle(DtMessageRetractionHandle handle)
{
   return RTI_API::MessageRetractionHandleFriend::MessageRetractionHandle(handle);
}

inline  RTI_API::MessageRetractionHandle makeMessageRetractionHandle(DtFederateHandle fedHandle, unsigned long serialNumber)
{
   DtMessageRetractionHandle handleImpl = { serialNumber, fedHandle };
   return makeMessageRetractionHandle(handleImpl);
};

inline RTI_API::MessageRetractionHandle makeMessageRetraction(RTI_API::VariableLengthData const& encodedValue)
{
   return RTI_API::MessageRetractionHandleFriend::MessageRetractionHandle(encodedValue);
}



namespace RTI_API
{
#define DEFINE_FILL_HANDLE_SET(HandleKind)                                    \
                                                                              \
inline void fill##HandleKind##Set(                                            \
   Dt##HandleKind##StdSet const & internHandleSet,                            \
   RTI_API::HandleKind##Set & rtiHandleSet)                                   \
{                                                                             \
   for (Dt##HandleKind##StdSet::const_iterator iter = internHandleSet.begin();\
      iter != internHandleSet.end();                                          \
      iter++)                                                                 \
   {                                                                          \
      rtiHandleSet.insert(make##HandleKind(*iter));                           \
   }                                                                          \
}

DEFINE_FILL_HANDLE_SET(FederateHandle)
DEFINE_FILL_HANDLE_SET_IMPL(FederateHandle)
DEFINE_FILL_HANDLE_SET(AttributeHandle)
DEFINE_FILL_HANDLE_SET_IMPL(AttributeHandle)
DEFINE_FILL_HANDLE_SET(DimensionHandle)
DEFINE_FILL_HANDLE_SET_IMPL(DimensionHandle)
DEFINE_FILL_HANDLE_SET(RegionHandle)
DEFINE_FILL_HANDLE_SET_IMPL(RegionHandle)

};

#endif 



#if defined(DtIFSPEC13)
inline DtTransportHandle makeTransportationTypeImpl(RTI_API::TransportType handle)
{
   return DtTransportHandle(handle);
}

inline RTI_API::TransportType makeTransportationType(DtTransportHandle handle)
{
   return RTI_API::TransportType(handle);
}
#elif defined(DtIFSPEC1516) || defined(DtIFSPEC1516E)
inline DtTransportHandle makeTransportationTypeImpl(RTI_API::TransportationType handle)
{
   return DtTransportHandle(handle);
}

inline RTI_API::TransportationType makeTransportationType(DtTransportHandle handle)
{
   return RTI_API::TransportationType(handle);
}
#else
// Maker macro above would work for HLA4 but it would change macro's name,
// so define it here explicitly with same name as others
inline DtTransportHandle makeTransportationTypeImpl(RTI_API::TransportationTypeHandle handle)
{
   return (DtTransportationTypeHandle)RTI_API::TransportationTypeHandleFriend::getImplementation(handle);
}

inline RTI_API::TransportationTypeHandle makeTransportationType(DtTransportHandle handle)
{
   return RTI_API::TransportationTypeHandleFriend::TransportationTypeHandle(handle);
}

inline RTI_API::TransportationTypeHandle makeTransportationType(RTI_API::VariableLengthData const& encodedValue)
{
   return RTI_API::TransportationTypeHandleFriend::TransportationTypeHandle(encodedValue);
}

#endif

#if defined(DtIFSPEC13)
inline MAKRti::DtOrderType makeOrderTypeImpl(RTI_API::OrderType order)
{
   return MAKRti::DtOrderType(order);
}

inline RTI_API::OrderType makeOrderType(MAKRti::DtOrderType order)
{
   return order;
}
#else
inline MAKRti::DtOrderType makeOrderTypeImpl(RTI_API::OrderType order)
{
   return (order == RTI_API::RECEIVE) ? MAKRti::DtReceive : MAKRti::DtTimestamp;
}

inline RTI_API::OrderType makeOrderType(MAKRti::DtOrderType order)
{
   return (order == MAKRti::DtReceive) ? RTI_API::RECEIVE : RTI_API::TIMESTAMP;
}
#endif


#endif