---

CdbAnyTypeDict.hh

Go to the documentation of this file.

#ifndef CDBBASE_ANY_TYPE_DICT_HH
#define CDBBASE_ANY_TYPE_DICT_HH

// File and Version Information:
//      $Id: CdbAnyTypeDict.hh,v 1.2 2005/11/07 18:14:37 gapon Exp $

#include "CdbBase/CdbCommon.hh"

#include <map>
#include <vector>

/// The internal machinery of the dictionary

namespace CdbAnyTypeDictImpl {

    struct TypeIdGenerator {
        static int next( ) { static int id = 0; return id++; }
    };

    template< typename T >
    struct Type2Id {
        static int id( ) { static int myId = TypeIdGenerator::next( ); return myId; }
    };

    struct HolderBase {
        HolderBase( int theTypeId ) : typeId(theTypeId) { }
        virtual ~HolderBase( ) { }
        virtual HolderBase* clone( ) const = 0;
        int typeId;
    };

    template< typename T >
    struct Holder : public HolderBase {
        Holder( T* thePtr ) : HolderBase( Type2Id<T>::id( )), ptr(thePtr) { }
        Holder( const Holder<T>& other ) : HolderBase( other ), ptr(new T( *other.ptr )) { }
        Holder<T>& operator=( const Holder<T>& other )
        {
            if( this != &other ) {
                HolderBase::operator=( other );
                delete ptr;
                ptr = new T( *other.ptr );
            }
            return *this;
        }
        virtual ~Holder( ) { delete ptr; }
        virtual HolderBase* clone( ) const { return new Holder( *this ); }
        T* ptr;
    private:
        Holder( );
    };
}

/// A dictionary class for objects of any type
/**
  * The class can be used to store heterogenious collections of objects.
  * The only template parameter of the class is:
  *
  *   K - a type of the dictionary's keys
  *
  * Objects stored in the dictionary can be of any types as long as these types
  * support the value semantics (meet the following minimal interface):
  *
  *   class T {
  *   public:
  *     T();
  *     T(const T&);
  *     ~T();
  *     T& operator=(const T&);
  *   };
  *
  * All keys in the dictionary are unique. A type of each object is also remembered (in some form)
  * by the dictionary, therefore next time, when a user will be making a query to find an object
  * for a certain key then the stored object's type will get compared with the one expected by
  * the users, and they should match. Otherwise a error code will get returned.
  *
  * Here is a simple example how to use the dictionary:
  *
  *   CdbAnyTypeDict<std::string> dict;
  *
  *   if( !dict.exists( "PI" )) {
  *     const double pi = 3.14;
  *     if( CdbStatus::Success != dict.insert( "PI", pi )) {
  *       cerr << "failed to insert 'PI' into the dictionary\n";
  *       ...
  *     }
  *   }
  *   if( CdbStatus::Success != dict.replace( "PI", 3.14195, false )) {
  *     cerr << "failed to replice 'PI' in the dictionary with a more precise value\n";
  *     ...
  *   }
  */
template< class K >
class CdbAnyTypeDict {

private:

  /// The dictionary type for storing kay-value pairs

    typedef std::map<K,CdbAnyTypeDictImpl::HolderBase*> HolderBaseMap;

public:

  /// The default constructor

    CdbAnyTypeDict( ) { }

  /// The copy constructor

    CdbAnyTypeDict( const CdbAnyTypeDict<K>& other )
    {
        for( typename HolderBaseMap::const_iterator itr = other._data.begin( );
                                                    itr != other._data.end( );
                                                    ++itr ) _data[itr->first] = itr->second->clone( );
    }

  /// The destructor

    virtual ~CdbAnyTypeDict( )
    {
        for( typename HolderBaseMap::iterator itr = _data.begin( );
                                              itr != _data.end( );
                                            ++itr ) delete itr->second;
    }

  /// The assignment operator

    CdbAnyTypeDict<K>& operator=( const CdbAnyTypeDict<K>& other )
    {
        if( this != &other ) {
            for( typename HolderBaseMap::iterator itr = _data.begin( );
                                                  itr != _data.end( );
                                                ++itr ) delete itr->second;
        _data.clear( );
        for( typename HolderBaseMap::const_iterator itr = other._data.begin( );
                                                    itr != other._data.end( );
                                                  ++itr ) _data[itr->first] = itr->second->clone( );
        }
        return *this;
    }

  /// Check if the dictionary is empty (has no keys registered)

    bool empty( ) const
    {
        return _data.empty( );
    }

  /// Check if the specified key exists in the dictionary

    bool exists( const K& theKey ) const
    {
        typename HolderBaseMap::const_iterator itr = _data.find( theKey );
        return itr != _data.end( );
    }

  /// Insert the new object into the dictionary
  /**
    * The method is meant to make a copy of the input object and register it in the dictionary
    * with the specified key. A type of the input object will also be remembered, so that next
    * time when a user will be making a query for that key then the stored type will get compared
    * with the one expected by the user.
    *
    * The method will return CdbStatus::Error if the specified key is already known to the dictionary.
    */
    template< typename V >
    CdbStatus insert( const K& theKey,
                      const V& theValue
                    )
    {
        if( exists( theKey )) return CdbStatus::Error;
        _data[theKey] = new CdbAnyTypeDictImpl::Holder<V>( new V( theValue ));
        return CdbStatus::Success;
    }

  /// Replace an object in the dictionary
  /**
    * The method will replace an existing object in the dictionary for the specified key.
    * Depending on a value of the optional "forceCreateFlag" the key may or may not be allowed
    * to be missing in the dictionary prior to calling the method. If the keys is not known
    * and the flag is set to "false" then the CdbStatus::NotFound value will be returned. Otherwise
    * a new entry will be created.
    *
    * If the key is already known to the dictionary then the new object's type should match
    * the one stored before. Otherwise the CdbStatus::ConflictOfParameters status value will
    * be returned.
    */
    template< typename V >
    CdbStatus replace( const K&   theKey,
                       const V&   theValue,
                       const bool forceCreateFlag = true )
    {
        typename HolderBaseMap::const_iterator itr = _data.find( theKey );
        if( itr !=  _data.end( )) {
            if( itr->second->typeId != CdbAnyTypeDictImpl::Type2Id<V>::id( )) return CdbStatus::ConflictOfParameters;
            delete itr->second;
        } else {
            if( !forceCreateFlag) return CdbStatus::NotFound;
        }
        _data[theKey] = new CdbAnyTypeDictImpl::Holder<V>( new V( theValue ));
        return CdbStatus::Success;
    }

  /// Find an object in the dictionary
  /**
    * The method will try to find an existing object in the dictionary for the specified key.
    * If the key is not found then the CdbStatus::NotFound value will be returned.
    *
    * If the key is already known to the dictionary then the expected object's type should match
    * the one stored before. Otherwise the CdbStatus::ConflictOfParameters status value will
    * be returned.
    */
    template< typename V >
    CdbStatus find( const K& theKey,
                    V&       theValue ) const
    {
        typename HolderBaseMap::const_iterator itr = _data.find( theKey );
        if( itr == _data.end( )) return CdbStatus::NotFound;

        const CdbAnyTypeDictImpl::HolderBase* holderBasePtr = itr->second;
        if( holderBasePtr->typeId != CdbAnyTypeDictImpl::Type2Id<V>::id( )) return CdbStatus::ConflictOfParameters;

        const CdbAnyTypeDictImpl::Holder<V>* holderPtr = (const CdbAnyTypeDictImpl::Holder<V>*)holderBasePtr;
        theValue = V( *holderPtr->ptr );

        return CdbStatus::Success;
    }

  /// Get a vector of keys registered in the dictionary
  /**
    * The method would initialize and fill the specified vector with known keys.
    * Note that the keys will not be sorted.
    */
    void keys( std::vector<K>& theVectorOfKeys ) const
    {
        theVectorOfKeys.resize( 0 );
        for( typename HolderBaseMap::const_iterator itr = _data.begin( );
                                                    itr != _data.end( );
                                                  ++itr ) theVectorOfKeys.push_back( itr->first );
        return;
    }

private:

  // The storage for keys and objects

    HolderBaseMap _data;
};

#endif  // CDBBASE_ANY_TYPE_DICT_HH

---