[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
vigra/functortraits.hxx | ![]() |
---|
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2005 by Ullrich Koethe */ 00004 /* Cognitive Systems Group, University of Hamburg, Germany */ 00005 /* */ 00006 /* This file is part of the VIGRA computer vision library. */ 00007 /* ( Version 1.3.2, Jan 27 2005 ) */ 00008 /* You may use, modify, and distribute this software according */ 00009 /* to the terms stated in the LICENSE file included in */ 00010 /* the VIGRA distribution. */ 00011 /* */ 00012 /* The VIGRA Website is */ 00013 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00014 /* Please direct questions, bug reports, and contributions to */ 00015 /* koethe@informatik.uni-hamburg.de */ 00016 /* */ 00017 /* THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR */ 00018 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ 00019 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */ 00020 /* */ 00021 /************************************************************************/ 00022 00023 00024 #ifndef VIGRA_FUNCTORTRAITS_HXX 00025 #define VIGRA_FUNCTORTRAITS_HXX 00026 00027 #include <functional> 00028 #include <vigra/metaprogramming.hxx> 00029 00030 namespace vigra { 00031 00032 template <class T> 00033 class FunctorTraitsBase 00034 { 00035 public: 00036 typedef T type; 00037 00038 typedef VigraFalseType isInitializer; 00039 00040 typedef VigraFalseType isUnaryFunctor; 00041 typedef VigraFalseType isBinaryFunctor; 00042 typedef VigraFalseType isTernaryFunctor; 00043 00044 typedef VigraFalseType isUnaryAnalyser; 00045 typedef VigraFalseType isBinaryAnalyser; 00046 typedef VigraFalseType isTernaryAnalyser; 00047 }; 00048 00049 00050 00051 /** \addtogroup Functors 00052 */ 00053 //@{ 00054 /** \brief Export associated information for a functor. 00055 00056 The FunctorTraits class contains the following fields: 00057 00058 \code 00059 template <class T> 00060 struct FunctorTraits 00061 { 00062 typedef T type; 00063 00064 typedef ... isInitializer; 00065 00066 typedef ... isUnaryFunctor; 00067 typedef ... isBinaryFunctor; 00068 typedef ... isTernaryFunctor; 00069 00070 typedef ... isUnaryAnalyser; 00071 typedef ... isBinaryAnalyser; 00072 typedef ... isTernaryAnalyser; 00073 }; 00074 \endcode 00075 00076 Where the dots are either <tt>VigraTrueType</tt> or <tt>VigraFalseType</tt> 00077 depending on whether the functor supports the respective functionality or not. 00078 If a functor <tt>f<tt> is a model of these categories, it supports the following 00079 calls (<tt>v</tt> is a variable such that the result type of the functor 00080 calls can be converted into <tt>v</tt>'s type, and <tt>a1, a2, a3</tt> are 00081 variables convertible into the functor's argument types): 00082 00083 <DL> 00084 <DT><b>Initializer</b> 00085 <DD> <tt>v = f()</tt> (used with initImageWithFunctor()) 00086 <DT><b>UnaryFunctor</b> 00087 <DD> <tt>v = f(a1)</tt> (used with transformImage()) 00088 <DT><b>BinaryFunctor</b> 00089 <DD> <tt>v = f(a1, a2)</tt> (used with combineTwoImages()) 00090 <DT><b>TernaryFunctor</b> 00091 <DD> <tt>v = f(a1, a2, a3)</tt> (used with combineThreeImages()) 00092 <DT><b>UnaryAnalyser</b> 00093 <DD> <tt>f(a1)</tt> (return type <tt>void>/tt>, used with inspectImage()) 00094 <DT><b>BinaryAnalyser</b> 00095 <DD> <tt>f(a1, a2)</tt> (return type <tt>void>/tt>, used with inspectTwoImages()) 00096 <DT><b>TernaryAnalyser</b> 00097 <DD> <tt>f(a1, a2, a3)</tt> (return type <tt>void>/tt>) 00098 </DL> 00099 00100 It should be noted that the functor's argument and result types are not contained 00101 in the traits class: Since the function calls are often member template functions in 00102 VIGRA, many functors do not have fixed argument types. Neither are the result 00103 types fixed in this case because they are computed (via a template meta-program) 00104 from the argument types. 00105 00106 <b>\#include</b> "<a href="functortraits_8hxx-source.html">vigra/functortraits.hxx</a>" 00107 Namespace: vigra 00108 */ 00109 template <class T> 00110 class FunctorTraits 00111 : public FunctorTraitsBase<T> 00112 {}; 00113 00114 #define VIGRA_DEFINE_STL_FUNCTOR(name, unary, binary) \ 00115 template <class T> \ 00116 class FunctorTraits<name<T> > \ 00117 { \ 00118 public: \ 00119 typedef T type; \ 00120 \ 00121 typedef VigraFalseType isInitializer; \ 00122 \ 00123 typedef unary isUnaryFunctor; \ 00124 typedef binary isBinaryFunctor; \ 00125 typedef VigraFalseType isTernaryFunctor; \ 00126 \ 00127 typedef VigraFalseType isUnaryAnalyser; \ 00128 typedef VigraFalseType isBinaryAnalyser; \ 00129 typedef VigraFalseType isTernaryAnalyser; \ 00130 }; 00131 00132 // ???TODO: these should also be specialized for the ptr_fun and mem_fun_ptr wrappers 00133 VIGRA_DEFINE_STL_FUNCTOR(std::plus, VigraFalseType, VigraTrueType) 00134 VIGRA_DEFINE_STL_FUNCTOR(std::minus, VigraFalseType, VigraTrueType) 00135 VIGRA_DEFINE_STL_FUNCTOR(std::multiplies, VigraFalseType, VigraTrueType) 00136 VIGRA_DEFINE_STL_FUNCTOR(std::divides, VigraFalseType, VigraTrueType) 00137 VIGRA_DEFINE_STL_FUNCTOR(std::modulus, VigraFalseType, VigraTrueType) 00138 VIGRA_DEFINE_STL_FUNCTOR(std::equal_to, VigraFalseType, VigraTrueType) 00139 VIGRA_DEFINE_STL_FUNCTOR(std::not_equal_to, VigraFalseType, VigraTrueType) 00140 VIGRA_DEFINE_STL_FUNCTOR(std::greater, VigraFalseType, VigraTrueType) 00141 VIGRA_DEFINE_STL_FUNCTOR(std::less, VigraFalseType, VigraTrueType) 00142 VIGRA_DEFINE_STL_FUNCTOR(std::greater_equal, VigraFalseType, VigraTrueType) 00143 VIGRA_DEFINE_STL_FUNCTOR(std::less_equal, VigraFalseType, VigraTrueType) 00144 VIGRA_DEFINE_STL_FUNCTOR(std::logical_and, VigraFalseType, VigraTrueType) 00145 VIGRA_DEFINE_STL_FUNCTOR(std::logical_or, VigraFalseType, VigraTrueType) 00146 VIGRA_DEFINE_STL_FUNCTOR(std::binary_negate, VigraFalseType, VigraTrueType) 00147 00148 VIGRA_DEFINE_STL_FUNCTOR(std::negate, VigraTrueType, VigraFalseType) 00149 VIGRA_DEFINE_STL_FUNCTOR(std::logical_not, VigraTrueType, VigraFalseType) 00150 VIGRA_DEFINE_STL_FUNCTOR(std::unary_negate, VigraTrueType, VigraFalseType) 00151 VIGRA_DEFINE_STL_FUNCTOR(std::binder1st, VigraTrueType, VigraFalseType) 00152 VIGRA_DEFINE_STL_FUNCTOR(std::binder2nd, VigraTrueType, VigraFalseType) 00153 #undef VIGRA_DEFINE_STL_FUNCTOR 00154 00155 template <class R> 00156 class FunctorTraits<R (*)()> 00157 { 00158 public: 00159 typedef R (*type)(); 00160 00161 typedef VigraTrueType isInitializer; 00162 typedef VigraFalseType isUnaryFunctor; 00163 typedef VigraFalseType isBinaryFunctor; 00164 typedef VigraFalseType isTernaryFunctor; 00165 typedef VigraFalseType isUnaryAnalyser; 00166 typedef VigraFalseType isBinaryAnalyser; 00167 typedef VigraFalseType isTernaryAnalyser; 00168 }; 00169 00170 template <class R, class T> 00171 class FunctorTraits<R (*)(T)> 00172 { 00173 public: 00174 typedef R (*type)(T); 00175 00176 typedef VigraFalseType isInitializer; 00177 typedef VigraTrueType isUnaryFunctor; 00178 typedef VigraFalseType isBinaryFunctor; 00179 typedef VigraFalseType isTernaryFunctor; 00180 typedef VigraFalseType isUnaryAnalyser; 00181 typedef VigraFalseType isBinaryAnalyser; 00182 typedef VigraFalseType isTernaryAnalyser; 00183 }; 00184 00185 template <class R, class T1, class T2> 00186 class FunctorTraits<R (*)(T1, T2)> 00187 { 00188 public: 00189 typedef R (*type)(T1, T2); 00190 00191 typedef VigraFalseType isInitializer; 00192 typedef VigraFalseType isUnaryFunctor; 00193 typedef VigraTrueType isBinaryFunctor; 00194 typedef VigraFalseType isTernaryFunctor; 00195 typedef VigraFalseType isUnaryAnalyser; 00196 typedef VigraFalseType isBinaryAnalyser; 00197 typedef VigraFalseType isTernaryAnalyser; 00198 }; 00199 00200 template <class R, class T1, class T2, class T3> 00201 class FunctorTraits<R (*)(T1, T2, T3)> 00202 { 00203 public: 00204 typedef R (*type)(T1, T2, T3); 00205 00206 typedef VigraFalseType isInitializer; 00207 typedef VigraFalseType isUnaryFunctor; 00208 typedef VigraFalseType isBinaryFunctor; 00209 typedef VigraTrueType isTernaryFunctor; 00210 typedef VigraFalseType isUnaryAnalyser; 00211 typedef VigraFalseType isBinaryAnalyser; 00212 typedef VigraFalseType isTernaryAnalyser; 00213 }; 00214 00215 //@} 00216 00217 } // namespace vigra 00218 00219 #endif // VIGRA_FUNCTORTRAITS_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|