UnorderedMap.h

Go to the documentation of this file.

#pragma once
 
 
#include "objects/containers/Array.h"
#include "objects/wrappers/Optional.h"
 
NAMESPACE_SPH_BEGIN
 
template <typename TKey, typename TValue>
class UnorderedMap : public Noncopyable {
public:
    struct Element {
        TKey key;
        TValue value;
    };
 
private:
    Array<Element> data;
 
public:
    UnorderedMap() = default;
 
    UnorderedMap(std::initializer_list<Element> list)
        : data(list) {}
 
    INLINE TValue& operator[](const TKey& key) {
        Element* element = this->find(key);
        SPH_ASSERT(element);
        return element->value;
    }
 
    INLINE const TValue& operator[](const TKey& key) const {
        const Element* element = this->find(key);
        SPH_ASSERT(element);
        return element->value;
    }
 
    INLINE TValue& insert(const TKey& key, const TValue& value) {
        Element* element = this->find(key);
        if (!element) {
            return this->add(key, value);
        } else {
            element->value = value;
            return element->value;
        }
    }
 
    INLINE TValue& insert(const TKey& key, TValue&& value) {
        Element* element = this->find(key);
        if (!element) {
            return this->add(key, std::move(value));
        } else {
            element->value = std::move(value);
            return element->value;
        }
    }
 
    INLINE void remove(const TKey& key) {
        Element* element = this->find(key);
        SPH_ASSERT(element);
        const Size index = element - &data[0];
        data.remove(index);
    }
 
    INLINE bool tryRemove(const TKey& key) {
        Element* element = this->find(key);
        if (!element) {
            return false;
        } else {
            const Size index = element - &data[0];
            data.remove(index);
            return true;
        }
    }
 
    INLINE void clear() {
        data.clear();
    }
 
    INLINE Optional<TValue&> tryGet(const TKey& key) {
        Element* element = this->find(key);
        if (!element) {
            return NOTHING;
        } else {
            return element->value;
        }
    }
 
    INLINE Optional<const TValue&> tryGet(const TKey& key) const {
        const Element* element = this->find(key);
        if (!element) {
            return NOTHING;
        } else {
            return element->value;
        }
    }
 
    INLINE bool contains(const TKey& key) const {
        return this->find(key) != nullptr;
    }
 
    INLINE Size size() const {
        return data.size();
    }
 
    INLINE Size empty() const {
        return data.empty();
    }
 
    INLINE Iterator<Element> begin() {
        return data.begin();
    }
 
    INLINE Iterator<const Element> begin() const {
        return data.begin();
    }
 
    INLINE Iterator<Element> end() {
        return data.end();
    }
 
    INLINE Iterator<const Element> end() const {
        return data.end();
    }
 
    INLINE operator ArrayView<Element>() {
        return data;
    }
 
    INLINE operator ArrayView<const Element>() const {
        return data;
    }
 
    UnorderedMap clone() const {
        UnorderedMap cloned;
        cloned.data = data.clone();
        return cloned;
    }
 
private:
    INLINE Element* find(const TKey& key) {
        for (Element& element : data) {
            if (element.key == key) {
                return &element;
            }
        }
        return nullptr;
    }
 
    INLINE const Element* find(const TKey& key) const {
        return const_cast<UnorderedMap*>(this)->find(key);
    }
 
    template <typename T>
    INLINE TValue& add(const TKey& key, T&& value) {
        data.push(Element{ key, std::forward<T>(value) });
        return data.back().value;
    }
};
 
 
NAMESPACE_SPH_END