SequenceOffsets.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_SEQUENCEOFFSETS_HPP_
#define RTI_DDS_FLAT_SEQUENCEOFFSETS_HPP_

#include "rti/flat/Offset.hpp"
#include "rti/flat/SequenceIterator.hpp"

namespace rti { namespace flat {

template <typename T>
class AbstractPrimitiveList : public OffsetBase {
public:
    typedef T value_type;

protected:
    AbstractPrimitiveList()
    {
    }

    AbstractPrimitiveList(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : OffsetBase(sample, offset, sequence_size)
    {
    }

public:

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


    /*@private
     * @brief Gets direct access to the elements
     *
     * Returns a pointer to the elements of this sequence.
     *
     * @note If the Sample that contains this PrimitiveSequenceOffset has an endianess
     * different from the native one, the element bytes may be swapped. This can
     * happen if this Sample was published by a DataWriter running on a platform
     * with a different endianess and received by a DataReader running locally.
     *
     * This function is not for public use. See rti::flat::plain_cast() instead.
     */
    T * get_elements()
    {
        return reinterpret_cast<T*>(this->get_buffer());
    }

    /*@private
     * @brief Gets direct access to the array elements
     *
     * (Const overload)
     */
    const T * get_elements() const
    {
        return reinterpret_cast<const T*>(this->get_buffer());
    }

    T get_element(unsigned int i) const
    {
        // OffsetBase::serialize only checks this as a debug assertion; in
        // a sequence or array we need to do it in release mode too
        if (!stream_.check_size((i + 1) * ((unsigned int) sizeof(T)))) {
            return T();
        }

        return OffsetBase::template deserialize<T>(i * (unsigned int) sizeof(T));
    }

    bool set_element(unsigned int i, T value)
    {
        // OffsetBase::serialize only checks this as a debug assertion; in
        // a sequence or array we need to do it in release mode too
        if (!stream_.check_size((i + 1) * static_cast<unsigned int>(sizeof(T)))) {
            return false;
        }

        return OffsetBase::serialize(i * static_cast<unsigned int>(sizeof(T)), value);
    }
};

template <typename T>
struct PrimitiveSequenceOffsetHelper;

template <typename T>
class PrimitiveSequenceOffset : public AbstractPrimitiveList<T> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef PrimitiveSequenceOffsetHelper<T> Helper;

    PrimitiveSequenceOffset() : element_count_(0)
    {
    }

    PrimitiveSequenceOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t serialized_size)
        : AbstractPrimitiveList<T>(
                // passing NULL causes the base constructors to fail
                serialized_size >= static_cast<offset_t>(sizeof(rti::xcdr::length_t)) ? sample : NULL,
                offset + static_cast<offset_t>(sizeof(rti::xcdr::length_t)),
                serialized_size - static_cast<offset_t>(sizeof(rti::xcdr::length_t))),
        element_count_(0)
    {
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        if (!this->is_null()) { // without exceptions, we need to check if the base ctor failed
#endif
        rti::xcdr::Stream::Memento stream_memento(this->stream_);
        this->stream_.skip_back(sizeof(rti::xcdr::length_t));
        element_count_ = this->stream_.template deserialize_fast<rti::xcdr::length_t>();
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        }
#endif

    }

    unsigned int element_count() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return 0);

        return element_count_;
    }

private:
    unsigned int element_count_;

};

template <typename T>
struct PrimitiveSequenceOffsetHelper {
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_size)
    {
        RTI_FLAT_ASSERT(sample != NULL, return 0);
        RTI_FLAT_ASSERT(max_size > sizeof(rti::xcdr::length_t), return 0);

        PrimitiveSequenceOffset<T> tmp(sample, absolute_offset, max_size);

        // elements + header
        if ((RTIXCdrUnsignedLong_MAX
                - static_cast<unsigned int>(sizeof(rti::xcdr::length_t)))
                / static_cast<unsigned int>(sizeof(T))
                < tmp.element_count()) {
            RTI_FLAT_OFFSET_PRECONDITION_ERROR(
                    "Serialized size of a sequence of primitive elements "
                    "exceeds maximum representable 32-bit unsigned integer.",
                    return 0);
        }
        return (tmp.element_count() * static_cast<unsigned int>(sizeof(T)))
                + static_cast<unsigned int>(sizeof(rti::xcdr::length_t));
    }
};

template <typename T, unsigned int N>
class PrimitiveArrayOffset : public AbstractPrimitiveList<T> {
public:
    typedef fixed_size_type_tag_t offset_kind;

    PrimitiveArrayOffset()
    {
    }

    PrimitiveArrayOffset(rti::flat::SampleBase *sample, offset_t offset)
        : AbstractPrimitiveList<T>(
                sample,
                offset,
                serialized_size(0))
    {
    }

public:

    unsigned int element_count() const
    {
        return N;
    }

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

// Note: the modern C++ API defines a PrimitiveArrayOffset specializations for
// safe_enum and wchar_t

struct StringOffsetHelper;

class StringOffset : public PrimitiveSequenceOffset<char> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef StringOffsetHelper Helper;

    StringOffset()
    {
    }

    StringOffset(
            SampleBase *sample,
            offset_t absolute_offset,
            offset_t serialized_size)
        : PrimitiveSequenceOffset<char>(
                sample,
                absolute_offset,
                serialized_size)
    {
    }

    char * get_string()
    {
        return reinterpret_cast<char*>(this->get_buffer());
    }

    const char * get_string() const
    {
        return reinterpret_cast<const char*>(this->get_buffer());
    }

    unsigned int element_count() const
    {
        RTI_FLAT_ASSERT(PrimitiveSequenceOffset<char>::element_count() > 0, return 0);

        return PrimitiveSequenceOffset<char>::element_count() - 1;
    }
};

struct StringOffsetHelper {
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_size)
    {
        StringOffset tmp(sample, absolute_offset, max_size);
        return tmp.element_count()
            + 1 // null terminator
            + (unsigned int) sizeof(rti::xcdr::length_t); // length header
    }
};

// Wide strings are treated as a sequence of octets
typedef PrimitiveSequenceOffset<unsigned char> WStringOffset;

// The base class of SequenceOffset, and FinalAlignedArrayOffset
//
// This encapsulates the functionality that allows iterating through a list
// of elements (a sequence or an array). The list must be always aligned to 4
// (that excludes FinalArrayOffset)
//
template <typename ElementOffset>
class AbstractAlignedList : public OffsetBase {
public:

    typedef SequenceIterator<ElementOffset, typename ElementOffset::offset_kind>
            iterator;

protected:
    AbstractAlignedList()
    {
    }

    AbstractAlignedList(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : OffsetBase(
                sample,
                offset,
                sequence_size)
    {
    }

public:
    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_collection<
                        typename rti::flat::flat_type_traits<ElementOffset>::flat_type>();
    }

    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        return get_element_impl<ElementOffset>(
                i,
                typename ElementOffset::offset_kind());
    }

    iterator begin()
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return iterator(NULL, 0, 0));

        return iterator(
                sample_,
                absolute_offset_,
                absolute_offset_ + get_buffer_size());
    }

    iterator end()
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return iterator(NULL, 0, 0));

        return iterator(
                sample_,
                absolute_offset_ + get_buffer_size(),
                absolute_offset_ + get_buffer_size());
    }

private:
    // for variable size types we skip element by element
    template <typename E>
    E get_element_impl(unsigned int i, variable_size_type_tag_t)
    {
        iterator it = begin();
        while (it != end() && i > 0) {
            if (!it.advance()) {
                return E();
            }
            i--;
        }

        return *it;
    }

    // for fixed-size types we support random access
    template <typename E>
    E get_element_impl(unsigned int i, fixed_size_type_tag_t)
    {
        offset_t size = i * E::serialized_size_w_padding();

        // Ensure that the stream has space for i + 1 elements
        if (!stream_.check_size(size + E::serialized_size(0))) {
            return E();
        }

        return E(this->sample_, this->absolute_offset_ + size);
    }
};

template <typename ElementOffset>
struct SequenceOffsetHelper;

template <typename ElementOffset>
class SequenceOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef variable_size_type_tag_t offset_kind;
    typedef SequenceOffsetHelper<ElementOffset> Helper;

    SequenceOffset() : element_count_(0)
    {
    }

    SequenceOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : AbstractAlignedList<ElementOffset>(
                // Member size in bytes must be > 4, otherwise let base ctor fail
                sequence_size >= sizeof(rti::xcdr::length_t) ? sample: NULL,
                // The offset begins after any padding to align to 4; padding
                // may be needed for example for an array of sequence of final
                // types; the end position of the previous sequence may not be
                // aligned
                RTIXCdrAlignment_alignSizeUp(offset, RTI_XCDR_SEQ_LENGTH_ALIGNMENT)
                        + static_cast<offset_t>(sizeof(rti::xcdr::length_t)),
                sequence_size - static_cast<offset_t>(sizeof(rti::xcdr::length_t))),
        element_count_(0)
    {
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        if (!this->is_null()) { // without exceptions, we need to check if the base ctor failed
#endif
        rti::xcdr::Stream::Memento stream_memento(this->stream_);
        this->stream_.skip_back(sizeof(rti::xcdr::length_t));
        element_count_ = this->stream_.template deserialize_fast<rti::xcdr::length_t>();
#ifdef RTI_FLAT_DATA_NO_EXCEPTIONS
        }
#endif
    }

    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= element_count_) {
            return ElementOffset();
        }
        return AbstractAlignedList<ElementOffset>::get_element(i);
    }

    unsigned int element_count() const
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return 0);

        return element_count_;
    }

private:
    unsigned int element_count_;
};

template <typename E>
struct SequenceOffsetHelper {
    // Calculates the serialized size of a Sequence by skipping each element
    static offset_t calculate_serialized_size(
            rti::flat::SampleBase *sample,
            offset_t absolute_offset,
            offset_t max_offset)
    {
        // Create a SequenceOffset beginning at sample + absolute_offset,
        // with a size we don't know, but no greater than
        // max_offset - absolute_offset
        SequenceOffset<E> tmp(
                sample,
                absolute_offset,
                max_offset - absolute_offset);
        unsigned int count = tmp.element_count();
        typename SequenceOffset<E>::iterator it = tmp.begin();
        for (unsigned int i = 0; i < count; i++) {
            if (!it.advance()) {
                return 0; // error
            }
        }

        return detail::ptrdiff(it.get_position(), sample->get_buffer())
                - absolute_offset;
    }
};

template <typename ElementOffset, unsigned int N>
class MutableArrayOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef variable_size_type_tag_t offset_kind;

    MutableArrayOffset()
    {
    }

    MutableArrayOffset(
            rti::flat::SampleBase *sample,
            offset_t offset,
            offset_t sequence_size)
        : AbstractAlignedList<ElementOffset>(
                sample,
                offset,
                sequence_size)
    {
    }

    ElementOffset get_element(unsigned int i)
    {
        if (i >= N) {
            return ElementOffset();
        }

        return AbstractAlignedList<ElementOffset>::get_element(i);
    }
};

template <typename ElementOffset, unsigned int N>
class FinalArrayOffset : public OffsetBase {
public:
    typedef fixed_size_type_tag_t offset_kind;

    FinalArrayOffset()
    {
    }

    // Constructor used when this array is part of a fixed-size type, and
    // therefore it's initial alignment is not known ahead of time
    FinalArrayOffset(
        rti::flat::SampleBase *sample,
        offset_t absolute_offset,
        offset_t first_element_size,
        offset_t element_size)
        : OffsetBase(
                sample,
                absolute_offset,
                first_element_size + element_size * (N - 1)),
          first_element_size_(first_element_size),
          element_size_(element_size)
    {
    }

    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= N) {
            return ElementOffset(); // null offset
        }

        offset_t element_offset = this->absolute_offset_;
        if (i > 0) {
            element_offset += this->first_element_size_
                + (i - 1) * this->element_size_;
        }

        return ElementOffset(this->sample_, element_offset);
    }

private:
    offset_t first_element_size_;
    offset_t element_size_;
};

template <typename ElementOffset, unsigned int N>
class FinalAlignedArrayOffset : public AbstractAlignedList<ElementOffset> {
public:
    typedef fixed_size_type_tag_t offset_kind;

    FinalAlignedArrayOffset()
    {
    }

    // Constructor used when this array is part of a mutable type, and
    // therefore it's aligned to 4 always
    FinalAlignedArrayOffset(
        rti::flat::SampleBase *sample,
        offset_t absolute_offset)
        : AbstractAlignedList<ElementOffset>(
                sample,
                absolute_offset,
                serialized_size(0))
    {
    }

    // serialized_size() only works when this array is part of a mutable type
    // and we know it's aligned to 4
    static offset_t serialized_size(offset_t)
    {
        // [element1][pad][element2][pad]...[elementN]
        return ElementOffset::serialized_size_w_padding() * (N - 1)
                + ElementOffset::serialized_size(0);
    }

    ElementOffset get_element(unsigned int i)
    {
        RTI_FLAT_OFFSET_CHECK_NOT_NULL(return ElementOffset());

        if (i >= N) {
            return ElementOffset();
        }

        return AbstractAlignedList<ElementOffset>::get_element(i);
    }
};

} }

#endif // RTI_DDS_FLAT_SEQUENCEOFFSETS_HPP_