map

    template <class c, class t>
        struct map : public set<key_value<c, t>>
    {
        map(const char* name)
            : set<key_value<c, t>>(name) {}

        map(const char* name, const char* directory)
            : set<key_value<c, t>>(name, directory) {}

        map(const wchar_t* name)
            : set<key_value<c, t>>(name) {}

        map(const wchar_t* name, const wchar_t* directory)
            : set<key_value<c, t>>(name, directory) {}

        void insert(c key, t value)
        {
            try { erase(key); } catch (...) {}
            *this << key_value<c, t>(key, value);
        }

        void erase(c key)
        {
            set<key_value<c,t>>::erase(key_value<c,t>(key));
        }

        t get(c key)
        {
            return set<key_value<c, t>>::find(key_value<c, t>(key)).value;
        }

        bool contains(c key)
        {
            try
            {
                set<key_value<c, t>>::find(key_value<c, t>(key));
                return true;
            }
            catch (...)
            {
                return false;
            }
        }

        const t& operator[](const c& key) const { return set<key_value<c, t>>::find(key).value(); }

        class reference
        {
        public:

            reference(map<c, t>& dicSet, const c& keySet)
                : dic(&dicSet), key(&keySet) {}

            reference& operator=(const t& value)
            {
                dic->insert(*key, value);
                return *this;
            }

            operator t () const
            {
                return dic->get(*key);
            }

            map<c, t>* dic;
            const c* key;
        };

        reference operator[](const c& key) { return reference(*this, key); }

        map& operator>>(const c& key) { erase(key); return *this; }
    };