FlatSample.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_FLATSAMPLE_HPP_
#define RTI_DDS_FLAT_FLATSAMPLE_HPP_
 
// Note: FlatSampleImpl.hpp needs to be included in addition to this header.
 
#include <cstdlib>
#include <memory>
 
#include "xcdr/xcdr_stream_impl.h"
#include "xcdr/xcdr_flat_data.h"
#include "xcdr/xcdr_interpreter.h"
 
#include "rti/xcdr/Interpreter.hpp" // for type_programs
 
namespace rti { namespace flat {
 
struct fixed_size_type_tag_t {};
struct variable_size_type_tag_t {};
 
typedef RTIXCdrUnsignedLong offset_t;
typedef RTIXCdrUnsignedLong member_id_t;
 
// The untemplated base of Sample<T>
class SampleBase {
public:
 
    unsigned char* get_buffer()
    {
        return &data[0];
    }
 
    const unsigned char* get_buffer() const
    {
        return &data[0];
    }
 
    unsigned char* get_root_buffer()
    {
        return get_buffer() + RTI_XCDR_ENCAPSULATION_SIZE;
    }
 
    /*i
     * @brief Provides the address of the top-level type
     */
    const unsigned char* get_root_buffer() const
    {
        return get_buffer() + RTI_XCDR_ENCAPSULATION_SIZE;
    }
 
    void initialize_stream(
        RTIXCdrStream& stream, 
        offset_t offset, 
        offset_t serialized_size) const
    {
        RTIXCdrFlatData_initializeStream(
                &stream, 
                const_cast<unsigned char*>(get_buffer()),
                offset,
                serialized_size);
    }
 
protected: // xlc compiler fails when the default constructor is private
#if !defined(RTI_FLAT_DATA_CXX11_DELETED_FUNCTIONS)    
    SampleBase() {} // Samples can only be created via Sample::create_data
    SampleBase(const SampleBase&) {}
    SampleBase& operator=(const SampleBase&);
#else
    SampleBase() = delete;
    SampleBase(const SampleBase&) = delete;
    SampleBase& operator=(const SampleBase&) = delete;
#endif
 
    // The actual size of data (and therefore, the Sample object) is variable,    
    // and equal to the serialized size of the IDL Sample
    unsigned char data[1];
};
 
template <typename OffsetType>
class Sample : public SampleBase {
public:
    typedef OffsetType Offset;
 
    typedef typename OffsetType::ConstOffset ConstOffset;
 
    Offset root()
    {
        return root_impl(typename Offset::offset_kind());
    }
 
    ConstOffset root() const
    {
        return root_impl(typename ConstOffset::offset_kind());
    }
 
    RTIXCdrEndian endian() const
    {
        RTIXCdrStream tmp_stream;
        initialize_stream(tmp_stream, 0, RTI_XCDR_ENCAPSULATION_SIZE);
        return tmp_stream._endian;
    }
 
    static Sample<OffsetType>* from_buffer(unsigned char *buffer)
    {
        return reinterpret_cast<Sample<OffsetType>*>(buffer);
    }
 
    static Sample<OffsetType>* create_data(); // impl in FlatSampleImpl.hpp
 
    Sample<OffsetType>* clone() const
    {
        unsigned char *buffer = RTIXCdrFlatData_cloneSample(
                get_buffer(),
                sample_size());
 
        if (buffer == NULL) {
          #ifndef RTI_FLAT_DATA_NO_EXCEPTIONS
            throw std::bad_alloc();
          #else
            return NULL;
          #endif
        }
 
        return reinterpret_cast<rti::flat::Sample<OffsetType> *>(buffer);
    }
 
    static void delete_data(rti::flat::Sample<OffsetType>* sample)
    {
        RTIXCdrFlatData_deleteSample(sample);
    }
 
    offset_t buffer_size() const
    {
        return sample_size() + RTI_XCDR_ENCAPSULATION_SIZE;
    }
 
    offset_t sample_size() const
    {
        return sample_size_impl(typename OffsetType::offset_kind());
    }
 
private:
    offset_t sample_size_impl(fixed_size_type_tag_t) const
    {
        return OffsetType::serialized_size(0);
    }
 
    offset_t sample_size_impl(variable_size_type_tag_t) const
    {
        return RTIXCdrFlatSample_getMutableSampleSize(
                get_buffer(),
                RTI_XCDR_ENCAPSULATION_SIZE);
    }
 
    Offset root_impl(fixed_size_type_tag_t)
    {
        return Offset(this, RTI_XCDR_ENCAPSULATION_SIZE); 
    }
 
    Offset root_impl(variable_size_type_tag_t)
    {
        return Offset(this, RTI_XCDR_ENCAPSULATION_SIZE, sample_size()); 
    }
 
    ConstOffset root_impl(fixed_size_type_tag_t) const
    {
        return ConstOffset(this, RTI_XCDR_ENCAPSULATION_SIZE); 
    }
 
    ConstOffset root_impl(variable_size_type_tag_t) const
    {
        return ConstOffset(this, RTI_XCDR_ENCAPSULATION_SIZE, sample_size()); 
    }
};
 
template <typename T>
struct flat_type_traits;
 
} }
 
#ifdef DOXYGEN_DOCUMENTATION_ONLY
 
typedef rti::flat::Sample<MyFlatFinalOffset> MyFlatFinal;
 
typedef rti::flat::Sample<MyFlatMutableOffset> MyFlatMutable;
 
typedef rti::flat::Sample<MyFlatUnionOffset> MyFlatUnion;
#endif
 
#endif // RTI_DDS_FLAT_FLATSAMPLE_HPP_