---

skAlist.h

/*
  Copyright 1996-2003
  Simon Whiteside

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

* $Id: skAlist_8h-source.html,v 1.6 2004/12/17 21:31:15 sdw Exp $
*/

#ifndef skALIST_H
#define skALIST_H


#include "skGeneral.h"
  
class  CLASSEXPORT skAList;  

class  CLASSEXPORT skAListIterator 
#ifdef __SYMBIAN32__
: public CBase
#endif
{       
 public:
  void  reset();
  virtual ~skAListIterator();
 protected:
  skAListIterator(const skAList&);
  skAListIterator& operator=(const skAListIterator&);
  void * operator()();
 private:
  USize m_Current;
  const skAList& m_AList;
};    
class  CLASSEXPORT skAList 
#ifdef __SYMBIAN32__
: public CBase
#endif
{   
 public:
  inline virtual ~skAList();       
  IMPORT_C void clearAndDestroy();
  IMPORT_C void clear();
  inline USize entries() const;
  IMPORT_C void deleteElt(USize  n);
  IMPORT_C void test() const;
  IMPORT_C void growTo(USize size);
  inline USize getArraySize() const;
 protected:
  inline skAList();
  void insert(void *,USize index);
  void prepend(void *);
  inline void append(void *);
  void remove(void *);
  void removeAndDestroy(void *); 
  inline void * operator[](USize  n) const;
  inline int index(const void *) const;
  inline bool contains(const void *) const;
  virtual void deleteItem(void *)=0;
  friend class skAListIterator;
  inline int findElt(const void * i) const;
  IMPORT_C void grow();
  IMPORT_C void createArray();
  void ** m_Array;
  USize m_ArraySize;
  USize m_Entries;
 private:
  skAList(const skAList&);
  skAList& operator=(const skAList&);
};    
template <class T> class CLASSEXPORT skTAList : public skAList
{
 public:
  skTAList();
  virtual ~skTAList();
  void insert(T *,USize index);
  void prepend(T *);
  void append(T *);
  void remove(T *);
  void removeAndDestroy(T *);
  T * operator[](USize  n) const;
  int index(const T *) const;
  bool contains(const T *) const;
 protected:
  void deleteItem(void *);
 private:
  skTAList<T>& operator=(const skTAList<T>& l);
  skTAList(const skTAList<T>&);
};
template <class T> class CLASSEXPORT skTAListIterator : public skAListIterator
{       
 public:
  skTAListIterator(const skTAList<T>&);
  T * operator()();
};    

#include "skAlist.inl"

#endif

---