ObjectMap.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * ObjectMap.h
 *
 * @author: 31 Jul 2018 - Mikee47 <mike@sillyhouse.net>
 *
 */
 
#pragma once
 
#include "WVector.h"
#include <memory>
 
template <typename K, typename V> class ObjectMap
{
public:
    ObjectMap()
    {
    }
 
    ~ObjectMap()
    {
        clear();
    }
 
    class Value
    {
    public:
        Value(ObjectMap<K, V>& map, const K& key) : map(map), key(key)
        {
        }
 
        const K& getKey() const
        {
            return key;
        }
 
        V* getValue() const
        {
            return map.find(key);
        }
 
        Value& operator=(V* newValue)
        {
            map.set(key, newValue);
            return *this;
        }
 
        operator V*() const
        {
            return getValue();
        }
 
        V* operator->() const
        {
            return getValue();
        }
 
        bool remove()
        {
            return map.remove(key);
        }
 
        V* extract()
        {
            return map.extract(key);
        }
 
    private:
        ObjectMap<K, V>& map;
        K key;
    };
 
    unsigned count() const
    {
        return entries.count();
    }
 
    /*
     * @brief Get a key at a specified index, non-modifiable
     * @param idx the index to get the key at
     * @return The key at index idx
     */
    const K& keyAt(unsigned idx) const
    {
        return entries[idx].key;
    }
 
    /*
     * @brief Get a key at a specified index
     * @param idx the index to get the key at
     * @return Reference to the key at index idx
     */
    K& keyAt(unsigned idx)
    {
        return entries[idx].key;
    }
 
    /*
     * @brief Get a value at a specified index, non-modifiable
     * @param idx the index to get the value at
     * @retval The value at index idx
     * @note The caller must not use `delete` on the returned value
     */
    const V* valueAt(unsigned idx) const
    {
        return entries[idx].value;
    }
 
    /*
     * @brief Get a value at a specified index
     * @param idx the index to get the value at
     * @retval Value Reference to value at index idx
     * @see `operator[]`
     */
    Value valueAt(unsigned idx)
    {
        return Value(*this, entries[idx].key);
    }
 
    const V* operator[](const K& key) const
    {
        return find(key);
    }
 
    Value operator[](const K& key)
    {
        return get(key);
    }
 
    Value get(const K& key)
    {
        return Value(*this, key);
    }
 
    void set(const K& key, V* value)
    {
        int i = entries.indexOf(key);
        if(i >= 0) {
            entries[i].value.reset(value);
        } else {
            entries.addElement(new Entry(key, value));
        }
    }
 
    V* find(const K& key) const
    {
        int index = entries.indexOf(key);
        return (index < 0) ? nullptr : entries[index].value.get();
    }
 
    int indexOf(const K& key) const
    {
        return entries.indexOf(key);
    }
 
    bool contains(const K& key) const
    {
        return entries.contains(key);
    }
 
    void removeAt(unsigned index)
    {
        entries.remove(index);
    }
 
    bool remove(const K& key)
    {
        int index = indexOf(key);
        if(index < 0) {
            return false;
        }
        removeAt(index);
        return true;
    }
 
    V* extract(const K& key)
    {
        int i = indexOf(key);
        return (i < 0) ? nullptr : extractAt(i);
    }
 
    V* extractAt(unsigned index)
    {
        std::unique_ptr<V> value;
        if(index < entries.count()) {
            entries[index].value.swap(value);
            entries.remove(index);
        }
        return value.release();
    }
 
    void clear()
    {
        entries.clear();
    }
 
protected:
    struct Entry {
        K key;
        std::unique_ptr<V> value;
 
        bool operator==(const K& keyToFind) const
        {
            return key == keyToFind;
        }
 
        Entry(const K& key, V* value) : key(key)
        {
            this->value.reset(value);
        }
    };
 
    Vector<Entry> entries;
 
private:
    // Copy constructor unsafe, so prevent access
    ObjectMap(ObjectMap<K, V>& that);
};