src/main/symbian/vectorbuffer.h

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