traits.hh

#ifndef VTESTBED_GUILE_TRAITS_HH
#define VTESTBED_GUILE_TRAITS_HH

#include <vtestbed/guile/wrapper.hh>

namespace vtb {

    namespace guile {

        template <class T>
        class Traits {

        public:
            using value_type = T;

        public:
            static void define();
            static SCM type();
            static inline SCM make() { return make_object<T>(type()); }
            static inline SCM make(const T& rhs) {
                return make_object<T>(type(), new Aspect<T>(rhs));
            }
            static inline SCM make(T&& rhs) {
                return make_object<T>(type(), new Aspect<T>(std::move(rhs)));
            }

        };

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

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

        public:
            static void define();
            static SCM type();
            static inline SCM make() { return make_object<T>(type()); }
            static inline SCM make(value_type&& rhs) {
                return make_object<T>(type(), std::move(rhs));
            }

        };

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

        public:
            using value_type = std::any;

        public:
            static void define();
            static SCM type();
            static inline SCM make() { return make_object<value_type>(type()); }
            static inline SCM make(const value_type& rhs) {
                return make_object(type(), rhs);
            }
            static inline SCM make(value_type&& rhs) {
                return make_object(type(), std::move(rhs));
            }

        };

        template <class T> inline Wrapper<T>*
        get_wrapper(SCM object) {
            scm_assert_foreign_object_type(Traits<T>::type(), object);
            auto* wrapper = to_wrapper<T>(object);
            if (!wrapper->get()) { throw std::invalid_argument("pointer is null"); }
            return wrapper;
        }

        template <> inline Wrapper<std::any>*
        get_wrapper(SCM object) {
            scm_assert_foreign_object_type(Traits<std::any>::type(), object);
            auto* wrapper = to_wrapper<std::any>(object);
            if (!wrapper->get().has_value()) { throw std::invalid_argument("pointer is null"); }
            return wrapper;
        }

        template <class T> inline T*
        get_object(SCM object) {
            SCM type = scm_class_of(object);
            T* ptr = nullptr;
            if (type == Traits<T>::type()) {
                ptr = to_wrapper<T>(object)->get();
            } else if (type == Traits<std::any>::type()) {
                auto* wrapper = to_wrapper<std::any>(object);
                if (!wrapper->get().has_value()) {
                    throw std::invalid_argument("pointer is null");
                }
                if (wrapper->get().type() != typeid(T*)) {
                    throw std::invalid_argument("bad guile object type");
                }
                ptr = std::any_cast<T*>(wrapper->get());
            } else {
                throw std::invalid_argument("bad guile object type");
            }
            if (!ptr) { throw std::invalid_argument("pointer is null"); }
            return ptr;
        }

        template <class T> inline T*
        get_pointer(SCM object) {
            scm_assert_foreign_object_type(Traits<std::any>::type(), object);
            auto* wrapper = to_wrapper<std::any>(object);
            if (!wrapper->get().has_value()) { throw std::invalid_argument("pointer is null"); }
            if (wrapper->get().type() != typeid(T*)) {
                throw std::invalid_argument("bad guile object type");
            }
            return std::any_cast<T*>(wrapper->get());
        }

    }

}

#endif // vim:filetype=cpp