Branch data     Line data    Source code

       1                 :            : #ifndef GFXTOOLS_BUFFER_INCLUDED // -*- C++ -*-
       2                 :            : #define GFXTOOLS_BUFFER_INCLUDED
       3                 :            : 
       4                 :            : #include "Array.h"
       5                 :            : 
       6                 :            : template<class T>
       7                 :      10408 : class buffer : public array<T> {
       8                 :            : protected:
       9                 :            :     int fill;
      10                 :            : public:
      11         [ +  - ]:       5202 :     buffer() { init(8); }
      12         [ +  - ]:          2 :     buffer(int l) { init(l); }
      13                 :            :     
      14                 :      20812 :     inline void init(int l) { array<T>::init(l); fill=0; }
      15                 :            : 
      16                 :            :     inline int add(const T& t);
      17                 :            :     inline void reset();
      18                 :            :     inline int find(const T&);
      19                 :            :     inline T remove(int i);
      20                 :            :     inline int addAll(const buffer<T>& buf);
      21                 :            :     inline void removeDuplicates();
      22                 :            : 
      23                 :     159860 :     inline int length() const { return fill; }
      24                 :            :     inline int maxLength() const { return array<T>::len; }
      25                 :            : };
      26                 :            : 
      27                 :            : 
      28                 :            : template<class T>
      29                 :      32804 : inline int buffer<T>::add(const T& t)
      30                 :            : {
      31         [ +  + ]:      32804 :     if( fill == array<T>::len )
      32                 :      10212 :         array<T>::resize(  array<T>::len*2 );
      33                 :            : 
      34                 :      32804 :      array<T>::data[fill] = t;
      35                 :            : 
      36                 :      32804 :     return fill++;
      37                 :            : }
      38                 :            : 
      39                 :            : template<class T>
      40                 :       1088 : inline void buffer<T>::reset()
      41                 :            : {
      42                 :       1088 :     fill = 0;
      43                 :       1088 : }
      44                 :            : 
      45                 :            : template<class T>
      46                 :       3092 : inline int buffer<T>::find(const T& t)
      47                 :            : {
      48         [ +  - ]:       9806 :     for(int i=0;i<fill;i++)
      49         [ +  + ]:       9806 :         if(  array<T>::data[i] == t )
      50                 :       3092 :             return i;
      51                 :            : 
      52                 :          0 :     return -1;
      53                 :            : }
      54                 :            : 
      55                 :            : template<class T>
      56                 :       3092 : inline T buffer<T>::remove(int i)
      57                 :            : {
      58                 :            : #ifdef SAFETY
      59                 :            :     assert( i>=0 );
      60                 :            :     assert( i<fill );
      61                 :            : #endif
      62                 :            : 
      63                 :       3092 :     fill--;
      64                 :       3092 :     T temp =  array<T>::data[i];
      65                 :       3092 :      array<T>::data[i] =  array<T>::data[fill];
      66                 :            : 
      67                 :       3092 :     return temp;
      68                 :            : }
      69                 :            : 
      70                 :            : template<class T>
      71                 :            : inline int buffer<T>::addAll(const buffer<T>& buf)
      72                 :            : {
      73                 :            :     for(int i=0; i<buf.fill; i++)
      74                 :            :         add(buf(i));
      75                 :            : 
      76                 :            :     return fill;
      77                 :            : }
      78                 :            : 
      79                 :            : template<class T>
      80                 :            : inline void buffer<T>::removeDuplicates()
      81                 :            : {
      82                 :            :     for(int i=0; i<fill; i++)
      83                 :            :     {
      84                 :            :         for(int j=i+1; j<fill; )
      85                 :            :         {
      86                 :            :             if(  array<T>::data[j] ==  array<T>::data[i] )
      87                 :            :                 remove(j);
      88                 :            :             else
      89                 :            :                 j++;
      90                 :            :         }
      91                 :            :     }
      92                 :            : }
      93                 :            : 
      94                 :            : // GFXTOOLS_BUFFER_INCLUDED
      95                 :            : #endif