1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_RUNTIME_STRIDE_ITERATOR_H_ 18 #define ART_RUNTIME_STRIDE_ITERATOR_H_ 19 20 #include <iterator> 21 22 #include "base/logging.h" 23 24 namespace art { 25 26 template<typename T> 27 class StrideIterator : public std::iterator<std::random_access_iterator_tag, T> { 28 public: 29 using difference_type = 30 typename std::iterator<std::random_access_iterator_tag, T>::difference_type; 31 32 StrideIterator(const StrideIterator&) = default; 33 StrideIterator(StrideIterator&&) = default; 34 StrideIterator& operator=(const StrideIterator&) = default; 35 StrideIterator& operator=(StrideIterator&&) = default; 36 StrideIterator(T * ptr,size_t stride)37 StrideIterator(T* ptr, size_t stride) 38 : ptr_(reinterpret_cast<uintptr_t>(ptr)), 39 stride_(stride) {} 40 41 bool operator==(const StrideIterator& other) const { 42 DCHECK_EQ(stride_, other.stride_); 43 return ptr_ == other.ptr_; 44 } 45 46 bool operator!=(const StrideIterator& other) const { 47 return !(*this == other); 48 } 49 50 StrideIterator& operator++() { // Value after modification. 51 ptr_ += stride_; 52 return *this; 53 } 54 55 StrideIterator operator++(int) { 56 StrideIterator<T> temp = *this; 57 ++*this; 58 return temp; 59 } 60 61 StrideIterator& operator--() { // Value after modification. 62 ptr_ -= stride_; 63 return *this; 64 } 65 66 StrideIterator operator--(int) { 67 StrideIterator<T> temp = *this; 68 --*this; 69 return temp; 70 } 71 72 StrideIterator& operator+=(difference_type delta) { 73 ptr_ += static_cast<ssize_t>(stride_) * delta; 74 return *this; 75 } 76 77 StrideIterator operator+(difference_type delta) const { 78 StrideIterator<T> temp = *this; 79 temp += delta; 80 return temp; 81 } 82 83 StrideIterator& operator-=(difference_type delta) { 84 ptr_ -= static_cast<ssize_t>(stride_) * delta; 85 return *this; 86 } 87 88 StrideIterator operator-(difference_type delta) const { 89 StrideIterator<T> temp = *this; 90 temp -= delta; 91 return temp; 92 } 93 94 difference_type operator-(const StrideIterator& rhs) { 95 DCHECK_EQ(stride_, rhs.stride_); 96 DCHECK_EQ((ptr_ - rhs.ptr_) % stride_, 0u); 97 return (ptr_ - rhs.ptr_) / stride_; 98 } 99 100 T& operator*() const { 101 return *reinterpret_cast<T*>(ptr_); 102 } 103 104 T* operator->() const { 105 return &**this; 106 } 107 108 T& operator[](difference_type n) { 109 return *(*this + n); 110 } 111 112 private: 113 uintptr_t ptr_; 114 // Not const for operator=. 115 size_t stride_; 116 117 template <typename U> 118 friend bool operator<(const StrideIterator<U>& lhs, const StrideIterator<U>& rhs); 119 }; 120 121 template <typename T> 122 StrideIterator<T> operator+(typename StrideIterator<T>::difference_type dist, 123 const StrideIterator<T>& it) { 124 return it + dist; 125 } 126 127 template <typename T> 128 bool operator<(const StrideIterator<T>& lhs, const StrideIterator<T>& rhs) { 129 DCHECK_EQ(lhs.stride_, rhs.stride_); 130 return lhs.ptr_ < rhs.ptr_; 131 } 132 133 template <typename T> 134 bool operator>(const StrideIterator<T>& lhs, const StrideIterator<T>& rhs) { 135 return rhs < lhs; 136 } 137 138 template <typename T> 139 bool operator<=(const StrideIterator<T>& lhs, const StrideIterator<T>& rhs) { 140 return !(rhs < lhs); 141 } 142 143 template <typename T> 144 bool operator>=(const StrideIterator<T>& lhs, const StrideIterator<T>& rhs) { 145 return !(lhs < rhs); 146 } 147 148 } // namespace art 149 150 #endif // ART_RUNTIME_STRIDE_ITERATOR_H_ 151