Class MutableArray

API/fleece/Mutable.hh:77–147

A mutable form of Array. 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 MutableArray : public Array {
    public:
        /** Creates a new, empty mutable array. */
        static MutableArray newArray()          {return MutableArray(FLMutableArray_New(), false);}

        MutableArray()                          :Array() { }
        MutableArray(FLMutableArray a)          :Array((FLArray)FLMutableArray_Retain(a)) { }
        MutableArray(const MutableArray &a)     :Array((FLArray)FLMutableArray_Retain(a)) { }
        MutableArray(MutableArray &&a) noexcept :Array((FLArray)a) {a._val = nullptr;}
        ~MutableArray()                         {FLMutableArray_Release(*this);}

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

        MutableArray& operator= (const MutableArray &a) {
            FLMutableArray_Retain(a);
            FLMutableArray_Release(*this);
            _val = a._val;
            return *this;
        }

        MutableArray& operator= (MutableArray &&a) noexcept {
            if (a._val != _val) {
                FLMutableArray_Release(*this);
                _val = a._val;
                a._val = nullptr;
            }
            return *this;
        }

        /** The immutable Array this instance was constructed from (if any). */
        Array source() const                    {return FLMutableArray_GetSource(*this);}

        /** True if this array has been modified since it was created. */
        bool isChanged() const                  {return FLMutableArray_IsChanged(*this);}

        /** Removes a range of values from the array. */
        void remove(uint32_t first, uint32_t n =1) {FLMutableArray_Remove(*this, first, n);}

        /** Sets the array's size. If the array grows, new values begin as nulls. */
        void resize(uint32_t size)              {FLMutableArray_Resize(*this, size);}

        Slot set(uint32_t i)                    {return Slot(FLMutableArray_Set(*this, i));}
        void setNull(uint32_t i)                {set(i).setNull();}

        template <class T>
        void set(uint32_t i, T v)               {set(i) = v;}

        Slot append()                           {return FLMutableArray_Append(*this);}
        void appendNull()                       {append().setNull();}

        template <class T>
        void append(T v)                        {append() = v;}

        void insertNulls(uint32_t i, uint32_t n) {FLMutableArray_Insert(*this, i, n);}

        // This enables e.g. `array[10] = 17`
        inline keyref<MutableArray,uint32_t> operator[] (int i) {
            return keyref<MutableArray,uint32_t>(*this, i);