uniqEntryArr.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef uniqEntryArr_H_
#define uniqEntryArr_H_

#if DtDIS

#include <lgrSim/lgrSim.h>
#ifndef _MachineTypes_h
#include <vlutil/vlMachineTypes.h>
#endif

namespace MAKLogger
{

struct DT_DLL_LGRSIM DtKeyValuePair
{
   unsigned int key;
   unsigned int val;

public:
   inline DtKeyValuePair() : key( 0 ), val( 0 ) {}
   inline ~DtKeyValuePair() {}
   inline DtKeyValuePair( unsigned int _key, unsigned int _val ) :
      key( _key ), val( _val ) {}
   inline DtKeyValuePair( const DtKeyValuePair& src ) :
      key( src.key ), val( src.val ) {}
public:
   inline DtKeyValuePair& operator=( const DtKeyValuePair& src )
   {
      if ( this != &src )
      {
         key = src.key;  val = src.val;
      }
      return *this;
   }
   inline bool operator==( const DtKeyValuePair& rhs )
   {
      if ( this == &rhs )  return ( 1 == 1 );
      return ( key == rhs.key && val == rhs.val );
   }
   inline bool operator!=( const DtKeyValuePair& rhs )
   {
      if ( this == &rhs )  return ( 1 == 0 );
      return ( key != rhs.key || val != rhs.val );
   }
   inline unsigned int operator[]( int ix ) const
   {
      if ( ix < 0 || ix > 1 )
      {
         return (~(unsigned int)0);
      }
      else
      {
         return ( ( ix )  ?  val : key );
      }
   }
};




class DT_DLL_LGRSIM DtUniqueEntryArray
{
public:
   DtUniqueEntryArray();
   ~DtUniqueEntryArray();
   DtUniqueEntryArray( const DtUniqueEntryArray& src );
   DtUniqueEntryArray& operator=( const DtUniqueEntryArray& src );

public:
   bool operator==( const DtUniqueEntryArray& rhs ) const;
   bool operator!=( const DtUniqueEntryArray& rhs ) const;
   inline unsigned int operator[]( int ix ) const;

public:
   inline int count() const;
   inline bool isOK() const;
   inline unsigned int error() const;
   inline unsigned int minVal() const;
   inline unsigned int maxVal() const;

public:
   int  lookup( unsigned int val ) const;
   int  remove( unsigned int val );
   int  append( unsigned int val );
   void reset();

protected:
   void removeAt( int ix );
   bool insertAt( int ix );
   bool resizeTo( int ix );

protected:
   unsigned int* myArray;
   int sz_nu, sz_na, _isOK;
   unsigned int  ErrFlg;
};



inline unsigned int DtUniqueEntryArray::operator[]( int ix ) const
{
   return ( ( ix < 0 || ix >= sz_nu )  ?  (~(unsigned int)0) : myArray[ix] );
}


inline int DtUniqueEntryArray::count() const
{
   return sz_nu;
}


inline bool DtUniqueEntryArray::isOK() const
{
   return ( _isOK != 0 );
}


inline unsigned int DtUniqueEntryArray::error() const
{
   return ErrFlg;
}


inline unsigned int DtUniqueEntryArray::minVal() const
{
   return ( ( sz_nu <= 0 )  ?  (~(unsigned int)0) : myArray[0] );
}


inline unsigned int DtUniqueEntryArray::maxVal() const
{
   return ( ( sz_nu <= 0 )  ?  (~(unsigned int)0) : myArray[( sz_nu - 1 )] );
}




class DT_DLL_LGRSIM DtUniqueEntryArrWData
{
public:
   DtUniqueEntryArrWData();
   ~DtUniqueEntryArrWData();
   DtUniqueEntryArrWData( const DtUniqueEntryArrWData& src );
   DtUniqueEntryArrWData& operator=( const DtUniqueEntryArrWData& src );

   bool operator==( const DtUniqueEntryArrWData& rhs ) const;
   bool operator!=( const DtUniqueEntryArrWData& rhs ) const;
   inline const DtKeyValuePair& operator[]( int ix ) const;
   inline unsigned int operator()( int ix, int jx ) const;

   inline int count() const;
   inline bool isOK() const;
   inline unsigned int error() const;
   inline unsigned int minVal() const;
   inline unsigned int maxVal() const;

   int  lookup( unsigned int key, unsigned int* pval=0 ) const;
   int  remove( unsigned int key, unsigned int* pval=0 );
   int  append( unsigned int key, unsigned int val, unsigned int* pval=0 );
   bool setVal( int ix, unsigned int val, unsigned int* pval=0 );
   void reset();


   void removeAt( int ix );
   bool insertAt( int ix );
   bool resizeTo( int ix );

   static const DtKeyValuePair dfltDummyEntry;

protected:
   DtKeyValuePair* arr;
   int      sz_nu, sz_na, _isOK;
   unsigned int  ErrFlg;
};



inline const DtKeyValuePair& DtUniqueEntryArrWData::operator[]( int ix ) const
{
   return ( ( ix < 0 || ix >= sz_nu )  ?
      DtUniqueEntryArrWData::dfltDummyEntry : arr[ix] );
}


inline unsigned int DtUniqueEntryArrWData::operator()( int ix, int jx ) const
{
   return ( ( ix < 0 || ix >= sz_nu )  ?
      DtUniqueEntryArrWData::dfltDummyEntry[jx] : arr[ix][jx] );
}


inline int DtUniqueEntryArrWData::count() const
{
   return sz_nu;
}


inline bool DtUniqueEntryArrWData::isOK() const
{
   return ( _isOK != 0 );
}


inline unsigned int DtUniqueEntryArrWData::error() const
{
   return ErrFlg;
}


inline unsigned int DtUniqueEntryArrWData::minVal() const
{
   return ( ( sz_nu <= 0 )  ?  (~(unsigned int)0) : arr[0].key );
}


inline unsigned int DtUniqueEntryArrWData::maxVal() const
{
   return ( ( sz_nu <= 0 )  ?  (~(unsigned int)0) : arr[( sz_nu - 1 )].key );
}




class DT_DLL_LGRSIM DtUniqueEntryArrayVPtr
{
public:
   typedef int   ( *cmpEntries  )( void*, void* );
   typedef void* ( *copyEntry   )( void* );
   typedef void  ( *deleteEntry )( void* );

   DtUniqueEntryArrayVPtr();
   ~DtUniqueEntryArrayVPtr();
   DtUniqueEntryArrayVPtr( const DtUniqueEntryArrayVPtr& src );
   DtUniqueEntryArrayVPtr& operator=( const DtUniqueEntryArrayVPtr& src );

   bool operator==( const DtUniqueEntryArrayVPtr& rhs ) const;
   bool operator!=( const DtUniqueEntryArrayVPtr& rhs ) const;
   inline void* operator[]( int ix ) const;

   bool init( cmpEntries cmpFnc, copyEntry cpyFnc, deleteEntry delFnc );

   inline int count() const;
   inline bool isOK() const;
   inline unsigned int error() const;
   inline void* minVal() const;
   inline void* maxVal() const;

   int  lookup( void* val ) const;
   int  remove( void* val );
   int  append( void* val );
   void empty();

protected:

   bool duplicate( const DtUniqueEntryArrayVPtr& src );
   void reset( bool all );
   void removeAt( int ix );
   bool insertAt( int ix );
   bool resizeTo( int ix );

   cmpEntries  myCmpFnc;
   copyEntry   myCpyFnc;
   deleteEntry myDelFnc;
   void** myEntries;
   int    sz_nu, sz_na, myOkFlag;
   unsigned int  myErrorFlag;
};



inline void* DtUniqueEntryArrayVPtr::operator[]( int ix ) const
{
   return ( ( ix < 0 || ix >= sz_nu )  ?  0 : myEntries[ix] );
}


inline int DtUniqueEntryArrayVPtr::count() const
{
   return sz_nu;
}


inline bool DtUniqueEntryArrayVPtr::isOK() const
{
   return ( myOkFlag != 0 );
}


inline unsigned int DtUniqueEntryArrayVPtr::error() const
{
   return myErrorFlag;
}


inline void* DtUniqueEntryArrayVPtr::minVal() const
{
   return ( ( sz_nu <= 0 )  ?  0 : myEntries[0] );
}


inline void* DtUniqueEntryArrayVPtr::maxVal() const
{
   return ( ( sz_nu <= 0 )  ?  0 : myEntries[( sz_nu - 1 )] );
}

}

#endif
#endif