itkConceptChecking.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkConceptChecking.h,v $
  Language:  C++
  Date:      $Date: 2002/09/11 19:39:03 $
  Version:   $Revision: 1.8 $

  Copyright (c) 2002 Insight Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef _itkConceptChecking_h
#define _itkConceptChecking_h

#ifndef ITK_CONCEPT_NO_CHECKING
#  if defined(_MSC_VER) && !defined(__ICL)
#    define ITK_CONCEPT_IMPLEMENTATION_VTABLE
#  elif defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)
#    define ITK_CONCEPT_IMPLEMENTATION_VTABLE
#  elif defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x500)
#    define ITK_CONCEPT_IMPLEMENTATION_CALL
#  else
#    define ITK_CONCEPT_IMPLEMENTATION_STANDARD
#  endif
#endif

#if defined(ITK_CONCEPT_IMPLEMENTATION_STANDARD)

#  define itkConceptConstraintsMacro() \
    template <void (Constraints::*)()> struct Enforcer {}; \
    typedef Enforcer<&Constraints::constraints> EnforcerInstantiation
#  define itkConceptMacro(name, concept) enum { name = sizeof concept }

#elif defined(ITK_CONCEPT_IMPLEMENTATION_VTABLE)

#  define itkConceptConstraintsMacro() \
    virtual void Enforcer() { &Constraints::constraints; }
#  define itkConceptMacro(name, concept) enum { name = sizeof concept }

#elif define(ITK_CONCEPT_IMPLEMENTATION_CALL)

#  define itkConceptConstraintsMacro()
#  define itkConceptMacro(name, concept) enum { name = 0 }

#else

#  define itkConceptConstraintsMacro()
#  define itkConceptMacro(name, concept) enum { name = 0 }

#endif

namespace itk
{

namespace Concept
{

namespace Detail
{

template <typename T> struct UniqueType {};
template <int> struct UniqueType_int {};
template <unsigned int> struct UniqueType_unsigned_int {};

template <typename T> inline void IgnoreUnusedVariable(T) {}

template <class T>
void RequireBooleanExpression(const T& t)
{
  bool x = t;
  IgnoreUnusedVariable(x);
}

} // namespace Detail


template <typename T>
struct DefaultConstructible
{
  struct Constraints
  {
    void constraints()
      {
      T a;
      Detail::IgnoreUnusedVariable(a);
      }
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct CopyConstructible
{
  struct Constraints
  {
    void constraints()
      {
      T a(b);
      T* p = &a;
      const_constraints(a);
      Detail::IgnoreUnusedVariable(p);
      }
    void const_constraints(const T& a)
      {
      T c(a);
      const T* p = &a;
      Detail::IgnoreUnusedVariable(c);
      Detail::IgnoreUnusedVariable(p);
      }
    T b;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T1, typename T2>
struct Convertible
{
  struct Constraints
  {
    void constraints()
      {
      T2 b = a;
      Detail::IgnoreUnusedVariable(b);
      }
    T1 a;
  };
  itkConceptConstraintsMacro();
};

template <typename T>
struct Assignable
{
  struct Constraints
  {
    void constraints()
      {
      a = a;
      const_constraints(a);
      }
    void const_constraints(const T& b)
      {
      a = b;
      }
    T a;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct LessThanComparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a < b);
      }
    T a, b;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct EqualityComparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      }
    T a, b;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct Comparable
{
  struct Constraints
  {
    void constraints()
      {
      Detail::RequireBooleanExpression(a < b);
      Detail::RequireBooleanExpression(a > b);
      Detail::RequireBooleanExpression(a <= b);
      Detail::RequireBooleanExpression(a >= b);
      Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      }
    T a, b;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct AdditiveOperators
{
  struct Constraints
  {
    void constraints()
      {
      a = b + b;
      a = b - b;
      a += b;
      a -= b;
      const_constraints(b);
      }
    void const_constraints(const T& c)
      {
      a = c + c;
      a = c - c;
      a += c;
      a -= c;
      }
    T a, b;
  };
  
  itkConceptConstraintsMacro();
};

template <typename T>
struct MultiplicativeOperators
{
  struct Constraints
  {
    void constraints()
      {
      a = b * b;
      a = b / b;
      a *= b;
      a /= b;
      const_constraints(b);
      }
    void const_constraints(const T& c)
      {
      a = c * c;
      a = c / c;
      a *= c;
      a /= c;
      }
    T a, b;
  };
  
  itkConceptConstraintsMacro();
};

  
template <typename T1, typename T2>
struct SameType
{
  struct Constraints
  {
    void constraints()
      {
        Detail::UniqueType<T1> a = Detail::UniqueType<T2>();
        Detail::IgnoreUnusedVariable(a);
      }
  };
  itkConceptConstraintsMacro();
};

template <unsigned int D1, unsigned int D2>
struct SameDimension
{
  struct Constraints
  {
    typedef Detail::UniqueType_unsigned_int<D1> DT1;
    typedef Detail::UniqueType_unsigned_int<D2> DT2;
    void constraints()
      {
        DT1 a = DT2();
        Detail::IgnoreUnusedVariable(a);
      }
  };
  itkConceptConstraintsMacro();
};

} // namespace Concept

} // namespace itk

#endif

---