GeometryDataContainers.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H
#define LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H

// LArSoft libraries
#include "larcorealg/CoreUtils/span.h"
#include "larcorealg/Geometry/GeometryIDmapper.h"
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// Boost libraries
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/transform_iterator.hpp>

// C/C++ standard libraries
#include <algorithm> // std::fill(), std::for_each()
#include <cassert>
#include <initializer_list>
#include <stdexcept> // std::out_of_range
#include <string>
#include <utility> // std::forward()
#include <vector>

namespace geo {

  template <typename T, typename Mapper>
  class GeoIDdataContainer;

  template <typename T>
  class TPCDataContainer;

  template <typename T>
  class PlaneDataContainer;

  // ---------------------------------------------------------------------------
  namespace details {

    template <typename T>
    class GeoContainerData;

    template <typename GeoIDdataContainerClass, typename BaseIterator>
    class GeoIDdataContainerIterator;

    template <typename GeoIDIteratorClass>
    class GeoIDdataContainerItemIterator;

  } // namespace details
  // ---------------------------------------------------------------------------

} // namespace geo

// --- BEGIN Geometry data containers ----------------------------------------


template <typename T, typename Mapper>
class geo::GeoIDdataContainer {

  using This_t = geo::GeoIDdataContainer<T, Mapper>; 

  using Container_t = details::GeoContainerData<T>;

  using BaseIter_t = typename Container_t::iterator;

  using BaseConstIter_t = typename Container_t::const_iterator;

  struct IDextractor {
    template <typename Obj>
    decltype(auto) operator()(Obj&& obj) const
    {
      return obj.ID();
    }
  }; // struct IDextractor

public:
  using Mapper_t = Mapper;

  using ID_t = typename Mapper_t::ID_t; 


  using value_type = typename Container_t::value_type;
  using reference = typename Container_t::reference;
  using const_reference = typename Container_t::const_reference;
  using pointer = typename Container_t::pointer;
  using const_pointer = typename Container_t::const_pointer;
  using iterator = details::GeoIDdataContainerIterator<Mapper_t, BaseIter_t>;
  using const_iterator = details::GeoIDdataContainerIterator<Mapper_t, BaseConstIter_t>;
  //     using reverse_iterator       = typename Container_t::reverse_iterator      ;
  //     using const_reverse_iterator = typename Container_t::const_reverse_iterator;
  using difference_type = typename Container_t::difference_type;
  using size_type = typename Container_t::size_type;

  using item_iterator = details::GeoIDdataContainerItemIterator<iterator>;

  using item_const_iterator = details::GeoIDdataContainerItemIterator<const_iterator>;


  GeoIDdataContainer() = default;

  GeoIDdataContainer(std::initializer_list<unsigned int> dims);

  GeoIDdataContainer(std::initializer_list<unsigned int> dims, value_type const& defValue);

  // --- BEGIN Container status query ----------------------------------------

  size_type size() const;

  size_type capacity() const;

  bool empty() const;

  template <std::size_t Level>
  unsigned int dimSize() const;

  static constexpr unsigned int dimensions();

  template <typename GeoID>
  bool hasElement(GeoID const& id) const;

  template <typename GeoID = ID_t>
  GeoID firstID() const;

  template <typename GeoID = ID_t>
  GeoID lastID() const;

  Mapper_t const& mapper() const;

  // --- END Container status query ------------------------------------------

  // --- BEGIN Element access ------------------------------------------------


  reference operator[](ID_t const& id);

  const_reference operator[](ID_t const& id) const;

  reference at(ID_t const& id);

  const_reference at(ID_t const& id) const;

  reference first();

  const_reference first() const;

  reference last();

  const_reference last() const;

  // --- END Element access --------------------------------------------------

  // --- BEGIN Iterators -----------------------------------------------------

  iterator begin();

  iterator end();

  const_iterator begin() const;

  const_iterator end() const;

  const_iterator cbegin() const;

  const_iterator cend() const;

  item_iterator item_begin();

  item_iterator item_end();

  item_const_iterator item_begin() const;

  item_const_iterator item_end() const;

  item_const_iterator item_cbegin() const;

  item_const_iterator item_cend() const;

  auto items();

  auto items() const;

  // --- END Iterators -------------------------------------------------------

  // --- BEGIN Data modification ---------------------------------------------

  void fill(value_type value);

  void reset();

  template <typename Op>
  Op apply(Op&& op);

  template <typename Op>
  decltype(auto) apply(Op&& op) const;

  // --- END Data modification -------------------------------------------------

  // --- BEGIN Container modification ------------------------------------------

  void resize(std::initializer_list<unsigned int> dims);

  void resize(std::initializer_list<unsigned int> dims, value_type const& defValue);

  template <typename OT>
  void resizeAs(geo::GeoIDdataContainer<OT, Mapper_t> const& other);

  template <typename OT>
  void resizeAs(geo::GeoIDdataContainer<OT, Mapper_t> const& other, value_type const& defValue);

  void clear();

  // --- END Container modification --------------------------------------------

private:
  Mapper_t fMapper; 

  Container_t fData; 

  size_type index(ID_t const& id) const;

  ID_t ID(size_type const index) const;

}; // class geo::GeoIDdataContainer<>

//------------------------------------------------------------------------------
template <typename T>
class geo::TPCDataContainer : public geo::GeoIDdataContainer<T, geo::TPCIDmapper<>> {

  using BaseContainer_t = geo::GeoIDdataContainer<T, geo::TPCIDmapper<>>;

public:
  using value_type = typename BaseContainer_t::value_type;

  TPCDataContainer() = default;

  TPCDataContainer(unsigned int nCryo, unsigned int nTPCs) : BaseContainer_t({nCryo, nTPCs}) {}

  TPCDataContainer(unsigned int nCryo, unsigned int nTPCs, value_type const& defValue)
    : BaseContainer_t({nCryo, nTPCs}, defValue)
  {}

  // --- BEGIN Container modification ------------------------------------------

  void resize(unsigned int nCryo, unsigned int nTPCs) { BaseContainer_t::resize({nCryo, nTPCs}); }

  void resize(unsigned int nCryo, unsigned int nTPCs, T const& defValue)
  {
    BaseContainer_t::resize({nCryo, nTPCs}, defValue);
  }

  // --- END Container modification --------------------------------------------

  // --- BEGIN Container status query ------------------------------------------

  bool hasCryostat(geo::CryostatID const& cryoid) const
  {
    return BaseContainer_t::hasElement(cryoid);
  }

  bool hasTPC(geo::TPCID const& tpcid) const { return BaseContainer_t::hasElement(tpcid); }

  // --- END Container status query --------------------------------------------

}; // class geo::details::TPCDataContainer<>

//------------------------------------------------------------------------------
template <typename T>
class geo::PlaneDataContainer : public geo::GeoIDdataContainer<T, geo::PlaneIDmapper<>> {

  using BaseContainer_t = geo::GeoIDdataContainer<T, geo::PlaneIDmapper<>>;

public:
  PlaneDataContainer() = default;

  PlaneDataContainer(unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes)
    : BaseContainer_t({nCryo, nTPCs, nPlanes})
  {}

  PlaneDataContainer(unsigned int nCryo,
                     unsigned int nTPCs,
                     unsigned int nPlanes,
                     T const& defValue)
    : BaseContainer_t{{nCryo, nTPCs, nPlanes}, defValue}
  {}

  // --- BEGIN Container modification ------------------------------------------

  void resize(unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes)
  {
    BaseContainer_t::resize({nCryo, nTPCs, nPlanes});
  }

  void resize(unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes, T const& defValue)
  {
    BaseContainer_t::resize({nCryo, nTPCs, nPlanes}, defValue);
  }

  // --- END Container modification --------------------------------------------

  // --- BEGIN Container status query ------------------------------------------

  bool hasCryostat(geo::CryostatID const& cryoid) const
  {
    return BaseContainer_t::hasElement(cryoid);
  }

  bool hasTPC(geo::TPCID const& tpcid) const { return BaseContainer_t::hasElement(tpcid); }

  bool hasPlane(geo::PlaneID const& planeid) const { return BaseContainer_t::hasElement(planeid); }

  // --- END Container status query --------------------------------------------

}; // class geo::PlaneDataContainer

//------------------------------------------------------------------------------
template <typename GeoIDmapperClass, typename BaseIterator>
class geo::details::GeoIDdataContainerIterator
  : public boost::iterator_adaptor<
      geo::details::GeoIDdataContainerIterator<GeoIDmapperClass, BaseIterator>,
      BaseIterator> {

  using Mapper_t = GeoIDmapperClass;

  using BaseIterator_t = BaseIterator; 

  using Index_t = typename Mapper_t::index_type;

  struct ExtraData_t {

    Mapper_t const* mapper = nullptr;

    BaseIterator_t start; 

  }; // struct ExtraData_t

  ExtraData_t fData; 

  BaseIterator_t const& current() const
  {
    return GeoIDdataContainerIterator::iterator_adaptor_::base();
  }
  BaseIterator_t& current() { return GeoIDdataContainerIterator::iterator_adaptor_::base(); }

  BaseIterator_t const& start() const { return fData.start; }

  Mapper_t const& mapper() const
  {
    assert(fData.mapper);
    return *(fData.mapper);
  }

  Index_t index() const { return static_cast<Index_t>(current() - start()); }

public:
  using ID_t = typename Mapper_t::ID_t; 

  GeoIDdataContainerIterator() = default;

  GeoIDdataContainerIterator(Mapper_t const& mapper,
                             BaseIterator_t const& start,
                             BaseIterator_t const& current)
    : GeoIDdataContainerIterator::iterator_adaptor_(current), fData{&mapper, start}
  {}

  template <typename OBaseIterator>
  GeoIDdataContainerIterator(
    GeoIDdataContainerIterator<Mapper_t, OBaseIterator> const& other,
    std::enable_if_t<std::is_convertible_v<OBaseIterator, BaseIterator_t>> = nullptr)
    : GeoIDdataContainerIterator::iterator_adaptor_(other.base()), fData(other.fData)
  {}

  ID_t ID() const { return mapper().ID(index()); }

private:
  //   friend class boost::iterator_core_access;

  // there might be some need for other interoperability methods (comparison?)

}; // geo::details::GeoIDdataContainerIterator

template <typename GeoIDIteratorClass>
class geo::details::GeoIDdataContainerItemIterator
  : public boost::iterator_adaptor<geo::details::GeoIDdataContainerItemIterator<GeoIDIteratorClass>,
                                   GeoIDIteratorClass,
                                   std::pair<typename GeoIDIteratorClass::ID_t,
                                             typename GeoIDIteratorClass::reference> // Value
                                   ,
                                   boost::use_default // Category
                                   ,
                                   std::pair<typename GeoIDIteratorClass::ID_t,
                                             typename GeoIDIteratorClass::reference> // Reference
                                   > {
  /*
   * Implementation notes:
   *  * boost::transform_iterator can't be used to wrap
   *      `geo::GeoIDdataContainerIterator` because it acts on the value of
   *      the wrapped iterator, while we need to extract information from
   *      the iterator itself (its `ID()` data member)
   *  * we need to specify the type of reference the iterator returns,
   *      because... it's not a reference; this is not really a STL random
   *      access iterator since it dereferences to a temporary value (rvalue)
   *      like an input iterator can; but for the rest it's a full blown random
   *      access iterator (same stuff as the infamous `std::vector<bool>`)
   *
   */

  using GeoIDiterator_t = GeoIDIteratorClass; 

  using iterator_adaptor_ = typename GeoIDdataContainerItemIterator::iterator_adaptor_;

public:
  using ID_t = typename GeoIDiterator_t::ID_t;

  GeoIDdataContainerItemIterator() = default;

  GeoIDdataContainerItemIterator(GeoIDiterator_t const& iter) : iterator_adaptor_(iter) {}

  template <typename OGeoIDIteratorClass>
  GeoIDdataContainerItemIterator(
    GeoIDdataContainerItemIterator<OGeoIDIteratorClass> const& other,
    std::enable_if_t<std::is_convertible_v<OGeoIDIteratorClass, GeoIDiterator_t>> = nullptr)
    : iterator_adaptor_(other.base())
  {}

private:
  friend class boost::iterator_core_access;

  using iterator_adaptor_::base;

  typename iterator_adaptor_::reference dereference() const { return {base().ID(), *base()}; }

  // there might be some need for other interoperability methods (comparison?)

}; // geo::details::GeoIDdataContainerItemIterator

// --- END Geometry data containers --------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//--- Template implementation
//------------------------------------------------------------------------------
//--- geo::details::GeoContainerData
//------------------------------------------------------------------------------
template <typename T>
class geo::details::GeoContainerData {

  using Container_t = std::vector<T>;

public:
  // --- BEGIN STL container types ---------------------------------------------

  using value_type = typename Container_t::value_type;
  using reference = typename Container_t::reference;
  using const_reference = typename Container_t::const_reference;
  using pointer = typename Container_t::pointer;
  using const_pointer = typename Container_t::const_pointer;
  using iterator = typename Container_t::iterator;
  using const_iterator = typename Container_t::const_iterator;
  using reverse_iterator = typename Container_t::reverse_iterator;
  using const_reverse_iterator = typename Container_t::const_reverse_iterator;
  using difference_type = typename Container_t::difference_type;
  using size_type = typename Container_t::size_type;

  // --- END STL container types -----------------------------------------------

  using index_type = size_type; 

  // --- BEGIN Constructors ----------------------------------------------------

  GeoContainerData() = default;

  GeoContainerData(size_type size) : fData(size) {}

  // Prepares the container with copies of the specified default value.
  GeoContainerData(size_type size, value_type const& defValue) : fData(size, defValue) {}

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

  // --- BEGIN Container status query ------------------------------------------

  size_type size() const { return fData.size(); }

  size_type capacity() const { return fData.capacity(); }

  bool empty() const { return fData.empty(); }

  // --- END Container status query --------------------------------------------

  // --- BEGIN Data modification -----------------------------------------------

  void fill(value_type value) { std::fill(fData.begin(), fData.end(), value); }

  void reset() { fill(value_type{}); }

  template <typename Op>
  Op apply(Op&& op)
  {
    for (auto& data : fData)
      op(data);
    return op;
  }

  template <typename Op>
  Op apply(Op&& op) const
  {
    for (auto const& data : fData)
      op(data);
    return op;
  }

  // --- END Element access ----------------------------------------------------

  // --- BEGIN Container modification ------------------------------------------

  void resize(size_type size) { fData.resize(size); }

  void resize(size_type size, value_type const& defValue) { fData.resize(size, defValue); }

  void clear() { fData.clear(); }

  // --- END Container modification --------------------------------------------

  // --- BEGIN Element access --------------------------------------------------

  reference operator[](index_type index) { return fData[index]; }

  const_reference operator[](index_type index) const { return fData[index]; }

  // --- END Element access ----------------------------------------------------

  // --- BEGIN Iterators -------------------------------------------------------

  iterator begin() { return fData.begin(); }
  iterator end() { return fData.end(); }
  const_iterator begin() const { return fData.begin(); }
  const_iterator end() const { return fData.end(); }
  const_iterator cbegin() const { return fData.cbegin(); }
  const_iterator cend() const { return fData.cend(); }

  reverse_iterator rbegin() { return fData.rbegin(); }
  reverse_iterator rend() { return fData.rend(); }
  const_reverse_iterator rbegin() const { return fData.rbegin(); }
  const_reverse_iterator rend() const { return fData.rend(); }
  const_reverse_iterator crbegin() const { return fData.crbegin(); }
  const_reverse_iterator crend() const { return fData.crend(); }

  // --- END Iterators ---------------------------------------------------------

  template <typename Value, typename Upper>
  static bool bounded(Value v, Upper upper)
  {
    return (v >= 0) && (static_cast<size_type>(v) < upper);
  }

private:
  Container_t fData; 

}; // class geo::details::GeoContainerData

//------------------------------------------------------------------------------
//--- geo::GeoIDdataContainer
//------------------------------------------------------------------------------
template <typename T, typename Mapper>
geo::GeoIDdataContainer<T, Mapper>::GeoIDdataContainer(std::initializer_list<unsigned int> dims)
  : fMapper(dims), fData(fMapper.size())
{
  assert(!fData.empty());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
geo::GeoIDdataContainer<T, Mapper>::GeoIDdataContainer(std::initializer_list<unsigned int> dims,
                                                       value_type const& defValue)
  : fMapper(dims), fData(fMapper.computeSize(), defValue)
{
  assert(!fData.empty());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::size() const -> size_type
{
  return fData.size();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::capacity() const -> size_type
{
  return fData.capacity();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
bool geo::GeoIDdataContainer<T, Mapper>::empty() const
{
  return fData.empty();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <std::size_t Level>
unsigned int geo::GeoIDdataContainer<T, Mapper>::dimSize() const
{
  return mapper().template dimSize<Level>();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
constexpr unsigned int geo::GeoIDdataContainer<T, Mapper>::dimensions()
{
  return Mapper_t::dimensions();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename GeoID>
bool geo::GeoIDdataContainer<T, Mapper>::hasElement(GeoID const& id) const
{
  return mapper().template hasElement<GeoID>(id);
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename GeoID /* = ID_t */>
GeoID geo::GeoIDdataContainer<T, Mapper>::firstID() const
{
  return mapper().template firstID<GeoID>();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename GeoID /* = ID_t */>
GeoID geo::GeoIDdataContainer<T, Mapper>::lastID() const
{
  return mapper().template lastID<GeoID>();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::mapper() const -> Mapper_t const&
{
  return fMapper;
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::operator[](ID_t const& id) -> reference
{
  return fData[mapper().index(id)];
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::operator[](ID_t const& id) const -> const_reference
{
  return fData[mapper().index(id)];
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::at(ID_t const& id) -> reference
{
  if (hasElement(id)) return operator[](id);
  throw std::out_of_range("No data for " + std::string(id));
} // geo::GeoIDdataContainer<>::at()

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::at(ID_t const& id) const -> const_reference
{
  if (hasElement(id)) return operator[](id);
  throw std::out_of_range("No data for " + std::string(id));
} // geo::GeoIDdataContainer<>::at() const

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::first() -> reference
{
  return operator[](firstID());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::first() const -> const_reference
{
  return operator[](firstID());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::last() -> reference
{
  return operator[](lastID());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::last() const -> const_reference
{
  return operator[](lastID());
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::begin() -> iterator
{
  return {mapper(), fData.begin(), fData.begin()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::end() -> iterator
{
  return {mapper(), fData.begin(), fData.end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::begin() const -> const_iterator
{
  return {mapper(), fData.begin(), fData.begin()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::end() const -> const_iterator
{
  return {mapper(), fData.begin(), fData.end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::cbegin() const -> const_iterator
{
  return begin();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::cend() const -> const_iterator
{
  return end();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_begin() -> item_iterator
{
  return {begin()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_end() -> item_iterator
{
  return {end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_begin() const -> item_const_iterator
{
  return {begin()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_end() const -> item_const_iterator
{
  return {end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_cbegin() const -> item_const_iterator
{
  return item_begin();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::item_cend() const -> item_const_iterator
{
  return item_end();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::items()
{
  return util::span{item_begin(), item_end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::items() const
{
  return util::span{item_begin(), item_end()};
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
void geo::GeoIDdataContainer<T, Mapper>::fill(value_type value)
{
  fData.fill(value);
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
void geo::GeoIDdataContainer<T, Mapper>::reset()
{
  fData.reset();
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename Op>
Op geo::GeoIDdataContainer<T, Mapper>::apply(Op&& op)
{
  return fData.apply(std::forward<Op>(op));
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
void geo::GeoIDdataContainer<T, Mapper>::resize(std::initializer_list<unsigned int> dims)
{
  fMapper.resize(dims);
  fData.resize(mapper().size());
} // geo::GeoIDdataContainer<T, Mapper>::resize()

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
void geo::GeoIDdataContainer<T, Mapper>::resize(std::initializer_list<unsigned int> dims,
                                                value_type const& defValue)
{
  fMapper.resize(dims);
  fData.resize(mapper().size(), defValue);
} // geo::GeoIDdataContainer<T, Mapper>::resize(value_type)

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename OT>
void geo::GeoIDdataContainer<T, Mapper>::resizeAs(
  geo::GeoIDdataContainer<OT, Mapper_t> const& other)
{
  fMapper.resizeAs(other.mapper());
  fData.resize(mapper().size());
} // geo::GeoIDdataContainer<T, Mapper>::resizeAs()

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename OT>
void geo::GeoIDdataContainer<T, Mapper>::resizeAs(
  geo::GeoIDdataContainer<OT, Mapper_t> const& other,
  value_type const& defValue)
{
  fMapper.resizeAs(other.mapper());
  fData.resize(mapper().size(), defValue);
} // geo::GeoIDdataContainer<T, Mapper>::resizeAs(value_type)

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
void geo::GeoIDdataContainer<T, Mapper>::clear()
{
  fMapper.clear();
  fData.clear();
} // geo::GeoIDdataContainer<>::clear()

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
template <typename Op>
decltype(auto) geo::GeoIDdataContainer<T, Mapper>::apply(Op&& op) const
{
  return fData.apply(std::forward<Op>(op));
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::index(ID_t const& id) const -> size_type
{
  return mapper().index(id);
}

//------------------------------------------------------------------------------
template <typename T, typename Mapper>
auto geo::GeoIDdataContainer<T, Mapper>::ID(size_type const index) const -> ID_t
{
  return mapper().ID(index);
}

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

#endif // LARCOREALG_GEOMETRY_GEOMETRYDATACONTAINERS_H