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>::const_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