PersistentMap

template <class Key, class FileType, class Compare = std::less<Key>>
class PersistentMap;

//Proxy trida pro umozneni pouzivat something[index]= value; konstrukce, kde je somethind=konteiner, index=key,value= mapped_type;
template<class Key, class Mapped_Type, class Compare = std::less<Key>>
struct PersistentMapProxy
{
    PersistentMap<Key, Mapped_Type, Compare> & parent;
    Key key;
    Mapped_Type *value;
    //konstruktor
    PersistentMapProxy(PersistentMap<Key, Mapped_Type, Compare> & parent, Key key)
        : parent(parent), key(key),value(new Mapped_Type((*parent.find(key)).second))
    {
        /* kdy bych potreboval aby behem myMap[10]; vytvoril novy uzel dreva a file tak bych tady pridal kode, ale ne ma to smysl protoze kdy bych uzivatel napsal  myMap[10]; a potom mapped_type a=myMap[10];
        tak do a dosli bych ne konsinstentny data;
        */
    }


    //pridava nebo updejtuje strom ktery je v parent
    const Mapped_Type& operator = (const Mapped_Type& value_)   const
    {
        *value = value_;
        parent.insert(std::make_pair(key, value_));
        return *value;
    }

    //vrati hodnotu
    operator Mapped_Type&() const
    {
        //PersistentMap<Key, Mapped_Type, Compare>::iterator it = parent.find(key);
        return *value;
    }

    ~PersistentMapProxy()
    {
        parent.insert(std::make_pair(key, *value));
        delete value;
    }
};

template <typename Key, typename FileType, class Compare = std::less<Key>>
class PersistentMap {
public:
    typedef int size_type;
    typedef std::pair<Key, FileType> value_type;
    typedef FileType mapped_type;
    typedef AVL_Tree<Key, FileType> tree;
    typedef PersistentMapProxy<Key, mapped_type, Compare> Proxy;

private:
    std::string dirName;
    tree *strom;
    Compare comp;
public:

    typedef typename tree::iterator iterator;
    typedef typename tree::const_iterator const_iterator;

    //iteratory
    iterator begin()
    {
        //iterator::a = t;
        return strom->begin();
    }

    iterator end()
    {
        return strom->end();
    }

    const_iterator cbegin()
    {
        return strom->cbegin();
    }

    const_iterator cend()
    {
        return strom->cend();
    }

    //constructory & destruktory
    PersistentMap(std::string ag) :dirName(ag)
    {
        path p(ag);
        if (!fs::exists(p))
            fs::create_directory(ag);
        strom = new tree(dirName);
    };

    ~PersistentMap()
    {
        delete strom;
    }

    //operatory
    const Proxy operator[] (Key key)
    {
        return Proxy(*this, key);
    }


    //methody
    //vrati pair iteratoru na `a` & bool ktery rika, byl ly vytvoren uzel, nebo jenom updejtovan
    std::pair<iterator, bool> insert(const value_type& a)
    {
        int count = strom->getCount();
        iterator it = iterator(strom->insert(a));
        if (count< strom->getCount())
            return std::make_pair(it, true);
        else
            return std::make_pair(it, false);
    }

    //vrati iterator na a
    iterator find(const Key& a)
    {
        return iterator(*strom->findKey(a));
    }

    //vrati const_iterator na a
    const_iterator find(const Key& a) const
    {
        return const_iterator(*strom->findKey(a));
    }

    //vrati iterator na a++
    iterator erase(const_iterator a)
    {
        iterator prev = a++;
        erase((*prev).first);
        return a;
    }

    //maze z kontejneru element s klicem "a"
    void erase(iterator first, iterator last)
    {
        iterator it;
        iterator prev = first++;
        for (it = first; it != last; prev = it++)
        {
            strom->erase((*prev).first);
        }
        strom->erase((*prev).first);
    }

    //maze uzel s key a file key, a vrati pocet uzlu v stromu
    size_type erase(const Key& k)
    {
        strom->erase(k);
        return strom->getCount();
    }
};