---

skValist.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: skValist_8h-source.html,v 1.7 2004/12/17 21:31:15 sdw Exp $
  */

#ifndef skVALIST_H
#define skVALIST_H


#include "skGeneral.h"
#include "skBoundsException.h"
    

template <class T> class CLASSEXPORT skTVAList 
#ifdef __SYMBIAN32__
: public CBase
#endif
{         
 public:
  skTVAList();
#ifndef __SYMBIAN32__

  skTVAList(const skTVAList<T>&);
#endif

  virtual ~skTVAList();                                 
  skTVAList& operator=(const skTVAList<T>&);
  void moveFrom(skTVAList<T>&);
  void  clear();                                        
  USize entries() const;
  void  deleteElt(USize  n);
  void  prepend(const T &t);
  void  insert(const T &t,USize index);
  void  append(const T &t);
  void  remove(const T &t);     
  T& operator[](USize  n) const;
  int index(const T &t) const;
  bool  contains(const T &t) const;
  void  growTo(USize new_size);
  USize getArraySize() const;
#ifdef __SYMBIAN32__

  operator TCleanupItem();
  static void Cleanup(TAny * s);
#endif
 protected:
  int   findElt(const T &t) const;
  void  grow();
  void createArray();
  T*  m_Array;  
  USize m_ArraySize;
  USize m_Entries;
};        

#ifdef __gnuc__
#define skTVALIST_PRE template <class T> 
#else
#define skTVALIST_PRE template <class T> 
#endif


//-----------------------------------------------------------------
skTVALIST_PRE inline skTVAList<T>::skTVAList()
//-----------------------------------------------------------------
  :m_Array(0),m_ArraySize(0),m_Entries(0)
{
}
#ifndef __SYMBIAN32__
//-----------------------------------------------------------------
skTVALIST_PRE inline skTVAList<T>::skTVAList(const skTVAList& l)
//-----------------------------------------------------------------
  : m_ArraySize(l.m_ArraySize),m_Entries(l.m_Entries)
{
  if(m_ArraySize){
    m_Array=skARRAY_NEW(T,m_ArraySize);
    for (USize x=0;x<m_Entries;x++)
      m_Array[x]=l.m_Array[x];
  }else
    m_Array = 0;
}
#endif
//-----------------------------------------------------------------
skTVALIST_PRE inline skTVAList<T>::~skTVAList()
//-----------------------------------------------------------------
{
  if(m_Array)
    delete [] m_Array;
}
//-----------------------------------------------------------------
skTVALIST_PRE inline void skTVAList<T>::createArray()
//-----------------------------------------------------------------
{
  if (m_ArraySize==0)
    m_ArraySize=1;
  if (m_ArraySize)
    m_Array=skARRAY_NEW(T,m_ArraySize);
}
//-----------------------------------------------------------------
skTVALIST_PRE inline void skTVAList<T>::clear()
//-----------------------------------------------------------------
{
  m_Entries=0;
  if(m_Array)
    delete [] m_Array;
  m_Array=0;
  m_ArraySize=0;
}
//-----------------------------------------------------------------
skTVALIST_PRE inline USize skTVAList<T>::entries() const
     //-----------------------------------------------------------------
{
  return m_Entries;
}
//-----------------------------------------------------------------
skTVALIST_PRE inline USize skTVAList<T>::getArraySize() const
//-----------------------------------------------------------------
{
  return m_ArraySize;
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::deleteElt(USize  n)
//-----------------------------------------------------------------
{
  assert(n<m_Entries);
  if (n>=m_Entries)
#ifdef EXCEPTIONS_DEFINED
    throw skBoundsException("Invalid index to DeleteElt",__FILE__,__LINE__);
#else
  ExitSystem();
#endif
  else{
    for (USize x=n;x<m_Entries-1;x++)
      m_Array[x]=m_Array[x+1];
    m_Entries--;
  }
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::insert(const T &t,USize index)
//-----------------------------------------------------------------
{
  assert(index<=m_Entries);
  if (index>m_Entries)
#ifdef EXCEPTIONS_DEFINED
    throw skBoundsException("Invalid index to Insert",__FILE__,__LINE__);
#else
  ExitSystem();
#endif
  if (m_Array==0)
    createArray();
  if (m_ArraySize==m_Entries)
    grow();
  if (index<m_Entries){
    for (USize x=m_Entries;x>index;x--)
      m_Array[x]=m_Array[x-1];
  }
  m_Array[index]=t;
  m_Entries++;
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::prepend(const T &t)
//-----------------------------------------------------------------
{
  if (m_Array==0)
    createArray();
  if (m_ArraySize==m_Entries)
    grow();
  m_Entries++;
  for (USize x=m_Entries-1;x>=1;x--)
    m_Array[x]=m_Array[x-1];
  m_Array[0]=t;
}
//-----------------------------------------------------------------
skTVALIST_PRE inline void skTVAList<T>::append(const T &t)
//-----------------------------------------------------------------
{
  if (m_Array==0)
    createArray();
  if (m_ArraySize==m_Entries)
    grow();
  m_Array[m_Entries]=t;
  m_Entries++;
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::remove(const T &t)
//-----------------------------------------------------------------
{
  int index = findElt(t);
  assert(index>=0 && "VAList does not contain item"!=0);
  if (index>=0){
    for (USize x=(USize)index;x<m_Entries-1;x++)
      m_Array[x]=m_Array[x+1];

    m_Entries--;
  }
}
//-----------------------------------------------------------------
skTVALIST_PRE inline T& skTVAList<T>::operator[](USize  n) const
//-----------------------------------------------------------------
{
  assert(n<m_Entries);
  if (n>=m_Entries)
#ifdef EXCEPTIONS_DEFINED
    throw skBoundsException(skSTR("Invalid index to []"),__FILE__,__LINE__);
#else
  ExitSystem();
#endif
  return m_Array[n];
}
//-----------------------------------------------------------------
skTVALIST_PRE inline int skTVAList<T>::index(const T &t) const
//-----------------------------------------------------------------
{
  return (USize)findElt(t);
}
//-----------------------------------------------------------------
skTVALIST_PRE inline bool skTVAList<T>::contains(const T &t) const
//-----------------------------------------------------------------
{
  return (bool)(findElt(t) >= 0);
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::moveFrom(skTVAList<T>& l)
//-----------------------------------------------------------------
{
  if (&l!=this){
    clear();
    // transfer the other list's contents across to us
    m_ArraySize=l.m_ArraySize;
    m_Entries=l.m_Entries;
    m_Array=l.m_Array;
    l.m_ArraySize=0;
    l.m_Entries=0;
    l.m_Array=0;
  }
}
//-----------------------------------------------------------------
skTVALIST_PRE skTVAList<T>& skTVAList<T>::operator=(const skTVAList<T>& l)
//-----------------------------------------------------------------
{
  if (&l!=this){
    clear();
    m_ArraySize=l.m_Entries;
    m_Entries=l.m_Entries;
    if(m_Entries){
      m_Array=skARRAY_NEW(T,m_Entries);
      for (USize x=0;x<m_Entries;x++)           
        m_Array[x]=l.m_Array[x];
    }else{
      m_Array=0;        // don't allocate until needed
      m_ArraySize=0;
    }
  }
  return *this;
}
// Returns -1 if not found.
//-----------------------------------------------------------------
skTVALIST_PRE inline int skTVAList<T>::findElt(const T &t) const
//-----------------------------------------------------------------
{
  for (USize index=0;index<m_Entries;index++){
    if (m_Array[index]==t)
      return (int)index;                // jump out
  }
  return -1;
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::grow()
//-----------------------------------------------------------------
{
  m_ArraySize *= 2;     // constant increase in size
  T *  new_array=skARRAY_NEW(T,m_ArraySize);
  if(m_Array){
    for (USize x=0;x<m_Entries;x++)             
      new_array[x]=m_Array[x];
    delete [] m_Array;
  }
  m_Array=new_array;
}
//-----------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::growTo(USize new_size)
//-----------------------------------------------------------------
{
  if (new_size>m_ArraySize){
    m_ArraySize=new_size;

    T *  new_array=skARRAY_NEW(T,m_ArraySize);
    if(m_Array){
      for (USize x=0;x<m_Entries;x++)           
        new_array[x]=m_Array[x];
      delete [] m_Array;
    }
    m_Array=new_array;
  }
}
#ifdef __SYMBIAN32__
//-------------------------------------------------------------------------
skTVALIST_PRE skTVAList<T>::operator TCleanupItem()
//-------------------------------------------------------------------------
// used for leave support of local variable lists
{
  return TCleanupItem(Cleanup,this);
}
//-------------------------------------------------------------------------
skTVALIST_PRE void skTVAList<T>::Cleanup(TAny * s)
//-------------------------------------------------------------------------
// called in case there is a leave
{
  ((skTVAList<T> *)s)->clear();
}
#endif

#endif

---