mfbt/Range.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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_Range_h
   8 #define mozilla_Range_h
   9
  10 #include "mozilla/RangedPtr.h"
  11 #include "mozilla/TypeTraits.h"
  12 #include "mozilla/Span.h"
  13
  14 #include <stddef.h>
  15
  16 namespace mozilla {
  17
  18 // Range<T> is a tuple containing a pointer and a length.
  19 template <typename T>
  20 class Range {
  21   const RangedPtr<T> mStart;
  22   const RangedPtr<T> mEnd;
  23
  24  public:
  25   Range() : mStart(nullptr, 0), mEnd(nullptr, 0) {}
  26   Range(T* aPtr, size_t aLength)
  27       : mStart(aPtr, aPtr, aPtr + aLength),
  28         mEnd(aPtr + aLength, aPtr, aPtr + aLength) {}
  29   Range(const RangedPtr<T>& aStart, const RangedPtr<T>& aEnd)
  30       : mStart(aStart.get(), aStart.get(), aEnd.get()),
  31         mEnd(aEnd.get(), aStart.get(), aEnd.get()) {
  32     // Only accept two RangedPtrs within the same range.
  33     aStart.checkIdenticalRange(aEnd);
  34     MOZ_ASSERT(aStart <= aEnd);
  35   }
  36
  37   template <typename U, class = typename EnableIf<
  38                             IsConvertible<U (*)[], T (*)[]>::value, int>::Type>
  39   MOZ_IMPLICIT Range(const Range<U>& aOther)
  40       : mStart(aOther.mStart), mEnd(aOther.mEnd) {}
  41
  42   MOZ_IMPLICIT Range(Span<T> aSpan) : Range(aSpan.Elements(), aSpan.Length()) {}
  43
  44   template <typename U, class = typename EnableIf<
  45                             IsConvertible<U (*)[], T (*)[]>::value, int>::Type>
  46   MOZ_IMPLICIT Range(const Span<U>& aSpan)
  47       : Range(aSpan.Elements(), aSpan.Length()) {}
  48
  49   RangedPtr<T> begin() const { return mStart; }
  50   RangedPtr<T> end() const { return mEnd; }
  51   size_t length() const { return mEnd - mStart; }
  52
  53   T& operator[](size_t aOffset) const { return mStart[aOffset]; }
  54
  55   explicit operator bool() const { return mStart != nullptr; }
  56
  57   operator Span<T>() { return Span<T>(mStart.get(), length()); }
  58
  59   operator Span<const T>() const { return Span<T>(mStart.get(), length()); }
  60 };
  61
  62 template <class T>
  63 Span<T> MakeSpan(Range<T>& aRange) {
  64   return aRange;
  65 }
  66
  67 template <class T>
  68 Span<const T> MakeSpan(const Range<T>& aRange) {
  69   return aRange;
  70 }
  71
  72 }  // namespace mozilla
  73
  74 #endif /* mozilla_Range_h */