Class MutableDict

API/fleece/Mutable.hh:153–211

A mutable form of Dict. Its storage lives in the heap, not in the (immutable) Fleece document. It can be used to make a changed form of a document, which can then be encoded to a new Fleece document. */

        document. It can be used to make a changed form of a document, which can then be
        encoded to a new Fleece document. */
    class MutableDict : public Dict {
    public:
        static MutableDict newDict()            {return MutableDict(FLMutableDict_New(), false);}

        MutableDict()                           :Dict() { }
        MutableDict(FLMutableDict d)            :Dict((FLDict)d) {FLMutableDict_Retain(*this);}
        MutableDict(const MutableDict &d)       :Dict((FLDict)d) {FLMutableDict_Retain(*this);}
        MutableDict(MutableDict &&d) noexcept   :Dict((FLDict)d) {d._val = nullptr;}
        ~MutableDict()                          {FLMutableDict_Release(*this);}

        operator FLMutableDict () const         {return (FLMutableDict)_val;}

        MutableDict& operator= (const MutableDict &d) {
            FLMutableDict_Retain(d);
            FLMutableDict_Release(*this);
            _val = d._val;
            return *this;
        }

        MutableDict& operator= (MutableDict &&d) noexcept {
            if (d._val != _val) {
                FLMutableDict_Release(*this);
                _val = d._val;
                d._val = nullptr;
            }
            return *this;
        }

        Dict source() const                     {return FLMutableDict_GetSource(*this);}
        bool isChanged() const                  {return FLMutableDict_IsChanged(*this);}

        void remove(slice key)                  {FLMutableDict_Remove(*this, key);}

        Slot set(slice key)                     {return FLMutableDict_Set(*this, key);}
        void setNull(slice key)                 {set(key) = nullValue;}

        template <class T>
        void set(slice key, T v)                {set(key) = v;}


        // This enables e.g. `dict["key"_sl] = 17`
        inline keyref<MutableDict,slice> operator[] (slice key)
            {return keyref<MutableDict,slice>(*this, key);}
        inline keyref<MutableDict,slice> operator[] (const char *key)
            {return keyref<MutableDict,slice>(*this, slice(key));}
        inline keyref<MutableDict,Key&> operator[] (Key &key)
            {return keyref<MutableDict,Key&>(*this, key);}

        inline Value operator[] (slice key) const       {return Dict::get(key);}
        inline Value operator[] (const char *key) const {return Dict::get(key);}

        inline MutableArray getMutableArray(slice key);
        inline MutableDict getMutableDict(slice key);

    private:
        MutableDict(FLMutableDict d, bool)      :Dict((FLDict)d) {}
        friend class RetainedValue;
        friend class Dict;