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