1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
//
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//
#pragma once
#include <scm/detail/convert.hpp>
namespace scm {
namespace detail {
template <typename T>
struct convert_wrapper_type
{
static T to_cpp(SCM v) { return T{v}; }
static SCM to_scm(T v) { return v.get(); }
};
struct wrapper
{
wrapper() = default;
wrapper(SCM hdl) : handle_{hdl} {}
SCM get() const { return handle_; }
operator SCM () const { return handle_; }
bool operator==(wrapper other) { return handle_ == other.handle_; }
bool operator!=(wrapper other) { return handle_ != other.handle_; }
protected:
SCM handle_ = SCM_UNSPECIFIED;
};
} // namespace detail
struct val : detail::wrapper
{
using base_t = detail::wrapper;
using base_t::base_t;
template <typename T,
typename = std::enable_if_t<
(!std::is_same<std::decay_t<T>, val>{} &&
!std::is_same<std::decay_t<T>, SCM>{})>>
val(T&& x)
: base_t(detail::to_scm(std::forward<T>(x)))
{}
template <typename T,
typename = std::enable_if_t<
std::is_same<T, decltype(detail::to_cpp<T>(SCM{}))>{}>>
operator T() const { return detail::to_cpp<T>(handle_); }
template <typename T,
typename = std::enable_if_t<
std::is_same<T&, decltype(detail::to_cpp<T>(SCM{}))>{}>>
operator T& () const { return detail::to_cpp<T>(handle_); }
template <typename T,
typename = std::enable_if_t<
std::is_same<const T&, decltype(detail::to_cpp<T>(SCM{}))>{}>>
operator const T& () const { return detail::to_cpp<T>(handle_); }
val operator() () const
{ return val{scm_call_0(get())}; }
val operator() (val a0) const
{ return val{scm_call_1(get(), a0)}; }
val operator() (val a0, val a1) const
{ return val{scm_call_2(get(), a0, a1)}; }
val operator() (val a0, val a1, val a3) const
{ return val{scm_call_3(get(), a0, a1, a3)}; }
};
} // namespace scm
#define SCM_DECLARE_WRAPPER_TYPE(cpp_name__) \
namespace scm { \
namespace detail { \
template <> \
struct convert<cpp_name__> \
: convert_wrapper_type<cpp_name__> {}; \
}} /* namespace scm::detail */ \
/**/
SCM_DECLARE_WRAPPER_TYPE(val);
|
