|
3975
|
1 /*
|
|
|
2 vectorbuffer.cpp
|
|
|
3 yet another circle buffer
|
|
|
4
|
|
|
5 Markus Mertama
|
|
|
6 */
|
|
|
7
|
|
|
8 #ifndef __VECTORBUFFER_H__
|
|
|
9 #define __VECTORBUFFER_H__
|
|
|
10
|
|
|
11 #include<e32std.h>
|
|
|
12 #define VLOG(x)
|
|
|
13 #define VECPANIC(x) VectorPanic(x, __LINE__)
|
|
|
14 void VectorPanic(TInt, TInt);
|
|
|
15
|
|
|
16
|
|
|
17 //int DEBUG_INT;
|
|
|
18
|
|
|
19 NONSHARABLE_CLASS(TNodeBuffer)
|
|
|
20 {
|
|
|
21 public:
|
|
|
22 protected:
|
|
|
23 NONSHARABLE_CLASS(TNode)
|
|
|
24 {
|
|
|
25 public:
|
|
|
26 static TNode* Empty(TUint8* iBuffer);
|
|
|
27 static TNode* New(TNode* aPrev, const TDesC8& aData);
|
|
|
28 const TUint8* Ptr() const;
|
|
|
29 TInt Size() const;
|
|
|
30 inline TNode* Succ();
|
|
|
31 static void SetSucc(TNode*& aNode);
|
|
|
32 void Terminator(TNode* aNode);
|
|
|
33 private:
|
|
|
34 TNode* iSucc;
|
|
|
35 };
|
|
|
36 };
|
|
|
37
|
|
|
38 inline TNodeBuffer::TNode* TNodeBuffer::TNode::Succ()
|
|
|
39 {
|
|
|
40 return iSucc;
|
|
|
41 }
|
|
|
42
|
|
|
43 template <TInt C>
|
|
|
44 NONSHARABLE_CLASS(TVectorBuffer) : public TNodeBuffer
|
|
|
45 {
|
|
|
46 public:
|
|
|
47 TVectorBuffer();
|
|
|
48 TInt Append(const TDesC8& aData);
|
|
|
49 // TInt AppendOverwrite(const TDesC8& aData);
|
|
|
50 TPtrC8 Shift();
|
|
|
51 TPtrC8 operator[](TInt aIndex) const;
|
|
|
52 TInt Size() const;
|
|
|
53 private:
|
|
|
54 TInt GetRoom(TInt aSize) const;
|
|
|
55 TInt Unreserved() const;
|
|
|
56 private:
|
|
|
57 TNode* iTop;
|
|
|
58 TNode* iBottom;
|
|
|
59 TInt iSize;
|
|
|
60 TUint8 iBuffer[C];
|
|
|
61 };
|
|
|
62
|
|
|
63 template <TInt C>
|
|
|
64 TVectorBuffer<C>::TVectorBuffer() : iSize(0)
|
|
|
65 {
|
|
|
66 Mem::FillZ(iBuffer, C);
|
|
|
67 iTop = TNode::Empty(iBuffer); //these points to buffer
|
|
|
68 iBottom = TNode::Empty(iBuffer);
|
|
|
69 }
|
|
|
70
|
|
|
71 template<TInt C >
|
|
|
72 TInt TVectorBuffer<C>::Unreserved() const
|
|
|
73 {
|
|
|
74 __ASSERT_DEBUG(iBottom < iBottom->Succ(), VECPANIC(KErrCorrupt));
|
|
|
75 const TInt bytesbetween =
|
|
|
76 reinterpret_cast<const TUint8*>(iBottom->Succ()) -
|
|
|
77 reinterpret_cast<const TUint8*>(iTop);
|
|
|
78 const TInt topsize = sizeof(TNode);
|
|
|
79 if(bytesbetween > 0) //bytesbetween is room between bottom and top
|
|
|
80 { //therefore free room is subracted from free space
|
|
|
81
|
|
|
82 const TInt room = C - bytesbetween - topsize;
|
|
|
83 return room;
|
|
|
84 }
|
|
|
85 if(bytesbetween == 0)
|
|
|
86 {
|
|
|
87
|
|
|
88 if(Size() > 0)
|
|
|
89 return 0;
|
|
|
90 else
|
|
|
91 return C - topsize;
|
|
|
92 }
|
|
|
93 const TInt room = -bytesbetween - topsize; //free is space between pointers
|
|
|
94 return room;
|
|
|
95 }
|
|
|
96
|
|
|
97 template <TInt C>
|
|
|
98 TInt TVectorBuffer<C>::GetRoom(TInt aSize) const
|
|
|
99 {
|
|
|
100 const TInt bytesnew = sizeof(TNode) + aSize;
|
|
|
101 const TInt room = Unreserved() - bytesnew;
|
|
|
102 return room;
|
|
|
103 }
|
|
|
104
|
|
|
105 template <TInt C>
|
|
|
106 TInt TVectorBuffer<C>::Append(const TDesC8& aData) //ei ole ok!
|
|
|
107 {
|
|
|
108 const TInt len = aData.Length();
|
|
|
109 if(GetRoom(len) < 0)
|
|
|
110 {
|
|
|
111 return KErrOverflow;
|
|
|
112 }
|
|
|
113 if(iBottom->Succ()->Ptr() - iBuffer > (C - (len + TInt(sizeof(TNode)))))
|
|
|
114 {
|
|
|
115 VLOG("rc");
|
|
|
116 // RDebug::Print(_L("vector: append"));
|
|
|
117 TNode* p = TNode::Empty(iBuffer);
|
|
|
118 iBottom->Terminator(p);
|
|
|
119 iBottom = p;
|
|
|
120 return Append(aData);
|
|
|
121 // Append();
|
|
|
122 // iBottom = TNode::New(p, aData); //just append something into end
|
|
|
123 }
|
|
|
124
|
|
|
125 //DEBUG_INT++;
|
|
|
126
|
|
|
127 iBottom = TNode::New(iBottom, aData);
|
|
|
128
|
|
|
129 iSize += len;
|
|
|
130 return KErrNone;
|
|
|
131 }
|
|
|
132
|
|
|
133 /*
|
|
|
134 template <TInt C>
|
|
|
135 TInt TVectorBuffer<C>::AppendOverwrite(const TDesC8& aData) //ei ole ok!
|
|
|
136 {
|
|
|
137 while(Append(aData) == KErrOverflow)
|
|
|
138 {
|
|
|
139 if(iTop->Succ() == NULL)
|
|
|
140 {
|
|
|
141 return KErrUnderflow;
|
|
|
142 }
|
|
|
143 //Shift(); //data is lost
|
|
|
144 }
|
|
|
145 return KErrNone;
|
|
|
146 }
|
|
|
147 */
|
|
|
148 template <TInt C>
|
|
|
149 TPtrC8 TVectorBuffer<C>::Shift()
|
|
|
150 {
|
|
|
151 __ASSERT_ALWAYS(iTop->Succ() != NULL, VECPANIC(KErrUnderflow)); //can never pass-by bottom
|
|
|
152 TNode* node = iTop;
|
|
|
153 iTop = iTop->Succ();
|
|
|
154 if(iTop > node)
|
|
|
155 {
|
|
|
156 // DEBUG_INT--;
|
|
|
157 iSize -= node->Size();
|
|
|
158 return TPtrC8(node->Ptr(), node->Size());
|
|
|
159 }
|
|
|
160 else
|
|
|
161 {
|
|
|
162 // RDebug::Print(_L("vector: shift"));
|
|
|
163 return Shift(); //this happens when buffer is terminated, and data lies in next
|
|
|
164 }
|
|
|
165 }
|
|
|
166
|
|
|
167 template <TInt C>
|
|
|
168 TInt TVectorBuffer<C>::Size() const
|
|
|
169 {
|
|
|
170 return iSize;
|
|
|
171 }
|
|
|
172
|
|
|
173 template <TInt C>
|
|
|
174 TPtrC8 TVectorBuffer<C>::operator[](TInt aIndex) const
|
|
|
175 {
|
|
|
176 TInt index = 0;
|
|
|
177 TNode* t = iTop->Size() > 0 ? iTop : iTop->Succ(); //eliminate terminator
|
|
|
178 while(index < aIndex)
|
|
|
179 {
|
|
|
180 TNode* nt = t->Succ();
|
|
|
181 if(nt < t)
|
|
|
182 {
|
|
|
183 nt = nt->Succ();
|
|
|
184 }
|
|
|
185 t = nt;
|
|
|
186 if(t->Size() > 0)
|
|
|
187 index++;
|
|
|
188 __ASSERT_ALWAYS(t->Succ() != NULL, VECPANIC(KErrUnderflow)); //can never pass-by bottom
|
|
|
189 }
|
|
|
190 return t->Ptr();
|
|
|
191 }
|
|
|
192
|
|
|
193
|
|
|
194 template <class T, TInt C>
|
|
|
195 NONSHARABLE_CLASS(TVector) : public TVectorBuffer<C * sizeof(T)>
|
|
|
196 {
|
|
|
197 public:
|
|
|
198 TVector();
|
|
|
199 TInt Append(const T& aData);
|
|
|
200 const T& Shift();
|
|
|
201 TInt Size() const;
|
|
|
202 const T& operator[](TInt aIndex) const;
|
|
|
203 };
|
|
|
204
|
|
|
205 template <class T, TInt C>
|
|
|
206 TVector<T, C>::TVector() : TVectorBuffer<C * sizeof(T)>()
|
|
|
207 {
|
|
|
208 }
|
|
|
209
|
|
|
210 template <class T, TInt C>
|
|
|
211 TInt TVector<T, C>::Append(const T& aData)
|
|
|
212 {
|
|
|
213 const TPckgC<T> data(aData);
|
|
|
214 return TVectorBuffer<C * sizeof(T)>::Append(data);
|
|
|
215 }
|
|
|
216
|
|
|
217 template <class T, TInt C>
|
|
|
218 const T& TVector<T, C>::Shift()
|
|
|
219 {
|
|
|
220 const TPtrC8 ptr = TVectorBuffer<C * sizeof(T)>::Shift();
|
|
|
221 return *(reinterpret_cast<const T*>(ptr.Ptr()));
|
|
|
222 }
|
|
|
223
|
|
|
224
|
|
|
225 template <class T, TInt C>
|
|
|
226 TInt TVector<T, C>::Size() const
|
|
|
227 {
|
|
|
228 return TVectorBuffer<C * sizeof(T)>::Size() / sizeof(T);
|
|
|
229 }
|
|
|
230
|
|
|
231 template <class T, TInt C>
|
|
|
232 const T& TVector<T, C>::operator[](TInt aIndex) const
|
|
|
233 {
|
|
|
234 const TPtrC8 ptr = TVectorBuffer<C * sizeof(T)>::operator[](aIndex);
|
|
|
235 return *(reinterpret_cast<const T*>(ptr.Ptr()));
|
|
|
236 }
|
|
|
237
|
|
|
238 #endif
|
|
|
239
|
|
|
240
|
