FlatTypeTraits.hpp

/*
(c) Copyright, Real-Time Innovations, 2018.
All rights reserved.
 
No duplications, whole or partial, manual or electronic, may be made
without express written permission.  Any such copies, or
revisions thereof, must display this notice unaltered.
This code contains trade secrets of Real-Time Innovations, Inc.
*/
 
#ifndef RTI_DDS_FLAT_FLATTYPETRAITS_HPP_
#define RTI_DDS_FLAT_FLATTYPETRAITS_HPP_
 
#include "rti/flat/Offset.hpp"
#include "rti/flat/SequenceOffsets.hpp"
#include "rti/flat/AggregationBuilders.hpp"
 
namespace rti { namespace flat {
 
 
// For aggregation types, this template is to be specialized in generated code
template <typename T>
struct flat_type_traits;
 
template <typename T, unsigned int N>
struct flat_type_traits<FinalArrayOffset<T, N> > {
    typedef typename flat_type_traits<T>::plain_type plain_type;
};
 
template <typename T, unsigned int N>
struct flat_type_traits<PrimitiveArrayOffset<T, N> > {
    typedef T plain_type;
};
 
template <typename T>
struct flat_type_traits<PrimitiveSequenceOffset<T> > {
    typedef T plain_type;
};
 
template <typename T, unsigned int N>
struct flat_type_traits<FinalAlignedArrayOffset<T, N> > {
    typedef typename flat_type_traits<T>::plain_type plain_type;
};
 
template <typename T, unsigned int N>
struct flat_type_traits<MutableArrayOffset<T, N> > {
    typedef typename flat_type_traits<T>::plain_type plain_type;
};
 
template <typename T>
struct flat_type_traits<SequenceOffset<T> > {
    typedef typename flat_type_traits<T>::plain_type plain_type;
};
 
template <>
struct flat_type_traits<StringOffset > :
        flat_type_traits<PrimitiveSequenceOffset<char> > {
};
 
template <typename T>
struct flat_type_traits<PrimitiveOffset<T> > {
    typedef T plain_type;
};
 
template <typename OffsetType>
typename flat_type_traits<OffsetType>::plain_type* plain_cast(OffsetType& offset)
{
    RTI_FLAT_CHECK_PRECONDITION(offset.is_cpp_compatible(), return NULL);
    return reinterpret_cast<typename flat_type_traits<OffsetType>::plain_type*>(
            offset.get_buffer());
}
 
template <typename OffsetType>
const typename flat_type_traits<OffsetType>::plain_type* plain_cast(const OffsetType& offset)
{
    RTI_FLAT_CHECK_PRECONDITION(offset.is_cpp_compatible(), return NULL);
    return reinterpret_cast<const typename flat_type_traits<OffsetType>::plain_type*>(
            offset.get_buffer());
}
 
namespace detail {
 
template <typename OffsetKind>
struct offset_kind_is_fixed_size {
    enum { value = 0 };
};
 
template <>
struct offset_kind_is_fixed_size<rti::flat::fixed_size_type_tag_t> {
    enum { value = 1 };
};
 
}
 
// Utility to determine if a Flat Data type is fixed size (final) or variable
// size (mutable)
template <typename T>
struct is_fixed_size_type
        : detail::offset_kind_is_fixed_size<typename T::Offset::offset_kind>
{
};
 
} }
 
#endif // RTI_DDS_FLAT_FLATSAMPLE_HPP_