Debian Codegraph @

yo/classtemplates/examples/cirque.h

raw
1 #ifndef INCLUDED_CIRQUE_H_
2 #define INCLUDED_CIRQUE_H_
3
4 #include <memory>
5 #include <cstring>
6 #include <algorithm>
7
8 template<typename Data>
9 class CirQue
10 {
11 //DATA
12 size_t d_size;
13 size_t d_maxSize;
14 Data *d_data;
15 Data *d_front;
16 Data *d_back;
17 //=
18
19 public:
20 //TYPEDEFS
21 using value_type = Data;
22 using const_reference = value_type const &;
23 //=
24
25 //EXCEPTION
26 enum Exception
27 {
28 EMPTY,
29 FULL
30 };
31 //=
32 explicit CirQue(size_t maxSize = 0);
33 CirQue(CirQue<Data> const &other);
34 CirQue(CirQue<Data> &&tmp);
35
36 template <size_t Size>
37 explicit CirQue(Data const (&arr)[Size]);
38
39 explicit CirQue(Data const *data, size_t size);
40
41 ~CirQue();
42
43 CirQue &operator=(CirQue<Data> const &other);
44 CirQue &operator=(CirQue<Data> &&tmp);
45
46 Data &back();
47 Data &front();
48 bool empty() const;
49 bool full() const;
50 size_t maxSize() const;
51 size_t size() const;
52 void pop_front();
53 void push_back(Data const &object);
54 void swap(CirQue<Data> &other);
55
56 private:
57 Data *inc(Data *ptr);
58 };
59
60 //CIRQUE
61 template<typename Data>
62 CirQue<Data>::CirQue(size_t maxSize)
63 :
64 d_size(0),
65 d_maxSize(maxSize),
66 d_data(
67 maxSize == 0 ?
68 0
69 :
70 static_cast<Data *>(
71 operator new(maxSize * sizeof(Data)))
72 ),
73 d_front(d_data),
74 d_back(d_data)
75 {}
76 //=
77
78 //COPYCONS
79 template<typename Data>
80 CirQue<Data>::CirQue(CirQue<Data> const &other)
81 :
82 d_size(other.d_size),
83 d_maxSize(other.d_maxSize),
84 d_data(
85 d_maxSize == 0 ?
86 0
87 :
88 static_cast<Data *>(
89 operator new(d_maxSize * sizeof(Data)))
90 ),
91 d_front(d_data + (other.d_front - other.d_data))
92 {
93 Data const *src = other.d_front;
94 d_back = d_front;
95 for (size_t count = 0; count != d_size; ++count)
96 {
97 new(d_back) Data(*src);
98 d_back = inc(d_back);
99 if (++src == other.d_data + d_maxSize)
100 src = other.d_data;
101 }
102 }
103 //=
104
105 //MOVECONS
106 template<typename Data>
107 CirQue<Data>::CirQue(CirQue<Data> &&tmp)
108 :
109 d_data(0)
110 {
111 swap(tmp);
112 }
113 //=
114
115 //MEMBER
116 template <typename Data>
117 template <size_t Size>
118 CirQue<Data>::CirQue(Data const (&arr)[Size])
119 :
120 d_size(0),
121 d_maxSize(Size),
122 d_data(static_cast<Data *>(operator new(sizeof(arr)))),
123 d_front(d_data),
124 d_back(d_data)
125 {
126 std::copy(arr, arr + Size, std::back_inserter(*this));
127 }
128 //=
129 //DESTRUCTOR
130 template<typename Data>
131 CirQue<Data>::~CirQue()
132 {
133 if (d_data == 0)
134 return;
135 for (; d_size--; )
136 {
137 d_front->~Data();
138 d_front = inc(d_front);
139 }
140 operator delete(d_data);
141 }
142 //=
143
144 //COPYASSIGN
145 template<typename Data>
146 CirQue<Data> &CirQue<Data>::operator=(CirQue<Data> const &rhs)
147 {
148 CirQue<Data> tmp(rhs);
149 swap(tmp);
150 return *this;
151 }
152 //=
153
154 //MOVEASSIGN
155 template<typename Data>
156 inline CirQue<Data> &CirQue<Data>::operator=(CirQue<Data> &&tmp)
157 {
158 swap(tmp);
159 return *this;
160 }
161 //=
162
163 //SWAP
164 template<typename Data>
165 void CirQue<Data>::swap(CirQue<Data> &other)
166 {
167 static size_t const size = sizeof(CirQue<Data>);
168
169 char tmp[size];
170 memcpy(tmp, &other, size);
171 memcpy(reinterpret_cast<char *>(&other), this, size);
172 memcpy(reinterpret_cast<char *>(this), tmp, size);
173 }
174 //=
175
176 //POPFRONT
177 template<typename Data>
178 void CirQue<Data>::pop_front()
179 {
180 if (d_size == 0)
181 throw EMPTY;
182
183 d_front->~Data();
184 d_front = inc(d_front);
185 --d_size;
186 }
187 //=
188
189
190 //PUSHBACK
191 template<typename Data>
192 void CirQue<Data>::push_back(Data const &object)
193 {
194 if (d_size == d_maxSize)
195 throw FULL;
196
197 new (d_back) Data(object);
198 d_back = inc(d_back);
199 ++d_size;
200 }
201 //=
202
203
204 //BACK
205 template<typename Data>
206 inline Data &CirQue<Data>::back()
207 {
208 return d_back == d_data ? d_data[d_maxSize - 1] : d_back[-1];
209 }
210 //=
211
212 //FRONT
213 template<typename Data>
214 inline Data &CirQue<Data>::front()
215 {
216 return *d_front;
217 }
218 //=
219
220 //EMPTY
221 template<typename Data>
222 inline bool CirQue<Data>::empty() const
223 {
224 return d_size == 0;
225 }
226 //=
227
228 //FULL
229 template<typename Data>
230 inline bool CirQue<Data>::full() const
231 {
232 return d_size == d_maxSize;
233 }
234 //=
235
236 //SIZE
237 template<typename Data>
238 inline size_t CirQue<Data>::size() const
239 {
240 return d_size;
241 }
242 //=
243
244 //MAXSIZE
245 template<typename Data>
246 inline size_t CirQue<Data>::maxSize() const
247 {
248 return d_maxSize;
249 }
250 //=
251
252 //INC
253 template<typename Data>
254 Data *CirQue<Data>::inc(Data *ptr)
255 {
256 ++ptr;
257 return ptr == d_data + d_maxSize ? d_data : ptr;
258 }
259 //=
260
261 #endif