ofstd/include/dcmtk/ofstd/ofuoset.h

/*
 *
 *  Copyright (C) 1997-2010, OFFIS e.V.
 *  All rights reserved.  See COPYRIGHT file for details.
 *
 *  This software and supporting documentation were developed by
 *
 *    OFFIS e.V.
 *    R&D Division Health
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *
 *  Module:  ofstd
 *
 *  Author:  Thomas Wilkens
 *
 *  Purpose: Template class for administrating an unordered set of elements
 *           of an arbitrary type.
 *
 *  Last Update:      $Author: joergr $
 *  Update Date:      $Date: 2010-10-14 13:15:51 $
 *  CVS/RCS Revision: $Revision: 1.7 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */

#ifndef OFUnorderedSet_h
#define OFUnorderedSet_h

#include "dcmtk/config/osconfig.h"
#include "dcmtk/ofstd/oftypes.h"
#include "dcmtk/ofstd/ofset.h"

template <class T> class OFUnorderedSet : public OFSet<T>
{
  protected:

  public:
    OFUnorderedSet()
        : OFSet<T>()
      {
      }


    OFUnorderedSet( const OFUnorderedSet<T> &src )
        : OFSet<T>( src )
      {
      }


    virtual ~OFUnorderedSet()
      {
      }


    const OFUnorderedSet<T> &operator=( const OFUnorderedSet<T> &src )
      {
        if( this == &src )
          return( *this );

        OFSet<T>::operator=( src );

        return( *this );
      }


    virtual OFBool operator==( const OFUnorderedSet<T> &other ) const
      {
        // check if both sets contain the same
        // amount of items; if not, return OFFalse
        if( OFSet<T>::num != other.num )
          return( OFFalse );

        // initialize result with OFTrue
        OFBool result = OFTrue;

        // make a copy of this
        OFUnorderedSet<T> s = *this;

        // as long as result is OFTrue go through all items in other
        for( unsigned int i=0 ; i<other.num && result == OFTrue ; i++ )
        {
          // in case s contains the current item of other
          if( s.Contains( *other.items[i] ) )
          {
            // remove this item from s so that it will not be
            // considered again in a later call to s.Contains()
            s.Remove( *other.items[i] );
          }
          // in case s doesn't contain the current item of other the result is OFFalse
          else
            result = OFFalse;
        }

        // return result
        return( result );
      }


    virtual OFBool operator!=( const OFUnorderedSet<T> &other ) const
      {
        return( !( *this == other ) );
      }


    virtual void Insert( const T &item )
      {
        // if size equals num, we need more space
        if( OFSet<T>::size == OFSet<T>::num )
          Resize( OFSet<T>::size * 2 );

        // copy item
        T *newItem = new T( item );

        // insert copy into array
        OFSet<T>::items[OFSet<T>::num] = newItem;

        // increase counter
        OFSet<T>::num++;
      }


    virtual void Insert( const OFUnorderedSet<T> &other )
      {
        // go through all items in other and insert each item into this
        for( unsigned int i=0 ; i<other.num ; i++ )
          Insert( *other.items[i] );
      }


    virtual void Remove( const T &item )
      {
        // so far, nothing was deleted
        OFBool itemDeleted = OFFalse;

        // go through all items
        for( unsigned int i=0 ; i<OFSet<T>::num && !itemDeleted ; i++ )
        {
          // if current item is the one which shall be deleted
          if( *OFSet<T>::items[i] == item )
          {
            // delete item
            delete OFSet<T>::items[i];

            // and - so that there are no holes in the array - move the last
            // item to the array field from which the item was deleted;
            // only do so in case we did _not_ delete the last item
            if( i != OFSet<T>::num - 1 )
            {
              OFSet<T>::items[i] = OFSet<T>::items[OFSet<T>::num-1];
              OFSet<T>::items[OFSet<T>::num-1] = NULL;
            }
            else
              OFSet<T>::items[i] = NULL;

            // reduce counter
            OFSet<T>::num--;

            // remember that an item was deleted (so that always only one item will be deleted)
            itemDeleted = OFTrue;
          }
        }
      }


    virtual void RemoveByIndex( unsigned int index )
      {
        // do something only if the given index is not out of range
        if( index < OFSet<T>::num )
        {
          // delete item with given index
          delete OFSet<T>::items[index];

          // and - so that there are no holes in the array - move the last
          // item to the array field from which the item was deleted;
          // only do so in case we did _not_ delete the last item
          if( index != OFSet<T>::num - 1 )
          {
            OFSet<T>::items[index] = OFSet<T>::items[OFSet<T>::num-1];
            OFSet<T>::items[OFSet<T>::num-1] = NULL;
          }
          else
            OFSet<T>::items[index] = NULL;

          // reduce counter
          OFSet<T>::num--;
        }
      }


    virtual T *Find( const T &item ) const
      {
        unsigned int i;
        OFBool itemFound = OFFalse;

        for( i=0 ; i<OFSet<T>::num && !itemFound ; i++ )
        {
          if( *OFSet<T>::items[i] == item )
            itemFound = OFTrue;
        }

        if( itemFound )
          return( OFSet<T>::items[i-1] );
        else
          return( NULL );
      }


    virtual OFBool Contains( const T &item ) const
      {
        OFBool itemFound = OFFalse;

        for( unsigned int i=0 ; i<OFSet<T>::num && !itemFound ; i++ )
        {
          if( *OFSet<T>::items[i] == item )
            itemFound = OFTrue;
        }

        return( itemFound );
      }


    virtual OFBool IsSupersetOf( const OFUnorderedSet<T> &other ) const
      {
        // if this contains less or the same amount of items than other, return OFFalse
        if( OFSet<T>::num <= other.num )
          return( OFFalse );

        // initialize result with OFTrue
        OFBool result = OFTrue;

        // make a copy of this
        OFUnorderedSet<T> s = *this;

        // as long as result is OFTrue go through all items in other
        for( unsigned int i=0 ; i<other.num && result == OFTrue ; i++ )
        {
          // in case s contains the current item of other
          if( s.Contains( *other.items[i] ) )
          {
            // remove this item from s so that it will not be
            // considered again in a later call to s.Contains()
            s.Remove( *other.items[i] );
          }
          // in case s does not contain the current item of other the result is OFFalse
          else
            result = OFFalse;
        }

        // return result
        return( result );
      }


    virtual OFBool IsSubsetOf( const OFUnorderedSet<T> &other ) const
      {
        return( other.IsSupersetOf( *this ) );
      }


    OFUnorderedSet<T> Union( const OFUnorderedSet<T> &other ) const
      {
        // initialize result set
        OFUnorderedSet<T> resultSet = *this;

        // insert other set into result set
        resultSet.Insert( other );

        // return result set
        return( resultSet );
      }


    OFUnorderedSet<T> Intersection( const OFUnorderedSet<T> &other ) const
      {
        // initialize result set
        OFUnorderedSet<T> resultSet;

        // make a copy of other
        OFUnorderedSet<T> s = other;

        // go through all items in this
        for( unsigned int i=0 ; i< OFSet<T>::num ; i++ )
        {
          // if s contains the current item
          if( s.Contains( *OFSet<T>::items[i] ) )
          {
            // insert the item into the result set
            resultSet.Insert( *OFSet<T>::items[i] );

            // and remove the item from s so that it will not be
            // considered again in a later call to s.Contains()
            s.Remove( *OFSet<T>::items[i] );
          }
        }

        // return result set
        return( resultSet );
      }


    OFUnorderedSet<T> Difference( const OFUnorderedSet<T> &other ) const
      {
        // initialize result set
        OFUnorderedSet<T> resultSet;

        // make a copy of other
        OFUnorderedSet<T> s = other;

        // go through all items in this
        for( unsigned int i=0 ; i< OFSet<T>::num ; i++ )
        {
          // if s does not contain the current item
          if( !s.Contains( *OFSet<T>::items[i] ) )
          {
            // insert the item into the result set
            resultSet.Insert( *OFSet<T>::items[i] );
          }
          else
          {
            // else remove the item from s so that it will not be
            // considered again in a later call to s.Contains()
            s.Remove( *OFSet<T>::items[i] );
          }
        }

        // return result set
        return( resultSet );
      }


    OFUnorderedSet<T> SymmetricDifference( const OFUnorderedSet<T> &other ) const
      {
        // determine s1 = this - other
        OFUnorderedSet<T> s1 = (*this).Difference( other );

        // determine s2 = other - this
        OFUnorderedSet<T> s2 = other.Difference( *this );

        // determine the union of s1 and s2
        OFUnorderedSet<T> resultSet = s1.Union( s2 );

        // return result set
        return( resultSet );
      }
};

#endif

/*
** CVS/RCS Log:
** $Log: ofuoset.h,v $
** Revision 1.7  2010-10-14 13:15:51  joergr
** Updated copyright header. Added reference to COPYRIGHT file.
**
** Revision 1.6  2005/12/12 09:24:27  meichel
** Added explicit references to parent template class, needed for
**   gcc 3.4.2 (MinGW port)
**
** Revision 1.5  2005/12/08 16:06:12  meichel
** Changed include path schema for all DCMTK header files
**
** Revision 1.4  2002/12/16 10:40:25  wilkens
** Removed superfluous implementation files and modified header and make files.
**
** Revision 1.3  2002/07/09 18:29:47  wilkens
** Added some more functionality.
**
**
*/

---

Generated on 6 Jan 2011 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.5.1