Class HeapArray

Fleece/Mutable/HeapArray.hh:26–118

namespace fleece { namespace impl { namespace internal {

    class HeapArray : public HeapCollection {
    public:
        HeapArray()
        :HeapCollection(kArrayTag)
        { }

        HeapArray(uint32_t initialCount)
        :HeapCollection(kArrayTag)
        ,_items(initialCount)
        { }

        HeapArray(const Array*);

        static MutableArray* asMutableArray(HeapArray *a)   {return (MutableArray*)asValue(a);}
        MutableArray* asMutableArray() const        {return (MutableArray*)asValue();}

        uint32_t count() const                      {return (uint32_t)_items.size();}
        bool empty() const                          {return _items.empty();}

        const Array* source() const                 {return _source;}

        const Value* get(uint32_t index);

        ValueSlot& setting(uint32_t index);
        ValueSlot& appending();
        ValueSlot& inserting(uint32_t index)        {insert(index, 1); return setting(index);}


        template <typename T>
        void set(uint32_t index, T t)               {setting(index).set(t);}

        // Warning: Changing the size of a MutableArray invalidates pointers to items that are
        // small scalar values, and also invalidates iterators.

        /** Appends a new Value. */
        template <typename T>
        void append(const T &t)                     {appending().set(t);}


        void resize(uint32_t newSize);              ///< Appends nulls, or removes items from end
        void insert(uint32_t where, uint32_t n);    ///< Inserts `n` nulls at index `where`
        void remove(uint32_t where, uint32_t n);    ///< Removes items starting at index `where`

        /** Promotes an Array item to a MutableArray (in place) and returns it.
            Or if the item is already a MutableArray, just returns it. Else returns null. */
        MutableArray* getMutableArray(uint32_t i);

        /** Promotes a Dict item to a MutableDict (in place) and returns it.
            Or if the item is already a MutableDict, just returns it. Else returns null. */
        MutableDict* getMutableDict(uint32_t i);

        void disconnectFromSource();
        void copyChildren(CopyFlags flags);

        class iterator {
        public:
            iterator(const HeapArray* NONNULL) noexcept;
            iterator(const MutableArray* NONNULL) noexcept;