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

Go to the documentation of this file.

#ifndef _GEMFIRE_VECTORT_HPP_
#define _GEMFIRE_VECTORT_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 "VectorOfSharedBase.hpp"
#include "Cacheable.hpp"
#include "CacheableKey.hpp"

namespace gemfire {

template < class PTR_TYPE > class VectorT
{
  private:
    VectorOfSharedBase m_vector;

  public:

    class Iterator
    {
      private:

        VectorOfSharedBase::Iterator m_iter;


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

        // Never defined.
        Iterator( );


      public:

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

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

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

    inline size_t length( ) const
    {
      return m_vector.size();
    }

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

    inline size_t capacity( ) const
    {
      return m_vector.capacity();
    }

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

    inline PTR_TYPE operator [] ( size_t n )
    {
      return staticCast<PTR_TYPE>( m_vector[n] );
    }

    inline const PTR_TYPE operator [] ( size_t n ) const
    {
      return staticCast<PTR_TYPE>( m_vector[n] );
    }

    inline PTR_TYPE at( size_t n )
    {
      return staticCast<PTR_TYPE>( m_vector.at( n ) );
    }

    inline const PTR_TYPE at( size_t n ) const
    {
      return staticCast<PTR_TYPE>( m_vector.at( n ) );
    }

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

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

    inline VectorT( )
    : m_vector( )
    {
    }

    inline VectorT( size_t n )
    : m_vector( n )
    {
    }

    inline VectorT( size_t n, const PTR_TYPE& t )
    : m_vector( n, t )
    {
    }

    inline VectorT( const VectorT& other )
    : m_vector( other.m_vector )
    {
    }

    inline ~VectorT( )
    {
      // destructor of m_vector field does all the work.
    }

    inline VectorT& operator = ( const VectorT& other )
    {
      m_vector = other.m_vector;
      return *this;
    }

    inline void reserve( size_t n )
    {
      m_vector.reserve( n );
    }

    inline PTR_TYPE front( )
    {
      return staticCast<PTR_TYPE>( m_vector.front( ) );
    }

    inline const PTR_TYPE front( ) const
    {
      return staticCast<PTR_TYPE>( m_vector.front( ) );
    }

    inline PTR_TYPE back( )
    {
      return staticCast<PTR_TYPE>( m_vector.back( ) );
    }

    inline const PTR_TYPE back( ) const
    {
      return staticCast<PTR_TYPE>( m_vector.back( ) );
    }

    inline void push_back( const PTR_TYPE& e )
    {
      m_vector.push_back( e );
    }

    inline void pop_back( )
    {
      m_vector.pop_back();
    }

    inline void swap( VectorT& other )
    {
      m_vector.swap( other.m_vector );
    }

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

    inline void resize( size_t n, const PTR_TYPE& t = NULL )
    {
      m_vector.resize( n, t );
    }

    inline void insert( size_t index, const PTR_TYPE& t )
    {
      m_vector.insert( index, t );
    }

    inline void erase( size_t index )
    {
      m_vector.erase( index );
    }

};

typedef VectorT<CacheablePtr> _VectorOfCacheable;
typedef VectorT<CacheableKeyPtr> _VectorOfCacheableKey;
typedef VectorT<RegionEntryPtr> VectorOfRegionEntry;
typedef VectorT<RegionPtr> VectorOfRegion;

class CPPCACHE_EXPORT VectorOfCacheable :
  public _VectorOfCacheable, public SharedBase
{
public:
  typedef _VectorOfCacheable::Iterator Iterator;

  inline VectorOfCacheable() :
    _VectorOfCacheable() { }

  inline VectorOfCacheable(size_t n) :
    _VectorOfCacheable(n) { }

  inline VectorOfCacheable(size_t n, const CacheablePtr& t ) :
    _VectorOfCacheable(n, t) { }

  inline VectorOfCacheable(const VectorOfCacheable& other) :
    _VectorOfCacheable(other) { }
};

class CPPCACHE_EXPORT VectorOfCacheableKey :
  public _VectorOfCacheableKey, public SharedBase
{
public:
  typedef _VectorOfCacheableKey::Iterator Iterator;

  inline VectorOfCacheableKey() :
    _VectorOfCacheableKey() { }

  inline VectorOfCacheableKey(size_t n) :
    _VectorOfCacheableKey(n) { }

  inline VectorOfCacheableKey(size_t n, const CacheableKeyPtr& t ) :
    _VectorOfCacheableKey(n, t) { }

  inline VectorOfCacheableKey(const VectorOfCacheableKey& other) :
    _VectorOfCacheableKey(other) { }
};

typedef SharedPtr<VectorOfCacheable> VectorOfCacheablePtr;
typedef SharedPtr<VectorOfCacheableKey> VectorOfCacheableKeyPtr;

}

#endif

---