ContainerTraits.h

 
#pragma once
 
#if defined(ContainerTraits_RECURSES)
#error Recursive header files inclusion detected in ContainerTraits.h
#else // defined(ContainerTraits_RECURSES)
#define ContainerTraits_RECURSES
 
#if !defined ContainerTraits_h
#define ContainerTraits_h
 
// Inclusions
#include <iostream>
#include <vector>
#include <list>
#include <deque>
#include <set>
#include <map>
#include <boost/type_traits.hpp>
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
#include <array>
 
#include "DGtal/base/Common.h"
 
namespace DGtal
{
 
  // Tag classes for containers
  struct NotContainerCategory {};
  struct ContainerCategory {};
  struct SequenceCategory :  ContainerCategory {};
  struct AssociativeCategory :  ContainerCategory {};
  struct SimpleAssociativeCategory :  AssociativeCategory {};
  struct PairAssociativeCategory :  AssociativeCategory {};
  struct UniqueAssociativeCategory :  AssociativeCategory {};
  struct MultipleAssociativeCategory :  AssociativeCategory {};
  struct OrderedAssociativeCategory :  AssociativeCategory {};
  struct UnorderedAssociativeCategory :  AssociativeCategory {};
  struct SetAssociativeCategory :  OrderedAssociativeCategory, SimpleAssociativeCategory, UniqueAssociativeCategory {};
  struct MultisetAssociativeCategory :  OrderedAssociativeCategory, SimpleAssociativeCategory, MultipleAssociativeCategory {};
  struct MapAssociativeCategory :  OrderedAssociativeCategory, PairAssociativeCategory, UniqueAssociativeCategory {};
  struct MultimapAssociativeCategory :  OrderedAssociativeCategory, PairAssociativeCategory, MultipleAssociativeCategory {};
  struct UnorderedSetAssociativeCategory :  UnorderedAssociativeCategory, SimpleAssociativeCategory, UniqueAssociativeCategory {};
  struct UnorderedMultisetAssociativeCategory :  UnorderedAssociativeCategory, SimpleAssociativeCategory, MultipleAssociativeCategory {};
  struct UnorderedMapAssociativeCategory :  UnorderedAssociativeCategory, PairAssociativeCategory, UniqueAssociativeCategory {};
  struct UnorderedMultimapAssociativeCategory :  UnorderedAssociativeCategory, PairAssociativeCategory, MultipleAssociativeCategory {};
  
  template <typename TContainer>
  struct ContainerTraits 
  {
    typedef NotContainerCategory Category;
  };
 
  template < class T, class Alloc >
  struct ContainerTraits< std::vector<T, Alloc> >
  {
    typedef SequenceCategory Category;
  };
 
  template < class T, class Alloc >
  struct ContainerTraits< std::list<T, Alloc> >
  {
    typedef SequenceCategory Category;
  };
 
  template < class T, class Alloc >
  struct ContainerTraits< std::deque<T, Alloc> >
  {
    typedef SequenceCategory Category;
  };
  
  template < class T, class Alloc >
  struct ContainerTraits< std::forward_list<T, Alloc> >
  {
    typedef SequenceCategory Category;
  };
 
  template < class T, size_t N >
  struct ContainerTraits< std::array<T, N> >
  {
    typedef SequenceCategory Category;
  };
 
  template < class T, class Compare, class Alloc >
  struct ContainerTraits< std::set<T, Compare, Alloc> >
  {
    typedef SetAssociativeCategory Category;
  };
  
  template < class Key, class T, class Compare, class Alloc >
  struct ContainerTraits< std::map<Key, T, Compare, Alloc> >
  {
    typedef MapAssociativeCategory Category;
  };
 
  template < class T, class Compare, class Alloc >
  struct ContainerTraits< std::multiset<T, Compare, Alloc> >
  {
    typedef MultisetAssociativeCategory Category;
  };
  
  template < class Key, class T, class Compare, class Alloc >
  struct ContainerTraits< std::multimap<Key, T, Compare, Alloc> >
  {
    typedef MultimapAssociativeCategory Category;
  };
 
  template < typename Value, typename Hash, typename Pred, typename Alloc >
  struct ContainerTraits< boost::unordered_set<Value, Hash, Pred, Alloc> >
  {
    typedef UnorderedSetAssociativeCategory Category;
  };
 
  template < typename Value, typename Hash, typename Pred, typename Alloc >
  struct ContainerTraits< boost::unordered_multiset<Value, Hash, Pred, Alloc> >
  {
    typedef UnorderedMultisetAssociativeCategory Category;
  };
 
  template < typename Value, typename T, typename Hash, typename Pred, typename Alloc >
  struct ContainerTraits< boost::unordered_map<Value, T, Hash, Pred, Alloc> >
  {
    typedef UnorderedMapAssociativeCategory Category;
  };
 
  template < typename Value, typename T, typename Hash, typename Pred, typename Alloc >
  struct ContainerTraits< boost::unordered_multimap<Value, T, Hash, Pred, Alloc> >
  {
    typedef UnorderedMultimapAssociativeCategory Category;
  };
 
  template < class Key, class Hash, class Pred, class Alloc >
  struct ContainerTraits< std::unordered_set<Key, Hash, Pred, Alloc> >
  {
    typedef UnorderedSetAssociativeCategory Category;
  };
 
  template < class Key, class Hash, class Pred, class Alloc >
  struct ContainerTraits< std::unordered_multiset<Key, Hash, Pred, Alloc> >
  {
    typedef UnorderedMultisetAssociativeCategory Category;
  };
 
  template < class Key, class T, class Hash, class Pred, class Alloc >
  struct ContainerTraits< std::unordered_map<Key, T, Hash, Pred, Alloc> >
  {
    typedef UnorderedMapAssociativeCategory Category;
  };
 
  template < class Key, class T, class Hash, class Pred, class Alloc >
  struct ContainerTraits< std::unordered_multimap<Key, T, Hash, Pred, Alloc> >
  {
    typedef UnorderedMultimapAssociativeCategory Category;
  };
 
  namespace detail
  {
 
 
    template <typename T> 
    struct HasNestedTypeCategory 
    {
      typedef char yes[1]; 
      typedef char no[2]; 
      
      template <typename C>
      static yes& test(typename C::Category*);
      
      template <typename C>
      static no& test(...);
      
      BOOST_STATIC_CONSTANT(bool, value = sizeof(test<T>(0)) == sizeof(yes));  
    };
 
    template <typename TCategory>
    struct IsContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<ContainerCategory,TCategory>::value ) );
    };
 
    template <typename TCategory>
    struct IsSequenceContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<SequenceCategory,TCategory>::value ) );
    };
 
    template <typename TCategory>
    struct IsAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<AssociativeCategory,TCategory>::value ) );
    };
 
    template <typename TCategory>
    struct IsOrderedAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<OrderedAssociativeCategory,TCategory>::value ) );
    };
 
    template <typename TCategory>
    struct IsUnorderedAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<UnorderedAssociativeCategory,TCategory>::value ) );
    };
 
    template <typename TCategory>
    struct IsSimpleAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<SimpleAssociativeCategory,TCategory>::value ) );
    };
    
    template <typename TCategory>
    struct IsPairAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<PairAssociativeCategory,TCategory>::value ) );
    };
    
    template <typename TCategory>
    struct IsUniqueAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<UniqueAssociativeCategory,TCategory>::value ) );
    };
    
    template <typename TCategory>
    struct IsMultipleAssociativeContainerFromCategory {
      BOOST_STATIC_CONSTANT(bool, value = ( boost::is_base_of<MultipleAssociativeCategory,TCategory>::value ) );
    };
    
  }
 
  template <typename T>
  struct IsContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsSequenceContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsSequenceContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsOrderedAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsOrderedAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsUnorderedAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsUnorderedAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsSimpleAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsSimpleAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsPairAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsPairAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsUniqueAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsUniqueAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
  template <typename T>
  struct IsMultipleAssociativeContainer {
    BOOST_STATIC_CONSTANT( bool, 
                           value = ( detail::HasNestedTypeCategory< ContainerTraits<T> >::value
                                     && detail::IsMultipleAssociativeContainerFromCategory<typename ContainerTraits<T>::Category>::value ) );
  };
 
 
} // namespace DGtal
 
 
 
//                                                                           //
 
#endif // !defined ContainerTraits_h
 
#undef ContainerTraits_RECURSES
#endif // else defined(ContainerTraits_RECURSES)