[ 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.5.0, Dec 07 2006 ) */ 00008 /* The VIGRA Website is */ 00009 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00010 /* Please direct questions, bug reports, and contributions to */ 00011 /* koethe@informatik.uni-hamburg.de or */ 00012 /* vigra@kogs1.informatik.uni-hamburg.de */ 00013 /* */ 00014 /* Permission is hereby granted, free of charge, to any person */ 00015 /* obtaining a copy of this software and associated documentation */ 00016 /* files (the "Software"), to deal in the Software without */ 00017 /* restriction, including without limitation the rights to use, */ 00018 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00019 /* sell copies of the Software, and to permit persons to whom the */ 00020 /* Software is furnished to do so, subject to the following */ 00021 /* conditions: */ 00022 /* */ 00023 /* The above copyright notice and this permission notice shall be */ 00024 /* included in all copies or substantial portions of the */ 00025 /* Software. */ 00026 /* */ 00027 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00028 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00029 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00030 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00031 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00032 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00033 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00034 /* OTHER DEALINGS IN THE SOFTWARE. */ 00035 /* */ 00036 /************************************************************************/ 00037 00038 00039 #ifndef VIGRA_FUNCTORTRAITS_HXX 00040 #define VIGRA_FUNCTORTRAITS_HXX 00041 00042 #include <functional> 00043 #include "metaprogramming.hxx" 00044 00045 namespace vigra { 00046 00047 template <class T> 00048 class FunctorTraitsBase 00049 { 00050 public: 00051 typedef T type; 00052 00053 typedef VigraFalseType isInitializer; 00054 00055 typedef VigraFalseType isUnaryFunctor; 00056 typedef VigraFalseType isBinaryFunctor; 00057 typedef VigraFalseType isTernaryFunctor; 00058 00059 typedef VigraFalseType isUnaryAnalyser; 00060 typedef VigraFalseType isBinaryAnalyser; 00061 typedef VigraFalseType isTernaryAnalyser; 00062 }; 00063 00064 00065 00066 /** \addtogroup Functors 00067 */ 00068 //@{ 00069 /** \brief Export associated information for a functor. 00070 00071 The FunctorTraits class contains the following fields: 00072 00073 \code 00074 template <class T> 00075 struct FunctorTraits 00076 { 00077 typedef T type; 00078 00079 typedef ... isInitializer; 00080 00081 typedef ... isUnaryFunctor; 00082 typedef ... isBinaryFunctor; 00083 typedef ... isTernaryFunctor; 00084 00085 typedef ... isUnaryAnalyser; 00086 typedef ... isBinaryAnalyser; 00087 typedef ... isTernaryAnalyser; 00088 }; 00089 \endcode 00090 00091 Where the dots are either <tt>VigraTrueType</tt> or <tt>VigraFalseType</tt> 00092 depending on whether the functor supports the respective functionality or not. 00093 If a functor <tt>f<tt> is a model of these categories, it supports the following 00094 calls (<tt>v</tt> is a variable such that the result type of the functor 00095 calls can be converted into <tt>v</tt>'s type, and <tt>a1, a2, a3</tt> are 00096 variables convertible into the functor's argument types): 00097 00098 <DL> 00099 <DT><b>Initializer</b> 00100 <DD> <tt>v = f()</tt> (used with initImageWithFunctor()) 00101 <DT><b>UnaryFunctor</b> 00102 <DD> <tt>v = f(a1)</tt> (used with transformImage()) 00103 <DT><b>BinaryFunctor</b> 00104 <DD> <tt>v = f(a1, a2)</tt> (used with combineTwoImages()) 00105 <DT><b>TernaryFunctor</b> 00106 <DD> <tt>v = f(a1, a2, a3)</tt> (used with combineThreeImages()) 00107 <DT><b>UnaryAnalyser</b> 00108 <DD> <tt>f(a1)</tt> (return type <tt>void>/tt>, used with inspectImage()) 00109 <DT><b>BinaryAnalyser</b> 00110 <DD> <tt>f(a1, a2)</tt> (return type <tt>void>/tt>, used with inspectTwoImages()) 00111 <DT><b>TernaryAnalyser</b> 00112 <DD> <tt>f(a1, a2, a3)</tt> (return type <tt>void>/tt>) 00113 </DL> 00114 00115 It should be noted that the functor's argument and result types are not contained 00116 in the traits class: Since the function calls are often member template functions in 00117 VIGRA, many functors do not have fixed argument types. Neither are the result 00118 types fixed in this case because they are computed (via a template meta-program) 00119 from the argument types. 00120 00121 <b>\#include</b> "<a href="functortraits_8hxx-source.html">vigra/functortraits.hxx</a>" 00122 Namespace: vigra 00123 */ 00124 template <class T> 00125 class FunctorTraits 00126 : public FunctorTraitsBase<T> 00127 {}; 00128 00129 #define VIGRA_DEFINE_STL_FUNCTOR(name, unary, binary) \ 00130 template <class T> \ 00131 class FunctorTraits<name<T> > \ 00132 { \ 00133 public: \ 00134 typedef T type; \ 00135 \ 00136 typedef VigraFalseType isInitializer; \ 00137 \ 00138 typedef unary isUnaryFunctor; \ 00139 typedef binary isBinaryFunctor; \ 00140 typedef VigraFalseType isTernaryFunctor; \ 00141 \ 00142 typedef VigraFalseType isUnaryAnalyser; \ 00143 typedef VigraFalseType isBinaryAnalyser; \ 00144 typedef VigraFalseType isTernaryAnalyser; \ 00145 }; 00146 00147 // ???TODO: these should also be specialized for the ptr_fun and mem_fun_ptr wrappers 00148 VIGRA_DEFINE_STL_FUNCTOR(std::plus, VigraFalseType, VigraTrueType) 00149 VIGRA_DEFINE_STL_FUNCTOR(std::minus, VigraFalseType, VigraTrueType) 00150 VIGRA_DEFINE_STL_FUNCTOR(std::multiplies, VigraFalseType, VigraTrueType) 00151 VIGRA_DEFINE_STL_FUNCTOR(std::divides, VigraFalseType, VigraTrueType) 00152 VIGRA_DEFINE_STL_FUNCTOR(std::modulus, VigraFalseType, VigraTrueType) 00153 VIGRA_DEFINE_STL_FUNCTOR(std::equal_to, VigraFalseType, VigraTrueType) 00154 VIGRA_DEFINE_STL_FUNCTOR(std::not_equal_to, VigraFalseType, VigraTrueType) 00155 VIGRA_DEFINE_STL_FUNCTOR(std::greater, VigraFalseType, VigraTrueType) 00156 VIGRA_DEFINE_STL_FUNCTOR(std::less, VigraFalseType, VigraTrueType) 00157 VIGRA_DEFINE_STL_FUNCTOR(std::greater_equal, VigraFalseType, VigraTrueType) 00158 VIGRA_DEFINE_STL_FUNCTOR(std::less_equal, VigraFalseType, VigraTrueType) 00159 VIGRA_DEFINE_STL_FUNCTOR(std::logical_and, VigraFalseType, VigraTrueType) 00160 VIGRA_DEFINE_STL_FUNCTOR(std::logical_or, VigraFalseType, VigraTrueType) 00161 VIGRA_DEFINE_STL_FUNCTOR(std::binary_negate, VigraFalseType, VigraTrueType) 00162 00163 VIGRA_DEFINE_STL_FUNCTOR(std::negate, VigraTrueType, VigraFalseType) 00164 VIGRA_DEFINE_STL_FUNCTOR(std::logical_not, VigraTrueType, VigraFalseType) 00165 VIGRA_DEFINE_STL_FUNCTOR(std::unary_negate, VigraTrueType, VigraFalseType) 00166 VIGRA_DEFINE_STL_FUNCTOR(std::binder1st, VigraTrueType, VigraFalseType) 00167 VIGRA_DEFINE_STL_FUNCTOR(std::binder2nd, VigraTrueType, VigraFalseType) 00168 #undef VIGRA_DEFINE_STL_FUNCTOR 00169 00170 template <class R> 00171 class FunctorTraits<R (*)()> 00172 { 00173 public: 00174 typedef R (*type)(); 00175 00176 typedef VigraTrueType isInitializer; 00177 typedef VigraFalseType 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 T> 00186 class FunctorTraits<R (*)(T)> 00187 { 00188 public: 00189 typedef R (*type)(T); 00190 00191 typedef VigraFalseType isInitializer; 00192 typedef VigraTrueType isUnaryFunctor; 00193 typedef VigraFalseType 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> 00201 class FunctorTraits<R (*)(T1, T2)> 00202 { 00203 public: 00204 typedef R (*type)(T1, T2); 00205 00206 typedef VigraFalseType isInitializer; 00207 typedef VigraFalseType isUnaryFunctor; 00208 typedef VigraTrueType isBinaryFunctor; 00209 typedef VigraFalseType isTernaryFunctor; 00210 typedef VigraFalseType isUnaryAnalyser; 00211 typedef VigraFalseType isBinaryAnalyser; 00212 typedef VigraFalseType isTernaryAnalyser; 00213 }; 00214 00215 template <class R, class T1, class T2, class T3> 00216 class FunctorTraits<R (*)(T1, T2, T3)> 00217 { 00218 public: 00219 typedef R (*type)(T1, T2, T3); 00220 00221 typedef VigraFalseType isInitializer; 00222 typedef VigraFalseType isUnaryFunctor; 00223 typedef VigraFalseType isBinaryFunctor; 00224 typedef VigraTrueType isTernaryFunctor; 00225 typedef VigraFalseType isUnaryAnalyser; 00226 typedef VigraFalseType isBinaryAnalyser; 00227 typedef VigraFalseType isTernaryAnalyser; 00228 }; 00229 00230 //@} 00231 00232 } // namespace vigra 00233 00234 #endif // VIGRA_FUNCTORTRAITS_HXX
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|