TypeInfo.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2017.
 * 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_ROUTING_ADAPTER_TYPE_INFOHPP_
#define RTI_ROUTING_ADAPTER_TYPE_INFOHPP_
 
// IMPORTANT: macros.hpp must be the first RTI header included in every header
// file so that symbols are exported correctly on Windows
#include <dds/core/macros.hpp>
 
#include <routingservice/routingservice_infrastructure.h>
#include <dds/core/Value.hpp>
#include <dds/core/SafeEnumeration.hpp>
#include <dds/core/xtypes/DynamicType.hpp>
#include <rti/core/NativeValueType.hpp>
 
namespace rti { namespace routing {
 
struct TypeRepresentationKind_def {
    enum type {
        DYNAMIC_TYPE = RTI_ROUTING_SERVICE_TYPE_REPRESENTATION_DYNAMIC_TYPE,
        XML = RTI_ROUTING_SERVICE_TYPE_REPRESENTATION_XML,
        JAVA_OBJECT = RTI_ROUTING_SERVICE_TYPE_REPRESENTATION_JAVA_OBJECT,
        CUSTOM = RTI_ROUTING_SERVICE_TYPE_REPRESENTATION_FIRST_CUSTOM_REPRESENTATION
    };
};
 
typedef dds::core::safe_enum<TypeRepresentationKind_def> TypeRepresentationKind;
 
 
class TypeInfoAdapter {
public:
    typedef RTI_RoutingServiceTypeInfo native_type;
 
    static void initialize(native_type& native_value)
    {
        static const native_type default_value = {
            NULL,
            DDS_BOOLEAN_TRUE,
            RTI_ROUTING_SERVICE_TYPE_REPRESENTATION_DYNAMIC_TYPE,
            NULL};
        native_value = default_value;
    }
 
    static void finalize(native_type& native_value)
    {
        if (native_value.type_name != NULL) {
            RTIOsapiHeap_freeString(native_value.type_name);
            native_value.type_name = NULL;
        }
    }
 
    static void copy(native_type& destination, const native_type& source)
    {
        char *result = DDS_String_replace(
                &destination.type_name,
                source.type_name);
        if (source.type_name != NULL && result == NULL) {
            throw std::bad_alloc();
        }
        destination.can_be_optimized = source.can_be_optimized;
        destination.type_representation_kind =
                source.type_representation_kind;
        destination.type_representation =
                source.type_representation;
    }
 
    static bool equals(const native_type& first, const native_type& second)
    {
        if (strcmp(first.type_name, second.type_name) != 0) {
            return false;
        }
        if (first.type_representation_kind
                != second.type_representation_kind) {
            return false;
        }
 
        return first.type_representation == second.type_representation;
    }
 
};
 
class TypeInfo;
 
}
 
// native_type_traits needs to be defined in rti::core
namespace core {
 
template <>
struct native_type_traits<rti::routing::TypeInfo> {
    typedef rti::routing::TypeInfoAdapter adapter_type;
    typedef RTI_RoutingServiceTypeInfo native_type;
};
 
}
 
namespace routing {
 
class TypeInfo : public rti::core::NativeValueType<TypeInfo> {
public:
    RTI_NATIVE_VALUE_TYPE_DEFINE_DEFAULT_MOVE_OPERATIONS(TypeInfo)
 
    typedef rti::core::NativeValueType<TypeInfo> Base;
 
    typedef RTI_RoutingServiceTypeRepresentation TypeRepresentationType;
public:
 
    TypeInfo(
            const std::string& the_type_name,
            TypeRepresentationKind the_type_representation_kind =
                    TypeRepresentationKind::DYNAMIC_TYPE)
    {
        type_name(the_type_name);
        type_representation_kind(the_type_representation_kind);
        native().can_be_optimized = DDS_BOOLEAN_TRUE;
    }
 
    TypeInfo(const struct RTI_RoutingServiceTypeInfo &native_stream_info)
            : Base(native_stream_info)
    {
    }
 
    std::string type_name() const
    {
        return native().type_name;
    }
 
    TypeInfo& type_name(const std::string& the_type_name)
    {
 
        if (DDS_String_replace(
                &native().type_name,
                the_type_name.c_str()) == NULL) {
            throw std::bad_alloc();
        }
 
        return *this;
    }
 
    TypeRepresentationKind type_representation_kind() const
    {
        return static_cast<TypeRepresentationKind::type>(
                native().type_representation_kind);
    }
 
    TypeInfo& type_representation_kind(
            TypeRepresentationKind the_type_representation_kind)
    {
        native().type_representation_kind = static_cast<int>(
                the_type_representation_kind.underlying());
        return *this;
    }
 
    TypeRepresentationType  type_representation() const
    {
        return native().type_representation;
    }
 
    TypeInfo&  type_representation(TypeRepresentationType the_type_representation)
    {
        native().type_representation = the_type_representation;
        return *this;
    }
 
    const dds::core::xtypes::DynamicType& dynamic_type() const
    {
        if (type_representation_kind() != TypeRepresentationKind::DYNAMIC_TYPE) {
            throw dds::core::IllegalOperationError(
                    "type representation is not dynamic type");
        }
 
        const DDS_TypeCode *native_typecode = reinterpret_cast<DDS_TypeCode*>(
                type_representation());
        return rti::core::native_conversions::cast_from_native<
                dds::core::xtypes::DynamicType>(*native_typecode);
    }
 
    void dynamic_type(const dds::core::xtypes::DynamicType *dynamic_type)
    {
        DDS_TypeCode *native_typecode = const_cast<DDS_TypeCode*>(
                reinterpret_cast<const DDS_TypeCode *>(dynamic_type));
        type_representation(static_cast<TypeRepresentationType>(native_typecode));
        type_representation_kind(TypeRepresentationKind::DYNAMIC_TYPE);
    }
};
 
}}
 
#endif // RTI_ROUTING_ADAPTER_TYPE_INFOHPP_