Class DynamicStruct

src/dbal/DynamicStruct_proto.hpp:119–168

template <class Derived, class Container, bool IsMutable = Container::isMutable>
class DynamicStruct
  : public DynamicStructBase<Derived, Container, Container::isMutable> {

public:
    typedef DynamicStructBase<Derived, Container> Base;
    typedef typename Base::Storage_type Storage_type;
    typedef typename Base::Container_type Container_type;
    typedef typename Base::RootContainer_type RootContainer_type;
    typedef typename Base::ByteStream_type ByteStream_type;
    typedef typename Base::Init_type Init_type;
    typedef typename ByteStream_type::char_type char_type;
    enum { isMutable = Container_type::isMutable };

    DynamicStruct(Init_type& inInitialization);

    using Base::rootContainer;
    RootContainer_type& rootContainer();
    using Base::storage;
    Storage_type& storage();
    using Base::byteStream;
    ByteStream_type& byteStream();

    size_t begin() const;
    size_t end() const;
    const char_type* ptr() const;
    char_type* ptr();
    size_t size() const;

    void bindToStream(ByteStream_type& inStream);

    /**
     * @brief Bind a DynamicStruct object to the current position in the stream
     *
     * The following idiom (in-class friend function together with static
     * polymorphicsm) is called the "Barton-Nackman trick". Essentially, we only
     * make operator>> visible if type Derived is involved.
     *
     * Subclasses have to implement the bind() function.
     */
    friend
    ByteStream_type&
    operator>>(ByteStream_type& inStream, Derived& inStruct) {
        inStruct.bindToStream(inStream);
        return inStream;
    }

protected:
    size_t mBegin;
    size_t mEnd;
};

template <class Derived, class Container>
class DynamicStruct<Derived, Container, Mutable>