257 lines
7.4 KiB
C++
257 lines
7.4 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 1994,1995 Southeastern Universities Research Association,
|
|
// Continuous Electron Beam Accelerator Facility
|
|
//
|
|
// This software was developed under a United States Government license
|
|
// described in the NOTICE file included as part of this distribution.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Description:
|
|
// Single Linked List for pointers rsvcHashable pointer
|
|
// Primary used inside rsvcHash
|
|
//
|
|
// Note: remove and clean operations on the list
|
|
// will only remove link nodes without removal of
|
|
// the content inside the nodes. It is callers'
|
|
// responsiblity to clean up those contents
|
|
//
|
|
//
|
|
// Author: Jie Chen
|
|
// CEBAF Data Acquisition Group
|
|
//
|
|
//
|
|
//
|
|
//
|
|
#ifndef _RSVC_HSLIST_H
|
|
#define _RSVC_HSLIST_H
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#if defined (RSVC_USE_THREAD) && defined (_REENTRANT)
|
|
#include <cpSynch.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
|
|
|
|
//======================================================================
|
|
// class rsvcSlist
|
|
// Single Linked List for void* pointer
|
|
//======================================================================
|
|
class rsvcHSlistLink;
|
|
class rsvcHSlistIterator;
|
|
class rsvcHSlistCursor;
|
|
class rsvcHash;
|
|
class rsvcHashable;
|
|
|
|
class rsvcHSlist
|
|
{
|
|
public:
|
|
// constructors
|
|
rsvcHSlist (void);
|
|
rsvcHSlist (const rsvcHSlist & source);
|
|
virtual ~rsvcHSlist (void);
|
|
|
|
// operations
|
|
|
|
// add list item to the beginning of the list
|
|
virtual void add (rsvcHashable* value);
|
|
// add item to the end of list
|
|
virtual void addToEnd (rsvcHashable* value);
|
|
|
|
// remove a list item from the list
|
|
// return 0: nothing to remove
|
|
// return 1: remove success
|
|
virtual int remove (rsvcHashable* value);
|
|
|
|
// clean up the list.
|
|
virtual void deleteAllValues (void);
|
|
|
|
// return first element of the list
|
|
virtual rsvcHashable* firstElement (void);
|
|
|
|
// return last element of the list
|
|
virtual rsvcHashable* lastElement (void);
|
|
|
|
// duplicate ths whole list
|
|
virtual rsvcHSlist* duplicate (void);
|
|
|
|
// check whether this list contains a particular item
|
|
// return 1: yes. return 0: no
|
|
virtual int includes (rsvcHashable* value);
|
|
|
|
// Is list empty
|
|
// return 1: yes. return 0: no
|
|
virtual int isEmpty (void);
|
|
|
|
// remove first element of the list
|
|
virtual void removeFirst (void);
|
|
|
|
// return number of elements inside the list
|
|
virtual int count (void);
|
|
|
|
protected:
|
|
// data field
|
|
rsvcHSlistLink* ptrToFirstLink;
|
|
|
|
// number elements in the list
|
|
int count_;
|
|
|
|
#if defined (RSVC_USE_THREAD) && defined (_REENTRANT)
|
|
cpMutex lock_;
|
|
#endif
|
|
|
|
// some internal functions which must be called with lock held
|
|
virtual void add_i (rsvcHashable* value);
|
|
virtual int isEmpty_i (void) const;
|
|
virtual void deleteAllValues_i (void);
|
|
virtual void removeFirst_i (void);
|
|
virtual rsvcHashable* firstElement_i (void);
|
|
virtual rsvcHashable* lastElement_i (void);
|
|
|
|
// friends
|
|
friend class rsvcHSlistIterator;
|
|
// cannot modify list in anyways
|
|
friend class rsvcHSlistCursor;
|
|
friend class rsvcHash;
|
|
|
|
private:
|
|
// deny access to assignment operation
|
|
rsvcHSlist& operator = (const rsvcHSlist& list);
|
|
};
|
|
|
|
//======================================================================
|
|
// class rsvcHSlistLink
|
|
// Single linked list link node
|
|
//======================================================================
|
|
class rsvcHSlistLink
|
|
{
|
|
public:
|
|
// constructor
|
|
rsvcHSlistLink (rsvcHashable* linkValue, rsvcHSlistLink * nextPtr);
|
|
|
|
// insert a new element following the current value
|
|
rsvcHSlistLink* insert (rsvcHashable* val);
|
|
// return data value
|
|
rsvcHashable* data (void);
|
|
|
|
// return next data item
|
|
rsvcHSlistLink* next (void);
|
|
|
|
|
|
private:
|
|
|
|
// duplicate
|
|
rsvcHSlistLink* duplicate (void);
|
|
|
|
// data areas
|
|
rsvcHashable* value;
|
|
rsvcHSlistLink* ptrToNextLink;
|
|
|
|
// friends
|
|
friend class rsvcHSlist;
|
|
friend class rsvcHSlistIterator;
|
|
friend class rsvcHSlistCursor;
|
|
};
|
|
|
|
//===================================================================
|
|
// class rsvcHSlistIterator
|
|
// implements iterator protocol for linked lists
|
|
// also permits removal and addition of elements
|
|
//===================================================================
|
|
|
|
class rsvcHashIterator;
|
|
|
|
class rsvcHSlistIterator
|
|
{
|
|
public:
|
|
// constructor
|
|
rsvcHSlistIterator (rsvcHSlist& aList);
|
|
|
|
// iterator protocol
|
|
virtual int init (void);
|
|
virtual rsvcHashable* operator () (void);
|
|
virtual int operator ! (void);
|
|
virtual int operator ++ (void);
|
|
virtual void operator = (rsvcHashable* value);
|
|
|
|
// new methods specific to list iterators
|
|
|
|
// remove current item pointed by the iterator from the list
|
|
void removeCurrent(void);
|
|
|
|
// add an item to the list before the position pointed by the iterator
|
|
void addBefore(rsvcHashable* newValue);
|
|
|
|
// add an item to the list after the position pointed by the iterator
|
|
void addAfter(rsvcHashable* newValue);
|
|
|
|
// search an item and move the iterator to that position
|
|
int searchSame(rsvcHashable* &value);
|
|
|
|
protected:
|
|
// some internal functions which must be called with lock held
|
|
virtual int init_i (void);
|
|
// move cursor forward
|
|
virtual int forward_i (void);
|
|
// internal remove current
|
|
void removeCurrent_i (void);
|
|
// data areas
|
|
rsvcHSlistLink * currentLink;
|
|
rsvcHSlistLink * previousLink;
|
|
rsvcHSlist& theList;
|
|
#if defined (RSVC_USE_THREAD) && defined (_REENTRANT)
|
|
cpMutex lock_;
|
|
#endif
|
|
|
|
private:
|
|
// friend class
|
|
friend class rsvcHashIterator;
|
|
|
|
// deny access of copy and assignment
|
|
rsvcHSlistIterator (const rsvcHSlistIterator& ir);
|
|
rsvcHSlistIterator& operator = (const rsvcHSlistIterator& ir);
|
|
};
|
|
|
|
//===================================================================
|
|
// class rsvcHSlistCursor
|
|
// implements cursor protocol for linked lists
|
|
//===================================================================
|
|
class rsvcHSlistCursor
|
|
{
|
|
public:
|
|
// constructor
|
|
rsvcHSlistCursor (const rsvcHSlist& aList);
|
|
|
|
// iterator protocol
|
|
virtual int init (void);
|
|
virtual rsvcHashable* operator () (void);
|
|
virtual int operator ! (void);
|
|
virtual int operator ++ (void);
|
|
virtual void operator = (rsvcHashable* value);
|
|
|
|
int searchSame (rsvcHashable* &value);
|
|
|
|
protected:
|
|
// internal functions which must be called with lock
|
|
virtual int init_i (void);
|
|
// data areas
|
|
rsvcHSlistLink * currentLink;
|
|
rsvcHSlistLink * previousLink;
|
|
const rsvcHSlist& theList;
|
|
#if defined (RSVC_USE_THREAD) && defined (_REENTRANT)
|
|
cpMutex lock_;
|
|
#endif
|
|
|
|
private:
|
|
// deny access to copy and assignment operations
|
|
rsvcHSlistCursor (const rsvcHSlistCursor &);
|
|
rsvcHSlistCursor& operator = (const rsvcHSlistCursor &);
|
|
};
|
|
#endif
|