HashSetT.hpp

Go to the documentation of this file.

#ifndef _GEMFIRE_HASHSETT_HPP_
#define _GEMFIRE_HASHSETT_HPP_

/*=========================================================================
 * Copyright (c) 2002-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * more patents listed at http://www.pivotal.io/patents.
 *========================================================================
 */

#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 int32_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 int32_t size() const
      {
        return m_set.size();
      }

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

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

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

      inline void resize( int32_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 int32_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 );
      }

      int32_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( int32_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(int32_t n) :
      _HashSetOfCacheableKey(n) { }

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

  private:
    const HashSetOfCacheableKey& operator=( const HashSetOfCacheableKey& );

  };

  typedef SharedPtr<HashSetOfCacheableKey> HashSetOfCacheableKeyPtr;

}


#endif