labelClasses.h

Go to the documentation of this file.

#ifndef TIL_LABEL_CLASSES_H
#define TIL_LABEL_CLASSES_H



// includes from TIL library
#include "til/templateTools.h"


namespace til
{

        // Predeclarations
        template < typename T > struct PointerTraits;

        // TODO: isn't it better to just have traits somewhere?
        // Especially since inheritance here is never used...


// This macro declares both a label class and the associated test class
// to test whether a class has this label or not.
// NB: to be undef at the end of the file
#define DEFINE_LABEL_CLASS(name) DEFINE_LABEL_CLASS_WITH_INHERITANCE(name, )

#define DEFINE_LABEL_CLASS_WITH_INHERITANCE(name, inherit)                        \
DEFINE_LABEL_CLASS_FULL(name##_label, Is##name)                                   \
DEFINE_TEST_CLASS_FULL(is_##name, Is##name, inherit)                              \

#define DEFINE_LABEL_CLASS_FULL(labelname, memtypename)                           \
class labelname { public: typedef void memtypename; };                            \


// Same as above, with possible inheritance
// NB: to be undef at the end of the file
// NB: using an enum instead of a static const bool brings in somw problems with template
// argument deduction, especially in CPPUNIT macros.
// NB: I used protected instead of private just to have gcc shut up that "all member functions 
// in class X are private"
#ifdef _MSC_VER
#define DEFINE_TEST_CLASS_FULL(testname, memtypename, inherit)                    \
template <typename T>                                                             \
class testname inherit                                                            \
{                                                                                 \
protected:                                                                        \
  typedef char Yes;                                                               \
  struct No { char a[2]; };                                                       \
  template <typename U> static Yes testfunc (typename U::memtypename const*);     \
  template <typename U> static No  testfunc (...);                                \
public:                                                                           \
  static const bool value = (sizeof(testfunc <T>(0)) == sizeof(Yes));                           \
};
#else
#define DEFINE_TEST_CLASS_FULL(testname, memtypename, inherit)                    \
template <typename T>                                                             \
class testname inherit                                                            \
{                                                                                 \
protected:                                                                        \
  typedef char Yes;                                                               \
  struct No { char a[2]; };                                                       \
  template <typename U> static Yes testfunc (typename U:: memtypename const*);    \
  template <typename U> static No  testfunc (...);                                \
public:                                                                           \
  enum {                                                                          \
    value = (sizeof(testname <T>::template testfunc <T>(0)) == sizeof(Yes))       \
  };                                                                              \
};
#endif

  DEFINE_TEST_CLASS_FULL(has_result_type, result_type, );

template < typename T >
class is_ImagePointer
{
protected:
        typedef char Yes;
        struct No { char a[2]; };
        template <typename U> static Yes isImagePointer(typename PointerTraits<U>::DataType::IsImagePointer const*);
        template <typename U> static No  isImagePointer(...);
public:
        enum {
                value = (sizeof(is_ImagePointer<T>::template isImagePointer<T>(0)) == sizeof(Yes))
        };
};
/*
template < typename T >
class is_detemplated_functor
{
private:
        typedef char Yes;
        struct No { char a[2]; };
        template
        template <typename U> static Yes zztest(typename U::TypeStruct<double>::type const*);
        template <typename U> static Yes zztest(typename U::TypeStruct<double,double>::type const*);
        template <typename U> static No  zztest(...);
public:
        / *
        enum {
                value = (sizeof(is_detemplated_functor<T>::template zztest<T>(0)) == sizeof(Yes))
        };
        * /
        static const bool value = (sizeof(zztest<T>(0)) == sizeof(Yes));
};
*/

        // Definitions begin here

        DEFINE_LABEL_CLASS(ExtrapolableImage);
        DEFINE_LABEL_CLASS(Image);
        DEFINE_LABEL_CLASS(ImageExtrapolator);
        DEFINE_LABEL_CLASS(ImageFunctor);
        DEFINE_LABEL_CLASS(ImageIterator);
        DEFINE_LABEL_CLASS(Interpolator);
        DEFINE_LABEL_CLASS(Mapping);
        //DEFINE_LABEL_CLASS(SmartPtr);
        DEFINE_LABEL_CLASS_WITH_INHERITANCE(VolumetricImageIterator, : public ImageIterator_label);
        //DEFINE_LABEL_CLASS(Neighborhood);
        DEFINE_LABEL_CLASS(detemplated_functor);
  DEFINE_LABEL_CLASS(minimization_algorithm_nd);
        

class Neighborhood_label { typedef void IsNeighborhood; };
template <typename T>
class is_Neighborhood
{
protected:
        typedef char Yes;
        struct No { char a[2]; };
        template <typename U> static Yes isNeighborhood (typename U::IsNeighborhood const*);
        template <typename U> static No  isNeighborhood (...);
public:
        //static const bool value = (sizeof(isNeighborhood <T>(0)) == 1);
        enum {
#ifdef _MSC_VER
                value = (sizeof(isNeighborhood <T>(0)) == 1)
#else
                value = (sizeof(is_Neighborhood<T>::template isNeighborhood<T>(0)) == sizeof(Yes))
#endif

        };
};


#undef DEFINE_LABEL_CLASS
#undef DEFINE_LABEL_CLASS_WITH_INHERITANCE
} // namespace

#endif