Class Array

Fleece/Core/Array.hh:24–74

A Value that's an array. */

    /** A Value that's an array. */
    class Array : public Value {
        struct impl {
            const Value* _first;
            uint32_t _count;
            uint8_t _width;

            impl(const Value*) noexcept;
            const Value* second() const noexcept FLPURE      {return offsetby(_first, _width);}
            const Value* firstValue() const noexcept FLPURE;
            const Value* deref(const Value*) const noexcept FLPURE;
            const Value* operator[] (unsigned index) const noexcept FLPURE;
            size_t indexOf(const Value *v) const noexcept FLPURE;
            void offset(uint32_t n);
            bool isMutableArray() const noexcept FLPURE      {return _width > 4;}
        };

    public:

        /** The number of items in the array. */
        uint32_t count() const noexcept FLPURE;

        bool empty() const noexcept FLPURE;

        /** Accesses an array item. Returns nullptr for out of range index.
            If you're accessing a lot of items of the same array, it's faster to make an
            iterator and use its sequential or random-access accessors. */
        const Value* get(uint32_t index) const noexcept FLPURE;

        /** If this array is mutable, returns the equivalent MutableArray*, else returns nullptr. */
        MutableArray* asMutable() const FLPURE;

        /** An empty Array. */
        static const Array* const kEmpty;

        using iterator = ArrayIterator;

        inline iterator begin() const noexcept;

        constexpr Array()  :Value(internal::kArrayTag, 0, 0) { }

    protected:
        internal::HeapArray* heapArray() const;

    private:
        friend class Value;
        friend class ArrayIterator;
        friend class Dict;
        friend class DictIterator;
        template <bool WIDE> friend struct dictImpl;
        friend class internal::HeapArray;
    };


    /** A stack-based array iterator */