ObjectMap.h

/****
 * 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>
 *
 */

#ifndef _SMING_CORE_DATA_OBJECT_MAP_H_
#define _SMING_CORE_DATA_OBJECT_MAP_H_

#include "WVector.h"

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 = indexOf(key);
        if(i >= 0) {
            delete entries[i].value;
            entries[i].value = value;
        } else {
            entries.addElement(new Entry(key, value));
        }
    }

    V* find(const K& key) const
    {
        int index = indexOf(key);
        return (index < 0) ? nullptr : entries[index].value;
    }

    int indexOf(const K& key) const
    {
        for(unsigned i = 0; i < entries.count(); i++) {
            if(entries[i].key == key) {
                return i;
            }
        }
        return -1;
    }

    bool contains(const K& key) const
    {
        return indexOf(key) >= 0;
    }

    void removeAt(unsigned index)
    {
        entries.remove(index);
    }

    bool remove(const K& key)
    {
        int index = indexOf(key);
        if(index < 0) {
            return false;
        } else {
            removeAt(index);
            return true;
        }
    }

    V* extract(const K& key)
    {
        int i = indexOf(key);
        return (i < 0) ? nullptr : extractAt(i);
    }

    V* extractAt(unsigned index)
    {
        V* value = nullptr;
        if(index < entries.count()) {
            value = entries[index].value;
            entries[index].value = nullptr;
            entries.remove(index);
        }
        return value;
    }

    void clear()
    {
        entries.clear();
    }

protected:
    struct Entry {
        K key;
        V* value = nullptr;

        Entry(const K& key, V* value) : key(key), value(value)
        {
        }

        ~Entry()
        {
            delete value;
        }
    };

    Vector<Entry> entries;

private:
    // Copy constructor unsafe, so prevent access
    ObjectMap(ObjectMap<K, V>& that);
};

#endif // _SMING_CORE_DATA_OBJECT_MAP_H_