CollectionView.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_COLLECTIONVIEW_H
#define LARDATA_UTILITIES_COLLECTIONVIEW_H


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


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