VIGRA - vigra/functortraits.hxx Source File

[ 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) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.5.0 (7 Dec 2006)