dom/quota/Flatten.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef DOM_QUOTA_FLATTEN_H_
   8 #define DOM_QUOTA_FLATTEN_H_
   9
  10 #include <iterator>
  11 #include <type_traits>
  12 #include <utility>
  13
  14 // XXX This should be moved to MFBT.
  15
  16 namespace mozilla::dom::quota {
  17
  18 namespace detail {
  19
  20 using std::begin;
  21 using std::end;
  22
  23 template <typename T, typename NestedRange>
  24 auto Flatten(NestedRange&& aRange)
  25     -> std::enable_if_t<
  26         std::is_same_v<T,
  27                        std::decay_t<typename decltype(begin(
  28                            std::declval<const NestedRange&>()))::value_type>>,
  29         std::conditional_t<std::is_rvalue_reference_v<NestedRange>,
  30                            std::decay_t<NestedRange>, NestedRange>> {
  31   return std::forward<NestedRange>(aRange);
  32 }
  33
  34 template <typename T, typename NestedRange>
  35 struct FlatIter {
  36   using OuterIterator =
  37       decltype(begin(std::declval<const std::decay_t<NestedRange>&>()));
  38   using InnerIterator =
  39       decltype(begin(*begin(std::declval<const std::decay_t<NestedRange>&>())));
  40
  41   explicit FlatIter(const NestedRange& aRange, OuterIterator aIter)
  42       : mOuterIter{std::move(aIter)}, mOuterEnd{end(aRange)} {
  43     InitInner();
  44   }
  45
  46   const T& operator*() const { return *mInnerIter; }
  47
  48   FlatIter& operator++() {
  49     ++mInnerIter;
  50     if (mInnerIter == mInnerEnd) {
  51       ++mOuterIter;
  52       InitInner();
  53     }
  54     return *this;
  55   }
  56
  57   bool operator!=(const FlatIter& aOther) const {
  58     return mOuterIter != aOther.mOuterIter ||
  59            (mOuterIter != mOuterEnd && mInnerIter != aOther.mInnerIter);
  60   }
  61
  62  private:
  63   void InitInner() {
  64     while (mOuterIter != mOuterEnd) {
  65       const typename OuterIterator::value_type& innerRange = *mOuterIter;
  66
  67       mInnerIter = begin(innerRange);
  68       mInnerEnd = end(innerRange);
  69
  70       if (mInnerIter != mInnerEnd) {
  71         break;
  72       }
  73
  74       ++mOuterIter;
  75     }
  76   }
  77
  78   OuterIterator mOuterIter;
  79   const OuterIterator mOuterEnd;
  80
  81   InnerIterator mInnerIter;
  82   InnerIterator mInnerEnd;
  83 };
  84
  85 template <typename T, typename NestedRange>
  86 struct FlatRange {
  87   explicit FlatRange(NestedRange aRange) : mRange{std::move(aRange)} {}
  88
  89   auto begin() const {
  90     using std::begin;
  91     return FlatIter<T, NestedRange>{mRange, begin(mRange)};
  92   }
  93   auto end() const {
  94     using std::end;
  95     return FlatIter<T, NestedRange>{mRange, end(mRange)};
  96   }
  97
  98  private:
  99   NestedRange mRange;
 100 };
 101
 102 template <typename T, typename NestedRange>
 103 auto Flatten(NestedRange&& aRange)
 104     -> std::enable_if_t<
 105         !std::is_same_v<T, std::decay_t<typename decltype(begin(
 106                                std::declval<const std::decay_t<
 107                                    NestedRange>&>()))::value_type>>,
 108         FlatRange<T, NestedRange>> {
 109   return FlatRange<T, NestedRange>{std::forward<NestedRange>(aRange)};
 110 }
 111
 112 }  // namespace detail
 113
 114 template <typename T, typename NestedRange>
 115 auto Flatten(NestedRange&& aRange) -> decltype(auto) {
 116   return detail::Flatten<T>(std::forward<NestedRange>(aRange));
 117 }
 118
 119 }  // namespace mozilla::dom::quota
 120
 121 #endif