adapt_macros.h

Go to the documentation of this file.

/*********************************************************************************************
(c) 2005-2014 Copyright, Real-Time Innovations, Inc.  All rights reserved.
RTI grants Licensee a license to use, modify, compile, and create derivative works
of the Software.  Licensee has the right to distribute object form only for use with RTI
products.  The Software is provided "as is", with no warranty of any type, including
any warranty for fitness for any purpose. RTI is under no obligation to maintain or
support the Software.  RTI shall not be liable for any incidental or consequential
damages arising out of the use or inability to use the software.
**********************************************************************************************/

#ifdef REFLEX_DOXYGEN

#define REFLEX_STATIC_STRING_BOUND 

#define REFLEX_STATIC_CONTAINER_BOUND 

#endif // REFLEX_DOXYGEN

#define REFLEX_ENUM_DEF_CUSTOM(EnumType, Name, Size)     \
namespace reflex { namespace codegen {            \
  template <>                                     \
  struct EnumDef<EnumType>                        \
  {                                               \
      static const char *name() {                 \
        return Name;                              \
      }                                           \
                                                  \
      enum { is_enum = true };                    \
      static const unsigned int size = Size;      \
                                                  \
      template <unsigned Index>                   \
      struct EnumMember {                         \
        static MemberInfo info(); \
      };                                          \
  };                                              \
} } // namespace reflex::detail                         

#define REFLEX_ENUM_MEMBER_DEF_CUSTOM(EnumType, Index, Name, Ordinal)   \
namespace reflex { namespace codegen {                           \
  template<>                                                     \
  inline MemberInfo                                              \
  EnumDef<EnumType>::EnumMember<Index>::info()                   \
    {                                                            \
    return MemberInfo(Name, Ordinal);                            \
    }                                                            \
} } // namespace reflex::detail                         

#define REFLEX_STRUCT_NAME_DEF_CUSTOM(FullyQualifiedType, Name)   \
namespace reflex { namespace codegen {                            \
  template <>                                                     \
  struct StructName<FullyQualifiedType>                           \
  {                                                               \
    static std::string get() {                                    \
    return Name;                                                  \
  }                                                               \
  };                                                              \
} } // namespace reflex::detail                         

#define REFLEX_STRUCT_MEMBER_DEF_CUSTOM(FullyQualifiedType, Index, Name, Flags)   \
namespace reflex { namespace codegen {                                            \
  template <>                                                                     \
  struct MemberTraits<FullyQualifiedType, Index>                                  \
    {                                                                             \
    static MemberInfo member_info()                               \
        {                                                                         \
      return MemberInfo(Name, Flags);                             \
        }                                                                         \
    };                                                                            \
} } // namespace reflex::detail                         

#define REFLEX_ADAPT_ENUM(EnumType, Attributes)              \
namespace reflex { namespace codegen {                       \
  template <>                                                \
  struct EnumDef<EnumType>                                   \
        {                                                    \
    static const char *name() {                              \
      return                                                 \
        detail::NameHelper::basename                         \
         (#EnumType);                                        \
                }                                            \
                                                             \
    enum { is_enum = true };                                 \
                                                             \
    static const unsigned int size =                         \
      BOOST_PP_SEQ_SIZE(RTI_PARENTHESIZE(Attributes));       \
                                                             \
    template <unsigned Index>                                \
    struct EnumMember {                                      \
      static MemberInfo info();                              \
                };                                           \
        };                                                   \
} } /* namespace reflex::detail */                           \
BOOST_PP_SEQ_FOR_EACH_I(RTI_ENUM_MEMBER_INFO_INTERNAL,       \
                        EnumType,                            \
                        RTI_PARENTHESIZE(Attributes))

#define REFLEX_ADAPT_STRUCT(Type,Attributes)        \
  RTI_STRUCT_NAME_DEF_INTERNAL(Type)                \
  RTI_MEMBER_TRAITS(Type, Attributes)               \
  BOOST_FUSION_ADAPT_STRUCT(Type, RTI_TRANSFORM_TRIPLETS_TO_PAIRS(Attributes))

#define REFLEX_ADAPT_VALUETYPE(Type, Base, Attributes)  \
  RTI_INHERITANCE_TRAITS(Type, Base)                    \
  REFLEX_ADAPT_STRUCT(Type, Attributes)

// The parenthesis below are essential for the RTI_DUMMY macro.
#define REFLEX_OPTIONAL    (DDS_TYPECODE_NONKEY_MEMBER)

#define REFLEX_KEY         (DDS_TYPECODE_KEY_MEMBER)

#define REFLEX_REQUIRED    (DDS_TYPECODE_NONKEY_REQUIRED_MEMBER)

#define REFLEX_EXTENDS(X) X

#ifndef REFLEX_DOXYGEN

#define RTI_STRUCT_NAME_DEF_INTERNAL(FullyQualifiedType)          \
  namespace reflex { namespace codegen {                          \
  template <>                                                     \
  struct StructName<FullyQualifiedType>                           \
    {                                                             \
    static std::string get()                                      \
        {                                                         \
      return detail::NameHelper::basename(#FullyQualifiedType);   \
        }                                                         \
    };                                                            \
} } // namespace reflex::detail                         

#define RTI_INHERITANCE_TRAITS(Derived, Base)      \
namespace reflex { namespace type_traits {         \
  template <>                                      \
  struct inheritance_traits<Derived> {              \
    typedef true_type has_base;                    \
    typedef Base basetype;                         \
    };                                             \
} } // namespace reflex::detail                    

#ifdef RTI_WIN32
#define RTI_DUMMY(X) X
#define RTI_DUMMY_VAR   DDS_Octet RTI_DUMMY=REFLEX_REQUIRED

#define RTI_GET_NAME_FLAGS(Type, Name, ...)   \
    #Name, RTI_DUMMY ## __VA_ARGS__
#else
// Not needed outside Visual Studio
#define RTI_DUMMY_VAR

#define RTI_WITH_FLAG(Time, Name, Flag)  #Name, Flag
#define RTI_WITHOUT_FLAG(Time, Name)     #Name, REFLEX_REQUIRED

#define RTI_PUSH_4TH_ARG(arg1, arg2, arg3, arg4, ...) arg4

// A pair    will push out RTI_WITHOUT_FLAGS
// A triplet will push out RTI_WITH_FLAGS
#define RTI_FLAGS_CHOOSER(...) RTI_PUSH_4TH_ARG(__VA_ARGS__, RTI_WITH_FLAG, RTI_WITHOUT_FLAG)

// __VA_ARGS__ is either a pair or a triplet.
#define RTI_GET_NAME_FLAGS(...)            \
    RTI_FLAGS_CHOOSER(__VA_ARGS__)(__VA_ARGS__)
#endif

#define RTI_GET_NAME_ORDINAL(Name, Ordinal) #Name, Ordinal

// Note that Attr is already has parenthesis.
// Attr is either a pair or a triplet
// RTI_GET_NAME_FLAGS macro eats the parenthesis around Attr.
// RTI_DUMMY_VAR is used on for Win32 only
#define RTI_MEMBER_INFO_INTERNAL(R,Data,I,Attr)        \
namespace reflex { namespace codegen {                 \
  template<>                                           \
  MemberInfo MemberTraits<Data, I>::member_info()      \
    {                                                  \
      RTI_DUMMY_VAR;                                   \
      return MemberInfo(                               \
        RTI_GET_NAME_FLAGS Attr);                      \
    }                                                  \
} } // namespace reflex::detail      

#define RTI_FILLER_0(...) ((__VA_ARGS__)) RTI_FILLER_1
#define RTI_FILLER_1(...) ((__VA_ARGS__)) RTI_FILLER_0
#define RTI_FILLER_0_END
#define RTI_FILLER_1_END

// Convert (a,1,A)(b,2,B)(c,3,C) into ((a,1,A))((b,2,B))((c,3,C))
// Otherwise preprocessor will get confused due to commas.
// The PARENTHESIZE macro expands as follows:
//
// RTI_FILLER_0 Attr                                               ---->
// RTI_FILLER_0 (a,1,A)(b,2,B)(c,3,C)                              ---->
// ((a,1,A)) RTI_FILLER_1 (b,2,B)(c,3,C)                           ---->
// ((a,1,A)) ((b,2,B)) RTI_FILLER_0 (c,3,C)                        ---->
// ((a,1,A)) ((b,2,B)) ((c,3,C)) RTI_FILLER_1                      ---->
// BOOST_PP_CAT(((a,1,A)) ((b,2,B)) ((c,3,C)) RTI_FILLER_1, _END)  ---->
// ((a,1,A)) ((b,2,B)) ((c,3,C)) RTI_FILLER_1_END                  ---->
// ((a,1,A)) ((b,2,B)) ((c,3,C))                                   ---->
// voila!!!

#define RTI_PARENTHESIZE(Attr) BOOST_PP_CAT(RTI_FILLER_0 Attr,_END)

#define RTI_MEMBER_TRAITS(Name,Attributes) \
  BOOST_PP_SEQ_FOR_EACH_I(RTI_MEMBER_INFO_INTERNAL,Name,RTI_PARENTHESIZE(Attributes))

#define RTI_SKIP_LAST_0(X, Y, ...) (X, Y) RTI_SKIP_LAST_1
#define RTI_SKIP_LAST_1(X, Y, ...) (X, Y) RTI_SKIP_LAST_0
#define RTI_SKIP_LAST_0_END
#define RTI_SKIP_LAST_1_END


// Convert (a,1,A)(b,2,B)(c,3,C) into (a,1)(b,2)(c,3)
// Otherwise BOOST_FUSION_ADAPT_STRUCT macro will be confused.
// The TRANSFORM macro expands as follows:
//
// RTI_SKIP_LAST_0 Attr                                   ---->
// RTI_SKIP_LAST_0 (a,1,A)(b,2,B)(c,3,C)                  ---->
// (a,1) RTI_SKIP_LAST_1 (b,2,B)(c,3,C)                   ---->
// (a,1) (b,2) RTI_SKIP_LAST_0 (c,3,C)                    ---->
// (a,1) (b,2) (c,3) RTI_SKIP_LAST_1                      ---->
// BOOST_PP_CAT((a,1) (b,2) (c,3) RTI_SKIP_LAST_1, _END)  ---->
// (a,1) (b,2) (c,3) RTI_SKIP_LAST_1_END                  ---->
// (a,1) (b,2) (c,3)                                      ---->
// voila!!!

#define RTI_TRANSFORM_TRIPLETS_TO_PAIRS(Attributes) \
  BOOST_PP_CAT(RTI_SKIP_LAST_0 Attributes, _END)


#define RTI_ENUM_MEMBER_INFO_INTERNAL(R,EnumType,Index,Attr)       \
namespace reflex { namespace codegen {                             \
  template<>                                                       \
  MemberInfo EnumDef<EnumType>::EnumMember<Index>::info()          \
    {                                                              \
      return MemberInfo(RTI_GET_NAME_ORDINAL Attr);                \
    }                                                              \
} } // namespace reflex::detail      

#endif // REFLEX_DOXYGEN