CollectionView.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_COLLECTIONVIEW_H
#define LARDATA_UTILITIES_COLLECTIONVIEW_H

// C/C++ standard libraries
#include <cstddef>     // std::size_t
#include <iterator>    // std::iterator_traits, std::reverse_iterator
#include <stdexcept>   // std::out_of_range
#include <string>      // std::to_string()
#include <type_traits> // std::declval(), ...

namespace lar {

  // forward declarations
  template <typename Range>
  class CollectionView;

  namespace details {

    //--------------------------------------------------------------------------
    template <typename Range>
    struct RangeTraits {
      using range_t = Range;
      using traits_t = RangeTraits<range_t>;
      static auto getCBegin(range_t const& range)
      {
        using std::cbegin;
        return cbegin(range);
      }
      static auto getCEnd(range_t const& range)
      {
        using std::cend;
        return cend(range);
      }
      using begin_iterator_t = std::decay_t<decltype(traits_t::getCBegin(std::declval<range_t>()))>;
      using end_iterator_t = std::decay_t<decltype(traits_t::getCEnd(std::declval<range_t>()))>;
    }; // RangeTraits<>

    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter = BeginIter>
    class CollectionExtremes {
    public:
      using begin_iterator_t = BeginIter;
      using end_iterator_t = EndIter;

      struct FromContainerTag {};
      static constexpr FromContainerTag fromContainer{};

      CollectionExtremes(BeginIter b, EndIter e) : b(b), e(e) {}

      begin_iterator_t const& begin() const { return b; }

      end_iterator_t const& end() const { return e; }

    private:
      begin_iterator_t b; 
      end_iterator_t e;   
    };                    // class CollectionExtremes<>

    //--------------------------------------------------------------------------
    template <typename BeginIter, typename EndIter>
    auto makeCollectionExtremes(BeginIter const& b, EndIter const& e)
    {
      return CollectionExtremes<BeginIter, EndIter>(b, e);
    }

    //--------------------------------------------------------------------------
    template <typename Range>
    auto makeCollectionExtremes(Range const& range)
    {
      using std::cbegin;
      using std::cend;
      return makeCollectionExtremes(cbegin(range), cend(range));
    } // makeCollectionExtremes(range)

    //--------------------------------------------------------------------------
    // forward declaration
    template <typename Range>
    CollectionView<Range> makeCollectionView(Range&&);
    //--------------------------------------------------------------------------

  } // namespace details

  //----------------------------------------------------------------------------
  template <typename Range>
  class CollectionView : private Range {
    using this_t = CollectionView<Range>;           
    using range_t = Range;                          
    using traits_t = details::RangeTraits<range_t>; 

    using begin_iter_t = typename traits_t::begin_iterator_t;
    using end_iter_t = typename traits_t::end_iterator_t;

    using iter_traits_t = std::iterator_traits<begin_iter_t>;

  public:
    using collection_type = range_t; 

    using value_type = typename iter_traits_t::value_type;
    // reference not provided
    using const_reference = typename iter_traits_t::reference;
    // pointer not provided
    using const_pointer = typename iter_traits_t::pointer;
    // iterator not provided
    using const_iterator = begin_iter_t;
    // reverse_iterator not provided
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using difference_type = typename iter_traits_t::difference_type;
    using size_type = std::size_t;


    bool empty() const noexcept { return cbegin() == cend(); }

    size_type size() const noexcept { return std::distance(cbegin(), cend()); }

    const_iterator cbegin() const noexcept
    {
      using std::cbegin;
      return cbegin(asRange());
    }

    end_iter_t cend() const noexcept
    {
      using std::cend;
      return cend(asRange());
    }

    const_iterator begin() const noexcept { return cbegin(); }

    end_iter_t end() const noexcept { return cend(); }

    auto front() const -> decltype(auto) { return *cbegin(); }



    const_reverse_iterator rbegin() const noexcept { return crbegin(); }

    const_reverse_iterator rend() const noexcept { return crend(); }

    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }

    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }

    auto back() const -> decltype(auto) { return *crbegin(); }



    auto operator[](size_type i) const -> decltype(auto) { return cbegin()[i]; }

    auto at(size_type i) const -> decltype(auto)
    {
      if (i >= size()) {
        throw std::out_of_range("CollectionView index out of range: " + std::to_string(i) +
                                " >= " + std::to_string(size()));
      }
      return operator[](i);
    }



    const_pointer data() const { return &front(); }


  protected:
    /*
    CollectionViewWrapper() = default;
    CollectionViewWrapper(this_t const&) = default;
    CollectionViewWrapper(this_t&&) = default;
    CollectionViewWrapper& operator=(this_t const&) = default;
    CollectionViewWrapper& operator=(this_t&&) = default;
    */

    explicit CollectionView(range_t&& range) : range_t(std::move(range)) {}

    // we license the creation of this class from ranges to a single function
    // (and to derived classes)
    friend this_t details::makeCollectionView<range_t>(range_t&&);

  private:
    range_t const& asRange() const { return static_cast<range_t const&>(*this); }

  }; // class CollectionView<>

  //----------------------------------------------------------------------------
  template <typename Range>
  CollectionView<Range> const& wrapCollectionIntoView(Range const& c)
  {
    return reinterpret_cast<CollectionView<Range> const&>(c);
  }

  //----------------------------------------------------------------------------
  template <typename BeginIter, typename EndIter>
  auto makeCollectionView(BeginIter const& b, EndIter const& e)
  {
    return details::makeCollectionView(details::makeCollectionExtremes(b, e));
  }

  template <typename BeginIter, typename EndIter = BeginIter>
  using RangeAsCollection_t =
    decltype(makeCollectionView(std::declval<BeginIter>(), std::declval<EndIter>()));

  //----------------------------------------------------------------------------
  namespace details {
    template <typename Range>
    CollectionView<Range> makeCollectionView(Range&& range)
    {
      return CollectionView<Range>(std::move(range));
    }
  } // namespace details
  //----------------------------------------------------------------------------

} // namespace lar

#endif // LARDATA_UTILITIES_COLLECTIONVIEW_H