H:/gfcppsancout/product/include/gfcpp/HashSetT.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_HASHSETT_HPP_
#define _GEMFIRE_HASHSETT_HPP_

/*=========================================================================
 * (c) Copyright 2002-2007, GemStone Systems, Inc. All Rights Reserved.
 * 1260 NW Waterhouse Ave., Suite 200,  Beaverton, OR 97006
 *========================================================================
 */

#include "gfcpp_globals.hpp"
#include "HashSetOfSharedBase.hpp"
#include "CacheableKey.hpp"


namespace gemfire
{

  template< typename TKEY > class HashSetT
  {
    private:

      HashSetOfSharedBase m_set;


    public:

      class Iterator
      {
        private:

          HashSetOfSharedBase::Iterator m_iter;


          inline Iterator( const HashSetOfSharedBase::Iterator& iter )
            : m_iter( iter ) { }

          // Never defined.
          Iterator( );


        public:

          inline const TKEY operator * ( ) const
          {
            return staticCast<TKEY>( *m_iter );
          }

          inline bool isEnd( ) const
          {
            return m_iter.isEnd( );
          }

          inline Iterator& operator ++ ( )
          {
            ++m_iter;
            return *this;
          }

          inline void operator ++ ( int )
          {
            m_iter++;
          }

          inline bool operator == ( const Iterator& other ) const
          {
            return ( m_iter == other.m_iter );
          }

          inline bool operator != ( const Iterator& other ) const
          {
            return ( m_iter != other.m_iter );
          }

          inline void reset( )
          {
            m_iter.reset( );
          }


          friend class HashSetT;
      };


      inline static size_t hasher( const SharedBasePtr& p )
      {
        return gemfire::hashFunction< TKEY >( staticCast<TKEY>( p ) );
      }

      inline static bool equal_to( const SharedBasePtr& x, const SharedBasePtr& y )
      {
        return gemfire::equalToFunction< TKEY >( staticCast<TKEY>( x ),
            staticCast<TKEY>( y ) );
      }

      inline size_t size() const
      {
        return m_set.size();
      }

      inline size_t max_size() const
      {
        return m_set.max_size();
      }

      inline bool empty( ) const
      {
        return m_set.empty( );
      }

      inline size_t bucket_count( ) const
      {
        return m_set.bucket_count( );
      }

      inline void resize( size_t n )
      {
        m_set.resize( n );
      }

      inline void swap( HashSetT& other )
      {
        m_set.swap( other.m_set );
      }

      inline bool insert( const TKEY& k )
      {
        return m_set.insert( k );
      }

      inline size_t erase( const TKEY& k )
      {
        return m_set.erase( k );
      }

      inline void clear( )
      {
        m_set.clear( );
      }

      inline bool contains( const TKEY& k ) const
      {
        return m_set.contains( k );
      }

      size_t count( const TKEY& k ) const
      {
        return m_set.count( k );
      }

      inline Iterator begin( ) const
      {
        return Iterator( m_set.begin( ) );
      }

      inline Iterator end( ) const
      {
        return Iterator( m_set.end( ) );
      }

      inline HashSetT& operator = ( const HashSetT& other )
      {
        m_set = other.m_set;
        return *this;
      }

      inline HashSetT( )
        : m_set( hasher, equal_to )
      {
      }

      inline HashSetT( size_t n )
        : m_set( n, hasher, equal_to )
      {
      }

      inline HashSetT( const HashSetT& other )
        : m_set( other.m_set )
      {
      }

      inline ~HashSetT( )
      {
      }
  };


  typedef HashSetT<CacheableKeyPtr> _HashSetOfCacheableKey;

  class CPPCACHE_EXPORT HashSetOfCacheableKey :
    public _HashSetOfCacheableKey, public SharedBase
  {
  public:
    typedef _HashSetOfCacheableKey::Iterator Iterator;

    inline HashSetOfCacheableKey() :
      _HashSetOfCacheableKey() { }

    inline HashSetOfCacheableKey(size_t n) :
      _HashSetOfCacheableKey(n) { }

    inline HashSetOfCacheableKey(const HashSetOfCacheableKey& other) :
      _HashSetOfCacheableKey(other) { }
  };

  typedef SharedPtr<HashSetOfCacheableKey> HashSetOfCacheableKeyPtr;

}


#endif

---