MunIndexManager.hpp

Go to the documentation of this file.

#ifndef __MUN_INDEX_MANAGER_HPP__
#define __MUN_INDEX_MANAGER_HPP__

#include <map>
#include <vector>
#include <mrs.hpp>

template< typename IndexKeyType, typename IndexType, typename IndexValueType >
class   IndexManager
{
protected:
    std::map<IndexType, IndexValueType>     m_IndexManager;
    
    std::map<IndexKeyType, IndexType>       m_IndexSearchMap;
    
    std::map<IndexType, IndexKeyType>       m_IndexKeySearchMap;
    
    IndexType                               m_GenerateIndex;
    
    IndexKeyType                            m_GenerateIndexKey;
    
public:
    std::map<IndexType, IndexValueType>* GetIndexManager(){ return &m_IndexManager; }
    
public:
    IndexManager() {
        m_GenerateIndex = 1;
        m_GenerateIndexKey = 1;
    }
    
    virtual ~IndexManager() {
        Clear();
    }
    
    void    Clear() {
        m_IndexManager.clear();
        m_IndexSearchMap.clear();
        m_IndexKeySearchMap.clear();
    }
    
    IndexType   GenerateIndex( IndexType indexMax ) {
        IndexType   startIndex = m_GenerateIndex;
        IndexType   index = 0;
        
        do {
            // ID候補の取得
            index = m_GenerateIndex;
            m_GenerateIndex++;
            
            // 上限に達したら 1 を設定し、循環させる
            if( indexMax == m_GenerateIndex ) {
                m_GenerateIndex = 1;
            }
            
            // インデックス候補がインデックス情報として未登録であれば、そのIDを返す
            if( m_IndexKeySearchMap.end() == m_IndexKeySearchMap.find(index) )  return  index;
        } while( startIndex != index );
        
        return  0;
    }
    
    IndexKeyType    GenerateIndexKey( IndexKeyType indexKeyMax ) {
        IndexKeyType    startIndexKey = m_GenerateIndexKey;
        IndexKeyType    indexKey = 0;
        
        do {
            // ID候補の取得.
            indexKey = m_GenerateIndexKey;
            m_GenerateIndexKey++;
            
            // 上限に達したら 1 を設定し、循環させる
            if( indexKeyMax == m_GenerateIndexKey ) {
                m_GenerateIndexKey = 1;
            }
            
            // インデックスキー候補がインデックス情報として未登録であれば、そのIDを返す
            if( m_IndexSearchMap.end() == m_IndexSearchMap.find(indexKey) ) return  indexKey;
        } while( startIndexKey != indexKey );
        
        return  0;
    }
    
    IndexType   GetIndexFromKey( IndexKeyType indexKey ) {
        typename std::map< IndexKeyType, IndexType >::iterator itr = m_IndexSearchMap.find( indexKey );
        return ( m_IndexSearchMap.end() == itr ) ? 0 : itr->second;
    }
    
    IndexValueType* GetValueFromIndex( IndexType index ) {
        typename std::map< IndexType, IndexValueType >::iterator itr = m_IndexManager.find( index );
        return ( m_IndexManager.end() == itr ) ? NULL : &(itr->second);
    }
    
    const IndexKeyType* GetIndexKey( IndexType index ) {
        typename std::map< IndexType, IndexKeyType >::iterator itr = m_IndexKeySearchMap.find( index );
        return ( m_IndexKeySearchMap.end() == itr ) ? NULL : &(itr->second);
    }
    
    bool    Create( IndexType& index, IndexType indexMax, IndexKeyType indexKey, IndexValueType indexValue ) {
        // インデックスキーが未登録でなければ失敗
        IndexType   _index = GetIndexFromKey( indexKey );
        if( 0 < _index )    return  false;
        
        // インデックスキーの生成
        _index = GenerateIndex( indexMax );
        if( 0 == _index )   return  false;
        
        // インデックスマネージャへの登録
        m_IndexManager.insert( std::pair<IndexType, IndexValueType>( _index, indexValue ) );
        m_IndexSearchMap.insert( std::pair<IndexKeyType, IndexType>( indexKey, _index ) );
        m_IndexKeySearchMap.insert( std::pair<IndexType, IndexKeyType>( _index, indexKey ) );
        
        // 取得結果を反映
        index = _index;
        
        return  true;
    }
    
    void    Delete( IndexType index ) {
        // インデックスキーが存在しないのであれば処理しない
        IndexValueType*     pValue = GetValueFromIndex( index );
        if( pValue == NULL )        return;
        
        // インデックスマネージャからの削除
        m_IndexSearchMap.erase( m_IndexKeySearchMap[index] );
        m_IndexManager.erase( index );
        m_IndexKeySearchMap.erase( index );
    }
    
    void    GetValues( std::vector<IndexValueType>& values ) {
        // 取得するインデックス情報について、１つずつデータを格納する
        values.reserve( GetSize() );
        for( typename std::map<IndexType, IndexValueType>::iterator itr = m_IndexManager.begin(); m_IndexManager.end() != itr; ++itr ) {
            values.push_back( itr->second );
        }
    }
    
    uint32  GetSize() {
        return  m_IndexManager.size();
    }
};

#endif  /* __MUN_INDEX_MANAGER_HPP__ */