Offset.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_FLATOFFSETS_HPP_
#define RTI_DDS_FLAT_FLATOFFSETS_HPP_

#include "xcdr/xcdr_stream.h"
#include "xcdr/xcdr_stream_impl.h"
#include "xcdr/xcdr_interpreter.h"

#include "rti/xcdr/Stream.hpp"

#ifdef DOXYGEN_DOCUMENTATION_ONLY

class MyFlatFinalOffset : public rti::flat::FinalOffset<MyFlatFinalOffset> {
  public:
    typedef MyFlatFinalConstOffset ConstOffset;

    MyFlatFinalOffset()
    {
    }

    int32_t my_primitive() const; 

    FlatFinalBar::ConstOffset my_complex() const; 

    const rti::flat::PrimitiveArrayOffset<int32_t, 10> my_primitive_array() const; 

    rti::flat::FinalArrayOffset<FlatFinalBar::ConstOffset, 10> my_complex_array() const; 

    bool my_primitive(int32_t value);

    FlatFinalBar::Offset my_complex(); 

    rti::flat::PrimitiveArrayOffset<int32_t, 10> my_primitive_array(); 

    rti::flat::FinalArrayOffset<FlatFinalBar::Offset, 10> my_complex_array(); 
};

class NDDSUSERDllExport MyFlatMutableOffset : public rti::flat::MutableOffset {
  public:
    typedef MyFlatMutableConstOffset ConstOffset;

    MyFlatMutableOffset()
    {
    }

    int32_t my_primitive() const;

    rti::flat::PrimitiveConstOffset<int32_t> my_optional_primitive() const; 

    const rti::flat::PrimitiveArrayOffset<int32_t, 10> my_primitive_array() const; 

    const rti::flat::PrimitiveSequenceOffset<int32_t> my_primitive_seq() const;

    MyFlatFinal::ConstOffset my_final() const; 

    rti::flat::FinalAlignedArrayOffset<MyFlatFinal::ConstOffset, 10> my_final_array() const;

    rti::flat::SequenceOffset<MyFlatFinal::ConstOffset> my_final_seq() const; 

    FlatMutableBar::ConstOffset my_mutable() const; 

    rti::flat::MutableArrayOffset<FlatMutableBar::ConstOffset, 10> my_mutable_array() const; 

    rti::flat::SequenceOffset<FlatMutableBar::ConstOffset> my_mutable_seq() const; 

    const rti::flat::StringOffset my_string() const; 

    rti::flat::SequenceOffset<const rti::flat::StringOffset> my_string_seq() const; 

    bool my_primitive(int32_t value);

    /* @brief Retrieves a non-const Offset to an optional primitive
     * 
     * Unlike the non-optional my_primitive(), which allows accessing the integer 
     * directly, an optional primitive may not exist. If it doesn't, the Offset 
     * this function returns will be null (\p is_null()).
     */
    rti::flat::PrimitiveOffset<int32_t> my_optional_primitive();

    rti::flat::PrimitiveArrayOffset<int32_t, 10> my_primitive_array(); 

    rti::flat::PrimitiveSequenceOffset<int32_t> my_primitive_seq(); 

    MyFlatFinal::Offset my_final(); 

    rti::flat::FinalAlignedArrayOffset<MyFlatFinal::Offset, 10> my_final_array(); 

    rti::flat::SequenceOffset<MyFlatFinal::Offset> my_final_seq(); 

    FlatMutableBar::Offset my_mutable(); 

    rti::flat::MutableArrayOffset<FlatMutableBar::Offset, 10> my_mutable_array(); 

    rti::flat::SequenceOffset<FlatMutableBar::Offset> my_mutable_seq(); 

    rti::flat::StringOffset my_string(); 

    rti::flat::SequenceOffset<rti::flat::StringOffset> my_string_seq(); 
};

class NDDSUSERDllExport MyFlatUnionOffset 
: public rti::flat::MutableOffset {
  public:
    typedef MyFlatUnionConstOffset ConstOffset;

    MyFlatUnionOffset()
    {
    }

    int32_t _d() const;

    int32_t my_primitive() const; 

    MyFlatMutable::ConstOffset my_mutable() const; 

    MyFlatFinal::ConstOffset my_final() const; 

    bool my_primitive(int32_t value);

    MyFlatMutable::Offset my_mutable(); 

    MyFlatFinal::Offset my_final(); 
};

#endif

namespace rti { namespace flat {

namespace detail {

inline rti::flat::offset_t ptrdiff(unsigned char *a, unsigned char *b)
{
    RTI_FLAT_ASSERT(a - b < RTI_XCDR_MAX_SERIALIZED_SIZE, return 0);

    return static_cast<rti::flat::offset_t>(a - b);
}

}

// Forward declaration
template <typename T, unsigned int N>
class FinalArrayOffset;

class OffsetBase {
public:

    bool is_null() const
    {
        return sample_ == NULL;
    }

    bool is_cpp_compatible() const
    {
        // Derived classes may indicate whether
        // a type is cpp-compatible
        return false;
    }

    unsigned char * get_buffer()
    {
        if (is_null()) {
            return NULL;
        }
        return stream_.current_position();
    }

    const unsigned char * get_buffer() const
    {
        if (is_null()) {
            return NULL;
        }
        return stream_.current_position();
    }

    offset_t get_buffer_size() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return 0);
        return stream_.total_size();
    }

    friend bool operator<(
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return s1.get_buffer() < s2.get_buffer();
    }

    friend bool operator > (
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return s1.get_buffer() > s2.get_buffer();
    }

    friend bool operator <= (
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return s1.get_buffer() <= s2.get_buffer();
    }

    friend bool operator >= (
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return s1.get_buffer() >= s2.get_buffer();
    }

    friend bool operator == (
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return s1.get_buffer() == s2.get_buffer();
    }

    friend bool operator != (
            const OffsetBase & s1,
            const OffsetBase & s2) {
        return !(s1 == s2);
    }

protected:

    OffsetBase() : 
            sample_(NULL), 
            absolute_offset_(0)
    {
    }

    OffsetBase(
            SampleBase *sample, 
            offset_t absolute_offset, 
            offset_t serialized_size) 
        : sample_(sample), 
          absolute_offset_(absolute_offset)
    {
        // In modern C++ this throws PreconditionNotMetError; in traditional
        // C++, this ends the constructor leaving the object in a state such
        // that is_null() is true.
        RTI_FLAT_CHECK_PRECONDITION(sample != NULL, return);

        sample_->initialize_stream(
                stream_.c_stream(), 
                absolute_offset_, 
                serialized_size);
    }

    // Gets the value of a primitive member at the specified relative Offset
    template <typename U>
    U deserialize(offset_t member_offset) const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return U());
        RTI_FLAT_ASSERT(stream_.check_size(member_offset + static_cast<offset_t>(sizeof(U))), return U());

        rti::xcdr::Stream::Memento stream_memento(stream_);
        stream_.skip_fast(member_offset);
        return stream_.deserialize_fast<U>();
    }

    // Sets the value of a primitive member at the specified relative Offset
    template <typename U>
    bool serialize(offset_t member_offset, U value)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        RTI_FLAT_ASSERT(stream_.check_size(member_offset + static_cast<offset_t>(sizeof(U))), return false);

        rti::xcdr::Stream::Memento stream_memento(stream_);

        stream_.skip_fast(member_offset);
        stream_.serialize_fast<U>(value);
        return true;
    }

    // Obtains a member at the specified relative offset
    //
    // U is the type of the member. U must be a subclass of Offset<U>.
    template <typename U>
    U get_member(offset_t relative_member_offset)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return U());

        return U(
            sample_,
            // the absolute location of the member:
            absolute_offset_ + relative_member_offset);
    }

    template <typename U>
    U get_member(offset_t relative_member_offset) const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return U());

        return U(
            sample_,
            // the absolute location of the member:
            absolute_offset_ + relative_member_offset);
    }

protected:
    SampleBase *sample_; // the actual CDR buffer is in the sample

    offset_t absolute_offset_; // the position of this Offset in the buffer
    mutable rti::xcdr::Stream stream_; // a substream that shares the same buffer
};

template <typename T>
class FinalOffset : public OffsetBase {
public:
    typedef fixed_size_type_tag_t offset_kind;

    static offset_t serialized_size_w_padding()
    {
        RTI_FLAT_ASSERT(T::serialized_size(0) > 0, return 0);
        RTI_FLAT_ASSERT(T::required_alignment > 0, return 0);

        const offset_t element_size = T::serialized_size(0);
        if (element_size % T::required_alignment != 0) {
           return element_size + T::required_alignment 
                    - element_size % T::required_alignment;
        } else {
            return element_size;
        }
    }

    bool is_cpp_compatible() const // override
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        return !stream_.needs_byte_swap() 
                && rti::xcdr::has_cpp_friendly_cdr_layout<
                        typename rti::flat::flat_type_traits<T>::flat_type>();
    }

protected:
    FinalOffset()
    {
    }

    // Creates an Offset within the sample's CDR  buffer at the specified 
    // absolute offset
    //
    // This overload requires T::serialized_size(offset_t)
    //
    FinalOffset(SampleBase *sample, offset_t absolute_offset)
        : OffsetBase(
                sample, 
                absolute_offset, 
                T::serialized_size(absolute_offset))
    {
    }

    // Gets the value of a primitive member at the specified relative offset
    // relative_member_offsets - the 4 possible offsets depending on the this
    // type's initial alignment
    template <typename U>
    U deserialize(const offset_t *relative_member_offsets) const
    {
        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return U());

        // In a FinalOffset the stream is guaranteed to have enough space to
        // contain all its members. There are two possible cases:
        // 
        // - If the FinalOffset is a member of a mutable type, the member getter
        // will ensure that the stream has enough space for the whole final 
        // type. 
        //
        // - If the final offset is a top-level type, the type plugin ensures
        // that the serialized buffer is large enough to contain the type.

        return OffsetBase::deserialize<U>(
                // pick the right offset based on the initial alignment
                get_value_for_alignment(relative_member_offsets));
    }

    // Sets the value of a primitive member at the specified relative offset
    template <typename U>
    bool serialize(const offset_t *relative_member_offsets, U value)
    {
        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return false);

        return OffsetBase::serialize<U>(
                // pick the right offset based on the initial alignment
                get_value_for_alignment(relative_member_offsets), value);
    }


    // Obtains a member at the specified relative offset
    //
    // U is the type of the member. U must be a subclass of Offset<U>.
    template <typename U>
    U get_member(const offset_t *relative_member_offsets)
    {
        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return U());

        return OffsetBase::get_member<U>(
                get_value_for_alignment(relative_member_offsets));
    }

    template <typename U>
    U get_member(const offset_t *relative_member_offsets) const
    {
        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return U());

        return OffsetBase::get_member<U>(
                get_value_for_alignment(relative_member_offsets));
    }

    // Returns an FinalArrayOffset located within this Offset
    template <typename U, unsigned int N>
    FinalArrayOffset<U, N> get_array_member(
        const offset_t *relative_member_offsets, 
        const offset_t *first_element_sizes, 
        offset_t element_size)
    {
        typedef FinalArrayOffset<U, N> ArrayType;

        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return ArrayType());
        RTI_FLAT_ASSERT(first_element_sizes != NULL, return ArrayType());

        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ArrayType());

        return ArrayType(
            sample_,
            // the absolute location of the member:
            absolute_offset_ + get_value_for_alignment(relative_member_offsets),
            // the size of the first element, which can differ from the rest
            get_value_for_alignment(first_element_sizes),
            // the size of every other element
            element_size);
    }

    template <typename U, unsigned int N>
    FinalArrayOffset<U, N> get_array_member(
        const offset_t *relative_member_offsets, 
        const offset_t *first_element_sizes, 
        offset_t element_size) const
    {
        typedef FinalArrayOffset<U, N> ArrayType;

        RTI_FLAT_ASSERT(relative_member_offsets != NULL, return ArrayType());
        RTI_FLAT_ASSERT(first_element_sizes != NULL, return ArrayType());

        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ArrayType());
        return ArrayType(
            sample_,
            // the absolute location of the member:
            absolute_offset_ + get_value_for_alignment(relative_member_offsets),
            // the size of the first element, which can differ from the rest
            get_value_for_alignment(first_element_sizes),
            // the size of every other element
            element_size);
    }

private:
    // A member's relative offset or an array's first element size
    // may be different depending on the alignment of the position in the CDR
    // buffer of the type that contains them (this). These values are passed 
    // to get_member or get_array_member as an array of 4 possible values. This
    // function picks the right one based on the alingmenet of absolute_offset_
    offset_t get_value_for_alignment(const offset_t *values_per_alignment) const
    {
        return values_per_alignment[absolute_offset_ % 4];
    }    
};

struct MutableOffsetHelper {
    // Obtains the size of a mutable struct located at the absolute_offset of
    // a FlatData sample
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t)
    {
        RTI_FLAT_ASSERT(sample != NULL, return 0);

        return RTIXCdrFlatSample_getMutableSampleSize(
                sample->get_buffer(),
                absolute_offset);
    }
};

class MutableOffset : public OffsetBase {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef MutableOffsetHelper Helper;

protected:
    MutableOffset()
    {
    }

    MutableOffset(
            SampleBase *sample, 
            offset_t absolute_offset, 
            offset_t serialized_size)
        : OffsetBase(
                sample, 
                absolute_offset, 
                serialized_size)
    {
    }

    template <typename U>
    U deserialize(member_id_t member_id, U default_val = U()) const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return U());

        rti::xcdr::Stream::Memento stream_memento(stream_);

        offset_t member_size = 0;
        if (!RTIXCdrStream_findV2MutableSampleMember(
                &stream_.c_stream(),
                member_id,
                &member_size)) {
            return default_val;
        }

        return stream_.deserialize_fast<U>();
    }

    // Sets the value of a primitive member at the specified relative offset
    template <typename U>
    bool serialize(member_id_t member_id, U value)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);

        rti::xcdr::Stream::Memento stream_memento(stream_);

        offset_t member_size = 0;
        if (!RTIXCdrStream_findV2MutableSampleMember(
                &stream_.c_stream(),
                member_id,
                &member_size)) {
            return false;
        }

        stream_.serialize_fast<U>(value);
        return true;
    }

    template <typename U>
    U get_member(member_id_t member_id) const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return U());

        rti::xcdr::Stream::Memento stream_memento(stream_);

        offset_t member_size = 0;
        if (!RTIXCdrStream_findV2MutableSampleMember(
                &stream_.c_stream(),
                member_id,
                &member_size)) {
            return U();
        }

        return get_member_impl<U>(
                // absolute offset to the found member
                detail::ptrdiff(stream_.current_position(), sample_->get_buffer()),
                member_size,
                typename U::offset_kind());
    }

private:
    template <typename U>
    U get_member_impl(
        offset_t absolute_member_offset, 
        offset_t member_size,
        variable_size_type_tag_t) const
    {
        RTI_FLAT_ASSERT(absolute_member_offset > 0, return U());

        // VariableOffsets receive a member_size
        return U(sample_, absolute_member_offset, member_size);
    }

    template <typename U>
    U get_member_impl(
        offset_t absolute_member_offset, 
        offset_t member_size,
        fixed_size_type_tag_t) const
    {
        (void) member_size; // supress unused-param warning in release mode
        
        RTI_FLAT_ASSERT(absolute_member_offset > 0, return U());
        RTI_FLAT_ASSERT(member_size == U::serialized_size(0), return U());
        
        // FixedOffsets do not receive a member_size (it's already known)
        return U(sample_, absolute_member_offset);
    }
};

template <typename T>
struct PrimitiveConstOffset : public OffsetBase {
public:
    typedef fixed_size_type_tag_t offset_kind;

    PrimitiveConstOffset()
    {
    }

    PrimitiveConstOffset(
            SampleBase *sample, 
            offset_t absolute_offset)
        : OffsetBase(
                sample, 
                absolute_offset, 
                serialized_size(0))
    {
    }

    bool is_cpp_compatible() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        return sizeof(T) == 1 || !stream_.needs_byte_swap();
    }    

    T get() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return T());
        RTI_FLAT_ASSERT(stream_.check_size(sizeof(T)), return T());

        return stream_.deserialize_fast<T>();
    }

    static offset_t serialized_size(offset_t)
    {
        return sizeof(T);
    }

    static offset_t serialized_size_w_padding()
    {
        return serialized_size(0);
    }

};

template <typename T>
struct PrimitiveOffset : public PrimitiveConstOffset<T> {
public:
    PrimitiveOffset()
    {
    }

    PrimitiveOffset(
            SampleBase *sample, 
            offset_t absolute_offset)
        : PrimitiveConstOffset<T>(
                sample,
                absolute_offset)
    {
    }

    bool set(T value)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return false);
        RTI_FLAT_ASSERT(this->stream_.check_size(sizeof(T)), return false);

        this->stream_.template serialize_fast<T>(value);
        return true;
    }
};

} }

#endif // RTI_DDS_FLAT_FLATOFFSETS_HPP_