#pragma once

#ifndef ZILIST

  #define ZILIST



//CMISListImp<classCSubscriptionInfo,class CStandardAllocator> *'

//CMListImp  <class CVoidPointer, class CStandardAllocator> &'

//  template <class T, class List, class Alloc> class CMInternalIListImp

//  Implements a managed list of pointers to objects of type T.

//  This is implemented through the form of CMListImp specified by List

//  Since pointers always have meaningful copy semantics, this class

//  can handle any type of object.



template <class T, class Alloc>

class CMSListImp : public CMListImp<T, Alloc>

{

  typedef CMListImp<T,Alloc> Parent;

public:

  friend CMListIteratorImp<T,Alloc>;

  int Add( const T& t );

  Parent::IterFunc;

  Parent::CondFunc;

  Parent::PeekHead;

  Parent::Detach;

  Parent::DetachAtHead;

  Parent::Find;

  Parent::Flush;

  Parent::IsEmpty;

  Parent::GetItemsInContainer;

  Parent::ForEach;

  Parent::FirstThat;

  Parent::LastThat;

  Parent::operator delete;

protected:

  Parent::Head;

  Parent::Tail;

  Parent::ItemsInContainer;

  Parent::DoDetach;

  Parent::DoDetachAtHead;

  Parent::DoFlush;

  virtual CMListElement<T,Alloc> *FindDetach( const T& t );

  virtual CMListElement<T,Alloc> *FindPred( const T& );

};



template <class T,class Alloc>

int CMSListImp<T,Alloc>::Add( const T& t )

{

  new CMListElement<T,Alloc>( t, FindPred(t) );

  ItemsInContainer++;

  return 1;

}



template <class T,class Alloc>

CMListElement<T,Alloc> *CMSListImp<T,Alloc>::FindDetach( const T& t )

{

  CMListElement<T,Alloc> *res = FindPred(t);

  if ( res != 0 && res->Next->Data == t )

    return res;

  else

    return &Tail;

}



template <class T,class Alloc>

CMListElement<T,Alloc> *CMSListImp<T,Alloc>::FindPred( const T& t )

{

  Tail.Data = t;

  CMListElement<T,Alloc> *cursor = &Head;

  while ( cursor->Next->Data < t )

    cursor = cursor->Next;

  return cursor;

}



template <class T,class List,class Alloc>

class CMInternalIListImp : public List

{

public:

  typedef List Parent;

  typedef void (*IterFunc)(T&, void *);

  typedef int  (*CondFunc)(const T&, void *);

  T *PeekHead() const

  {

    return static_cast<T *>(static_cast<void *>(Parent::PeekHead()));

  }

  int Add( T *t ) { return Parent::Add( t );}

  int Detach( T *t, int del = 0 ) { return Parent::DoDetach( t, del );}

  int DetachAtHead( int del = 0 ) { return Parent::DoDetachAtHead( del );}

  void Flush( int del = 0 ) { Parent::DoFlush(del);}

  T *Find( const T *t );

  void ForEach( IterFunc iter, void * );

  T *FirstThat( CondFunc cond, void * ) const;

  T *LastThat( CondFunc cond, void * ) const;

protected:

  virtual CMListElement<CVoidPointer,Alloc> * FindPred( const CVoidPointer& ) = 0;

private:

  virtual void RemoveData( CMListElement<CVoidPointer,Alloc> *block )

  {

    delete static_cast<T *>(static_cast<void *>(block->Data));

  }

};



template <class T,class List,class Alloc>

T *CMInternalIListImp<T,List,Alloc>::Find( const T *t )

{

  CMListElement<CVoidPointer,Alloc> *cur = Head.Next;

  Tail.Data = t;

  while ( !(*static_cast<T *>(static_cast<void *>(cur->Data)) == *t) )

    cur = cur->Next;

  Cail.Data = CVoidPointer();

  if ( cur == &Tail )

    return 0;

  else

    return static_cast<T *>(static_cast<void *>(cur->Data));

}



template <class T,class List,class Alloc>

void CMInternalIListImp<T,List,Alloc>::ForEach( IterFunc iter, void *args )

{

  CMListElement<CVoidPointer,Alloc> *cur = Head.Next;

  while ( cur->Next != cur )

  {

    iter( *static_cast<T *>(static_cast<void *>(cur->Data)), args );

    cur = cur->Next;

  }

}



template <class T,class List,class Alloc>

T *CMInternalIListImp<T,List,Alloc>::FirstThat( CondFunc cond, void *args ) const

{

  CMListElement<CVoidPointer,Alloc> *cur = Head.Next;

  while ( cur->Next != cur )

    if ( cond( *static_cast<T *>(static_cast<void *>(cur->Data)), args ) != 0 )

      return static_cast<T *>(static_cast<void *>(cur->Data));

    else

      cur = cur->Next;

  return 0;

}



template <class T,class List,class Alloc>

T *CMInternalIListImp<T,List,Alloc>::LastThat( CondFunc cond, void *args ) const

{

  T *res = 0;

  CMListElement<CVoidPointer,Alloc> *cur = Head.Next;

  while ( cur->Next != cur )

  {

    if ( cond( *static_cast<T *>(static_cast<void *>(cur->Data)), args ) != 0 )

      res = static_cast<T *>(static_cast<void *>(cur->Data));

    cur = cur->Next;

  }

  return res;

}



template <class T,class Alloc>

class CMISListIteratorImp;

template <class T,class Alloc>

class CMISListImp : private CMInternalIListImp<T, CMSListImp<CVoidPointer,Alloc>, Alloc > //jpd

{

public:

  typedef CMInternalIListImp<T, CMSListImp<CVoidPointer,Alloc>, Alloc > Parent;

  friend class CMISListIteratorImp<T,Alloc>;

  Parent::IterFunc;

  Parent::CondFunc;

  Parent::PeekHead;

  Parent::Add;

  Parent::Detach;

  Parent::DetachAtHead;

  Parent::Find;

  Parent::Flush;

  Parent::IsEmpty;

  Parent::GetItemsInContainer;

  Parent::ForEach;

  Parent::FirstThat;

  Parent::LastThat;

  Parent::operator delete;

protected:

  Parent::Head;

  Parent::Tail;

  Parent::ItemsInContainer;

  virtual CMListElement<CVoidPointer,Alloc> *FindDetach( const CVoidPointer& );

  virtual CMListElement<CVoidPointer,Alloc> *FindPred( const CVoidPointer& );

};



template <class T,class Alloc>

class CMISListIteratorImp : public CMListIteratorImp<CVoidPointer,Alloc>

{

public:

  typedef CMListIteratorImp<CVoidPointer,Alloc> Parent;

  CMISListIteratorImp( const CMISListImp<T,Alloc>  &l )

  : CMListIteratorImp<CVoidPointer,Alloc>(l) {}

  T *Current()

  {

    return static_cast<T *>(static_cast<void *>(Parent::Current()));

  }

  T *operator ++ (int)

  {

    return static_cast<T *>(static_cast<void *>(Parent::operator++(1)));

  }

  T *operator ++ ()

  {

    return static_cast<T *>(static_cast<void *>(Parent::operator++()));

  }

  Parent::Restart;

  operator int()

  {

    return Parent::operator int();

  }

};



template <class T,class Alloc>

CMListElement<CVoidPointer,Alloc> *

  CMISListImp<T,Alloc>::FindDetach( const CVoidPointer& t )

{

  CMListElement<CVoidPointer,Alloc> *res = FindPred(t);

  if ( res == 0 || res->Next == &Tail )

    return &Tail;

  else if ( *static_cast<T *>(static_cast<void *>(res->Next->Data)) ==

            *static_cast<T *>(static_cast<void *>(t)) )

    return res;

  else

    return &Tail;

}



template <class T,class Alloc>

CMListElement<CVoidPointer,Alloc> *

  CMISListImp<T,Alloc>::FindPred( const CVoidPointer& t )

{

  Tail.Data = t;

  CMListElement<CVoidPointer,Alloc> *cursor = &Head;

  while ( *static_cast<T *>(static_cast<void *>(cursor->Next->Data)) <

          *static_cast<T *>(static_cast<void *>(t)) )

    cursor = cursor->Next;

  Tail.Data = CVoidPointer();

  return cursor;

}



//  template <class T> class CISListImp

//  template <class T> class CISListIteratorImp

//  Implements a sorted list of pointers to objects of type T using

//  CStandardAllocator as its memory manager.

//  This is implemented through the template CInternalIListImp.  Since

//  pointers always have meaningful copy semantics, this class

//  can handle any type of object.



template <class T>

class CISListImp : public CMISListImp<T,CStandardAllocator>

{

};



template <class T>

class CISListIteratorImp : public CMISListIteratorImp<T,CStandardAllocator>

{

public:

  CISListIteratorImp( const CISListImp<T>& l )

  : CMISListIteratorImp<T,CStandardAllocator>( l ) {}

};



#endif