chxavvector.h

来自「symbian 下的helix player源代码」· C头文件 代码 · 共 280 行

/************************************************************************
 * chxavvector.h
 * -------------
 *
 * Synopsis:
 * Vector template container class.
 *
 *
 * (c) 1995-2003 RealNetworks, Inc. Patents pending. All rights reserved.
 *
 ************************************************************************/


#ifndef _chxavvector_h_
#define _chxavvector_h_

#include <stdlib.h>

// Symbian
#include <e32std.h>
#define NEW new (ELeave)



template<class T> class CHXAvVectorRep;
template<class T> class CHXAvVector;

template<class T>
class CHXAvVectorRep {
private:
//friend class CHXAvVector<T>;
public:

  CHXAvVectorRep(T* v, int len, int ownbase);
  ~CHXAvVectorRep();
  void Resize(int len, int exact);
  static void Copy(T* src, T* dest, int len);
  int Length();
  T* Base();
  
  T* base_;			// base address of vector
  int len_;			// current length of vector
  int maxlen_;			// maximum lenght of vector
  int ownbase_;			// if 1, own the base address
  int refcount_;		// reference count
};

/**    CHXAvVectorRep<T>    **/

template<class T>
void CHXAvVectorRep<T>::Resize(int len, int exact)
{
  if (len > maxlen_) {
    if (exact)
      maxlen_ = len;
    else {
      maxlen_ = 2;
      while (maxlen_ < len) maxlen_ <<= 1;
    }
    T* new_base = NEW T[maxlen_];
    Copy(base_, new_base, len_);
    if (ownbase_)
      delete [] base_;
    base_ = new_base;
    ownbase_ = 1;
  }
  len_ = len;
}


template<class T>
inline
void CHXAvVectorRep<T>::Copy(T* src, T* dest, int len)
{
  while (len-- > 0) *dest++ = *src++;
}

/**    CHXAvVector<T>    **/

template<class T>
class CHXAvVector {
public:
  CHXAvVector(int nelem = 0);
  CHXAvVector(T* v, int nelem, int ownbase=0);
  CHXAvVector(const CHXAvVector<T>& v);
  ~CHXAvVector();
  CHXAvVector<T>& operator=(const CHXAvVector<T>& v);
  T& operator[](int index);
  const T& operator[](int index) const;
  operator T* ();
  operator T* () const;
  void Copy(const CHXAvVector<T>& v);
  int Nelements() const;
  int ElemSize() const;
  void Bind(T* v, int nelem, int ownbase=0);
  void Resize(int nelem);
  void Fill(const T& t, int start, int n);
  void Reverse();
  void Sort(int (*cmp)(const void*, const void*));

private:
  CHXAvVectorRep<T>* rep_;
};


/**    CHXAvVector<T>    **/

template<class T>
/*inline*/
void CHXAvVector<T>::Copy(const CHXAvVector<T>& v)
{
  if (&v != this) {
    if (--rep_->refcount_ == 0)
      delete rep_;
    int nelem = v.Nelements();
    T* base = nelem > 0 ? NEW T[nelem] : 0;
    rep_ = NEW CHXAvVectorRep<T>(base, nelem, 1);
    if (nelem > 0)
      CHXAvVectorRep<T>::Copy(v.rep_->base_, rep_->base_, nelem);
  }
}

template<class T>
/*inline*/
void CHXAvVector<T>::Fill(const T& t, int start, int n)
{
  T* vec = rep_->Base();

  if (start < 0) start = 0;
  if (n+start > Nelements()) n = Nelements()-start;
  vec += start;
  while (n-- > 0)
    *vec++ = t;
}

template<class T>
inline
void CHXAvVector<T>::Reverse()
{
  T* l = rep_->Base();
  T* u = l + Nelements()-1;
  while (l < u) {
    T t = *l;
    *l++ = *u;
    *u-- = t;
  }
}




template<class T>
inline CHXAvVector<T>::CHXAvVector(int nelem)
{
  T* base = nelem > 0 ? NEW T[nelem] : 0; //XXXLCM leave
  rep_ = NEW CHXAvVectorRep<T>(base, nelem, 1);
}

template<class T>
inline CHXAvVector<T>::CHXAvVector(T* v, int nelem, int ownbase)
{
  rep_ = NEW CHXAvVectorRep<T>(v, nelem, ownbase);
}

template<class T>
inline CHXAvVector<T>::CHXAvVector(const CHXAvVector<T>& v)
{
  v.rep_->refcount_++;
  rep_ = v.rep_;
}

template<class T>
inline CHXAvVector<T>::~CHXAvVector()
{
  if (--rep_->refcount_ == 0)
    delete rep_;
}

template<class T>
inline CHXAvVector<T>& CHXAvVector<T>::operator=(const CHXAvVector<T>& v)
{
  if (this != &v) {
    v.rep_->refcount_++;
    if (--rep_->refcount_ == 0)
      delete rep_;
    rep_ = v.rep_;
  }
  return *this;
}




template<class T>
inline CHXAvVectorRep<T>::CHXAvVectorRep(T* v, int len, int ownbase)
: base_(v), len_(len), maxlen_(len), ownbase_(ownbase), refcount_(1)
{}

template<class T>
inline CHXAvVectorRep<T>::~CHXAvVectorRep()
{
  if (ownbase_)
    delete [] base_;
}

template<class T>
inline int CHXAvVectorRep<T>::Length()
{
  return len_;
}

template<class T>
inline T* CHXAvVectorRep<T>::Base()
{
  return base_;
}


template<class T>
inline T& CHXAvVector<T>::operator[](int index)
{
  return (rep_->Base())[index];
}

template<class T>
inline const T& CHXAvVector<T>::operator[](int index) const
{
  return (rep_->Base())[index];
}

template<class T>
inline CHXAvVector<T>::operator T* ()
{
  return rep_->Base();
}

template<class T>
inline CHXAvVector<T>::operator T* () const
{
  return rep_->Base();
}

template<class T>
inline int CHXAvVector<T>::Nelements() const
{
  return rep_->Length();
}

template<class T>
inline int CHXAvVector<T>::ElemSize() const
{
  return sizeof(T);
}

template<class T>
inline void CHXAvVector<T>::Bind(T* v, int nelem, int ownbase)
{
  if (--rep_->refcount_ == 0)
    delete rep_;
  rep_ = NEW CHXAvVectorRep<T>(v, nelem, ownbase);
}


template<class T>
inline void CHXAvVector<T>::Sort(int (*cmp)(const void*, const void*))
{
  qsort(rep_->Base(), Nelements(), sizeof(T), cmp);
}


template<class T>
inline void CHXAvVector<T>::Resize(int nelem)
{
  rep_->Resize(nelem, 0);
}



#endif /* _chxavvector_h_ */