1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef ROSEN_MODULE_FRAME_ANALYZER_EXPORT_RING_QUEUE_H 17 #define ROSEN_MODULE_FRAME_ANALYZER_EXPORT_RING_QUEUE_H 18 19 #include <array> 20 21 namespace OHOS { 22 namespace Rosen { 23 template<class T, int cap> 24 class RingQueue { 25 public: 26 static constexpr int realcap = cap + 1; 27 using Array = std::array<T, realcap>; 28 GetSize()29 int GetSize() const 30 { 31 return (back_ - front_ + realcap) % realcap; 32 } 33 Push(const T & t)34 T &Push(const T& t) 35 { 36 if (front_ == (back_ + 1) % realcap) { 37 front_ = (front_ + 1) % realcap; 38 } 39 queue_[back_++] = t; 40 back_ %= realcap; 41 return queue_[(back_ + cap) % realcap]; 42 } 43 Clear()44 void Clear() 45 { 46 front_ = 0; 47 back_ = 0; 48 } 49 50 class Iter { 51 public: Iter(Array * ptr,int offset)52 Iter(Array *ptr, int offset) 53 : ptr_(ptr), offset_(offset) 54 { 55 } 56 57 Iter &operator++() 58 { 59 offset_ = (offset_ + 1) % realcap; 60 return *this; 61 } 62 63 Iter operator++(int) 64 { 65 auto ret = *this; 66 offset_ = (offset_ + 1) % realcap; 67 return ret; 68 } 69 70 T &operator*() 71 { 72 return (*ptr_)[offset_]; 73 } 74 75 T *operator->() 76 { 77 return &(*ptr_)[offset_]; 78 } 79 80 bool operator==(const Iter &rhs) 81 { 82 return offset_ == rhs.offset_; 83 } 84 85 bool operator!=(const Iter &rhs) 86 { 87 return offset_ != rhs.offset_; 88 } 89 90 private: 91 Array *ptr_; 92 int offset_; 93 }; 94 95 class RevertIter { 96 public: RevertIter(Array * ptr,int offset)97 RevertIter(Array *ptr, int offset) 98 : ptr_(ptr), offset_(offset) 99 { 100 } 101 102 RevertIter &operator++() 103 { 104 offset_ = (offset_ + cap) % realcap; 105 return *this; 106 } 107 108 RevertIter operator++(int) 109 { 110 auto ret = *this; 111 offset_ = (offset_ + cap) % realcap; 112 return ret; 113 } 114 115 T &operator*() 116 { 117 return (*ptr_)[offset_]; 118 } 119 120 T *operator->() 121 { 122 return &(*ptr_)[offset_]; 123 } 124 125 bool operator==(const RevertIter &rhs) 126 { 127 return offset_ == rhs.offset_; 128 } 129 130 bool operator!=(const RevertIter &rhs) 131 { 132 return offset_ != rhs.offset_; 133 } 134 135 private: 136 Array *ptr_; 137 int offset_; 138 }; 139 begin()140 Iter begin() 141 { 142 return Iter(&queue_, front_); 143 } 144 end()145 Iter end() 146 { 147 return Iter(&queue_, back_); 148 } 149 rbegin()150 RevertIter rbegin() 151 { 152 return RevertIter(&queue_, (back_ + cap) % realcap); 153 } 154 rend()155 RevertIter rend() 156 { 157 return RevertIter(&queue_, (front_ + cap) % realcap); 158 } 159 160 private: 161 Array queue_; 162 int front_ = 0; 163 int back_ = 0; 164 }; 165 } // namespace Rosen 166 } // namespace OHOS 167 168 #endif // ROSEN_MODULE_FRAME_ANALYZER_EXPORT_RING_QUEUE_H 169