OpDetVisibilityData.h

Go to the documentation of this file.

#ifndef LARSIM_PHOTONPROPAGATION_LIBRARYMAPPINGTOOLS_OPDETVISIBILITYDATA_H
#define LARSIM_PHOTONPROPAGATION_LIBRARYMAPPINGTOOLS_OPDETVISIBILITYDATA_H

// LArSoft libraries
#include "lardataalg/Utilities/MappedContainer.h"

// C++ standard libraries
#include <iterator>    // std::size()
#include <type_traits> // std::enable_if_t<>
#include <utility>     // std::forward()

namespace phot {

  template <typename Cont, typename Enable = void>
  struct LibraryDataValidatorStruct;

  template <typename Cont>
  bool isValidLibraryData(Cont&& cont);

  template <typename Cont, typename Mapping>
  class OpDetVisibilityData : public util::MappedContainer<Cont, Mapping> {
    using ContainerBase_t = util::MappedContainer<Cont, Mapping>;

  public:
    // import types from base class
    using typename ContainerBase_t::DataContainer_t;
    using typename ContainerBase_t::Mapping_t;
    using typename ContainerBase_t::size_type;
    using typename ContainerBase_t::value_type;

  private:
    static size_type effectiveSize(DataContainer_t const& cont, size_type allegedSize);

    static size_type effectiveSize(DataContainer_t const& cont, Mapping_t const& mapping);

  public:
    // --- BEGIN Constructors --------------------------------------------------

    OpDetVisibilityData() = default;

    OpDetVisibilityData(DataContainer_t const& cont,
                        Mapping_t const& mapping,
                        size_type size,
                        value_type defValue)
      : ContainerBase_t(cont, mapping, effectiveSize(cont, size), defValue)
    {}

    OpDetVisibilityData(DataContainer_t const& cont, Mapping_t const& mapping, size_type size)
      : ContainerBase_t(cont, mapping, effectiveSize(cont, size))
    {}

    OpDetVisibilityData(DataContainer_t const& cont, Mapping_t const& mapping)
      : ContainerBase_t(cont, mapping, effectiveSize(cont, mapping))
    {}

    // --- END Constructors ----------------------------------------------------

    // --- BEGIN Validity information ------------------------------------------

    bool isValid() const { return !ContainerBase_t::empty(); }

    operator bool() const { return isValid(); }

    bool operator!() const { return !isValid(); }

    // --- END Validity information --------------------------------------------

  }; // OpDetVisibilityData

} // namespace phot

//------------------------------------------------------------------------------
//--- template implementation
//------------------------------------------------------------------------------

namespace phot {

  namespace details {

    //--------------------------------------------------------------------------
    template <typename Cont>
    auto generic_size(Cont&& cont)
    {
      using std::size;
      return size(std::forward<Cont>(cont));
    }

    //--------------------------------------------------------------------------
    // layered implementation of `LibraryDataValidatorStructStandardImpl`:

    // This is the last layer: if compiler points here,
    // the type `Cont` is not being supported yet:
    // - std::size() (or better, `generic_size()`)
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_size;

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_size<
      Cont,
      std::enable_if_t<util::always_true_v<decltype(generic_size(std::declval<Cont>()))>>> {
      static bool isValid(Cont const& cont) { return generic_size(cont) > 0U; }
    }; // struct LibraryDataValidatorStructStandardImpl_size

    // - Cont::empty()
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_empty
      : LibraryDataValidatorStructStandardImpl_size<Cont> {};

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_empty<
      Cont,
      std::enable_if_t<util::always_true_v<decltype(std::declval<Cont const>().empty())>>> {
      static bool isValid(Cont const& cont) { return !cont.empty(); }
    }; // struct LibraryDataValidatorStructStandardImpl_empty

    // - Cont::is_valid()
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_is_valid
      : LibraryDataValidatorStructStandardImpl_empty<Cont> {};

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_is_valid<
      Cont,
      std::enable_if_t<util::always_true_v<decltype(std::declval<Cont const>().is_valid())>>> {
      static bool isValid(Cont const& cont) { return cont.is_valid(); }
    }; // struct LibraryDataValidatorStructStandardImpl_is_valid

    // - Cont::isValid()
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_isValid
      : LibraryDataValidatorStructStandardImpl_is_valid<Cont> {};

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_isValid<
      Cont,
      std::enable_if_t<util::always_true_v<decltype(std::declval<Cont const>().isValid())>>> {
      static bool isValid(Cont const& cont) { return cont.isValid(); }
    }; // struct LibraryDataValidatorStructStandardImpl_isValid

    // - std::unique_ptr<> (using `enable_if` to catch all qualifiers)
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_unique_ptr
      : LibraryDataValidatorStructStandardImpl_isValid<Cont> {};

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_unique_ptr<
      Cont,
      std::enable_if_t<util::is_unique_ptr_v<Cont>>> {
      static bool isValid(Cont const& cont) { return bool(cont); }
    }; // struct LibraryDataValidatorStructStandardImpl_unique_ptr

    // C pointer types:
    template <typename T>
    struct LibraryDataValidatorStructStandardImpl_pointer_branch;

    // - T*
    template <typename T>
    struct LibraryDataValidatorStructStandardImpl_pointer_branch<T*> {
      static bool isValid(T* ptr) { return bool(ptr); }
    };

    // - T[]
    template <typename T>
    struct LibraryDataValidatorStructStandardImpl_pointer_branch<T[]>
      : LibraryDataValidatorStructStandardImpl_size<T*> {};

    // - T[N]
    template <typename T, std::size_t N>
    struct LibraryDataValidatorStructStandardImpl_pointer_branch<T[N]> {
      static bool isValid(T (&)[N]) { return N > 0U; }
    };

    // - entry point
    template <typename Cont, typename = void>
    struct LibraryDataValidatorStructStandardImpl_pointer
      : public LibraryDataValidatorStructStandardImpl_unique_ptr<Cont> {};

    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl_pointer<
      Cont,
      std::enable_if_t<std::is_pointer_v<std::decay_t<Cont>>>>
      : LibraryDataValidatorStructStandardImpl_pointer_branch<std::decay_t<Cont>> {};

    // - entry point
    template <typename Cont>
    struct LibraryDataValidatorStructStandardImpl
      : public LibraryDataValidatorStructStandardImpl_pointer<Cont> {};

    //--------------------------------------------------------------------------

  } // namespace details

  //----------------------------------------------------------------------------
  // we pick a standard implementation of our own, and let users add here
  template <typename Cont, typename /* = void */>
  struct LibraryDataValidatorStruct
    : public details::LibraryDataValidatorStructStandardImpl<std::remove_reference_t<Cont>> {};

  //----------------------------------------------------------------------------
  template <typename Cont>
  bool isValidLibraryData(Cont&& cont)
  {
    return LibraryDataValidatorStruct<std::remove_reference_t<Cont>>::isValid(cont);
  } // isValidLibraryData()

  //----------------------------------------------------------------------------
  template <typename Cont, typename Mapping>
  auto OpDetVisibilityData<Cont, Mapping>::effectiveSize(DataContainer_t const& cont,
                                                         size_type allegedSize) -> size_type
  {
    return isValidLibraryData(cont) ? allegedSize : 0U;
  }

  template <typename Cont, typename Mapping>
  auto OpDetVisibilityData<Cont, Mapping>::effectiveSize(DataContainer_t const& cont,
                                                         Mapping_t const& mapping) -> size_type
  {
    return isValidLibraryData(cont) ? ContainerBase_t::minimal_size(cont, mapping) : 0U;
  } // OpDetVisibilityData::effectiveSize(DataContainer_t, Mapping_t)

  //----------------------------------------------------------------------------

} // namespace phot

#endif // LARSIM_PHOTONPROPAGATION_LIBRARYMAPPINGTOOLS_OPDETVISIBILITYDATA_H