wrapper.hh

#ifndef VTESTBED_GUILE_WRAPPER_HH
#define VTESTBED_GUILE_WRAPPER_HH

#include <libguile.h>

#include <any>
#include <memory>
#include <typeinfo>

#include <vtestbed/guile/base.hh>

namespace vtb {

    namespace guile {

        template <class T> class Aspect;
        template <class T> class Traits;
        template <class T> class Wrapper;

        template <class T>
        class Aspect: public T {

        private:
            using base_type = T;
            using wrapper_type = Wrapper<T>;

        private:
            wrapper_type* _wrapper;

        public:
            using base_type::base_type;

            inline Aspect(const T& rhs): T(rhs) {}
            inline Aspect(T&& rhs): T(std::move(rhs)) {}
            inline ~Aspect() { this->_wrapper->clear(); this->_wrapper = nullptr; }

            inline void wrapper(wrapper_type* rhs) { this->_wrapper = rhs; }
            inline wrapper_type* wrapper() { return this->_wrapper; }
            inline const wrapper_type* wrapper() const { return this->_wrapper; }

        };

        template <class T>
        class Wrapper {

        public:
            using value_type = Aspect<T>;

        private:
            value_type* _ptr = nullptr;

        public:
            inline value_type* ptr() { return this->_ptr; }
            inline T* get() { return this->_ptr; }
            inline const T* get() const { return this->_ptr; }
            inline void set(value_type* rhs) { this->_ptr = rhs; }
            inline void release() { delete this->_ptr; this->_ptr = nullptr; }
            inline void clear() { this->_ptr = nullptr; }
            inline value_type* copy() { return new value_type(*this->_ptr); }

        };

        template <class T>
        class Wrapper<std::unique_ptr<T>> {

        public:
            using value_type = std::unique_ptr<T>;

        private:
            value_type _ptr;

        public:
            inline value_type& get() { return this->_ptr; }
            inline const T& get() const { return this->_ptr; }
            inline void set(value_type&& rhs) { this->_ptr = std::move(rhs); }
            inline void release() { this->_ptr.reset(); }
            inline void clear() { this->_ptr.reset(); }

        };

        template <>
        class Wrapper<std::any> {

        public:
            using value_type = std::any;

        private:
            value_type _any;

        public:
            inline value_type& get() { return this->_any; }
            inline const value_type& get() const { return this->_any; }
            inline void set(value_type&& rhs) { this->_any = std::move(rhs); }
            inline void set(const value_type& rhs) { this->_any = rhs; }
            inline void release() { this->_any.reset(); }
            inline void clear() { this->_any.reset(); }

        };

        template <class T> inline Wrapper<T>*
        to_wrapper(SCM object) {
            return reinterpret_cast<Wrapper<T>*>(scm_foreign_object_ref(object, 0));
        }

        template <class T> inline void
        finalize(SCM object) {
            to_wrapper<T>(object)->release();
        }

        template <class T> inline SCM
        make_type(const char* name) {
            return scm_make_foreign_object_type(scm_from_utf8_symbol(name),
                                                scm_list_1(scm_from_utf8_symbol("pointer")),
                                                finalize<T>);
        }

        template <class T> inline SCM
        define_type(const char* name) {
            SCM type = make_type<T>(name);
            scm_c_define(name, type);
            return type;
        }

        template <class T> inline Wrapper<T>*
        make_wrapper(Aspect<T>* ptr) {
            auto* wrapper = allocate<Wrapper<T>>(typeid(T).name());
            ptr->wrapper(wrapper);
            wrapper->set(ptr);
            return wrapper;
        }

        template <class T> inline Wrapper<std::unique_ptr<T>>*
        make_wrapper(std::unique_ptr<T>&& ptr) {
            auto* wrapper = allocate<Wrapper<std::unique_ptr<T>>>(typeid(T).name());
            wrapper->set(std::move(ptr));
            return wrapper;
        }

        inline Wrapper<std::any>*
        make_wrapper(std::any&& any) {
            auto* wrapper = allocate<Wrapper<std::any>>(any.type().name());
            wrapper->set(std::move(any));
            return wrapper;
        }

        inline Wrapper<std::any>*
        make_wrapper(const std::any& any) {
            auto* wrapper = allocate<Wrapper<std::any>>(any.type().name());
            wrapper->set(any);
            return wrapper;
        }

        template <class T> inline Wrapper<T>*
        make_wrapper() {
            return make_wrapper<T>(new Aspect<T>);
        }

        template <class T> inline SCM
        make_object(SCM type, Wrapper<T>* wrapper) {
            return scm_make_foreign_object_1(type, wrapper);
        }

        template <class T> inline SCM
        make_object(SCM type, Aspect<T>* ptr) {
            return make_object<T>(type, make_wrapper<T>(ptr));
        }

        template <class T> inline SCM
        make_object(SCM type, std::unique_ptr<T>&& ptr) {
            return make_object<std::unique_ptr<T>>(type, make_wrapper<T>(std::move(ptr)));
        }

        inline SCM
        make_object(SCM type, std::any&& any) {
            return make_object<std::any>(type, make_wrapper(std::move(any)));
        }

        inline SCM
        make_object(SCM type, const std::any& any) {
            return make_object<std::any>(type, make_wrapper(any));
        }

        template <class T> inline SCM
        make_object(SCM type) {
            return make_object<T>(type, make_wrapper<T>());
        }

    }

}

#endif // vim:filetype=cpp