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

Go to the documentation of this file.

#ifndef _GEMFIRE_HASHMAPT_HPP_
#define _GEMFIRE_HASHMAPT_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 "HashMapOfSharedBase.hpp"
#include "Cacheable.hpp"
#include "CacheableKey.hpp"
#include "Exception.hpp"


namespace gemfire
{

  template< typename TKEY, typename TVAL > class HashMapT
  {
    private:

      HashMapOfSharedBase m_map;


    public:

      class Iterator
      {
        private:

          HashMapOfSharedBase::Iterator m_iter;


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

          // Never defined.
          Iterator( );


        public:

          inline const TKEY first( ) const
          {
            return staticCast<TKEY>( m_iter.first( ) );
          }

          inline const TVAL second( ) const
          {
            return staticCast<TVAL>( m_iter.second( ) );
          }

          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 );
          }


          friend class HashMapT;
      };


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

      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_map.size();
      }

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

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

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

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

      inline void swap( HashMapT& other )
      {
        m_map.swap( other.m_map );
      }

      inline bool insert( const TKEY& k, const TVAL& v )
      {
        return m_map.insert( k, v );
      }

      inline void update( const TKEY& k, const TVAL& v )
      {
        m_map[k] = v;
      }

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

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

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

      inline Iterator find( const TKEY& k ) const
      {
        return Iterator( m_map.find( k ) );
      }

      size_t count( const SharedBasePtr& k ) const
      {
        return m_map.count( k );
      }

      inline TVAL operator [] ( const TKEY& k )
      {
        return staticCast<TVAL>( m_map[ k ] );
      }

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

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

      inline HashMapT& operator = ( const HashMapT& other )
      {
        m_map = other.m_map;
        return *this;
      }

      inline HashMapT( )
        : m_map( hasher, equal_to )
      {
      }

      inline HashMapT( size_t n )
        : m_map( n, hasher, equal_to )
      {
      }

      inline HashMapT( const HashMapT& other )
        : m_map( other.m_map )
      {
      }

      inline ~HashMapT( )
      {
      }
  };

  typedef HashMapT<CacheableKeyPtr, CacheablePtr> _HashMapOfCacheable;
  typedef HashMapT<CacheableKeyPtr, ExceptionPtr> _HashMapOfException;

  class CPPCACHE_EXPORT HashMapOfCacheable :
    public _HashMapOfCacheable, public SharedBase
  {
  public:
    typedef _HashMapOfCacheable::Iterator Iterator;

    inline HashMapOfCacheable() :
      _HashMapOfCacheable() { }

    inline HashMapOfCacheable(size_t n) :
      _HashMapOfCacheable(n) { }

    inline HashMapOfCacheable(const HashMapOfCacheable& other) :
      _HashMapOfCacheable(other) { }
  };

  class CPPCACHE_EXPORT HashMapOfException :
    public _HashMapOfException, public SharedBase
  {
  public:
    typedef _HashMapOfException::Iterator Iterator;

    inline HashMapOfException() :
      _HashMapOfException() { }

    inline HashMapOfException(size_t n) :
      _HashMapOfException(n) { }

    inline HashMapOfException(const HashMapOfException& other) :
      _HashMapOfException(other) { }
  };

  typedef SharedPtr<HashMapOfCacheable> HashMapOfCacheablePtr;
  typedef SharedPtr<HashMapOfException> HashMapOfExceptionPtr;

}


#endif

---