sitkMemberFunctionFactoryBase.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.
 *
 *=========================================================================*/
#ifndef sitkMemberFunctionFactoryBase_h
#define sitkMemberFunctionFactoryBase_h
 
#include "sitkConfigure.h"
#include "sitkPixelIDTypes.h"
#include "sitkPixelIDTypeLists.h"
#include "sitkMacro.h"
#include "sitkNonCopyable.h"
 
#include "Ancillary/type_list2.h"
#include "Ancillary/FunctionTraits.h"
 
#include <unordered_map>
#include <functional>
#include <tuple>
 
namespace itk::simple::detail
{
 
// make hash function available in current name space to take priority
 
template <typename T>
struct hash : public std::hash<T>
{};
 
template <typename T>
inline void
hash_combine(std::size_t & seed, const T & val)
{
  // Code from boost
  // Reciprocal of the golden ratio helps spread entropy
  //     and handles duplicates.
  std::hash<T> hasher;
  seed ^= hasher(val) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
 
template <typename S, typename T>
struct hash<std::pair<S, T>>
{
  inline size_t
  operator()(const std::pair<S, T> & val) const
  {
    size_t seed = 0;
    hash_combine(seed, val.first);
    hash_combine(seed, val.second);
    return seed;
  }
};
 
template <class... TupleArgs>
struct hash<std::tuple<TupleArgs...>>
{
private:
  // recursive hashing of std::tuple from Sarang Baheti's blog
  // https://www.variadic.xyz/2018/01/15/hashing-stdpair-and-stdtuple/
  template <size_t Idx, typename... TupleTypes>
  inline typename std::enable_if<Idx == sizeof...(TupleTypes), void>::type
  hash_combine_tup(size_t &, const std::tuple<TupleTypes...> &) const
  {}
 
  template <size_t Idx, typename... TupleTypes>
    inline typename std::enable_if < Idx<sizeof...(TupleTypes), void>::type
                                     hash_combine_tup(size_t & seed, const std::tuple<TupleTypes...> & tup) const
  {
    hash_combine(seed, std::get<Idx>(tup));
 
    //  on to next element
    hash_combine_tup<Idx + 1>(seed, tup);
  }
 
public:
  size_t
  operator()(std::tuple<TupleArgs...> tupleValue) const
  {
    size_t seed = 0;
    hash_combine_tup<0>(seed, tupleValue);
    return seed;
  }
};
 
 
template <typename TMemberFunctionPointer,
          typename TKey,
          unsigned int TArity = ::detail::FunctionTraits<TMemberFunctionPointer>::arity>
class MemberFunctionFactoryBase;
 
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 0> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  using FunctionObjectType = std::function<MemberFunctionResultType()>;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
    return [pfunc, objectPointer] { return std::invoke(pfunc, objectPointer); };
  }
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 1> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgumentType = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  using FunctionObjectType = std::function<MemberFunctionResultType(MemberFunctionArgumentType)>;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
 
    return [pfunc, objectPointer](auto && PH1) -> MemberFunctionResultType {
      return std::invoke(pfunc, objectPointer, std::forward<decltype(PH1)>(PH1));
    };
  }
 
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 2> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  using FunctionObjectType =
    std::function<MemberFunctionResultType(MemberFunctionArgument0Type, MemberFunctionArgument1Type)>;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
    return [pfunc, objectPointer](auto && PH1, auto && PH2) {
      return std::invoke(pfunc, objectPointer, std::forward<decltype(PH1)>(PH1), std::forward<decltype(PH2)>(PH2));
    };
  }
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 3> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  using FunctionObjectType = std::function<
    MemberFunctionResultType(MemberFunctionArgument0Type, MemberFunctionArgument1Type, MemberFunctionArgument2Type)>;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
    return [pfunc, objectPointer](auto && PH1, auto && PH2, auto && PH3) {
      return std::invoke(pfunc,
                         objectPointer,
                         std::forward<decltype(PH1)>(PH1),
                         std::forward<decltype(PH2)>(PH2),
                         std::forward<decltype(PH3)>(PH3));
    };
  }
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 4> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using MemberFunctionArgument3Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument3Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  using FunctionObjectType = std::function<MemberFunctionResultType(MemberFunctionArgument0Type,
                                                                    MemberFunctionArgument1Type,
                                                                    MemberFunctionArgument2Type,
                                                                    MemberFunctionArgument3Type)>;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
    return [pfunc, objectPointer](auto && PH1, auto && PH2, auto && PH3, auto && PH4) {
      return std::invoke(pfunc,
                         objectPointer,
                         std::forward<decltype(PH1)>(PH1),
                         std::forward<decltype(PH2)>(PH2),
                         std::forward<decltype(PH3)>(PH3),
                         std::forward<decltype(PH4)>(PH4));
    };
  }
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
template <typename TMemberFunctionPointer, typename TKey>
class MemberFunctionFactoryBase<TMemberFunctionPointer, TKey, 5> : protected NonCopyable
{
protected:
  using MemberFunctionType = TMemberFunctionPointer;
  using MemberFunctionResultType = typename ::detail::FunctionTraits<MemberFunctionType>::ResultType;
  using MemberFunctionArgument0Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument0Type;
  using MemberFunctionArgument1Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument1Type;
  using MemberFunctionArgument2Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument2Type;
  using MemberFunctionArgument3Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument3Type;
  using MemberFunctionArgument4Type = typename ::detail::FunctionTraits<MemberFunctionType>::Argument4Type;
  using ObjectType = typename ::detail::FunctionTraits<MemberFunctionType>::ClassType;
 
 
  MemberFunctionFactoryBase()
    : m_PFunction(3 * typelist2::length<InstantiatedPixelIDTypeList>::value)
  {}
 
public:
  typedef std::function<MemberFunctionResultType(MemberFunctionArgument0Type,
                                                 MemberFunctionArgument1Type,
                                                 MemberFunctionArgument2Type,
                                                 MemberFunctionArgument3Type,
                                                 MemberFunctionArgument4Type)>
    FunctionObjectType;
 
 
protected:
  using KeyType = TKey;
 
  static FunctionObjectType
  BindObject(MemberFunctionType pfunc, ObjectType * objectPointer)
  {
    return [pfunc, objectPointer](auto && PH1, auto && PH2, auto && PH3, auto && PH4, auto && PH5) {
      return std::invoke(pfunc,
                         objectPointer,
                         std::forward<decltype(PH1)>(PH1),
                         std::forward<decltype(PH2)>(PH2),
                         std::forward<decltype(PH3)>(PH3),
                         std::forward<decltype(PH4)>(PH4),
                         std::forward<decltype(PH5)>(PH5));
    };
  }
 
 
  using FunctionMapType = std::unordered_map<TKey, FunctionObjectType, hash<TKey>>;
 
  // maps of Keys to pointers to member functions
  FunctionMapType m_PFunction;
};
 
} // namespace itk::simple::detail
 
#endif // sitkMemberFunctionFactoryBase_h