Main MRPT website > C++ reference for MRPT 1.4.0
metaprogramming.h
Go to the documentation of this file.
1 /* +---------------------------------------------------------------------------+
2  | Mobile Robot Programming Toolkit (MRPT) |
3  | http://www.mrpt.org/ |
4  | |
5  | Copyright (c) 2005-2016, Individual contributors, see AUTHORS file |
6  | See: http://www.mrpt.org/Authors - All rights reserved. |
7  | Released under BSD License. See details in http://www.mrpt.org/License |
8  +---------------------------------------------------------------------------+ */
9 #ifndef metaprogramming_H
10 #define metaprogramming_H
11 
12 #include <mrpt/utils/CObject.h>
14 
15 namespace mrpt
16 {
17  namespace utils
18  {
19  class CStream;
20 
21  /** A set of utility objects for metaprogramming with STL algorithms.
22  * \ingroup stlext_grp
23  */
24  namespace metaprogramming
25  {
26  /** \addtogroup stlext_grp
27  * @{ */
28 
29  /** An object for deleting pointers (intended for STL algorithms) */
30  struct ObjectDelete {
31  template<typename T>
32  inline void operator()(const T *ptr) {
33  delete ptr;
34  }
35  };
36 
37  /** A function which deletes a container of pointers. */
38  template<typename T> inline void DeleteContainer(T &container) {
39  for_each(container.begin(),container.end(),ObjectDelete());
40  }
41 
42  //NOTE: when using this algorithm with for_each, replace the whole line with:
43  // for_each(bypassPointer(<beginning iterator>),bypassPointer(<ending iterator>),mem_fun_ref(&<NonPointerBaseClass>::clear)).
44  /** An object for clearing an object (invokes its method "->clear()") given a pointer or smart-pointer, intended for being used in STL algorithms. */
45  struct ObjectClear {
46  template<typename T>
47  inline void operator()(T &ptr) {
48  if (ptr) ptr->clear();
49  }
50  };
51 
52  //NOTE: replace this with mem_fun_ref(&<BaseClass>::clear).
53  /** An object for clearing an object (invokes its method ".clear()") given a pointer or smart-pointer, intended for being used in STL algorithms. */
54  struct ObjectClear2 {
55  template<typename T>
56  inline void operator()(T &ptr){
57  ptr.clear();
58  }
59  };
60 
61  /** An object for clearing an object->second (invokes its method "clear()") given a pointer or smart-pointer, intended for being used in STL algorithms. */
63  template<typename T>
64  inline void operator()(T obj) {
65  obj.second.clear();
66  }
67  };
68 
69  /** An object for transforming between types/classes, intended for being used in STL algorithms.
70  * Example of usage:
71  * \code
72  * vector<int> v1(10); // Input
73  * vector<double> v2(10); // Output
74  * std::transform(v1.begin(),v1.end(), v2.begin(), ObjectConvert<double> );
75  * \endcode
76  */
77  template <typename TARGET_TYPE>
78  struct ObjectConvert {
79  template<typename T>
80  inline TARGET_TYPE operator()(const T &val) {
81  return TARGET_TYPE(val);
82  }
83  };
84 
85  //NOTE: replace with mem_fun_ref(&CSerializable::make_unique)
86  /** An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms. */
89  typedef void result_type;
90  inline void operator()(mrpt::utils::CObjectPtr &ptr) {
91  ptr.make_unique();
92  }
93  };
94 
95  /** An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms. */
97  template <typename T>
98  inline void operator()(T &ptr) {
99  ptr.first.make_unique();
100  ptr.second.make_unique();
101  }
102  };
103 
104  //NOTE: replace with mem_fun_ref(&CSerializable::clear_unique)
105  /** An object for making smart pointers unique (ie, making copies if necessary), intended for being used in STL algorithms. */
108  typedef void result_type;
110  {
111  ptr.clear_unique();
112  }
113  };
114 
115  /** Behaves like std::copy but allows the source and target iterators to be of different types through static typecasting.
116  * \note As in std::copy, the target iterator must point to the first "slot" where to put the first transformed element, and sufficient space must be allocated in advance.
117  * \sa copy_container_typecasting
118  */
119  template<typename it_src, typename it_dst>
120  inline void copy_typecasting(it_src first, it_src last,it_dst target)
121  {
122  for (it_src i=first; i!=last ; ++i,++target)
123  *target = static_cast<typename it_dst::value_type>(*i);
124  }
125 
126  /** Copy all the elements in a container (vector, deque, list) into a different one performing the appropriate typecasting.
127  * The target container is automatically resized to the appropriate size, and previous contents are lost.
128  * This can be used to assign std::vector's of different types:
129  * \code
130  * std::vector<int> vi(10);
131  * std::vector<float> vf;
132  * vf = vi; // Compiler error
133  * mrpt::utils::metaprogramming::copy_container_typecasting(v1,vf); // Ok
134  * \endcode
135  */
136  template<typename src_container, typename dst_container>
137  inline void copy_container_typecasting(const src_container &src, dst_container &trg)
138  {
139  trg.resize( src.size() );
140  typename src_container::const_iterator i = src.begin();
141  typename src_container::const_iterator last = src.end();
142  typename dst_container::iterator target = trg.begin();
143  for ( ; i!=last ; ++i,++target)
144  *target = static_cast<typename dst_container::value_type>(*i);
145  }
146 
147  /** This class bypasses pointer access in iterators to pointers, thus allowing
148  * the use of algorithms that expect an object of class T with containers of T*.
149  * Although it may be used directly, use the bypassPointer function for better
150  * results and readability (since it most probably won't require template
151  * arguments).
152  */
153  template<typename T,typename U> class MemoryBypasserIterator {
154  private:
156  public:
157  typedef typename T::iterator_category iterator_category;
158  typedef U value_type;
159  typedef typename T::difference_type difference_type;
160  typedef U *pointer;
161  typedef U &reference;
162  inline MemoryBypasserIterator(const T &bi):baseIterator(bi) {}
163  inline reference operator*() {
164  return *(*baseIterator);
165  }
167  ++baseIterator;
168  return *this;
169  }
171  MemoryBypasserIterator it=*this;
172  ++baseIterator;
173  return it;
174  }
176  --baseIterator;
177  return *this;
178  }
180  MemoryBypasserIterator it=*this;
181  --baseIterator;
182  return *this;
183  }
185  baseIterator+=off;
186  return *this;
187  }
189  return (MemoryBypasserIterator<T,U>(*this))+=off;
190  }
192  baseIterator-=off;
193  return *this;
194  }
196  return (MemoryBypasserIterator<T,U>(*this))-=off;
197  }
199  return baseIterator-it.baseIterator;
200  }
202  return *(this+off);
203  }
204  inline bool operator==(const MemoryBypasserIterator<T,U> &i) const {
205  return baseIterator==i.baseIterator;
206  }
207  inline bool operator!=(const MemoryBypasserIterator<T,U> &i) const {
208  return baseIterator!=i.baseIterator;
209  }
210  inline bool operator<(const MemoryBypasserIterator<T,U> &i) const {
211  return baseIterator<i.baseIterator;
212  }
213  };
214 
215  /** Sintactic sugar for MemoryBypasserIterator.
216  * For example, having the following declarations:
217  * vector<double *> vec;
218  * void modifyVal(double &v);
219  * The following sentence is not legal:
220  * for_each(vec.begin(),vec.end(),&modifyVal)
221  * But this one is:
222  * for_each(bypassPointer(vec.begin()),bypassPointer(vec.end()),&modifyVal)
223  */
224  template<typename U,typename T> inline MemoryBypasserIterator<T,U> bypassPointer(const T &baseIterator) {
225  return MemoryBypasserIterator<T,U>(baseIterator);
226  }
227 
228  /** This template encapsulates a binary member function and a single object into a
229  * function expecting the two parameters of the member function.
230  * Don't use directly. Use the wrapMember function instead to avoid explicit
231  * template instantiation.
232  */
233  template<typename T,typename U1,typename U2,typename V> class BinaryMemberFunctionWrapper {
234  private:
235  typedef T (V::*MemberFunction)(U1,U2);
236  V &obj;
238  public:
241  typedef T result_type;
243  inline T operator()(U1 p1,U2 p2) {
244  return (obj.*func)(p1,p2);
245  }
246  };
247  /** This template encapsulates an unary member function and a single object into a
248  * function expecting the parameter of the member function.
249  * Don't use directly. Use the wrapMember function instead.
250  */
251  template<typename T,typename U,typename V> class UnaryMemberFunctionWrapper {
252  private:
253  typedef T (V::*MemberFunction)(U);
254  V &obj;
256  public:
257  typedef U argument_type;
258  typedef T result_type;
260  inline T operator()(U p) {
261  return (obj.*func)(p);
262  }
263  };
264  /** This template encapsulates a member function without arguments and a single
265  * object into a function.
266  * Don't use directly. Use the wrapMember function instead.
267  */
268  template<typename T,typename V> class MemberFunctionWrapper {
269  private:
270  typedef T (V::*MemberFunction)(void);
271  V &obj;
273  public:
275  inline T operator()() {
276  return (obj.*func)();
277  }
278  };
279  /** This function creates a function from an object and a member function.
280  * It has three overloads, for zero, one and two parameters in the function.
281  */
282  template<typename T,typename U1,typename U2,typename V> inline BinaryMemberFunctionWrapper<T,U1,U2,V> wrapMember(V &obj,T (V::*fun)(U1,U2)) {
284  }
285  template<typename T,typename U,typename V> inline UnaryMemberFunctionWrapper<T,U,V> wrapMember(V &obj,T (V::*fun)(U)) {
286  return UnaryMemberFunctionWrapper<T,U,V>(obj,fun);
287  }
288  template<typename T,typename V> inline MemberFunctionWrapper<T,V> wrapMember(V &obj,T (V::*fun)(void)) {
289  return MemberFunctionWrapper<T,V>(obj,fun);
290  }
291 
292  /** Equivalent of std::bind1st for functions with non-const arguments.
293  */
294  template<typename Op> class NonConstBind1st {
295  private:
296  Op &op;
297  typename Op::first_argument_type &val;
298  public:
299  typedef typename Op::second_argument_type argument_type;
300  typedef typename Op::result_type result_type;
301  NonConstBind1st(Op &o,typename Op::first_argument_type &t):op(o),val(t) {}
303  return op(val,s);
304  }
305  };
306  /** Use this function instead of directly calling NonConstBind1st.
307  */
308  template<typename Op> inline NonConstBind1st<Op> nonConstBind1st(Op &o,typename Op::first_argument_type &t) {
309  return NonConstBind1st<Op>(o,t);
310  }
311  /** Equivalent of std::bind2nd for functions with non-const arguments.
312  */
313  template<typename Op> class NonConstBind2nd {
314  private:
315  Op &op;
316  typename Op::second_argument_type &val;
317  public:
318  typedef typename Op::first_argument_type argument_type;
319  typedef typename Op::result_type result_type;
320  NonConstBind2nd(Op &o,typename Op::second_argument_type &t):op(o),val(t) {}
322  return op(f,val);
323  }
324  };
325  /** Do not directly use the NonConstBind2nd class directly. Use this function.
326  */
327  template<typename Op> inline NonConstBind2nd<Op> nonConstBind2nd(Op &o,typename Op::second_argument_type &t) {
328  return NonConstBind2nd<Op>(o,t);
329  }
330 
331  /** @} */ // end of grouping
332 
333  } // end metaprogramming
334  } // End of namespace
335 } // end of namespace
336 #endif
CObject.h
mrpt::utils::metaprogramming::ObjectMakeUnique::argument_type
mrpt::utils::CObjectPtr argument_type
Definition: metaprogramming.h:88
iterator
Scalar * iterator
Definition: eigen_plugins.h:23
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::MemberFunction
T(V::* MemberFunction)(U)
Definition: metaprogramming.h:253
mrpt::utils::metaprogramming::ObjectMakeUnique
An object for making smart pointers unique (ie, making copies if necessary), intended for being used ...
Definition: metaprogramming.h:87
mrpt::utils::metaprogramming::MemberFunctionWrapper::func
MemberFunction func
Definition: metaprogramming.h:272
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator==
bool operator==(const MemoryBypasserIterator< T, U > &i) const
Definition: metaprogramming.h:204
mrpt::utils::metaprogramming::NonConstBind2nd::val
Op::second_argument_type & val
Definition: metaprogramming.h:316
mrpt::utils::metaprogramming::NonConstBind2nd
Equivalent of std::bind2nd for functions with non-const arguments.
Definition: metaprogramming.h:313
stlplus::smart_ptr_base::make_unique
void make_unique(void)
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator--
MemoryBypasserIterator< T, U > operator--(int)
Definition: metaprogramming.h:179
mrpt::utils::metaprogramming::MemoryBypasserIterator::reference
U & reference
Definition: metaprogramming.h:161
mrpt::utils::metaprogramming::MemoryBypasserIterator::MemoryBypasserIterator
MemoryBypasserIterator(const T &bi)
Definition: metaprogramming.h:162
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::operator()
T operator()(U p)
Definition: metaprogramming.h:260
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator++
MemoryBypasserIterator< T, U > & operator++()
Definition: metaprogramming.h:166
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator++
MemoryBypasserIterator< T, U > operator++(int)
Definition: metaprogramming.h:170
mrpt::utils::metaprogramming::MemoryBypasserIterator::value_type
U value_type
Definition: metaprogramming.h:158
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::second_argument_type
U2 second_argument_type
Definition: metaprogramming.h:240
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator-=
MemoryBypasserIterator< T, U > & operator-=(difference_type off)
Definition: metaprogramming.h:191
mrpt::utils::metaprogramming::DeleteContainer
void DeleteContainer(T &container)
A function which deletes a container of pointers.
Definition: metaprogramming.h:38
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::func
MemberFunction func
Definition: metaprogramming.h:237
mrpt::utils::metaprogramming::nonConstBind2nd
NonConstBind2nd< Op > nonConstBind2nd(Op &o, typename Op::second_argument_type &t)
Do not directly use the NonConstBind2nd class directly.
Definition: metaprogramming.h:327
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::operator()
T operator()(U1 p1, U2 p2)
Definition: metaprogramming.h:243
mrpt::utils::metaprogramming::NonConstBind1st::result_type
Op::result_type result_type
Definition: metaprogramming.h:300
mrpt::utils::metaprogramming::ObjectClear
An object for clearing an object (invokes its method "->clear()") given a pointer or smart-pointer,...
Definition: metaprogramming.h:45
mrpt::utils::metaprogramming::MemberFunctionWrapper
This template encapsulates a member function without arguments and a single object into a function.
Definition: metaprogramming.h:268
mrpt::utils::CObjectPtr
A smart pointer to a CObject object.
Definition: CObject.h:32
mrpt::utils::metaprogramming::NonConstBind1st::NonConstBind1st
NonConstBind1st(Op &o, typename Op::first_argument_type &t)
Definition: metaprogramming.h:301
mrpt::utils::metaprogramming::MemberFunctionWrapper::obj
V & obj
Definition: metaprogramming.h:271
mrpt
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
Definition: CParticleFilter.h:16
mrpt::utils::metaprogramming::ObjectDelete
An object for deleting pointers (intended for STL algorithms)
Definition: metaprogramming.h:30
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator!=
bool operator!=(const MemoryBypasserIterator< T, U > &i) const
Definition: metaprogramming.h:207
mrpt::utils::metaprogramming::NonConstBind2nd::result_type
Op::result_type result_type
Definition: metaprogramming.h:319
mrpt::utils::metaprogramming::ObjectClearUnique::argument_type
mrpt::utils::CObjectPtr argument_type
Definition: metaprogramming.h:107
const_iterator
const typedef Scalar * const_iterator
Definition: eigen_plugins.h:24
mrpt::utils::metaprogramming::ObjectClearUnique::operator()
void operator()(mrpt::utils::CObjectPtr &ptr)
Definition: metaprogramming.h:109
mrpt::utils::metaprogramming::MemberFunctionWrapper::MemberFunctionWrapper
MemberFunctionWrapper(V &o, MemberFunction f)
Definition: metaprogramming.h:274
mrpt::utils::metaprogramming::ObjectClearSecond
An object for clearing an object->second (invokes its method "clear()") given a pointer or smart-poin...
Definition: metaprogramming.h:62
mrpt::utils::metaprogramming::MemoryBypasserIterator::difference_type
T::difference_type difference_type
Definition: metaprogramming.h:159
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper
This template encapsulates an unary member function and a single object into a function expecting the...
Definition: metaprogramming.h:251
mrpt::utils::metaprogramming::MemoryBypasserIterator::pointer
U * pointer
Definition: metaprogramming.h:160
t
const EIGEN_STRONG_INLINE AdjointReturnType t() const
Transpose.
Definition: eigen_plugins.h:470
mrpt::utils::metaprogramming::NonConstBind1st
Equivalent of std::bind1st for functions with non-const arguments.
Definition: metaprogramming.h:294
mrpt::utils::metaprogramming::ObjectClearSecond::operator()
void operator()(T obj)
Definition: metaprogramming.h:64
mrpt::utils::metaprogramming::ObjectConvert::operator()
TARGET_TYPE operator()(const T &val)
Definition: metaprogramming.h:80
stlplus::smart_ptr_base::clear_unique
void clear_unique(void)
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::first_argument_type
U1 first_argument_type
Definition: metaprogramming.h:239
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::BinaryMemberFunctionWrapper
BinaryMemberFunctionWrapper(V &o, MemberFunction f)
Definition: metaprogramming.h:242
mrpt::utils::metaprogramming::ObjectClear::operator()
void operator()(T &ptr)
Definition: metaprogramming.h:47
mrpt::utils::metaprogramming::nonConstBind1st
NonConstBind1st< Op > nonConstBind1st(Op &o, typename Op::first_argument_type &t)
Use this function instead of directly calling NonConstBind1st.
Definition: metaprogramming.h:308
mrpt::utils::metaprogramming::MemoryBypasserIterator
This class bypasses pointer access in iterators to pointers, thus allowing the use of algorithms that...
Definition: metaprogramming.h:153
mrpt::utils::metaprogramming::ObjectMakeUnique::operator()
void operator()(mrpt::utils::CObjectPtr &ptr)
Definition: metaprogramming.h:90
mrpt::utils::metaprogramming::MemberFunctionWrapper::operator()
T operator()()
Definition: metaprogramming.h:275
mrpt::utils::metaprogramming::NonConstBind2nd::op
Op & op
Definition: metaprogramming.h:315
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator-
MemoryBypasserIterator< T, U > operator-(difference_type off) const
Definition: metaprogramming.h:195
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::result_type
T result_type
Definition: metaprogramming.h:258
mrpt::utils::metaprogramming::bypassPointer
MemoryBypasserIterator< T, U > bypassPointer(const T &baseIterator)
Sintactic sugar for MemoryBypasserIterator.
Definition: metaprogramming.h:224
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator-
difference_type operator-(const MemoryBypasserIterator< T, U > &it) const
Definition: metaprogramming.h:198
mrpt::utils::metaprogramming::MemberFunctionWrapper::MemberFunction
T(V::* MemberFunction)(void)
Definition: metaprogramming.h:270
mrpt::utils::metaprogramming::NonConstBind1st::val
Op::first_argument_type & val
Definition: metaprogramming.h:297
mrpt::utils::metaprogramming::wrapMember
BinaryMemberFunctionWrapper< T, U1, U2, V > wrapMember(V &obj, T(V::*fun)(U1, U2))
This function creates a function from an object and a member function.
Definition: metaprogramming.h:282
mrpt::utils::metaprogramming::NonConstBind1st::op
Op & op
Definition: metaprogramming.h:296
mrpt::utils::metaprogramming::ObjectMakeUnique::result_type
void result_type
Definition: metaprogramming.h:89
mrpt::utils::metaprogramming::ObjectConvert
An object for transforming between types/classes, intended for being used in STL algorithms.
Definition: metaprogramming.h:78
mrpt::utils::metaprogramming::MemoryBypasserIterator::baseIterator
T baseIterator
Definition: metaprogramming.h:155
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::obj
V & obj
Definition: metaprogramming.h:236
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::MemberFunction
T(V::* MemberFunction)(U1, U2)
Definition: metaprogramming.h:235
mrpt::utils::metaprogramming::ObjectClear2::operator()
void operator()(T &ptr)
Definition: metaprogramming.h:56
metaprogramming_serialization.h
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator[]
reference operator[](difference_type off) const
Definition: metaprogramming.h:201
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper
This template encapsulates a binary member function and a single object into a function expecting the...
Definition: metaprogramming.h:233
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator*
reference operator*()
Definition: metaprogramming.h:163
mrpt::utils::metaprogramming::NonConstBind2nd::NonConstBind2nd
NonConstBind2nd(Op &o, typename Op::second_argument_type &t)
Definition: metaprogramming.h:320
mrpt::utils::metaprogramming::MemoryBypasserIterator::iterator_category
T::iterator_category iterator_category
Definition: metaprogramming.h:157
mrpt::utils::metaprogramming::BinaryMemberFunctionWrapper::result_type
T result_type
Definition: metaprogramming.h:241
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::obj
V & obj
Definition: metaprogramming.h:254
mrpt::utils::metaprogramming::copy_container_typecasting
void copy_container_typecasting(const src_container &src, dst_container &trg)
Copy all the elements in a container (vector, deque, list) into a different one performing the approp...
Definition: metaprogramming.h:137
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator+
MemoryBypasserIterator< T, U > operator+(difference_type off) const
Definition: metaprogramming.h:188
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::argument_type
U argument_type
Definition: metaprogramming.h:257
mrpt::utils::metaprogramming::NonConstBind1st::argument_type
Op::second_argument_type argument_type
Definition: metaprogramming.h:299
mrpt::utils::metaprogramming::NonConstBind2nd::argument_type
Op::first_argument_type argument_type
Definition: metaprogramming.h:318
mrpt::utils::metaprogramming::NonConstBind1st::operator()
result_type operator()(argument_type &s)
Definition: metaprogramming.h:302
mrpt::utils::metaprogramming::copy_typecasting
void copy_typecasting(it_src first, it_src last, it_dst target)
Behaves like std::copy but allows the source and target iterators to be of different types through st...
Definition: metaprogramming.h:120
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::UnaryMemberFunctionWrapper
UnaryMemberFunctionWrapper(V &o, MemberFunction f)
Definition: metaprogramming.h:259
mrpt::utils::metaprogramming::ObjectPairMakeUnique
An object for making smart pointers unique (ie, making copies if necessary), intended for being used ...
Definition: metaprogramming.h:96
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator--
MemoryBypasserIterator< T, U > & operator--()
Definition: metaprogramming.h:175
mrpt::utils::metaprogramming::ObjectPairMakeUnique::operator()
void operator()(T &ptr)
Definition: metaprogramming.h:98
mrpt::utils::metaprogramming::ObjectDelete::operator()
void operator()(const T *ptr)
Definition: metaprogramming.h:32
mrpt::utils::metaprogramming::NonConstBind2nd::operator()
result_type operator()(argument_type &f)
Definition: metaprogramming.h:321
mrpt::utils::metaprogramming::ObjectClearUnique::result_type
void result_type
Definition: metaprogramming.h:108
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator<
bool operator<(const MemoryBypasserIterator< T, U > &i) const
Definition: metaprogramming.h:210
mrpt::utils::metaprogramming::UnaryMemberFunctionWrapper::func
MemberFunction func
Definition: metaprogramming.h:255
mrpt::utils::metaprogramming::ObjectClearUnique
An object for making smart pointers unique (ie, making copies if necessary), intended for being used ...
Definition: metaprogramming.h:106
mrpt::utils::metaprogramming::MemoryBypasserIterator::operator+=
MemoryBypasserIterator< T, U > & operator+=(difference_type off)
Definition: metaprogramming.h:184
mrpt::utils::metaprogramming::ObjectClear2
An object for clearing an object (invokes its method ".clear()") given a pointer or smart-pointer,...
Definition: metaprogramming.h:54



Page generated by Doxygen 1.8.16 for MRPT 1.4.0 SVN: at Mon Oct 14 23:11:08 UTC 2019