IMP
2.0.0
The Integrative Modeling Platform
Main Page
Related Pages
Modules
Namespaces
Classes
Files
Examples
File List
File Members
tuple_macros.h
Go to the documentation of this file.
1
/**
2
* \file IMP/base/tuple_macros.h
3
* \brief Various general useful macros for IMP.
4
*
5
* Copyright 2007-2013 IMP Inventors. All rights reserved.
6
*
7
*/
8
9
#ifndef IMPBASE_TUPLE_MACROS_H
10
#define IMPBASE_TUPLE_MACROS_H
11
#include <IMP/base/base_config.h>
12
#include "
Value.h
"
13
#include "
Showable.h
"
14
#include "
hash.h
"
15
#include "
hash_macros.h
"
16
#include "
showable_macros.h
"
17
#include "
value_macros.h
"
18
#include "
comparison_macros.h
"
19
#include "
swig_macros.h
"
20
21
/** Implementation macro */
22
#define IMP_TUPLE_VALUE(Name, type_name, data_name, var_name) \
23
private: \
24
type_name var_name; \
25
public: \
26
IMP_HELPER_MACRO_PUSH_WARNINGS \
27
const type_name &get_##data_name() const {return var_name;} \
28
void set_##data_name(const type_name &v) { \
29
var_name=v; \
30
} \
31
IMP_NO_SWIG(type_name& access_##data_name() {return var_name;})\
32
IMP_HELPER_MACRO_POP_WARNINGS
33
34
35
/** \name Named tuples
36
It is often useful to declare little structures to aid in the passing
37
of arguments by name or returning sets of values. One can use
38
boost::tuples, but these don't have names for their parts and so
39
don't lead to clear code. Instead we provide a macro to aid
40
declaring such classes. The resulting class is hashable and
41
comparable too.
42
@{
43
*/
44
45
#define IMP_NAMED_TUPLE_1(Name, Names, type0, var0, invariant) \
46
struct Name: public IMP::base::Value { \
47
Name(type0 i0=type0()): var0##_(i0){invariant;} \
48
IMP_HASHABLE_INLINE(Name, { \
49
std::size_t value= IMP::base::hash_value(var0##_); \
50
return value; \
51
}); \
52
IMP_COMPARISONS_1(Name); \
53
IMP_SHOWABLE_INLINE(Name, out << "(" << #var0 << "=" \
54
<< IMP::base::Showable(var0##_) << ")"); \
55
IMP_TUPLE_VALUE(Name, type0, var0, var0##_); \
56
private: \
57
int compare(const Name &o) const { \
58
IMP_COMPARE_ONE(var0##_, o.var0##_); \
59
return 0; \
60
} \
61
}; \
62
IMP_VALUES(Name, Names)
63
64
65
66
#define IMP_NAMED_TUPLE_2(Name, Names, type0, var0, type1, var1, \
67
invariant) \
68
struct Name: public IMP::base::Value { \
69
Name(type0 i0=type0(), type1 i1=type1()): var0##_(i0), var1##_(i1) \
70
{invariant;} \
71
IMP_HASHABLE_INLINE(Name, { \
72
std::size_t value= IMP::base::hash_value(var0##_); \
73
boost::hash_combine(value, IMP::base::hash_value(var1##_)); \
74
return value; \
75
}); \
76
IMP_SHOWABLE_INLINE(Name, out << "(" << #var0 << "=" \
77
<< IMP::base::Showable(var0##_) \
78
<< " " <<#var1 << "=" \
79
<< IMP::base::Showable(var1##_) << ")"); \
80
IMP_COMPARISONS(Name); \
81
IMP_TUPLE_VALUE(Name, type0, var0, var0##_); \
82
IMP_TUPLE_VALUE(Name, type1, var1, var1##_); \
83
private: \
84
int compare(const Name &o) const { \
85
IMP_COMPARE_ONE(var0##_, o.var0##_); \
86
IMP_COMPARE_ONE(var1##_, o.var1##_); \
87
return 0; \
88
} \
89
}; \
90
IMP_VALUES(Name, Names)
91
92
93
#define IMP_NAMED_TUPLE_3(Name, Names, type0, var0, type1, var1, \
94
type2, var2, invariant) \
95
struct Name: public IMP::base::Value { \
96
Name(type0 i0=type0(), type1 i1=type1(),type2 i2=type2() \
97
): var0##_(i0), var1##_(i1), var2##_(i2){invariant;} \
98
IMP_HASHABLE_INLINE(Name, { \
99
std::size_t value= IMP::base::hash_value(var0##_); \
100
boost::hash_combine(value, IMP::base::hash_value(var1##_)); \
101
boost::hash_combine(value, IMP::base::hash_value(var2##_)); \
102
return value; \
103
}); \
104
IMP_COMPARISONS(Name); \
105
IMP_SHOWABLE_INLINE(Name, out << "(" << #var0 << "=" \
106
<< IMP::base::Showable(var0##_) \
107
<< " " <<#var1 << "=" \
108
<< IMP::base::Showable(var1##_) \
109
<< " " <<#var2 << "=" \
110
<< IMP::base::Showable(var2##_) << ")"); \
111
IMP_TUPLE_VALUE(Name, type0, var0, var0##_); \
112
IMP_TUPLE_VALUE(Name, type1, var1, var1##_); \
113
IMP_TUPLE_VALUE(Name, type2, var2, var2##_); \
114
private: \
115
int compare(const Name &o) const { \
116
IMP_COMPARE_ONE(var0##_, o.var0##_); \
117
IMP_COMPARE_ONE(var1##_, o.var1##_); \
118
IMP_COMPARE_ONE(var2##_, o.var2##_); \
119
return 0; \
120
} \
121
}; \
122
IMP_VALUES(Name, Names)
123
124
125
#define IMP_NAMED_TUPLE_4(Name, Names, type0, var0, type1, var1, \
126
type2, var2, type3, var3, invariant) \
127
struct Name: public IMP::base::Value { \
128
Name(type0 i0=type0(), type1 i1=type1(),type2 i2=type2(), \
129
type3 i3=type3()): var0##_(i0), var1##_(i1), var2##_(i2), \
130
var3##_(i3) {invariant;} \
131
IMP_HASHABLE_INLINE(Name, { \
132
std::size_t value= IMP::base::hash_value(var0##_); \
133
boost::hash_combine(value, IMP::base::hash_value(var1##_)); \
134
boost::hash_combine(value, IMP::base::hash_value(var2##_)); \
135
boost::hash_combine(value, IMP::base::hash_value(var3##_)); \
136
return value; \
137
}); \
138
IMP_COMPARISONS(Name); \
139
IMP_SHOWABLE_INLINE(Name, out << "(" << #var0 << "=" \
140
<< IMP::base::Showable(var0##_) \
141
<< " " <<#var1 << "=" \
142
<< IMP::base::Showable(var1##_) \
143
<< " " <<#var2 << "=" \
144
<< IMP::base::Showable(var2##_) \
145
<< " " <<#var3 << "=" \
146
<< IMP::base::Showable(var3##_) \
147
<< ")"); \
148
IMP_TUPLE_VALUE(Name, type0, var0, var0##_); \
149
IMP_TUPLE_VALUE(Name, type1, var1, var1##_); \
150
IMP_TUPLE_VALUE(Name, type2, var2, var2##_); \
151
IMP_TUPLE_VALUE(Name, type3, var3, var3##_); \
152
private: \
153
int compare(const Name &o) const { \
154
IMP_COMPARE_ONE(var0##_, o.var0##_); \
155
IMP_COMPARE_ONE(var1##_, o.var1##_); \
156
IMP_COMPARE_ONE(var2##_, o.var2##_); \
157
IMP_COMPARE_ONE(var3##_, o.var3##_); \
158
return 0; \
159
} \
160
}; \
161
IMP_VALUES(Name, Names)
162
163
164
#define IMP_NAMED_TUPLE_5(Name, Names, type0, var0, type1, var1, \
165
type2, var2, type3, var3, type4, var4, \
166
invariant) \
167
struct Name: public IMP::base::Value { \
168
Name(type0 i0=type0(), type1 i1=type1(),type2 i2=type2(), \
169
type3 i3=type3(), type4 i4=type4()): var0##_(i0), var1##_(i1), \
170
var2##_(i2), \
171
var3##_(i3), var4##_(i4) \
172
{invariant;} \
173
IMP_HASHABLE_INLINE(Name, { \
174
std::size_t value= IMP::base::hash_value(var0##_); \
175
boost::hash_combine(value, IMP::base::hash_value(var1##_)); \
176
boost::hash_combine(value, IMP::base::hash_value(var2##_)); \
177
boost::hash_combine(value, IMP::base::hash_value(var3##_)); \
178
boost::hash_combine(value, IMP::base::hash_value(var4##_)); \
179
return value; \
180
}); \
181
IMP_COMPARISONS(Name); \
182
IMP_SHOWABLE_INLINE(Name, out << "(" << #var0 << "=" \
183
<< IMP::base::Showable(var0##_) \
184
<< " " <<#var1 << "=" \
185
<< IMP::base::Showable(var1##_) \
186
<< " " <<#var2 << "=" \
187
<< IMP::base::Showable(var2##_) \
188
<< " " <<#var3 << "=" \
189
<< IMP::base::Showable(var3##_) \
190
<< " " <<#var4 << "=" \
191
<< IMP::base::Showable(var4##_) \
192
<< ")"); \
193
IMP_TUPLE_VALUE(Name, type0, var0, var0##_); \
194
IMP_TUPLE_VALUE(Name, type1, var1, var1##_); \
195
IMP_TUPLE_VALUE(Name, type2, var2, var2##_); \
196
IMP_TUPLE_VALUE(Name, type3, var3, var3##_); \
197
IMP_TUPLE_VALUE(Name, type4, var4, var4##_); \
198
private: \
199
int compare(const Name &o) const { \
200
IMP_COMPARE_ONE(var0##_, o.var0##_); \
201
IMP_COMPARE_ONE(var1##_, o.var1##_); \
202
IMP_COMPARE_ONE(var2##_, o.var2##_); \
203
IMP_COMPARE_ONE(var3##_, o.var3##_); \
204
IMP_COMPARE_ONE(var4##_, o.var4##_); \
205
return 0; \
206
} \
207
}; \
208
IMP_VALUES(Name, Names)
209
210
211
212
/**@}*/
213
214
#endif
/* IMPBASE_TUPLE_MACROS_H */