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         int retSize = 0;
32         if (realcap != 0) {
33             retSize = (back_ - front_ + realcap) % realcap;
34         }
35         return retSize;
36     }
37 
Push(const T & t)38     T &Push(const T& t)
39     {
40         if (realcap != 0 && front_ == (back_ + 1) % realcap) {
41             front_ = (front_ + 1) % realcap;
42         }
43         queue_[back_++] = t;
44         int retPoint = 0;
45         if (realcap != 0) {
46             back_ %= realcap;
47             retPoint = (back_ + cap) % realcap;
48         }
49         return queue_[retPoint];
50     }
51 
Clear()52     void Clear()
53     {
54         front_ = 0;
55         back_ = 0;
56     }
57 
58     class Iter {
59     public:
Iter(Array * ptr,int offset)60         Iter(Array *ptr, int offset)
61             : ptr_(ptr), offset_(offset)
62         {
63         }
64 
65         Iter &operator++()
66         {
67             if (realcap != 0) {
68                 offset_ = (offset_ + 1) % realcap;
69             }
70             return *this;
71         }
72 
73         Iter operator++(int)
74         {
75             auto ret = *this;
76             if (realcap != 0) {
77                 offset_ = (offset_ + 1) % realcap;
78             }
79             return ret;
80         }
81 
82         T &operator*()
83         {
84             return (*ptr_)[offset_];
85         }
86 
87         T *operator->()
88         {
89             return &(*ptr_)[offset_];
90         }
91 
92         bool operator==(const Iter &rhs)
93         {
94             return offset_ == rhs.offset_;
95         }
96 
97         bool operator!=(const Iter &rhs)
98         {
99             return offset_ != rhs.offset_;
100         }
101 
102     private:
103         Array *ptr_;
104         int offset_;
105     };
106 
107     class RevertIter {
108     public:
RevertIter(Array * ptr,int offset)109         RevertIter(Array *ptr, int offset)
110             : ptr_(ptr), offset_(offset)
111         {
112         }
113 
114         RevertIter &operator++()
115         {
116             if (realcap != 0) {
117                 offset_ = (offset_ + cap) % realcap;
118             }
119             return *this;
120         }
121 
122         RevertIter operator++(int)
123         {
124             auto ret = *this;
125             if (realcap != 0) {
126                 offset_ = (offset_ + cap) % realcap;
127             }
128             return ret;
129         }
130 
131         T &operator*()
132         {
133             return (*ptr_)[offset_];
134         }
135 
136         T *operator->()
137         {
138             return &(*ptr_)[offset_];
139         }
140 
141         bool operator==(const RevertIter &rhs)
142         {
143             return offset_ == rhs.offset_;
144         }
145 
146         bool operator!=(const RevertIter &rhs)
147         {
148             return offset_ != rhs.offset_;
149         }
150 
151     private:
152         Array *ptr_;
153         int offset_;
154     };
155 
begin()156     Iter begin()
157     {
158         return Iter(&queue_, front_);
159     }
160 
end()161     Iter end()
162     {
163         return Iter(&queue_, back_);
164     }
165 
rbegin()166     RevertIter rbegin()
167     {
168         if (realcap != 0) {
169             return RevertIter(&queue_, (back_ + cap) % realcap);
170         } else {
171             return RevertIter(&queue_, 0);
172         }
173     }
174 
rend()175     RevertIter rend()
176     {
177         if (realcap != 0) {
178             return RevertIter(&queue_, (front_ + cap) % realcap);
179         } else {
180             return RevertIter(&queue_, 0);
181         }
182     }
183 
184 private:
185     Array queue_;
186     int front_ = 0;
187     int back_ = 0;
188 };
189 } // namespace Rosen
190 } // namespace OHOS
191 
192 #endif // ROSEN_MODULE_FRAME_ANALYZER_EXPORT_RING_QUEUE_H
193