1 /* 2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 OHOS_SHARING_CIRCULAR_BUFFER_H 17 #define OHOS_SHARING_CIRCULAR_BUFFER_H 18 19 #include <cstddef> 20 #include <deque> 21 #include <memory> 22 #include "common/sharing_log.h" 23 namespace OHOS { 24 namespace Sharing { 25 26 template <class T> 27 class circular_buffer { 28 public: 29 typedef typename std::deque<T>::iterator Iterator; 30 31 circular_buffer() = default; 32 circular_buffer(int32_t capacity)33 explicit circular_buffer(int32_t capacity) 34 { 35 if (capacity <= 0) { 36 return; 37 } else { 38 capacity_ = capacity; 39 } 40 } 41 circular_buffer(circular_buffer & copy)42 explicit circular_buffer(circular_buffer& copy) 43 { 44 capacity_ = copy.capacity(); 45 T *temp = copy.begin(); 46 while (temp != copy.end()) { 47 circular_buffer_.push_back(*temp); 48 temp++; 49 } 50 } 51 ~circular_buffer()52 ~circular_buffer() 53 { 54 if (!circular_buffer_.empty()) { 55 circular_buffer_.clear(); 56 } 57 } 58 59 private: 60 size_t capacity_ = 0; 61 std::deque<T> circular_buffer_; 62 63 public: clear()64 void clear() 65 { 66 circular_buffer_.clear(); 67 SHARING_LOGD("size is %{public}zu", size()); 68 set_capacity(capacity_); 69 } 70 pop_back()71 void pop_back() 72 { 73 circular_buffer_.pop_back(); 74 } 75 pop_front()76 void pop_front() 77 { 78 circular_buffer_.pop_front(); 79 } 80 push_back(T item)81 void push_back(T item) 82 { 83 if (size() >= capacity()) { 84 circular_buffer_.pop_front(); 85 } 86 87 circular_buffer_.push_back(item); 88 } 89 push_front(T & item)90 void push_front(T &item) 91 { 92 if (size() >= capacity()) { 93 circular_buffer_.pop_back(); 94 } 95 96 circular_buffer_.push_front(item); 97 } 98 set_capacity(size_t new_capacity)99 void set_capacity(size_t new_capacity) 100 { 101 capacity_ = new_capacity; 102 } 103 full()104 bool full() 105 { 106 return size() == capacity_; 107 } 108 empty()109 bool empty() 110 { 111 return size() == 0; 112 } 113 size()114 size_t size() 115 { 116 return circular_buffer_.size(); 117 } 118 reserve()119 size_t reserve() 120 { 121 return capacity() - size(); 122 } 123 capacity()124 size_t capacity() 125 { 126 return capacity_; 127 } 128 at(size_t index)129 T &at(size_t index) 130 { 131 return circular_buffer_[index]; 132 } 133 back()134 T &back() 135 { 136 return circular_buffer_.back(); 137 } 138 front()139 T &front() 140 { 141 return circular_buffer_.front(); 142 } 143 begin()144 Iterator begin() 145 { 146 return circular_buffer_.begin(); 147 } 148 end()149 Iterator end() 150 { 151 return circular_buffer_.end(); 152 } 153 154 T &operator[](int32_t index) 155 { 156 return circular_buffer_[index]; 157 } 158 159 circular_buffer &operator=(circular_buffer ©) 160 { 161 if (this == ©) { 162 return *this; 163 } 164 165 clear(); 166 capacity_ = copy.capacity(); 167 T *temp = copy.begin(); 168 while (temp != copy.end()) { 169 circular_buffer_.push_back(*temp); 170 temp++; 171 } 172 } 173 }; 174 175 } // namespace Sharing 176 } // namespace OHOS 177 #endif