lazyload.h

Go to the documentation of this file.

#ifndef EBML_NG_LAZYLOADMASTERELEMENT_H
#define EBML_NG_LAZYLOADMASTERELEMENT_H

#include <unordered_map>
#include <map>
#include <unordered_set>
#include <mutex>
#include <shared_mutex>

#include "base/ebmlMasterElement.h"
#include "base/ebmlMasterElementClass.h"
#include "../ptrs.h"
#include "../seekdata.h"
#include "../exceptions.h"
#include "../ebmlDataElement.h"


namespace ebml {
    typedef std::map<off_t, std::unique_ptr<seekData_t>> children_m;

    template<typename T>
    class status_t {
    protected:
        bool result;
        union {
            std::string reason;
        };
        T _data;

    public:
        status_t(bool);
        status_t(bool, const T&);
        status_t(bool, T&&);

        // template<typename... Args>
        // status_t(bool, Args...);

        status_t(bool, const std::string&);
        status_t(bool, std::string&&);
        status_t(bool, const char*);

        status_t(bool, const std::string&, const T&);
        status_t(bool, const char*, const T&);
        status_t(bool, std::string&&, T&&);
        status_t(bool, const char*, T&&);

        // template<typename... Args>
        // status_t(bool, const std::string&, Args...);

        // template<typename... Args>
        // status_t(bool, std::string&&, Args...);

        status_t(const status_t&);Can padding for AFO br
        status_t(status_t&&);
        ~status_t();

        status_t& operator=(const status_t&);
        status_t& operator=(status_t&&);

        operator bool() const;
        operator const T&() const;
        const T& data() const;
        operator std::string() const;
        void throw_exc(const c_ebmlElement_sp&) const;
    };

    class prepared_base_t {
    protected:
        bool result;
        union {
            std::string reason;
        };

    public:
        prepared_base_t(bool);
        prepared_base_t(bool, const std::string&);
        prepared_base_t(bool, std::string&&);
        prepared_base_t(const prepared_base_t&);
        prepared_base_t(prepared_base_t&&);

        virtual ~prepared_base_t();

        prepared_base_t& operator=(const prepared_base_t&);
        prepared_base_t& operator=(prepared_base_t&&);

        operator bool() const;
    };

    class prepared_insert_t {
    public:
        off_t prevOffset;
        off_t prevEnd;
        off_t offset;
        off_t endOffset;
        off_t nextOffset;
        sizetree_t sizetree;
        children_m::iterator insertionHint;

        prepared_insert_t(off_t, off_t, off_t, off_t, off_t, const sizetree_t&, const children_m::iterator&);
        prepared_insert_t(off_t, off_t, off_t, off_t, off_t, sizetree_t&&, children_m::iterator&&);
        prepared_insert_t(off_t, off_t, off_t, off_t, off_t);
        // ~prepared_insert_t();

        prepared_insert_t(const prepared_insert_t&);
        prepared_insert_t(prepared_insert_t&&);

        prepared_insert_t& operator=(const prepared_insert_t&);
        prepared_insert_t& operator=(prepared_insert_t&&);

        void throw_exc(const std::string&, const c_ebmlElement_sp&) const;
        // operator ebmlInsertionError() const;
    };

    class prepared_move_t : public prepared_base_t {
    public:
        off_t srcPrevEnd;
        off_t srcOffset;
        off_t srcNextOffset;

        off_t prevOffset;
        off_t prevEnd;

        off_t dest_offset;
        off_t endOffset;

        off_t nextOffset;
        children_m::iterator sourceIter;
        children_m::iterator insertionHint;

        prepared_move_t(bool, off_t, off_t, off_t, off_t, off_t, off_t, off_t, off_t, const children_m::iterator&, const children_m::iterator&);
        prepared_move_t(bool, off_t, off_t, off_t, off_t, off_t, off_t, off_t, off_t, children_m::iterator&&, children_m::iterator&&);
        prepared_move_t(bool, const std::string&, off_t, off_t, off_t, off_t, off_t, off_t, off_t, off_t);
        prepared_move_t(bool, std::string&&, off_t, off_t, off_t, off_t, off_t, off_t, off_t, off_t);
        // ~prepared_move_t();

        prepared_move_t(const prepared_move_t&);
        prepared_move_t(prepared_move_t&&);

        prepared_move_t& operator=(const prepared_move_t&);
        prepared_move_t& operator=(prepared_move_t&&);

        operator ebmlMoveError() const;
    };

    class prepared_resize_t : public prepared_base_t {
    public:
        off_t offset;
        off_t endOffset;
        off_t lastChildOffset;
        off_t lastChildEnd;
        off_t nextSiblingOffset;
        seekData_t* seekData;

        prepared_resize_t(bool, off_t, off_t, off_t, off_t, off_t, seekData_t*);
        prepared_resize_t(bool, const std::string&, off_t, off_t, off_t, off_t, off_t);
        prepared_resize_t(bool, std::string&&, off_t, off_t, off_t, off_t, off_t);

        prepared_resize_t(const prepared_resize_t&);
        prepared_resize_t(prepared_resize_t&&);

        prepared_resize_t& operator=(const prepared_move_t&);
        prepared_resize_t& operator=(prepared_resize_t&&);

        operator ebmlResizeError() const;
    };

    class upgradedLock_t {
    private:
        std::unique_lock<std::shared_mutex> _lock;

    public:
        upgradedLock_t(std::shared_lock<std::shared_mutex>&);
        ~upgradedLock_t();
    };

    class localReadLock_t {
    private:
        std::shared_lock<std::shared_mutex> _glob;
        std::shared_lock<std::shared_mutex> _loc;

    public:
        localReadLock_t(std::shared_mutex&, std::shared_mutex&);
        upgradedLock_t upgradeLocal();
        upgradedLock_t upgradeGlobal();
    };

    class localWriteLock_t {
    private:
        std::shared_lock<std::shared_mutex> _glob;
        std::unique_lock<std::shared_mutex> _loc;

    public:
        localWriteLock_t(std::shared_mutex&, std::shared_mutex&);
        upgradedLock_t upgradeGlobal();
    };

    typedef std::unique_lock<std::shared_mutex> globalWriteLock_t;

    class childElemHelper_t {
    // public:
    //     childElemHelper_t();
    //     childElemHelper_t(const childElemHelper_t&);

    protected:
        virtual void _onBeforeInsert(ebmlLazyLoad&, off_t, const ebmlElement_sp&) const;
        virtual void _onAfterInsert(ebmlLazyLoad&, off_t, const ebmlElement_sp&, seekData_t*) const;
        virtual void _onBeforeMove(ebmlLazyLoad&) const;
        virtual void _onAfterMove(ebmlLazyLoad&) const;
        virtual void _onBeforeRemove(ebmlLazyLoad&) const;
        virtual void _onAfterRemove(ebmlLazyLoad&) const;
        friend class ebmlLazyLoad;
    };

    extern childElemHelper_t childHelper;

    class ebmlLazyLoadClass : public ClsMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass> {
    protected:
        const childElemHelper_t* _childHelper = &childHelper;
    public:
        ebmlLazyLoadClass(const char*, const std::wstring&, const childClassSpecArg_l&);
        ebmlLazyLoadClass(ebmlID_t, const std::wstring&, const childClassSpecArg_l&);
        ebmlLazyLoadClass(const char*, const std::wstring&, const childClassSpecArg_l&, const seekHelper_t*);
        ebmlLazyLoadClass(ebmlID_t, const std::wstring&, const childClassSpecArg_l&, const seekHelper_t*);

        ebmlLazyLoadClass(const char*, const std::wstring&, const childClassSpecArg_l&, const childElemHelper_t*);
        ebmlLazyLoadClass(ebmlID_t, const std::wstring&, const childClassSpecArg_l&, const childElemHelper_t*);
        ebmlLazyLoadClass(const char*, const std::wstring&, const childClassSpecArg_l&, const seekHelper_t*, const childElemHelper_t*);
        ebmlLazyLoadClass(ebmlID_t, const std::wstring&, const childClassSpecArg_l&, const seekHelper_t*, const childElemHelper_t*);

    protected:
        // Read existing element in file
        ebmlLazyLoad_sp operator()(ioBase*) const;
        ebmlLazyLoad_sp operator()(ioBase*, off_t) const;

        // Create new element in file
        ebmlLazyLoad_sp operator()(ioBase*, vintWidth_t, size_t) const;
        ebmlLazyLoad_sp operator()(ioBase*, off_t, vintWidth_t, size_t) const;
        // ebmlLazyLoad_sp operator()(ioBase*, vintWidth_t, size_t, const ebmlElement_l&) const;
        ebmlLazyLoad_sp operator()(ioBase*, off_t, vintWidth_t, size_t, const ebmlElement_l&) const;

        ebmlLazyLoad_sp operator()(ebmlLazyLoad*, off_t, vintWidth_t, size_t) const;
        // ebmlLazyLoad_sp operator()(ebmlLazyLoad*, vintWidth_t, size_t, const ebmlElement_l&) const;
        ebmlLazyLoad_sp operator()(ebmlLazyLoad*, off_t, vintWidth_t, size_t, const ebmlElement_l&) const;

        // ebmlElement* _new() const override;
        // ebmlElement_sp _decode(const parseFile&) const override;
        // ebmlElement_sp _cdecode(const parseFile&) const override;

    public:

        // Create new element in parent element
        // ebmlElement_sp operator()(const ebmlElement_sp&, vintWidth_t, size_t) const;
        // ebmlElement_sp operator()(ebmlElement_sp&&, vintWidth_t, size_t) const;
        // ebmlElement_sp operator()(ebmlElement_sp&&, off_t, vintWidth_t, size_t) const;
        friend class ebmlSchema;
        friend class ebmlLazyLoad;
    };

    class ebmlLazyLoad : public InstMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement> {
        friend class ClsMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass>;
        friend class InstMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement>;
        void _clone(const ebmlLazyLoad&);

    protected:
        mutable std::shared_mutex _mutex;
        ioBase_sp _file;
        ioBase* _file_raw = nullptr;
        size_t _dataSize;

        children_m _children_by_offset;
        std::unordered_map<
            ebmlID_t,
            std::map<off_t, seekData_t*>
        > _children_by_ebmlID;
        std::unordered_map<ebmlID_t, std::unique_ptr<seekMapBase>> _children_by_key;

    protected:
        ebmlLazyLoad(const ebmlLazyLoadClass*);
        ebmlLazyLoad(const ebmlLazyLoadClass*, ioBase&, vintWidth_t, size_t);
        ebmlLazyLoad(const ebmlLazyLoadClass*, ioBase&, off_t, vintWidth_t, size_t);
        ebmlLazyLoad(const ebmlLazyLoadClass*, ioBase&, off_t, vintWidth_t, size_t, const ebmlElement_l&);
        // ebmlLazyLoad_sp operator()(ioBase*, vintWidth_t, size_t, const ebmlElement_l&) const;
        ebmlLazyLoad(const ebmlLazyLoadClass*, ebmlLazyLoad&, off_t, vintWidth_t, size_t);
        ebmlLazyLoad(const ebmlLazyLoadClass*, ebmlLazyLoad&, off_t, vintWidth_t, size_t, const ebmlElement_l&);
        // ebmlLazyLoad_sp operator()(ioBase*) const;
        // ebmlLazyLoad_sp operator()(ioBase*, off_t) const;
        //
        // // Create new element in file
        // ebmlLazyLoad_sp operator()(ioBase*, vintWidth_t, size_t) const;
        // ebmlLazyLoad_sp operator()(ioBase*, off_t, vintWidth_t, size_t) const;
        // // ebmlLazyLoad_sp operator()(ioBase*, vintWidth_t, size_t, const ebmlElement_l&) const;
        // ebmlLazyLoad_sp operator()(ioBase*, off_t, vintWidth_t, size_t, const ebmlElement_l&) const;
        //
        // ebmlLazyLoad_sp operator()(ebmlLazyLoad*, off_t, vintWidth_t, size_t) const;
        // // ebmlLazyLoad_sp operator()(ebmlLazyLoad*, vintWidth_t, size_t, const ebmlElement_l&) const;
        // ebmlLazyLoad_sp operator()(ebmlLazyLoad*, off_t, vintWidth_t, size_t, const ebmlElement_l&) const;
        size_t _initNew(ioBase&, off_t, vintWidth_t, size_t);
        // size_t _initNew(ioBase*, off_t, vintWidth_t, size_t, const ebmlElement_l&);

    public:
        const children_m& seeksByOffset() const;
        const std::unordered_map<
                ebmlID_t,
                std::map<off_t, seekData_t*>
            >& seeksByEBMLID() const;
        const std::unordered_map<ebmlID_t, std::unique_ptr<seekMapBase>>& seeksByKey() const;
        ioBase& file() const;
        off_t endOfData() const;

        // Thread safe members
        ebmlElement_sp get(off_t);

        template<typename T>
        ebml::ptr<T> get(off_t);

        ebmlElement_sp get(ebmlID_t, size_t);

        template<typename T>
        ebml::ptr<T> get(ebmlID_t, size_t);

        c_ebmlElement_sp cget(off_t) const;

        template<typename T>
        ebml::ptr<T> cget(off_t) const;

        c_ebmlElement_sp cget(ebmlID_t, size_t) const;

        template<typename T>
        ebml::ptr<T> cget(ebmlID_t, size_t) const;

        template<typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        ebmlElement_sp getByKey(ebmlID_t, const K&);

        template<typename T, typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        std::enable_if_t<!std::is_same<ebmlElement, T>::value && std::is_base_of<ebmlElement, T>::value, ebml::ptr<T>>
        getByKey(ebmlID_t, const K&);

        template<typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        c_ebmlElement_sp cgetByKey(ebmlID_t, const K&) const;

        template<typename T, typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        std::enable_if_t<!std::is_same<const ebmlElement, T>::value && std::is_base_of<const ebmlElement, T>::value, ebml::ptr<T>>
        cgetByKey(ebmlID_t, const K&) const;

        // Insertion functions
        seekData_t* insert(off_t offset, const ebmlElement_sp& child);
        std::vector<seekData_t*> insert(off_t offset, const ebmlElement_l& children);
        seekData_t* insert(off_t offset, const std::string& data);
        std::vector<seekData_t*> insert(off_t offset, const std::vector<std::string>& data);
        seekData_t* insert(off_t offset, const char* data);

        template<typename T, typename... Args>
        std::enable_if_t<std::is_base_of<ebmlElementClass, T>::value, std::pair<ebmlElement_sp, seekData_t*>>
        insert(off_t offset, const T& cls, Args...);

        template<typename T>
        std::enable_if_t<!std::is_base_of<ebmlLazyLoad, T>::value && std::is_base_of<ebmlElement, T>::value, seekData_t*>
        insert(off_t offset, const ebml::ptr<T>& child);

        void move(off_t src_offset, off_t dest_offset);

        void resize(size_t size);

        void remove(const ebmlElement_sp& child);
        void remove(off_t offset);


        // Block boundary functions
        off_t findBoundary(off_t offset);
        off_t rfindBoundary(off_t offset);

        // Child navigation functions
        seekData_t* firstChild();
        seekData_t* lastChild();
        seekData_t* nextChild(off_t offset);
        seekData_t* prevChild(off_t offset);

        // Space management functions
        off_t findFree(off_t offset, size_t size);
        off_t rfindFree(off_t offset, size_t size);

        // Insertion and move check functions
        status_t<prepared_insert_t> canInsert(off_t offset, size_t size);
        status_t<prepared_insert_t> canInsert(off_t offset, const ebmlElement_sp&);
        status_t<prepared_insert_t> canInsert(off_t offset, const ebmlElement_l&);
        status_t<prepared_insert_t> canMove(off_t src_offset, off_t dst_offset);

        // Resize check functions
        status_t<prepared_insert_t> canResize(size_t size);
        // query_t canSetUnknownSize(bool flag);
        status_t<prepared_insert_t> canResizeChild(const seekData_t&, size_t size);
        status_t<prepared_insert_t> canResizeChild(ebmlElement* child, size_t size);

        // Range insertion functions
        status_t<prepared_insert_t> canInsertRange(off_t offset, size_t size);
        status_t<prepared_insert_t> insertRange(off_t offset, size_t size);

        // Range collapse functions
        status_t<prepared_insert_t> canCollapseRange(off_t offset, size_t size);
        status_t<prepared_insert_t> collapseRange(off_t offset, size_t size);

        // Hole punching functions
        status_t<prepared_insert_t> canPunchHole(off_t offset, size_t size);
        status_t<prepared_insert_t> punchHole(off_t offset, size_t size);

        // Members from ebmlElement
        std::wstring minirepr() const override;
        size_t dataSize() const override;
        bool sizeSupported(size_t size);

        // NON-thread safe functions
        // Use only when manually acquiring lock

        // Requires local read lock (getLocalRLock())
        ebmlElement_sp _get(off_t);

        template<typename T>
        ebml::ptr<T> _get(off_t);

        c_ebmlElement_sp _cget(off_t) const;

        template<typename T>
        ebml::ptr<T> _cget(off_t) const;

        ebmlElement_sp _get(ebmlID_t, size_t);

        template<typename T>
        ebml::ptr<T> _get(ebmlID_t, size_t);

        c_ebmlElement_sp _cget(ebmlID_t, size_t) const;

        template<typename T>
        ebml::ptr<T> _cget(ebmlID_t, size_t) const;

        template<typename T>
        ebml::ptr<T> _cget(ebmlID_t, size_t);

        template<typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        ebmlElement_sp _getByKey(ebmlID_t, const K&);

        template<typename T, typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        std::enable_if_t<!std::is_same<ebmlElement, T>::value && std::is_base_of<ebmlElement, T>::value, ebml::ptr<T>>
        _getByKey(ebmlID_t, const K&);

        template<typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        c_ebmlElement_sp _cgetByKey(ebmlID_t, const K&) const;

        template<typename T, typename K, typename H=std::hash<K>, typename E=std::equal_to<K>>
        std::enable_if_t<!std::is_same<const ebmlElement, T>::value && std::is_base_of<const ebmlElement, T>::value, ebml::ptr<T>>
        _cgetByKey(ebmlID_t, const K&) const;

        // Block boundary functions
        off_t _findBoundary(off_t offset);
        off_t _rfindBoundary(off_t offset);

        // Child navigation functions
        seekData_t* _firstChildSeek() const;
        seekData_t* _lastChildSeek() const;
        seekData_t* _prevChildSeek(off_t offset, bool strict=true) const;
        seekData_t* _nextChildSeek(off_t offset, bool strict=true) const;

        std::pair<children_m::iterator, children_m::iterator> _find(off_t offset, bool left=true);
        children_m::iterator _findNext(off_t offset, bool strict=true);
        children_m::iterator _findPrev(off_t offset, bool strict=true);
        // std::pair<seekData_t*, seekData_t*> _adjacentChildSeeks(off_t, bool left=true) const;

        // Space management functions
        off_t _findFree(off_t offset, size_t size);
        off_t _rfindFree(off_t offset, size_t size);

        // Insertion and move check functions
        status_t<prepared_insert_t> _canInsert(off_t offset, size_t size);
        status_t<prepared_insert_t> _canInsert(off_t offset, const ebmlElement_sp&);
        status_t<prepared_insert_t> _canInsert(off_t offset, const ebmlElement_l&);
        status_t<prepared_insert_t> _canInsert(off_t offset, const std::string& data);
        status_t<prepared_insert_t> _canInsert(off_t offset, const char* data);

        prepared_move_t _canMove(off_t src_offset, off_t dst_offset);

        // Resize check functions
        prepared_resize_t _canResize(size_t size);
        // query_t _canSetUnknownSize(bool flag);
        prepared_resize_t _canResizeChild(off_t, size_t size);
        prepared_resize_t _canResizeChild(const seekData_t&, size_t size);
        // query_t _canResizeChild(ebmlElement* child, size_t size);

        // fallocate check functions
        status_t<prepared_insert_t> _canInsertRange(off_t offset, size_t size);
        status_t<prepared_insert_t> _canCollapseRange(off_t offset, size_t size);
        status_t<prepared_insert_t> _canPunchHole(off_t offset, size_t size);

        // Requires local write lock

        // Insertion and removal functions
        seekData_t* _insert(off_t offset, const ebmlElement_sp& child);
        seekData_t* _insert(off_t offset, const ebmlElement_sp& child, const status_t<prepared_insert_t>&);
        seekData_t* _insert(off_t offset, const std::string& data);
        seekData_t* _insert(off_t offset, const std::string& data, const status_t<prepared_insert_t>&);
        std::vector<seekData_t*> _insert(off_t offset, const std::vector<std::string>& data);
        std::vector<seekData_t*> _insert(off_t offset, const std::vector<std::string>& data, const status_t<prepared_insert_t>&);

    // private:
    //     virtual void _preinsert_hook(off_t, const ebmlElement_sp&);
    //     virtual void _postinsert_hook(off_t, const ebmlElement_sp&, seekData_t*);

    public:
        std::vector<seekData_t*> _insert(off_t offset, const ebmlElement_l& children);
        std::vector<seekData_t*> _insert(off_t offset, const ebmlElement_l& children, const status_t<prepared_insert_t>&);

        seekData_t* _insert(off_t offset, const char* data);
        seekData_t* _insert(off_t offset, const char* data, const status_t<prepared_insert_t>&);

        template<typename T, typename... Args>
        std::enable_if_t<std::is_base_of<ebmlLazyLoadClass, T>::value, std::pair<ebmlElement_sp, seekData_t*>>
        _insert(off_t offset, const T& cls, vintWidth_t sizeWidth, size_t dataSize, Args...);

        template<typename T, typename... Args>
        std::enable_if_t<!std::is_base_of<ebmlLazyLoadClass, T>::value && std::is_base_of<ebmlElementClass, T>::value, std::pair<ebmlElement_sp, seekData_t*>>
        _insert(off_t offset, const T& cls, Args... args);

        template<typename T>
        std::enable_if_t<!std::is_base_of<ebmlLazyLoad, T>::value && std::is_base_of<ebmlElement, T>::value, seekData_t*>
        _insert(off_t offset, const ebml::ptr<T>& child);

        void _move(off_t src_offset, off_t dest_offset);
        void _move(off_t src_offset, off_t dest_offset, const prepared_move_t&);

        void _resize(size_t size);
        void _resize(size_t size, const prepared_resize_t&);

        // void _remove(const ebmlElement_sp& child);
        void _remove(off_t offset);
        void _remove(children_m::iterator);

    private:
        virtual void _preremove_hook(const children_m::iterator&);
        virtual void _postremove_hook(seekData_t*);

    public:
        // fallocate functions
        void _insertRange(off_t offset, size_t size);
        void _collapseRange(off_t offset, size_t size);
        void _punchHole(off_t offset, size_t size);

    protected:
        void _handleParseFile(const parseFile&) override;
        virtual void _handleSeekData(std::unique_ptr<seekData_t>&&);
        virtual void _handleSeekData(std::unique_ptr<seekData_t>&&, const children_m::iterator&);
        void _addChild(const ebmlElement_sp&) override;
        void _addChild(ebmlElement_sp&&) override;

        ebmlMasterElement::_iterator* _begin() override;
        ebmlMasterElement::_iterator* _end() override;
        ebmlMasterElement::_const_iterator* _cbegin() const override;
        ebmlMasterElement::_const_iterator* _cend() const override;

        // ebmlElement_sp _get_existing(seekData_t* seekData);
        ebmlElement_sp _read_elem(seekData_t* seekData);
        ebmlElement_sp _read_elem(seekData_t* seekData) const;
        ebmlElement_sp _read_elem(const parseFile& parsed);
        ebmlElement_sp _read_elem(const parseFile& parsed) const;

        localReadLock_t getLocalRLock() const;
        localWriteLock_t getLocalWLock() const;
        globalWriteLock_t getGlobalLock() const;
        friend class ebmlLazyLoadClass;
        friend class seekData_t;
    };
}

#define DECL_GETBYKEY_MEMBERS(K) \
    extern template ebmlElement_sp ebmlLazyLoad::getByKey<K>(ebmlID_t, const K&); \
    extern template ebmlElement_sp ebmlLazyLoad::_getByKey<K>(ebmlID_t, const K&); \
    extern template c_ebmlElement_sp ebmlLazyLoad::cgetByKey<K>(ebmlID_t, const K&); \
    extern template c_ebmlElement_sp ebmlLazyLoad::_cgetByKey<K>(ebmlID_t, const K&); \

#define INST_GETBYKEY_MEMBERS(K) \
    template ebmlElement_sp ebmlLazyLoad::getByKey<K>(ebmlID_t, const K&); \
    template ebmlElement_sp ebmlLazyLoad::_getByKey<K>(ebmlID_t, const K&); \
    template c_ebmlElement_sp ebmlLazyLoad::cgetByKey<K>(ebmlID_t, const K&); \
    template c_ebmlElement_sp ebmlLazyLoad::_cgetByKey<K>(ebmlID_t, const K&); \

#define DECL_GETBYKEY_MEMBERS2(T, K) \
    extern template ebml::ptr<T> ebmlLazyLoad::getByKey<T, K>(ebmlID_t, const K&); \
    extern template ebml::ptr<T> ebmlLazyLoad::_getByKey<T, K>(ebmlID_t, const K&); \
    extern template ptr<const T> ebmlLazyLoad::cgetByKey<const T, K>(ebmlID_t, const K&) const; \
    extern template ptr<const T> ebmlLazyLoad::_cgetByKey<const T, K>(ebmlID_t, const K&) const;

#define INST_GETBYKEY_MEMBERS2(T, K) \
    template ebml::ptr<T> ebmlLazyLoad::getByKey<T, K>(ebmlID_t, const K&); \
    template ebml::ptr<T> ebmlLazyLoad::_getByKey<T, K>(ebmlID_t, const K&); \
    template ptr<const T> ebmlLazyLoad::cgetByKey<const T, K>(ebmlID_t, const K&) const; \
    template ptr<const T> ebmlLazyLoad::_cgetByKey<const T, K>(ebmlID_t, const K&) const;

#define DECL_GET_MEMBERS(T) \
    extern template ebml::ptr<T> ebmlLazyLoad::get<T>(off_t); \
    extern template ebml::ptr<T> ebmlLazyLoad::get<T>(ebmlID_t, size_t); \
    extern template ebml::ptr<T> ebmlLazyLoad::_get<T>(off_t); \
    extern template ebml::ptr<T> ebmlLazyLoad::_get<T>(ebmlID_t, size_t); \
    extern template ptr<const T> ebmlLazyLoad::cget<const T>(off_t) const; \
    extern template ptr<const T> ebmlLazyLoad::cget<const T>(ebmlID_t, size_t) const; \
    extern template ptr<const T> ebmlLazyLoad::_cget<const T>(off_t) const; \
    extern template ptr<const T> ebmlLazyLoad::_cget<const T>(ebmlID_t, size_t) const; \
    DECL_GETBYKEY_MEMBERS2(T, unsigned long long) \
    DECL_GETBYKEY_MEMBERS2(T, long long) \
    DECL_GETBYKEY_MEMBERS2(T, std::string) \
    DECL_GETBYKEY_MEMBERS2(T, std::wstring) \
    DECL_GETBYKEY_MEMBERS2(T, double)

#define INST_GET_MEMBERS(T) \
    template ebml::ptr<T> ebmlLazyLoad::get<T>(off_t); \
    template ebml::ptr<T> ebmlLazyLoad::get<T>(ebmlID_t, size_t); \
    template ebml::ptr<T> ebmlLazyLoad::_get<T>(off_t); \
    template ebml::ptr<T> ebmlLazyLoad::_get<T>(ebmlID_t, size_t); \
    template ptr<const T> ebmlLazyLoad::cget<const T>(off_t) const; \
    template ptr<const T> ebmlLazyLoad::cget<const T>(ebmlID_t, size_t) const; \
    template ptr<const T> ebmlLazyLoad::_cget<const T>(off_t) const; \
    template ptr<const T> ebmlLazyLoad::_cget<const T>(ebmlID_t, size_t) const; \
    INST_GETBYKEY_MEMBERS2(T, unsigned long long) \
    INST_GETBYKEY_MEMBERS2(T, long long) \
    INST_GETBYKEY_MEMBERS2(T, std::string) \
    INST_GETBYKEY_MEMBERS2(T, std::wstring) \
    INST_GETBYKEY_MEMBERS2(T, double)

namespace ebml {
    // DECL_GET_MEMBERS(ebmlDataElement<unsigned long long>)
    // DECL_GET_MEMBERS(ebmlDataElement<long long>)
    // DECL_GET_MEMBERS(ebmlDataElement<double>)
    // DECL_GET_MEMBERS(ebmlDataElement<std::string>)
    // DECL_GET_MEMBERS(ebmlDataElement<std::wstring>)

    extern template class ClsMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass>;
    extern template class InstMixin<ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement>;
    extern template std::pair<ebmlElement_sp, seekData_t*> ebmlLazyLoad::insert(off_t, const ebmlLazyLoadClass&, vintWidth_t, size_t);
    extern template std::pair<ebmlElement_sp, seekData_t*> ebmlLazyLoad::_insert(off_t, const ebmlLazyLoadClass&, vintWidth_t, size_t);
    extern template std::pair<ebmlElement_sp, seekData_t*> ebmlLazyLoad::insert(off_t, const ebmlLazyLoadClass&, vintWidth_t, size_t, const ebmlElement_l&);
    extern template std::pair<ebmlElement_sp, seekData_t*> ebmlLazyLoad::_insert(off_t, const ebmlLazyLoadClass&, vintWidth_t, size_t, const ebmlElement_l&);
    // extern template ptr<const ebmlLazyLoad> ebmlLazyLoad::cgetByKey<const ebmlLazyLoad, unsigned long long>(ebmlID_t, const unsigned long long&);
    // DECL_GETBYKEY_MEMBERS2(ebmlDataElement<std::wstring>, unsigned long long)
}
#endif