c:/Users/efeyhl/devs/math2/fixArray.h

Go to the documentation of this file.

#ifndef __FIXARRAY_H__
#define __FIXARRAY_H__



template <class type, unsigned int maxElements>
class fixArray
{
public: //data


    type errElement;

    type element[maxElements]; 

    BM_STATUS bms[maxElements]; 

public: //methods


  fixArray()
  {
    for (unsigned int idx = 0; idx < maxElements; idx++)
    {
      bms[idx].status = 0;
      bms[idx].undef = 1;
    }
  };


  virtual ~fixArray()
  {
    for (unsigned int idx = 0; idx < maxElements; idx++)
    {
      bms[idx].undef = 1;
    }
  };


  unsigned int size()
  {
    return maxElements;
  };


  unsigned int count()
  {
    unsigned int count = 0;
    for (unsigned int idx = 0; idx < maxElements, idx++)
    {
      if ( ! bms[idx].undef )
      {
        ++count;
      }
    }
    return count;
  };


  type& getAt( const unsigned int index, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (index >= maxElements)
    { //index out of range
      if(elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return errElement;
    }
    if(elementStatus != (BM_STATUS*)0 )
    {
      elementStatus->status = bms[index].status;
    }
    return element[index];
  };


  int setAt( const unsigned int index, const type& elem, BM_STATUS elementStatus=0 )
  {
    if (index >= maxElements)
    {
      return -1;
    }
    bms[index].status = elementStatus.status;
    element[index] = elem;
    return 0;
  };


  type& operator [] ( const unsigned int index )
  {
    return getAt( index );
  };


  int find( type& elem, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (maxElements < 1)
    {
      if ( elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return -1;
    }
    int index = Find( element, maxElements, elem );
    if ( elementStatus != (BM_STATUS*)0 )
    {
      if ((0 <= index) && (index < maxElements))
      {
        elementStatus->status = bms[index].status;
      }
      else
      {
        elementStatus->undef = 1;
      }
    }
    return index;
  };


  bool isEmpty( unsigned int* index=(unsigned int*)0 )
  {
    if (maxElements < 1)
    {
      if ( index != (unsigned int*)0 )
      {
        index = (unsigned int*)-1;
      }
      return true;
    }
    for (unsigned int idx = 0; idx < maxElements, idx++)
    {
      if ( ! bms[idx].undef )
      {
        if ( index != (unsigned int*)0 )
        {
          *index = idx;
        }
        return true;
      }
    }
    return false;
  };


  type& first( unsigned int& iterateIndex, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (maxElements < 1)
    {
      iterateIndex = (unsigned int)-1;
      if ( elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return errElement;
    }
    iterateIndex = 0;
    if ( elementStatus != (BM_STATUS*)0 )
    {
      elementStatus->status = bms[iterateIndex].status;
    }
    return element[iterateIndex];
  };


  type& next( unsigned int& iterateIndex, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (maxElements < 1)
    {
      iterateIndex = (unsigned int)-1;
      if ( elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return errElement;
    }
    int nextIdx = (iterateIndex + 1) % maxElements;
    if (nextIdx <= iterateIndex)
    { //we rolled over bounds
      iterateIndex = nextIdx + maxElements;
    }
    if ( elementStatus != (BM_STATUS*)0 )
    {
      elementStatus->status = bms[nextIdx].status;
    }
    return element[nextIdx];
  };


  type& prev( unsigned int& iterateIndex, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (maxElements < 1)
    {
      iterateIndex = (unsigned int)-1;
      if ( elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return errElement;
    }
    int prevIdx = (iterateIndex + maxElements - 1) % maxElements;
    if (prevIdx >= iterateIndex)
    { //we rolled over bounds
      iterateIndex = prevIdx + maxElements; //=index at maxElements-1
    }
    if ( elementStatus != (BM_STATUS*)0 )
    {
      elementStatus->status = bms[prevIdx].status;
    }
    return element[prevIdx];
  };


  type& last( unsigned int& iterateIndex, BM_STATUS* elementStatus=(BM_STATUS*)0 )
  {
    if (maxElements < 1)
    {
      iterateIndex = (unsigned int)-1;
      if ( elementStatus != (BM_STATUS*)0 )
      {
        elementStatus->undef = 1;
      }
      return errElement;
    }
    iterateIndex = maxElements-1;
    if ( elementStatus != (BM_STATUS*)0 )
    {
      elementStatus->status = bms[iterateIndex].status;
    }
    return element[iterateIndex];
  };


  int isSubset( const fixArray& superSet )
  {
    if (maxElements < 1)
    {
      return INT_MAX; //this is an array with no elements
    }
    for ( unsigned int idx=0; idx < maxElements; idx++ )
    {
      if ( ! bms[idx].undef )
      {
        if ( superSet.find( element[idx] ) == false )
        {
          return idx+1;
        }
      }
    }
    return 0; //also if this array has only undef members
  };
  

  int isEqual( const fixArray& set )
  {
    if (maxElements < 1)
    {
      return INT_MAX; //this is an array with no elements
    }
    int notFoundIndex = isSubset( set );
    if ( notFoundIndex != 0 )
    {
      return notFoundIndex;
    }
    notFoundIndex = set.isSubset( *this );
    if (notFoundIndex == INT_MAX)
    {
      return INT_MIN;
    }
    notFoundIndex *= -1;
    return notFoundIndex; //can also be 0 if boht arrays have only undef members
  };
  

  int assignSortAscendant()
  {
    if (maxElements < 1)
    {
      return -1; //nothing to sort
    }
    type tmp;
    unsigned long idx = 0;
    int ready = 1;
    do
    {
      ready = 1;
      for (idx=0; idx < (maxElements-1); idx++)
      {
        if ( bms[idx].undef )
        {
          if ( ! bms[idx+1].undef )
          { //exchange
            tmp = element[idx];
            element[idx] = element[idx+1];
            element[idx+1] = tmp;
            ready = 0;
          }
          //else both elements are undef -> nothing todo
        }
        else if ( bms[idx+1].undef )
        { //element at idx is defined, but element at idx+1 is undef
          //nothing todo
        }
        else if ( Compare( element[idx], element[idx+1] ) == 1 )
        { //both elements are defined, 
          //but element at idx is greater then element at idx+1
          //exchange
          tmp = element[idx];
          element[idx] = element[idx+1];
          element[idx+1] = tmp;
          ready = 0;
        }
      }
    }while (ready == 0);
    return 0; //ok
  };


  fixArray& assignOverlap( const fixArray& set2 )
  {
    for ( unsigned int idx=0; idx < maxElements; idx++)
    {
      if ( ! bms[idx].undef )
      {
        set2Idx = set2.find( element[idx] );
        if ( set2Idx < 0 )
        {
          bms[idx].undef = 1;
        }
      }
    }
    return *this;
  };


  int overlap( fixArray& result, const fixArray& set2 ) const
  {
    int resCnt = 0;
    int set2Idx = -1;
    for ( unsigned int idx=0; idx < maxElements; idx++)
    {
      if ( ! bms[idx].undef )
      {
        set2Idx = set2.find( element[idx] );
        if ( set2Idx >= 0 )
        {
          if ( result.setAt( resCnt, element[idx] ) < 0 )
          { //not enough space to hold the complete result
            return -1;
          }
          ++resCnt;
        }
      }
    }
    for ( idx = resCnt ; idx < result.size(); idx++ )
    { //clear the rest of the result
      result.bms[idx].undef = 1;
    }
    return resCnt;
  };


  int assignConcatenate( const fixArray& set2 )
  {
    int resCnt = 0;
    unsigned int idx=0;
    unsigned int set2Idx = 0;
    for ( idx=0; (idx < maxElements) && (set2Idx < set2.size()); idx++)
    {
      if ( bms[idx].undef )
      { //idx is a free element
        if ( ! set2.bms[set2Idx].undef )
        { //we found a valid element in set2
          setAt( idx, set2.element[set2Idx] );
          ++resCnt;
        }
        ++set2Idx;
      }
    }
    for ( ; set2Idx < set2.size(); set2Idx++ )
    {
      if ( ! set2.bms[set2Idx].undef )
      { //we found a valid element in set2
        //but we don't have any free elements in this array
        return -1;
      }
    }
    return resCnt;
  };


  int concatenate( fixArray& result, const fixArray& set2 ) const
  {
    int resCnt = 0;
    unsigned int idx=0;
    for ( idx=0; idx < maxElements; idx++)
    {
      if ( ! bms[idx].undef )
      {
        if ( result.setAt( resCnt, element[idx] ) < 0 )
        { //not enough space to hold the complete result
          return -1;
        }
        ++resCnt;
      }
    }
    for ( idx=0; idx < set2.size(); idx++)
    {
      if ( ! set2.bms[idx].undef )
      {
        if ( result.setAt( resCnt, set2.element[idx] ) < 0 )
        { //not enough space to hold the complete result
          return -1;
        }
        ++resCnt;
      }
    }
    return resCnt;
  };



  int notInSet( fixArray& result, const fixArray& set2 ) const
  {
    int resCnt = 0;
    unsigned int idx=0;
    for ( idx=0; idx < maxElements; idx++)
    {
      if ( ! bms[idx].undef )
      {
        if ( set2.find( element[idx] ) < 0 )
        { //element[idx] is not in set2
          if ( result.setAt( resCnt, element[idx] ) < 0 )
          { //not enough space to hold the complete result
            return -1;
          }
          ++resCnt;
        }
      }
    }
    for ( idx = resCnt ; idx < result.size(); idx++ )
    { //clear the rest of the result
      result.bms[idx].undef = 1;
    }
    return resCnt;
  };

};

#endif //__FIXARRAY_H__

---