memory_layout.hh

Go to the documentation of this file.

#ifndef TYPELIB_MEMORY_LAYOUT_HH
#define TYPELIB_MEMORY_LAYOUT_HH

#include <stdexcept>
#include <typelib/typevisitor.hh>
#include <vector>
#include <boost/static_assert.hpp>

namespace Typelib
{
    struct NoLayout : public std::runtime_error
    { 
        NoLayout(Type const& type, std::string const& reason)
            : std::runtime_error("there is no memory layout for type " + type.getName() + ": " + reason) { }
    };

    struct UnknownLayoutBytecode : public std::runtime_error
    { 
        UnknownLayoutBytecode() : std::runtime_error("found an unknown marshalling bytecode operation") { }
    };

    // This is needed because the FLAG_CONTAINER descriptor is followed by a
    // pointer on a Container instance
    BOOST_STATIC_ASSERT((sizeof(size_t) == sizeof(void*)));

    typedef std::vector<size_t> MemoryLayout;

    namespace MemLayout
    {
        enum Operations {
            FLAG_MEMCPY,
            FLAG_ARRAY,
            FLAG_CONTAINER,
            FLAG_SKIP,
            FLAG_END
        };

        class Visitor : public TypeVisitor
        {
        private:
            MemoryLayout& ops;
            bool   accept_pointers;
            bool   accept_opaques;
            size_t current_op;
            size_t current_op_count;
            bool merge_skip_copy;

        protected:
            void push_current_op();
            void skip(size_t count);
            void memcpy(size_t count);
            void add_generic_op(size_t op, size_t count);
            bool generic_visit(Type const& value);
            bool visit_ (Numeric const& type);
            bool visit_ (Enum    const& type);
            bool visit_ (Array   const& type);
            bool visit_ (Container const& type);
            bool visit_ (Compound const& type);
            bool visit_ (Pointer const& type);
            bool visit_ (OpaqueType const& type);

            void merge_skips_and_copies();

        public:
            Visitor(MemoryLayout& ops, bool accept_pointers = false, bool accept_opaques = false);

            void apply(Type const& type, bool merge_skip_copy = true, bool remove_trailing_skips = true);
        };

        MemoryLayout::const_iterator skip_block(
                MemoryLayout::const_iterator begin,
                MemoryLayout::const_iterator end);
    }

    inline MemoryLayout layout_of(Type const& t, bool accept_pointers = false, bool accept_opaques = false, bool merge_skip_copy = true, bool remove_trailing_skips = true)
    {
        MemoryLayout ret;
        MemLayout::Visitor visitor(ret, accept_pointers, accept_opaques);
        visitor.apply(t, merge_skip_copy, remove_trailing_skips);
        return ret;
    }
}

#endif