source: cpp/gdk/list.h @ 106

// This file is a part of the Framsticks GDK library.
// Copyright (C) 2002-2011  Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#ifndef _LIST_H_
#define _LIST_H_

#include <stdlib.h>
#include <string.h>
#include "nonstd.h"

//#define SLISTSTATS

#ifdef SLISTSTATS
#include <stdio.h>
class SListStats
{
  public:
int objects, allocations, copied, totalmem, usedmem;
SListStats():objects(0),allocations(0),copied(0),totalmem(0),usedmem() {}
~SListStats()
        {
        printf("------------------------\n"
               " SListStats:\n"
               " objects     = %ld\n"
               " allocations = %ld\n"
               " copied      = %ld\n"
               " total mem   = %ld\n"
               " usage       = %ld %%\n"
               "------------------------\n",
               objects,allocations,copied,totalmem,(usedmem*100)/totalmem);
        }
};
#endif


template<class T> class SListTempl
{
protected:
int have,used,pos; // ile,zaj,poz
T *mem;
void resize(int x)
        {
        if (mem || x)
                {
                mem=(T*)realloc(mem,x*sizeof(T));
#ifdef SLISTSTATS
                SListStats::stats.allocations++;
                SListStats::stats.copied+=sizeof(T)*min(x,have);
#endif  
                }
        have=x;
        }

public:

SListTempl(const SListTempl<T>& src):have(0),used(0),mem(0),pos(0)
        {(*this)=src;}
SListTempl():have(0),used(0),pos(0),mem(0)
        {}
~SListTempl()
        {
#ifdef SLISTSTATS
        SListStats::stats.objects++;
        SListStats::stats.totalmem+=sizeof(T)*have;
        SListStats::stats.usedmem+=sizeof(T)*used;
#endif
        hardclear();
        }

void needSize(int s)
        { if (s>have) resize(s+3+s/8); }
void operator+=(const T& e) ///< append one element
 {append(e);}
void operator-=(const T& e) ///< remove one element
 {int i; if ((i=find(e))>=0) remove(i);}
void remove(int i,int n=1) ///< remove n elements from position i
        {
        if ((i>=size())||(i<0)) return;
        if (i>(size()-n)) n=size()-i;
        if (pos>=i) pos-=n;
        memmove(mem+i,mem+i+n,sizeof(T)*(used-n-i));
        used-=n;
        }
void operator-=(int i) {remove(i);} ///< remove element from position i
T& operator()(int i) const ///< return element at position i
        {return mem[i];}
bool hasMore() {return pos<size();}
T& operator()() ///< return next element
        { return mem[pos++];}
int operator==(const SListTempl<T>& l) const ///< compare list
 {
 if (size() != l.size()) return 0;
 for (int i=0;i<size();i++) if (l.mem[i] != mem[i]) return 0;
 return 1;
 }
int find(const T& e) const ///< return position of element, or -1 if not found
        { for (int i=0;i<size();i++) if (mem[i]==e) return i;   return -1; }
int start() {return pos=0;} ///< start iteration throgh list
void append(const T& data) ///< add 1 element
        {needSize(size()+1); mem[used++]=data;}
void append(const T* data,int n) ///< add n elements
        {
        needSize(size()+n);
        memcpy(mem+used,data,sizeof(T)*n);
        used+=n;
        }
void insert(int p,T* data,int n) ///< insert n elements at position p
        {
        if (p>size()) p=size();
        needSize(size()+n);
        memmove(mem+p+n,mem+p,sizeof(T)*(size()-p));
        memcpy(mem+p,data,sizeof(T)*n);
        if (pos>p) pos+=n;
        }
void insert(int p,const T& data) ///< insert 1 element at position p
        {
        if (p>size()) p=size();
        needSize(size()+1);
        memmove(mem+p+1,mem+p,sizeof(T)*(size()-p));
        if (pos>p) pos++;
        mem[p]=data;
        used++;
        }
void set(int p,const T& d)
        { needSize(p+1); mem[p]=d; if (used<(p+1)) used=p+1;}
void setSize(int s)
        { needSize(s); used=s;}
T& get(int i) const {return operator()(i);}
T& get() {return operator()();}
void clear() {used=0;} ///< remove all elements
void hardclear() {resize(0); used=0;} ///< remove all elements and free mem
int size() const {return used;} ///< list size 
int operator!() {return used;} ///< list size
void operator=(const SListTempl<T>&src) ///duplicate
 {
 setSize(src.size());
 memcpy(mem, src.mem, src.size()*sizeof(T));
 }
void operator+=(const SListTempl<T>&src) ///< append src contents
 {
 needSize(size()+src.size());
 memcpy(mem+used, src.mem, src.size()*sizeof(T));
 used+=src.used;
 }
void trim(int newsiz)
        {if (newsiz<used) used=newsiz;}
};

#define FOREACH(type,var,list) for(type var=(type)list.start();var=(type)list();)

// usage example: FOREACH(char*,t,thelist) printf("t=%s\n",t);

template<class T> class PtrListTempl: public SListTempl<T>
{
   public:
T operator()() ///< return next element
     {if (this->pos>=this->size()) return 0; else return 
this->mem[this->pos++];}

T operator()(int i) const ///< return element at position i
     {if (i>=this->size()) return 0; else return this->mem[i];}

T get(int i) const {return operator()(i);}
T get() {return operator()();}
};


typedef PtrListTempl<void*> SList;

#endif