| /* ----------------------------------------------------------------------- *//** |
| * |
| * @file DynamicStruct_proto.hpp |
| * |
| *//* ----------------------------------------------------------------------- */ |
| |
| #ifndef MADLIB_DBAL_DYNAMICSTRUCT_PROTO_HPP |
| #define MADLIB_DBAL_DYNAMICSTRUCT_PROTO_HPP |
| |
| namespace madlib { |
| |
| namespace dbal { |
| |
| template < |
| class Storage, |
| template <class T> class TypeTraits> |
| class DynamicStructRootContainer { |
| public: |
| typedef ByteStreamHandleBuf<Storage> StreamBuf_type; |
| typedef typename StreamBuf_type::Storage_type Storage_type; |
| typedef ByteStream<StreamBuf_type, TypeTraits> ByteStream_type; |
| enum { isMutable = Storage_type::isMutable }; |
| |
| DynamicStructRootContainer(const Storage_type& inStorage); |
| const StreamBuf_type& streambuf() const; |
| StreamBuf_type& streambuf(); |
| |
| protected: |
| StreamBuf_type mByteStreamBuf; |
| }; |
| |
| template <class Derived, class Container, bool IsMutable = Container::isMutable> |
| class DynamicStructBase { |
| public: |
| typedef Container Container_type; |
| typedef typename Container_type::RootContainer_type RootContainer_type; |
| typedef typename Container_type::Storage_type Storage_type; |
| typedef typename Container_type::ByteStream_type ByteStream_type; |
| typedef Container_type Init_type; |
| |
| DynamicStructBase(Init_type& inContainer); |
| void initialize(); |
| void rebindAll(); |
| const RootContainer_type& rootContainer() const; |
| |
| protected: |
| Container_type& mContainer; |
| }; |
| |
| template <class Derived, class Container> |
| class DynamicStructBase<Derived, Container, Mutable> |
| : public DynamicStructBase<Derived, Container, Immutable> { |
| public: |
| typedef DynamicStructBase<Derived, Container, Immutable> Base; |
| typedef typename Base::Init_type Init_type; |
| |
| DynamicStructBase(Init_type& inContainer); |
| |
| protected: |
| template <class SubStruct> void setSize(SubStruct &inSubStruct, size_t inSize); |
| |
| using Base::mContainer; |
| }; |
| |
| template < |
| class Derived, |
| bool IsMutable, |
| class Storage, |
| template <class T> class TypeTraits> |
| class DynamicStructBase<Derived, |
| DynamicStructRootContainer<Storage, TypeTraits>, IsMutable> { |
| public: |
| typedef DynamicStructRootContainer<Storage, TypeTraits> Container_type; |
| typedef Derived RootContainer_type; |
| typedef typename Container_type::Storage_type Storage_type; |
| typedef typename Container_type::ByteStream_type ByteStream_type; |
| typedef const Storage_type Init_type; |
| |
| DynamicStructBase(Init_type& inStorage); |
| void initialize(); |
| void rebindAll(); |
| const RootContainer_type& rootContainer() const; |
| const Storage_type& storage() const; |
| const ByteStream_type& byteStream() const; |
| |
| protected: |
| Container_type mContainer; |
| ByteStream_type mByteStream; |
| }; |
| |
| template < |
| class Derived, |
| class Storage, |
| template <class T> class TypeTraits> |
| class DynamicStructBase<Derived, |
| DynamicStructRootContainer<Storage, TypeTraits>, Mutable> |
| : public DynamicStructBase<Derived, |
| DynamicStructRootContainer<Storage, TypeTraits>, Immutable> { |
| |
| public: |
| typedef DynamicStructBase<Derived, |
| DynamicStructRootContainer<Storage, TypeTraits>, Immutable> Base; |
| typedef typename Base::Container_type Container_type; |
| typedef typename Base::Init_type Init_type; |
| |
| DynamicStructBase(Init_type& inStorage) : Base(inStorage) { } |
| // void initialize(); |
| |
| protected: |
| template <class SubStruct> void setSize(SubStruct &inSubStruct, |
| size_t inSize); |
| |
| using Base::mContainer; |
| using Base::mByteStream; |
| }; |
| |
| |
| 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 |
| * polymorphism) 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> |
| : public DynamicStruct<Derived, Container, Immutable> { |
| |
| public: |
| typedef DynamicStruct<Derived, Container, Immutable> Base; |
| typedef typename Base::Init_type Init_type; |
| typedef typename Base::ByteStream_type ByteStream_type; |
| |
| DynamicStruct(Init_type& inInitialization); |
| |
| using Base::setSize; |
| void setSize(size_t inSize); |
| void resize(); |
| |
| void bindToStream(ByteStream_type& inStream); |
| |
| protected: |
| bool mSizeIsLocked; |
| |
| template <class OtherDerived> DynamicStruct& copy( |
| const OtherDerived &inOtherStruct); |
| }; |
| |
| template <typename T, bool IsMutable> |
| class Ref; |
| |
| namespace eigen_integration { |
| |
| template <class EigenType, class Handle, int MapOptions> |
| class HandleMap; |
| |
| } |
| |
| // Because of its dependencies on Eigen, DynamicStructType is only declared in |
| // DynamicStruct_impl.hpp. |
| template <class T, bool IsMutable> |
| struct DynamicStructType; |
| |
| #define MADLIB_DYNAMIC_STRUCT_TYPEDEFS \ |
| enum { isMutable = Base::isMutable }; \ |
| typedef typename Base::Init_type Init_type; \ |
| typedef typename Base::ByteStream_type ByteStream_type; \ |
| typedef typename Base::Storage_type Storage_type; \ |
| typedef typename DynamicStructType<bool, isMutable>::type bool_type; \ |
| typedef typename DynamicStructType<double, isMutable>::type double_type; \ |
| typedef typename DynamicStructType<float, isMutable>::type float_type; \ |
| typedef typename DynamicStructType<uint64_t, isMutable>::type uint64_type; \ |
| typedef typename DynamicStructType<int64_t, isMutable>::type int64_type; \ |
| typedef typename DynamicStructType<uint32_t, isMutable>::type uint32_type; \ |
| typedef typename DynamicStructType<int32_t, isMutable>::type int32_type; \ |
| typedef typename DynamicStructType<uint16_t, isMutable>::type uint16_type; \ |
| typedef typename DynamicStructType<int16_t, isMutable>::type int16_type; \ |
| typedef typename DynamicStructType<ColumnVector, isMutable>::type \ |
| ColumnVector_type; \ |
| typedef typename DynamicStructType<IntegerVector, isMutable>::type \ |
| IntegerVector_type; \ |
| typedef typename DynamicStructType<Matrix, isMutable>::type Matrix_type |
| |
| |
| } // namespace dbal |
| |
| } // namespace madlib |
| |
| #endif // defined(MADLIB_DBAL_DYNAMICSTRUCT_PROTO_HPP) |