DynamicDataConverter.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2016-.
 * 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 HPP_SERVICE_DYNAMIC_DATA_CONVERTER_HPP_
#define HPP_SERVICE_DYNAMIC_DATA_CONVERTER_HPP_


// 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 "osapi/osapi_heap.h"
#include "routingservice/routingservice_log.h"
#include "routingservice/routingservice_common.h"

#include <dds/core/Value.hpp>
#include <dds/core/types.hpp>
#include <rtiboost/assert.hpp>
#include <dds/core/xtypes/DynamicType.hpp>
#include <dds/core/xtypes/DynamicData.hpp>
#include <rti/core/NativeValueType.hpp>
#include <rti/service/ServiceException.hpp>
#include <rti/service/DynamicBuffer.hpp>

namespace rti { namespace service {

class DynamicDataConverter {
public:

    class ScopedSample {
    public:

        ScopedSample(
                ROUTERDynamicDataConverter *converter,
                DDS_DynamicData *native) :
            converter_(converter),
            native_(native)
        {
        }

        ~ScopedSample()
        {
            ROUTERDynamicDataConverter_returnSample(converter_, native_);
        }

        dds::core::xtypes::DynamicData& get()
        {
            return rti::core::native_conversions::cast_from_native<
                    dds::core::xtypes::DynamicData>(*native_);
        }

    private:
        ROUTERDynamicDataConverter *converter_;
        DDS_DynamicData *native_;
    };

    class ScopedBuffer {
    public:

        ScopedBuffer() : converter_(NULL), native_(NULL), native_length_(0)
        {
        }

        ScopedBuffer(
                ROUTERDynamicDataConverter *converter,
                void *native,
                uint32_t native_length) :
            converter_(converter),
            native_(native),
            native_length_(native_length)
        {
        }

        ~ScopedBuffer()
        {
            if (native_ != NULL) {
                ROUTERDynamicDataConverter_returnBuffer(converter_, native_);
            }
        }

        void clear()
        {
            assign(converter_, NULL, 0);
        }

        void assign(
                ROUTERDynamicDataConverter *converter,
                void *native,
                uint32_t native_length)
        {
            if (native_ != NULL) {
                ROUTERDynamicDataConverter_returnBuffer(
                        converter_,
                        const_cast<void *>(native_));
            }
            converter_ = converter;
            native_ = native;
            native_length_ = native_length;
        }

        ScopedBuffer& operator =(ScopedBuffer& other)
        {
            assign(other.converter_, other.native_, other.native_length_);
            return *this;
        }

        const void * get()
        {
            return native_;
        }

        template <typename T>
        const T * get() {
            return static_cast<const T *>(native_);
        }

        uint32_t length()
        {
            return native_length_;
        }

    private:
        ROUTERDynamicDataConverter *converter_;
        void *native_;
        uint32_t native_length_;
    };

    DynamicDataConverter() : initialized_(false) {}

    DynamicDataConverter(
            const dds::core::xtypes::DynamicType& type_code,
            const DynamicBufferProperty &property) :
        initialized_(false)
    {
        set(type_code, property);
    }

    void set(
            const dds::core::xtypes::DynamicType& type_code,
            const DynamicBufferProperty &property)
    {
        if (!initialized_) {
            if (!ROUTERDynamicDataConverter_initialize(
                    &converter_,
                    &(type_code.native()),
                    (RTI_UINT32) property.min_size())) {
                RTI_THROW_SERVICE_EXCEPTION(
                        &RTI_LOG_INIT_FAILURE_s,
                        "native converter");
            }
            initialized_ = true;
        }
    }

    ~DynamicDataConverter()
    {
        if (initialized_) {
            ROUTERDynamicDataConverter_finalize(&converter_);
        }
    }

    ScopedSample sample(
            const dds::core::xtypes::DynamicData& sample,
            const DDS_DataRepresentationId_t target_representation)
    {
        DDS_DynamicData *native = ROUTERDynamicDataConverter_getSample(
                &converter_,
                const_cast<DDS_DynamicData *>(&sample.native()),
                target_representation);
        if (native == NULL) {
            RTI_THROW_SERVICE_EXCEPTION(
                    &RTI_LOG_ANY_FAILURE_s,
                    "get native sample");
        }
        return ScopedSample(&converter_, native);
    }

    ScopedBuffer buffer(
            const dds::core::xtypes::DynamicData& sample,
            const DDS_DataRepresentationId_t target_representation)
    {
        DDS_UnsignedLong native_length = 0;
        void *native = ROUTERDynamicDataConverter_getBuffer(
                &converter_,
                &native_length,
                const_cast<DDS_DynamicData *>(&sample.native()),
                target_representation);
        if (native == NULL) {
            RTI_THROW_SERVICE_EXCEPTION(
                    &RTI_LOG_ANY_FAILURE_s,
                    "get native buffer");
        }
        return ScopedBuffer(&converter_, native, (uint32_t) native_length);
    }

    void buffer(
            ScopedBuffer& scoped_buffer,
            const dds::core::xtypes::DynamicData& sample,
            const DDS_DataRepresentationId_t target_representation)
    {
        DDS_UnsignedLong native_length = 0;
        /*
         * The scoped buffer has to be cleared before we can use it again. The
         * buffer will automatically be returned to this converter. After this,
         * we can safely get the buffer again from the dynamic data sample and
         * reassign to the scoped buffer.
         */
        scoped_buffer.clear();
        void *native = ROUTERDynamicDataConverter_getBuffer(
                &converter_,
                &native_length,
                const_cast<DDS_DynamicData *>(&sample.native()),
                target_representation);
        if (native == NULL) {
            RTI_THROW_SERVICE_EXCEPTION(
                    &RTI_LOG_ANY_FAILURE_s,
                    "get native buffer");
        }
        scoped_buffer.assign(&converter_, native, (uint32_t) native_length);
    }

private:
    ROUTERDynamicDataConverter converter_;
    bool initialized_;
};


} } // rti::service
#endif /* HPP_SERVICE_DYNAMIC_DATA_CONVERTER_HPP_ */