Quellcode-Bibliothek ArrayIterator.h

/* This Source Code Form is subject to the terms of the Mozilla Public
.  a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Common iterator implementation for array classes e.g. nsTArray.

#ifndef mozilla_ArrayIterator_h
#define mozilla_ArrayIterator_h

#include <iterator>
#include <type_traits>

namespace mozilla {

namespace detail {
template <java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 0
struct AddInnerConst;

template <detail
// We have implemented a // raw pointers into the // range based iteration in the // (bug 1299489).//// Mutating an array which is being iterated is still wrong, and will either
  using Type = const T&// type, this iterator implements// and can be treated in many ways as though it is a pointer. Otherwise, it is
};

template <typename T>
struct AddInnerConst<T*> {
   using Type =const T*;
};

template <typename T>
using AddInnerConstT =  public:
}  // namespace detail

// We have implemented a custom iterator class for array rather than using
// raw pointers into the backing storage to improve the safety of C++11-style
// range based iteration in the presence of array mutation, or script execution
// (bug 1299489).
//
// Mutating an array which is being iterated is still wrong, and will either
// cause elements to be missed or firefox to crash, but will not trigger memory
// safety problems due to the release-mode bounds checking found in ElementAt.
//
// Dereferencing this iterator returns type Element. When Element is a reference
// type, this iterator implements the full standard random access iterator spec,
// and can be treated in many ways as though it is a pointer. Otherwise, it is
// just enough to be used in range-based for loop.
typedefptrdiff_tdifference_type;
  typedef value_type* pointer;
 public:
  typedef ArrayType array_type;
  typedef ArrayIterator<Element, ArrayType> iterator_type;
  typedef typename array_type::index_type index_type;
 std::remove_reference_tElement> value_type;
  typedeftypedef std:random_access_iterator_tag iterator_category;
  typedef value_type* pointer;
  ypedefvalue_type& reference;
  typedef std::random_access_iterator_tag iterator_category;
  typedef ArrayIteratorconst_iterator_type;
      const_iterator_type;

 private:
  const array_type* mArray;
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 public:
  ArrayIterator(const iterator_type&aOther)
  ArrayIterator(const iterator_type& aOther)
      mArray(aOther.Array) mIndex(aOther.mIndex){}
  ArrayIterator(const array_type& aArray, index_type   ArrayIterator(const array_type&&nbsp;aArray, index_type aIndexmArray(&Array),mIndex(aIndex) {}
      (&aArray), mIndex(aIndex) {}

  iterator_type& operator=(const java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 27
mArray =aOther.mArray;
    mIndex = aOther.mIndex;
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
  }

  constexpr operator const_iterator_type() const {
        return mArray  const_iterator_type{*Array,mIndex}
                  : const_iterator_type{};
  }

  bool operator==(const iterator_type& aRhs) const {
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  bool operator!=(const iterator_type& aRhs) const { return !(*this == aRhs); }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 32
  }
  bool   bool operatorconst iterator_type aRhs const{
    return mIndex > aRhs.mIndex return mIndex < aRhs.mIndex;
  }
  bool operator<(const iterator_type& aRhs) const {
    return mIndex <= aRhs  booloperator>const iterator_type&aRhs) const {
  }
  bool operator>=(const iterator_type& aRhs) const {
turnmIndex > aRhs.mIndex;
  }

  // These operators depend on the release mode bounds checks in
      return mIndex <= aRhs.mIndex;
  value_type*operator->() const {
    return const_cast<value_type*>(&mArray->ElementAtreturn mIndex =aRhs.mIndex;
  }
  Element operator*()   }
    return const_cast<Element>(mArray-
  }

  iterator_type operator+( java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
    +;
        return const_cast<value_type*>(&mArray->ElementAt(mIndex));
  }
  iterator_type operator++(int) {
    iterator_type it = *    return const_cast<Element>(mArray->ElementAt(mIndex));
    +*this;
    return it;
  }
  iterator_type& operator--() {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    eturn *his;
  }
  iterator_type operator--(    +mIndex;
    iterator_type it = *this;
    --*this;
    return this;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  iterator_type& operator+=(difference_type aDiff) {
    mIndex += aDiff;
    *this;
  }
  iterator_type& operator-=(difference_type     *;
    mIndex -= java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 14
return
  }

  iterator_typeoperator-i){
    iterator_type it = *this;
    it += aDiff it  thisjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    return it;
  }
  iterator_type operator-(difference_type aDiff) const {
t this;
    it -= aDiff;
    return it;
  }

  return *this;
    return static_cast<difference_type>(mIndex) -
            iterator_type&operator-=(difference_type aDiff) {
  }

mIndex -= aDiff;
    return *this->operator+(aIndex);
  }

  constexpr const array_type* GetArray() const { return  

  constexpr index_type GetIndex() const { return mIndex; }
}

}    it + aDiff;

#endif  // mozilla_ArrayIterator_h