Kisaragi_Lib::OrderedMap< KeyType, ValueType > クラステンプレート

順番を持つ連想配列 [詳解]

#include <OrderedMap.hpp>

公開メンバ関数
void	Push (KeyType _key, ValueType _value)
	要素を末尾に追加する.
void	Erase (KeyType _key)
	要素を削除する.
void	Clear ()
	配列をクリアする
bool	FindKey (const KeyType &_key)
	_key要素があるか検索する
	operator std::vector< ValueType > & ()
	要素を配列として扱う
ValueType &	operator[] (KeyType _key)
	連想配列の要素を取得する
void	SwapKeyOrder (KeyType _key1, KeyType _key2)
	要素順を変更する.
const std::vector< KeyType > &	KeyOrder ()
	現在のkey順を取得する

非公開変数類
std::unordered_map< KeyType, unsigned int >	keyToIndex
std::vector< KeyType >	keyOrder
std::vector< ValueType >	value

詳解

template<typename KeyType, typename ValueType>
class Kisaragi_Lib::OrderedMap< KeyType, ValueType >

順番を持つ連想配列

テンプレート引数

KeyType	連想配列のKey
ValueType	連想配列の要素

関数詳解

Push()

template<typename KeyType, typename ValueType>

void Kisaragi_Lib::OrderedMap< KeyType, ValueType >::Push ( KeyType _key, ValueType _value )

inline

要素を末尾に追加する.

引数

_key	引数
_value	要素

        {
            if (keyToIndex.count(_key))
            {
                return;
            }
 
            keyToIndex.emplace(_key, keyOrder.size());
            keyOrder.push_back(_key);
            value.push_back(_value);
        }

Erase()

template<typename KeyType, typename ValueType>

void Kisaragi_Lib::OrderedMap< KeyType, ValueType >::Erase ( KeyType _key )

inline

要素を削除する.

引数

_key	削除する要素のKey

        {
            if (!keyToIndex.count(_key))
            {
                return;
            }
 
            //引数を記憶
            unsigned int index = keyToIndex[_key];
            //末尾要素の引数を記憶
            unsigned int lastIndex = keyToIndex.size() - 1;
 
            //自身が末尾の場合 or 自身のみしか格納してない場合.
 
            //自身が末尾要素でない場合
            if (index != lastIndex)
            {
                //削除するKey以降のkeyToIndexを削除後に合わせる
                for (int i = index + 1; i <= lastIndex; i++)
                {
                    //indexを1下げる
                    keyToIndex[keyOrder[i]]--;
                }
            }
 
            //各配列の削除処理を行う.
            {
                //要素の削除
                value.erase(value.begin() + index);
                //疎配列の削除
                keyOrder.erase(keyOrder.begin() + index);
                //Keyの逆引きを削除
                keyToIndex.erase(_key);
            }
        }

Clear()

template<typename KeyType, typename ValueType>

void Kisaragi_Lib::OrderedMap< KeyType, ValueType >::Clear ( )

inline

配列をクリアする

        {
            keyToIndex.clear();
            keyOrder.clear();
            value.clear();
        }

FindKey()

template<typename KeyType, typename ValueType>

bool Kisaragi_Lib::OrderedMap< KeyType, ValueType >::FindKey ( const KeyType & _key )

inline

_key要素があるか検索する

引数

_key	検索したい要素のkey

戻り値

存在する : true,存在しない : false

        {
            return keyToIndex.count(_key);
        }

参照元 operator[]().

operator std::vector< ValueType > &()

template<typename KeyType, typename ValueType>

Kisaragi_Lib::OrderedMap< KeyType, ValueType >::operator std::vector< ValueType > & ( )

inline

要素を配列として扱う

        {
            return value;
        }

operator[]()

template<typename KeyType, typename ValueType>

ValueType & Kisaragi_Lib::OrderedMap< KeyType, ValueType >::operator[] ( KeyType _key )

inline

連想配列の要素を取得する

引数

_key	取得したい要素のkey

戻り値

取得した要素

        {
            if (!FindKey(_key))
            {
                assert(false);
            }
 
            return value[keyToIndex[_key]];
        }

SwapKeyOrder()

template<typename KeyType, typename ValueType>

void Kisaragi_Lib::OrderedMap< KeyType, ValueType >::SwapKeyOrder ( KeyType _key1, KeyType _key2 )

inline

要素順を変更する.

引数

_key1	変更したい要素のKey
_key2	変更したい要素のKey

        {
            //keyが存在するなら.
            if (keyToIndex.count(_key1)==1 && keyToIndex.count(_key2) == 1)
            {
                //順番を入れ替える.
                keyOrder[value[_key1]] = _key2;
                keyOrder[value[_key2]] = _key1;
 
                //対応処理.
                unsigned int tmp = value[_key1];
                value[_key1] = value[_key2];
                value[_key2] = tmp;
 
                unsigned int tmpIndex = keyToIndex[_key1];
                keyToIndex[_key1] = keyToIndex[_key2];
                keyToIndex[_key2] = tmpIndex;
            }
        }

KeyOrder()

template<typename KeyType, typename ValueType>

const std::vector< KeyType > & Kisaragi_Lib::OrderedMap< KeyType, ValueType >::KeyOrder ( )

inline

現在のkey順を取得する

戻り値

現在のkey順の配列

        {
            return keyOrder;
        }

メンバ詳解

keyToIndex

template<typename KeyType, typename ValueType>

std::unordered_map<KeyType, unsigned int> Kisaragi_Lib::OrderedMap< KeyType, ValueType >::keyToIndex

private

参照元 Clear(), Erase(), FindKey(), operator[](), Push(), SwapKeyOrder().

keyOrder

template<typename KeyType, typename ValueType>

std::vector<KeyType> Kisaragi_Lib::OrderedMap< KeyType, ValueType >::keyOrder

private

参照元 Clear(), Erase(), KeyOrder(), Push(), SwapKeyOrder().

value

template<typename KeyType, typename ValueType>

std::vector<ValueType> Kisaragi_Lib::OrderedMap< KeyType, ValueType >::value

private

参照元 Clear(), Erase(), operator std::vector< ValueType > &(), operator[](), Push(), SwapKeyOrder().

---

このクラス詳解は次のファイルから抽出されました:

• OrderedMap.hpp