itkMetaProgrammingLibrary.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
 *
 *         https://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.
 *
 *=========================================================================*/
#ifndef itkMetaProgrammingLibrary_h
#define itkMetaProgrammingLibrary_h
 
#include "itkMacro.h"
#include "itkSmartPointer.h"
 
namespace itk
{
 
namespace mpl
{
 
struct TrueType
{
  using ValueType = bool;
  using Type = TrueType;
 
  static constexpr ValueType Value = true;
  operator ValueType() { return Value; }
};
 
struct FalseType
{
  using ValueType = bool;
  using Type = FalseType;
  static constexpr ValueType Value = false;
  operator ValueType() { return Value; }
};
 
template <bool VP, typename T1, typename T2>
struct If;
template <typename T1, typename T2>
struct If<true, T1, T2>
{
  using Type = T1;
};
template <typename T1, typename T2>
struct If<false, T1, T2>
{
  using Type = T2;
};
 
template <bool VF1, bool VF2, bool VF3 = false>
struct OrC : TrueType
{};
template <>
struct OrC<false, false, false> : FalseType
{};
 
template <typename TF1, typename TF2, typename TF3 = FalseType>
struct Or : OrC<TF1::Value, TF2::Value, TF3::Value>
{
  using Type = typename OrC<TF1::Value, TF2::Value, TF3::Value>::Type;
};
 
template <bool VF1, bool VF2>
struct AndC : FalseType
{};
template <>
struct AndC<true, true> : TrueType
{};
 
template <typename TF1, typename TF2>
struct And : AndC<TF1::Value, TF2::Value>
{
  using Type = typename AndC<TF1::Value, TF2::Value>::Type;
};
 
template <bool VF1, bool VF2>
struct XorC : FalseType
{};
template <>
struct XorC<true, false> : TrueType
{};
template <>
struct XorC<false, true> : TrueType
{};
 
template <typename TF1, typename TF2>
struct Xor : XorC<TF1::Value, TF2::Value>
{
  using Type = typename XorC<TF1::Value, TF2::Value>::Type;
};
 
template <bool VF>
struct NotC : FalseType
{};
template <>
struct NotC<false> : TrueType
{};
template <>
struct NotC<true> : FalseType
{};
 
template <typename TF>
struct Not : NotC<TF::Value>
{
  using Type = typename NotC<TF::Value>::Type;
};
 
template <typename T>
struct IsSmartPointer : FalseType
{};
 
 
template <typename T>
struct IsSmartPointer<SmartPointer<T>> : TrueType
{};
 
template <typename T>
struct IsSmartPointer<const SmartPointer<T>> : TrueType
{};
 
template <typename TFromType, typename TToType>
using is_static_castable =
  std::integral_constant<bool,
                         std::is_constructible_v<TToType, TFromType> || std::is_convertible_v<TFromType, TToType>>;
} // namespace mpl
 
 
// TrueType and FalseType have moved to itk::mpl.
// Expect itk::TrueType and itk::False type to be deprecated.
using mpl::TrueType;
using mpl::FalseType;
 
} // namespace itk
#endif // itkMetaProgrammingLibrary_h