ArcProperties.h

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt 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 notice for more information.
//=========================================================================
 
#ifndef smtk_graph_ArcProperties_h
#define smtk_graph_ArcProperties_h
 
#include "smtk/Metaprogramming.h"
#include "smtk/common/Visit.h"
#include "smtk/graph/OwnershipSemantics.h"
#include "smtk/string/Token.h"
 
#include <functional>
#include <iterator>
#include <set>
#include <type_traits>
 
namespace smtk
{
namespace graph
{
 
constexpr inline std::size_t unconstrained()
{
  return std::numeric_limits<std::size_t>::max();
}
 
template<typename ArcTraits>
class ArcProperties
{
  template<class>
  struct type_sink
  {
    using type = void;
  }; // consume a type and make it `void`
  template<class T>
  using type_sink_t = typename type_sink<T>::type;
 
public:
  template<class T, class = void>
  struct hasOutVisitor : std::false_type
  {
  };
  template<class T>
  struct hasOutVisitor<
    T,
    type_sink_t<decltype(std::declval<T>().outVisitor(
      nullptr,
      std::function<smtk::common::Visited(typename T::ToType const*)>()))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasInVisitor : std::false_type
  {
  };
  template<class T>
  struct hasInVisitor<
    T,
    type_sink_t<decltype(std::declval<T>().inVisitor(
      nullptr,
      std::function<smtk::common::Visited(typename T::FromType const*)>()))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasOutNodeVisitor : std::false_type
  {
  };
  template<class T>
  struct hasOutNodeVisitor<
    T,
    type_sink_t<decltype(std::declval<T>().visitAllOutgoingNodes(
      nullptr,
      std::function<smtk::common::Visited(typename T::FromType const*)>()))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasInNodeVisitor : std::false_type
  {
  };
  template<class T>
  struct hasInNodeVisitor<
    T,
    type_sink_t<decltype(std::declval<T>().visitAllIncomingNodes(
      nullptr,
      std::function<smtk::common::Visited(typename T::ToType const*)>()))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasContains : std::false_type
  {
  };
  template<class T>
  struct hasContains<
    T,
    type_sink_t<decltype(std::declval<T>().contains(
      static_cast<const typename ArcTraits::FromType*>(nullptr),
      static_cast<const typename ArcTraits::ToType*>(nullptr)))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasOutDegree : std::false_type
  {
  };
  template<class T>
  struct hasOutDegree<
    T,
    type_sink_t<decltype(std::declval<T>().outDegree(
      static_cast<const typename ArcTraits::FromType*>(nullptr)))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasInDegree : std::false_type
  {
  };
  template<class T>
  struct hasInDegree<
    T,
    type_sink_t<decltype(std::declval<T>().inDegree(
      static_cast<const typename ArcTraits::ToType*>(nullptr)))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasConnect : std::false_type
  {
  };
  template<class T>
  struct hasConnect<
    T,
    type_sink_t<decltype(std::declval<T>().connect(
      static_cast<typename ArcTraits::FromType*>(nullptr),
      static_cast<typename ArcTraits::ToType*>(nullptr),
      static_cast<typename ArcTraits::FromType*>(nullptr),
      static_cast<typename ArcTraits::ToType*>(nullptr)))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasDisconnect : std::false_type
  {
  };
  template<class T>
  struct hasDisconnect<
    T,
    type_sink_t<decltype(std::declval<T>().disconnect(
      static_cast<typename ArcTraits::FromType*>(nullptr),
      static_cast<typename ArcTraits::ToType*>(nullptr)))>> : std::true_type
  {
  };
 
  template<class T, class = void>
  struct hasOnlyForwardIndex : std::false_type
  {
  };
  template<class T>
  struct hasOnlyForwardIndex<T, type_sink_t<typename T::ForwardIndexOnly>>
    : std::conditional<T::ForwardIndexOnly::value, std::true_type, std::false_type>::type
  {
  };
 
  template<class T, class = void>
  struct hasImmutableMark : std::false_type
  {
  };
  template<class T>
  struct hasImmutableMark<T, type_sink_t<typename T::Immutable>> : std::true_type
  {
    // Complain if we have ForwardIndexOnly but it is not true.
    static_assert(T::Immutable::value, "Immutable must be true_type if present.");
  };
 
  class isOrdered
  {
  public:
    using type = typename hasOnlyForwardIndex<ArcTraits>::type;
    static constexpr bool value = type::value;
  };
 
  class isOnlyForwardIndexed
  {
  public:
    using type = typename disjunction<
      // We have an inVisitor but want to disable it (using OnlyForwardIndex)
      conjunction<hasOnlyForwardIndex<ArcTraits>, hasInVisitor<ArcTraits>>,
      // We do not have an inVisitor but do have an outVisitor
      conjunction<negation<hasInVisitor<ArcTraits>>, hasOutVisitor<ArcTraits>>>::type;
    static constexpr bool value = type::value;
  };
 
  class isImplicit
  {
  public:
    using type = typename conjunction<
      // We must have an outVisitor() method.
      hasOutVisitor<ArcTraits>,
      // We must have an inVisitor() method or be marked as only allowing forward traversal.
      disjunction<isOnlyForwardIndexed, hasInVisitor<ArcTraits>>>::type;
    static constexpr bool value = type::value;
  };
 
  class isExplicit
  {
  public:
    using type = typename negation<isImplicit>::type;
    static constexpr bool value = type::value;
  };
 
  class isMutable
  {
  public:
    using type = typename conjunction<
      negation<hasImmutableMark<ArcTraits>>,
      disjunction<
        conjunction<isImplicit, hasConnect<ArcTraits>, hasDisconnect<ArcTraits>>,
        isExplicit>>::type;
    static constexpr bool value = type::value;
  };
 
  class isAutoUndirected
  {
  public:
    using type = typename conjunction<
      std::is_same<typename ArcTraits::FromType, typename ArcTraits::ToType>,
      negation<typename ArcTraits::Directed>>::type;
    static constexpr bool value = type::value;
  };
 
protected:
  template<class T, class = void>
  struct hasSemantics : std::false_type
  {
    inline constexpr OwnershipSemantics operator()() const { return OwnershipSemantics::None; }
  };
  template<class T>
  struct hasSemantics<T, type_sink_t<decltype(T::semantics)>> : std::true_type
  {
    inline constexpr OwnershipSemantics operator()() const { return T::semantics; }
  };
 
public:
  inline static constexpr OwnershipSemantics ownershipSemantics()
  {
    return hasSemantics<ArcTraits>()();
  }
};
 
 
template<typename T>
constexpr
  typename std::enable_if<std::is_integral<decltype(T::MaxOutDegree)>::value, std::size_t>::type
    maxOutDegree(std::size_t)
{
  return T::MaxOutDegree;
}
 
template<typename T>
constexpr std::size_t maxOutDegree(...)
{
  return smtk::graph::unconstrained();
}
 
 
template<typename T>
constexpr
  typename std::enable_if<std::is_integral<decltype(T::MaxInDegree)>::value, std::size_t>::type
    maxInDegree(std::size_t)
{
  return T::MaxInDegree;
}
 
template<typename T>
constexpr std::size_t maxInDegree(...)
{
  return smtk::graph::unconstrained();
}
 
 
template<typename T>
constexpr
  typename std::enable_if<std::is_integral<decltype(T::MinOutDegree)>::value, std::size_t>::type
    minOutDegree(std::size_t)
{
  return T::MinOutDegree;
}
 
template<typename T>
constexpr std::size_t minOutDegree(...)
{
  return 0;
}
 
 
template<typename T>
constexpr
  typename std::enable_if<std::is_integral<decltype(T::MinInDegree)>::value, std::size_t>::type
    minInDegree(std::size_t)
{
  return T::MinInDegree;
}
 
template<typename T>
constexpr std::size_t minInDegree(...)
{
  return 0;
}
 
} // namespace graph
} // namespace smtk
 
#endif