Repository navigation
Expand file tree
/
Copy pathstruct_wrapper.hpp
More file actions
137 lines (118 loc) · 4.63 KB
/
Copy pathstruct_wrapper.hpp
File metadata and controls
137 lines (118 loc) · 4.63 KB
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
/*
Copyright (C) 2015-present The DotCpp Authors.
This file is part of .C++, a native C++ implementation of
popular .NET class library APIs developed to facilitate
code reuse between C# and C++.
http://github.com/dotcpp/dotcpp (source)
http://dotcpp.org (documentation)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#pragma once
namespace dot
{
class object_impl;
class string;
class object;
class object_impl;
namespace detail
{
/// Empty structure.
class dummy_no_to_string : public virtual object_impl
{};
/// objects inherit this structure in case their inner struct class has method to_string
/// so object also have these method.
template <class W, class T>
class obj_to_string : public virtual object_impl
{
public:
virtual string to_string() override { return static_cast<T*>(static_cast<W*>(this))->to_string(); }
};
/// Detects existance of to_string method.
template<class T>
struct has_to_string
{
private:
static dummy_no_to_string detect(...);
template<class U> static decltype(std::declval<U>().to_string()) detect(const U&);
public:
static constexpr bool value = !std::is_same<dummy_no_to_string, decltype(detect(std::declval<T>()))>::value;
typedef std::integral_constant<bool, value> type;
};
/// For inheritance of to_string method.
template<class W, class T>
class inherit_to_string : public std::conditional<
has_to_string<T>::value,
obj_to_string<W, T>,
dummy_no_to_string
>::type
{};
/// Empty structure.
class dummy_no_get_hashcode : public virtual object_impl
{};
/// objects inherit this structure in case their inner struct class has method hash_code
/// so object also have these method.
template <class W, class T>
class obj_get_hashcode : public virtual object_impl
{
public:
virtual size_t hash_code() override { return static_cast<T*>(static_cast<W*>(this))->hash_code(); }
};
/// Detects existance of hash_code method.
template<class T>
struct has_get_hashcode
{
private:
static dummy_no_get_hashcode detect(...);
template<class U> static decltype(std::declval<U>().hash_code()) detect(const U&);
public:
static constexpr bool value = !std::is_same<dummy_no_get_hashcode, decltype(detect(std::declval<T>()))>::value;
typedef std::integral_constant<bool, value> type;
};
/// For inheritance of hash_code method.
template<class W, class T>
class inherit_get_hashcode : public std::conditional<
has_get_hashcode<T>::value,
obj_get_hashcode<W, T>,
dummy_no_get_hashcode
>::type
{};
/// Empty structure.
class dummy_no_equals : public virtual object_impl
{};
/// objects inherit this structure in case their inner struct class has method Equals
/// so object also have these method.
template <class W, class T>
class obj_equals : public virtual object_impl
{
public:
bool equals(object obj) override { return static_cast<T*>(static_cast<W*>(this))->equals(obj); }
};
/// Detects existance of Equals method.
template<class T>
struct has_equals
{
private:
static dummy_no_equals detect(...);
template<class U> static decltype(std::declval<U>().Equals(std::declval<object>())) detect(const U&);
public:
static constexpr bool value = !std::is_same<dummy_no_equals, decltype(detect(std::declval<T>()))>::value;
typedef std::integral_constant<bool, value> type;
};
/// For inheritance of Equals method.
template<class W, class T>
class inherit_equals : public std::conditional<
has_equals<T>::value,
obj_equals<W, T>,
dummy_no_equals
>::type
{};
}
}