AssnsTraits.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEPROXY_PROXYBASE_ASSNSTRAITS_H
#define LARDATA_RECOBASEPROXY_PROXYBASE_ASSNSTRAITS_H

// LArSoft libraries
#include "larcorealg/CoreUtils/MetaUtils.h" // util::is_not_same<>

// framework libraries
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"

// C/C++ standard 
#include <utility> // std::pair


namespace lar {
  
  namespace util {
    
    //--- BEGIN Traits for art associations ------------------------------------
    
    
    //--------------------------------------------------------------------------
    // was proxy::details::hasMetadata
    template <typename Assns>
    struct assns_has_metadata;
    
    // was: proxy::details::AssnWithMetadata_v
    template <typename Assns>
    constexpr bool assns_has_metadata_v = assns_has_metadata<Assns>::value;
    
    
    // was: proxy::details::AssnsMetadataTypeStruct, proxy::details::AssnNodeMetadataType
    template <typename Assns>
    struct assns_metadata_type;
    
    // was: proxy::details::AssnsMetadata_t, proxy::details::AssnNodeMetadata_t
    template <typename Assns>
    using assns_metadata_t = typename assns_metadata_type<Assns>::type;
    
    
    //--------------------------------------------------------------------------
    // FIXME simplify this code if issue #18769 is accepted
    // was: proxy::details::AssnsIteratorTypeStruct
    template <typename Assns>
    struct assns_iterator_type;
    
    // was: proxy::details::AssnsIterator_t
    template <typename Assns>
    using assns_iterator_t = typename assns_iterator_type<Assns>::type;
    
    //--------------------------------------------------------------------------
    // was: proxy::details::AssnsNodeTraits
    template <typename Assns>
    struct assns_traits;
    
    
    //--------------------------------------------------------------------------
    
    //--- END Traits for art associations --------------------------------------
    
  } // namespace util
  
} // namespace lar



//------------------------------------------------------------------------------
//---  template implementation
//------------------------------------------------------------------------------
namespace lar {
  
  namespace util {
    
    namespace details {
      
      // was: proxy::details::isAssnMetadata
      template <typename T>
      using isAssnMetadata = ::util::is_not_same<T, void>;
      
      
      template <typename Assns>
      struct node_of;
      
      template <typename Assns>
      using node_of_t = typename node_of<Assns>::type;
      
      template <typename L, typename R, typename D>
      struct node_of<art::Assns<L, R, D>> {
        using type = art::AssnsNode<L, R, D>;
      };
      
      template <typename L, typename R>
      struct node_of<art::Assns<L, R, void>> {
        using type = std::pair<art::Ptr<L>, art::Ptr<R>>;
      };
    
    } // namespace details
      
    //--------------------------------------------------------------------------
    template <typename L, typename R, typename D>
    struct assns_metadata_type<art::Assns<L, R, D>> {
      using type = D;
    };
    
    template <typename L, typename R, typename D>
    struct assns_metadata_type<art::AssnsNode<L, R, D>> {
      using type = D;
    };
    
    template <typename L, typename R>
    struct assns_metadata_type<std::pair<art::Ptr<L>, art::Ptr<R>>> {
      using type = void;
    };
    
    
    //--------------------------------------------------------------------------
    template <typename Assns>
    struct assns_has_metadata
      : details::isAssnMetadata<assns_metadata_t<Assns>>
    {};
    
    
    //--------------------------------------------------------------------------
    template <typename L, typename R, typename D>
    struct assns_iterator_type<art::Assns<L, R, D>> {
      using type = typename art::Assns<L, R, D>::const_iterator;
    }; // struct assns_iterator_type
    
    
    template <typename L, typename R>
    struct assns_iterator_type<art::Assns<L, R, void>> {
      using type = typename art::Assns<L, R, void>::assn_iterator;
    };
    
    
    //--------------------------------------------------------------------------
    // was proxy::details::AssnsNodeTraitsBase
    template <typename L, typename R, typename D>
    struct assns_traits<art::Assns<L, R, D>> {
      
      using left_t = L; 
      using right_t = R; 
      using data_t = D; 
      using leftptr_t = art::Ptr<left_t>; 
      using rightptr_t = art::Ptr<right_t>; 
      using dataptr_t = data_t const*; 
      
      using assns_t = art::Assns<L, R, D>; 
      
      using assns_iterator_t = typename assns_iterator_type<assns_t>::type;
      
      using art_assns_node_t = details::node_of_t<assns_t>;
      
      static constexpr bool hasMetadata = details::isAssnMetadata<data_t>();
      
    }; // struct assns_traits<Assns<L,R,D>>
    
    
    template <typename L, typename R, typename D>
    struct assns_traits<art::AssnsNode<L, R, D>>
      : public assns_traits<art::Assns<L, R, D>>
    {};
    
    template <typename L, typename R>
    struct assns_traits<std::pair<art::Ptr<L>, art::Ptr<R>>>
      : public assns_traits<art::Assns<L, R>>
    {};
    
    
    //--------------------------------------------------------------------------
    
  } // namespace util
  
} // namespace lar


#endif // LARDATA_RECOBASEPROXY_PROXYBASE_ASSNSTRAITS_H