map.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include <map>
 
#ifdef STRINGS_EXPORTS
#define STRINGS_API __declspec(dllexport) 
#else
#define STRINGS_API __declspec(dllimport) 
#endif
 
template<typename KeyType, typename ValueType> struct BlamMapPair
{
    KeyType key;     
    ValueType value; 
};
 
template<typename KeyType, typename ValueType> class BlamMap
{
private:
    std::vector<BlamMapPair<KeyType, ValueType>> internal_map = std::vector<BlamMapPair<KeyType, ValueType>>();
 
public:
    BlamMap() {}
 
    BlamMap(std::map<KeyType, ValueType> std_map)
    {
        typename std::map<KeyType, ValueType>::iterator it;
 
        for (it = std_map.begin(); it != std_map.end(); it++)
        {
            Add(it->first, it->second);
        }
    }
 
    int Size()
    {
        return internal_map.size();
    }
 
    ValueType At(KeyType key)
    {
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            if (pair.key == key)
            {
                return pair.value;
            }
        }
 
        throw std::exception("Map did not contain any item with matching key. Use Contains() before calling to ensure safety.");
    }
 
    BlamMapPair<KeyType, ValueType>* PairAt(int index)
    {
        if (index < Size())
        {
            return &internal_map.at(index);
        }
 
        throw std::exception("Attempted to fetch a pair with an index that was out of range. Check index against Size() first.");
    }
 
    void Add(std::pair<KeyType, ValueType> pair)
    {
        Add(pair.first, pair.second);
    }
 
    void Add(KeyType key, ValueType value)
    {
        BlamMapPair<KeyType, ValueType> new_pair = BlamMapPair<KeyType, ValueType>();
        {
            new_pair.key = key;
            new_pair.value = value;
        }
 
        for (int i = 0; i < internal_map.size(); i++)
        {
            BlamMapPair<KeyType, ValueType> pair = internal_map.at(i);
 
            if (pair.key == key)
            {
                pair.value = value;
                internal_map[i] = pair;
                return;
            }
        }
 
        internal_map.push_back(new_pair);
    }
 
    bool Contains(KeyType key)
    {
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            if (pair.key == key)
            {
                return true;
            }
        }
 
        return false;
    }
 
    std::vector<KeyType> KeySet()
    {
        std::vector<KeyType> key_list = std::vector<KeyType>();
 
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            key_list.push_back(pair.key);
        }
 
        return key_list;
    }
 
    std::vector<ValueType> Values()
    {
        std::vector<ValueType> value_list = std::vector<ValueType>();
 
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            value_list.push_back(pair.value);
        }
 
        return value_list;
    }
 
    std::map<KeyType, ValueType> ToStdMap()
    {
        std::map<KeyType, ValueType> std_map = std::map<KeyType, ValueType>();
 
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            std_map.insert(std::pair<KeyType, ValueType>(pair.key, pair.value));
        }
 
        return std_map;
    }
 
    bool GetFirstKey(ValueType value, KeyType* out_key)
    {
        if (!out_key)
        {
            return false;
        }
 
        for (BlamMapPair<KeyType, ValueType> pair : internal_map)
        {
            if (pair.value == value)
            {
                *out_key = pair.key;
                return true;
            }
        }
 
        return false;
    }
 
    bool Erase(KeyType key)
    {
        for (int i = 0; i < internal_map.size(); i++)
        {
            if (internal_map.at(i).key == key)
            {
                internal_map.erase(internal_map.begin() + i);
                return true;
            }
        }
 
        return false;
    }
 
    bool EraseAt(int index)
    {
        if (index >= 0 && index < internal_map.size())
        {
            internal_map.erase(internal_map.begin() + index);
            return true;
        }
 
        return false;
    }
 
    int EraseValues(ValueType value)
    {
        int count = 0;
 
        for (int i = internal_map.size() - 1; i >= 0; i--)
        {
            if (internal_map.at(i).value == value)
            {
                internal_map.erase(internal_map.begin() + i);
                count++;
            }
        }
 
        return count;
    }
 
    void Clear()
    {
        internal_map.clear();
    }
};