Search  

---

C:/temp/src/j2k/DataType/Link/AList.cpp

Go to the documentation of this file.

// AList.cpp - Class interface for a Array Based List

#ifndef __J2K__DataType__AList_CPP__
#define __J2K__DataType__AList_CPP__

#include <j2k/DataType/Link/AList.hpp>

#define LIST_SIZE  100

AList::AList()                            // Default Constructor
  : msize( LIST_SIZE ), nbList( 0 ), curr( 0 ) 
{
  listarray = new Elem[ LIST_SIZE ];
}

AList::AList( ULONG sz )                  // Constructor with Size
  : msize( sz ), nbList( 0 ), curr( 0 ) 
{
  listarray = new Elem[ sz ];
}

AList::~AList()                           // Destructor: return array space
{
  delete [] listarray;
}

void AList::clear()                       // Remove all Elems from list
{
  nbList = 0;                             // Simply reinitialize values
  curr = 0;
}

// Insert Elem at current position
void AList::insert( Elem item ) 
{
  // Array must not be full and curr must be a legal position
  assert( nbList < msize );
  assert( curr <= nbList );

  for( ULONG i = nbList; i > curr; i-- )  // Shift Elems up to make room
  {  
    listarray[ i ] = listarray[ i-1 ];
  }

  listarray[ curr ] = item;
  nbList++;                               // Increment current list size
}

void AList::append( Elem item )           // Insert Elem at tail of list
{
  assert( nbList < msize );               // List must not be full
  listarray[ nbList ] = item;            
  nbList++;                               // Increment list size
}

Elem AList::remove()                      // Remove and return current Elem
{
  assert( !isEmpty()  );                  // Must be an Elem to remove
  assert( isInList()  );  

  Elem temp = listarray[curr];            // Store removed Elem

  register ULONG i;
  for( i = curr; i < nbList-1; i++)       // Shift elements down
  {
    listarray[ i ] = listarray[ i + 1 ];
  }

  nbList--;                               // Decrement current list size

  return temp;  // This is OK ?!? or by copy constructor?
}
                            
inline void AList::setFirst()             // Set curr to first position
{
  curr = 0;
}

inline void AList::prev()                 // Move curr to previous position
{
  if ( curr <= 0 ) return;
  curr--;
}

inline void AList::next()                 // Move curr to next position
{
  if ( curr >= msize-1 ) return;
  curr++;
}

inline void AList::setPos( ULONG pos )    // Set curr to specified position
{
  if ( pos > msize-1 ) return;            // Position must be valid
  curr = pos;
}

inline long AList::getPos()               // Set curr to specified position
{
  if ( isEmpty() ) return -1;
  return curr;
}


inline ULONG AList::length() const        // Return current length of list
{
  return nbList;
}

inline ULONG AList::getMaxSize() const   
{
  return msize;
}

inline void AList::setValue( Elem item )  // Set current Elem's value
{
  assert( isInList() );                   // Curr must be at valid position
  listarray[ curr ] = item;
}

inline Elem AList::currValue() const      // Return current Elem's value
{
  assert( isInList() );                   // Curr must be at valid position
  return listarray[ curr ];               // This is OK ?!?
}

inline BOOL AList::isEmpty() const        // Return TRUE if List is empty
{
  return ( nbList == 0  &&  curr == 0 );
}

inline BOOL AList::isInList() const       // TRUE if curr is within List
{
  return ( nbList != 0  &&  curr >= 0  &&  curr < nbList );
}

long AList::find( Elem item )             // Find Elem in the list
{
  while( isInList() ) 
  {
    if ( listarray[ curr ] == item ) return getPos();
    next();
  }

  return -1;
}

void AList::display() const 
{
  register ULONG i = 0;

  printf( "===========================================\n" );

  for( ; i < nbList; i++ ) {
    printf( "%d \n ", listarray[i] );
  }

  printf( "===========================================\n" );
}

#endif // End of AList.cpp

---