itkConceptChecking.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
/*=========================================================================
 *
 *  Portions of this file are subject to the VTK Toolkit Version 3 copyright.
 *
 *  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
 *
 *  For complete copyright, license and disclaimer of warranty information
 *  please refer to the NOTICE file at the top of the ITK source tree.
 *
 *=========================================================================*/
#ifndef itkConceptChecking_h
#define itkConceptChecking_h
 
#include "itkPixelTraits.h"
#include "itkNumericTraits.h"
#include <iostream>
 
#ifndef ITK_CONCEPT_NO_CHECKING
#  if defined(_MSC_VER) && !defined(__ICL)
#    define ITK_CONCEPT_IMPLEMENTATION_VTABLE
// TST_RMV_20100730 #elif defined(__SUNPRO_CC)
// TST_RMV_20100730 #define ITK_CONCEPT_IMPLEMENTATION_VTABLE
#  else
#    define ITK_CONCEPT_IMPLEMENTATION_STANDARD
#  endif
#endif
 
#if defined(ITK_CONCEPT_IMPLEMENTATION_STANDARD)
 
// Leave ()'s off the sizeof to force the caller to pass them in the
// concept argument of the itkConceptMacro.  This is necessary because
// the argument may contain commas.
#  define itkConceptConstraintsMacro()                                                                                 \
    template <void (Constraints::*)()>                                                                                 \
    struct Enforcer                                                                                                    \
    {};                                                                                                                \
    using EnforcerInstantiation = Enforcer<&Constraints::constraints>;
#  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 defined(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 <bool>
struct UniqueType_bool
{};
 
template <typename T>
inline void IgnoreUnusedVariable(T)
{}
 
template <typename 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()
    {
      auto b = static_cast<T2>(a);
 
      Detail::IgnoreUnusedVariable(b);
    }
 
    T1 a;
  };
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct Assignable
{
  struct Constraints
  {
    void
    constraints()
    {
      T x = a;
      const_constraints(x);
    }
 
    void
    const_constraints(const T & b)
    {
      a = b;
    }
 
    T a;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1>
struct LessThanComparable
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::RequireBooleanExpression(a < b);
      Detail::RequireBooleanExpression(a <= b);
    }
 
    T1 a;
    T2 b;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1>
struct GreaterThanComparable
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::RequireBooleanExpression(a > b);
      Detail::RequireBooleanExpression(a >= b);
    }
 
    T1 a;
    T2 b;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1>
struct EqualityComparable
{
  struct Constraints
  {
    void
    constraints()
    {
      CLANG_PRAGMA_PUSH
      CLANG_SUPPRESS_Wfloat_equal Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      CLANG_PRAGMA_POP
    }
 
    T1 a;
    T2 b;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1>
struct Comparable
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::RequireBooleanExpression(a < b);
      Detail::RequireBooleanExpression(a > b);
      Detail::RequireBooleanExpression(a <= b);
      Detail::RequireBooleanExpression(a >= b);
      CLANG_PRAGMA_PUSH
      CLANG_SUPPRESS_Wfloat_equal Detail::RequireBooleanExpression(a == b);
      Detail::RequireBooleanExpression(a != b);
      CLANG_PRAGMA_POP
    }
 
    T1 a;
    T2 b;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1, typename T3 = T1>
struct AdditiveOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a = static_cast<T3>(b + c);
      a = static_cast<T3>(b - c);
      const_constraints(b, c);
    }
 
    void
    const_constraints(const T1 & d, const T2 & e)
    {
      a = static_cast<T3>(d + e);
      a = static_cast<T3>(d - e);
    }
 
    T3 a;
    T1 b;
    T2 c;
  };
 
  itkConceptConstraintsMacro();
};
 
 
template <typename T1, typename T2 = T1>
struct AdditiveAndAssignOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a += c;
      a -= c;
      const_constraints(c);
    }
 
    void
    const_constraints(const T1 & d)
    {
      a += d;
      a -= d;
    }
 
    T2 a;
    T1 c;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1, typename T3 = T1>
struct MultiplyOperator
{
  struct Constraints
  {
    void
    constraints()
    {
      a = static_cast<T3>(b * c);
      const_constraints(b, c);
    }
 
    void
    const_constraints(const T1 & d, const T2 & e)
    {
      a = static_cast<T3>(d * e);
    }
 
    T3 a;
    T1 b;
    T2 c;
  };
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1>
struct MultiplyAndAssignOperator
{
  struct Constraints
  {
    void
    constraints()
    {
      a *= b;
      const_constraints(b);
    }
 
    void
    const_constraints(const T1 & d)
    {
      a *= d;
    }
 
    T2 a;
    T1 b;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1, typename T3 = T1>
struct DivisionOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a = static_cast<T3>(b / c);
      const_constraints(b, c);
    }
 
    void
    const_constraints(const T1 & d, const T2 & e)
    {
      a = static_cast<T3>(d / e);
    }
 
    T3 a;
    T1 b;
    T2 c;
  };
 
  itkConceptConstraintsMacro();
};
 
 
template <typename T1, typename T2 = T1>
struct DivisionAndAssignOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a /= c;
      const_constraints(c);
    }
 
    void
    const_constraints(const T1 & d)
    {
      a /= d;
    }
 
    T1 c;
    T2 a;
  };
 
  itkConceptConstraintsMacro();
};
 
 
template <typename T1, typename T2 = T1, typename T3 = T1>
struct BitwiseOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a = static_cast<T3>(b & c);
      a = static_cast<T3>(b | c);
      a = static_cast<T3>(b ^ c);
      a &= static_cast<T3>(c);
      a |= static_cast<T3>(c);
      a ^= static_cast<T3>(c);
      const_constraints(b, c);
    }
 
    void
    const_constraints(const T1 & d, const T2 & e)
    {
      a = static_cast<T3>(d & e);
      a = static_cast<T3>(d | e);
      a = static_cast<T3>(d ^ e);
      a &= static_cast<T3>(e);
      a |= static_cast<T3>(e);
      a ^= static_cast<T3>(e);
    }
 
    T3 a;
    T1 b;
    T2 c;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2 = T1, typename T3 = T1>
struct BracketOperator
{
  struct Constraints
  {
    void
    constraints()
    {
      a = static_cast<T3>(b[c]);
      const_constraints(b, c);
    }
 
    void
    const_constraints(const T1 & d, const T2 & e)
    {
      a = static_cast<T3>(d[e]);
    }
 
    T3 a;
    T1 b;
    T2 c;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct NotOperator
{
  struct Constraints
  {
    void
    constraints()
    {
      a = !a;
    }
 
    T a;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct IncrementDecrementOperators
{
  struct Constraints
  {
    void
    constraints()
    {
      a++;
      a--;
      ++a;
      --a;
    }
 
    T a;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct OStreamWritable
{
  struct Constraints
  {
    void
    constraints()
    {
      std::cout << a;
    }
 
    T a;
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct Signed
{
  using Self = Signed;
  static constexpr bool IsSigned = NumericTraits<T>::is_signed;
  struct Constraints
  {
    using TrueT = Detail::UniqueType_bool<true>;
    using SignedT = Detail::UniqueType_bool<Self::IsSigned>;
    void
    constraints()
    {
      SignedT a = TrueT();
 
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  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
  {
    using DT1 = Detail::UniqueType_unsigned_int<D1>;
    using DT2 = Detail::UniqueType_unsigned_int<D2>;
    void
    constraints()
    {
      DT1 a = DT2();
 
      Detail::IgnoreUnusedVariable(a);
    }
  };
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct HasNumericTraits
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::UniqueType<typename NumericTraits<T>::ValueType>();
      Detail::UniqueType<typename NumericTraits<T>::PrintType>();
      Detail::UniqueType<typename NumericTraits<T>::AbsType>();
      Detail::UniqueType<typename NumericTraits<T>::AccumulateType>();
      Detail::UniqueType<typename NumericTraits<T>::RealType>();
      Detail::UniqueType<typename NumericTraits<T>::ScalarRealType>();
      Detail::UniqueType<typename NumericTraits<T>::FloatType>();
      T    a;
      bool b;
 
      // Test these methods that take an instance of T to
      // allow for types with variable length.
      a = NumericTraits<T>::NonpositiveMin(a);
      a = NumericTraits<T>::ZeroValue(a);
      a = NumericTraits<T>::OneValue(a);
 
      b = NumericTraits<T>::IsPositive(a);
      b = NumericTraits<T>::IsNonpositive(a);
      b = NumericTraits<T>::IsNegative(a);
      b = NumericTraits<T>::IsNonnegative(a);
      Detail::IgnoreUnusedVariable(a);
      Detail::IgnoreUnusedVariable(b);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct HasPixelTraits
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::UniqueType<typename PixelTraits<T>::ValueType>();
      unsigned int a = PixelTraits<T>::Dimension;
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct HasValueType
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::UniqueType<typename T::ValueType>();
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct HasZero
{
  struct Constraints
  {
    void
    constraints()
    {
      T a;
 
      a = NumericTraits<T>::ZeroValue();
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T1, typename T2>
struct HasJoinTraits
{
  struct Constraints
  {
    void
    constraints()
    {
      Detail::UniqueType<typename JoinTraits<T1, T2>::ValueType>();
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <unsigned int D1, unsigned int D2>
struct SameDimensionOrMinusOne
{
  struct Constraints
  {
    using Type1 = Detail::UniqueType_unsigned_int<D1>;
    using Type2 = Detail::UniqueType_unsigned_int<D1 - 1>;
 
    void f(Type1) {}
    void
    f(Type2, int = 0)
    {}
 
    void
    constraints()
    {
      Detail::UniqueType_unsigned_int<D2> tt;
      this->f(tt);
    }
  };
  itkConceptConstraintsMacro();
};
 
template <unsigned int D1, unsigned int D2>
struct SameDimensionOrMinusOneOrTwo
{
  struct Constraints
  {
    using Type1 = Detail::UniqueType_unsigned_int<D1>;
    using Type2 = Detail::UniqueType_unsigned_int<D1 - 1>;
    using Type3 = Detail::UniqueType_unsigned_int<D1 - 2>;
 
    void f(Type1) {}
    void
    f(Type2, int = 0)
    {}
    void
    f(Type3, int = 0, int = 0)
    {}
 
    void
    constraints()
    {
      Detail::UniqueType_unsigned_int<D2> tt;
      this->f(tt);
    }
  };
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct IsInteger
{
  using Self = IsInteger;
  static constexpr bool Integral = NumericTraits<T>::IsInteger;
  struct Constraints
  {
    using TrueT = Detail::UniqueType_bool<true>;
    using IntegralT = Detail::UniqueType_bool<Self::Integral>;
    void
    constraints()
    {
      IntegralT a = TrueT();
 
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
 
template <typename T>
struct IsUnsignedInteger
{
  using Self = IsUnsignedInteger;
  static constexpr bool Unsigned = !NumericTraits<T>::is_signed;
  struct Constraints
  {
    using TrueT = Detail::UniqueType_bool<true>;
    using UnsignedT = Detail::UniqueType_bool<Self::Unsigned>;
    void
    constraints()
    {
      UnsignedT a = TrueT();
 
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
 
template <typename T>
struct IsNonInteger
{
  using Self = IsNonInteger;
  static constexpr bool NonIntegral = NumericTraits<T>::IsInteger;
  struct Constraints
  {
    using FalseT = Detail::UniqueType_bool<false>;
    using NonIntegralT = Detail::UniqueType_bool<Self::NonIntegral>;
    void
    constraints()
    {
      NonIntegralT a = FalseT();
 
      Detail::IgnoreUnusedVariable(a);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct IsFloatingPoint
{
  using Self = IsFloatingPoint;
  static constexpr bool Integral = NumericTraits<T>::IsInteger;
  static constexpr bool IsExact = std::numeric_limits<typename NumericTraits<T>::ValueType>::is_exact;
  struct Constraints
  {
    using FalseT = Detail::UniqueType_bool<false>;
    using IntegralT = Detail::UniqueType_bool<Self::Integral>;
    using ExactT = Detail::UniqueType_bool<Self::IsExact>;
    void
    constraints()
    {
      IntegralT a = FalseT();
      ExactT    b = FalseT();
 
      Detail::IgnoreUnusedVariable(a);
      Detail::IgnoreUnusedVariable(b);
    }
  };
 
  itkConceptConstraintsMacro();
};
 
template <typename T>
struct IsFixedPoint
{
  using Self = IsFixedPoint;
  static constexpr bool Integral = NumericTraits<T>::IsInteger;
  static constexpr bool IsExact = std::numeric_limits<typename NumericTraits<T>::ValueType>::is_exact;
  struct Constraints
  {
    using TrueT = Detail::UniqueType_bool<true>;
    using FalseT = Detail::UniqueType_bool<false>;
    using IntegralT = Detail::UniqueType_bool<Self::Integral>;
    using ExactT = Detail::UniqueType_bool<Self::IsExact>;
    void
    constraints()
    {
      IntegralT a = FalseT();
      ExactT    b = TrueT();
 
      Detail::IgnoreUnusedVariable(a);
      Detail::IgnoreUnusedVariable(b);
    }
  };
 
  itkConceptConstraintsMacro();
};
} // end namespace Concept
} // end namespace itk
 
#endif