template class axl::sl::Array

#include <axl_sl_Array.h>

template <
    typename T,
    typename Details0 = ArrayDetails<T>
    >
class Array: public axl::sl::ArrayRef
{
public:
    // typedefs

    typedef sl::ArrayRef<T, Details0> ArrayRef;
    typedef ArrayRef::Details Details;
    typedef ArrayRef::Hdr Hdr;
    typedef ArrayRef::ValueArg ValueArg;
    typedef Details::Construct Construct;
    typedef Details::ZeroConstruct ZeroConstruct;

    // construction

    Array();
    Array(const Array& src);
    Array(const ArrayRef& src);
    Array(size_t count);

    Array(
        const T* p,
        size_t count
        );

    Array(
        const T* p,
        const void* end
        );

    Array(
        rc::BufKind bufKind,
        void* p,
        size_t size
        );

    // methods

    operator const T *() const;
    operator T *();

    Array&
    operator=(const Array& src);

    Array&
    operator=(const ArrayRef& src);

    const T&
    operator[](intptr_t i) const;

    T&
    operator[](intptr_t i);

    T*
    p();

    const T*
    getBegin() const;

    T*
    getBegin();

    const T*
    getEnd() const;

    T*
    getEnd();

    const T&
    getFront() const;

    T&
    getFront();

    const T&
    getBack() const;

    T&
    getBack();

    void
    clear();

    void
    zeroConstruct(
        size_t index,
        size_t count
        );

    void
    zeroConstruct();

    size_t
    copy(const ArrayRef& src);

    size_t
    copyReverse(const ArrayRef& src);

    size_t
    copy(
        const T* p,
        size_t count
        );

    size_t
    copyReverse(
        const T* p,
        size_t count
        );

    size_t
    copy(ValueArg e);

    size_t
    appendEmptySpace(size_t count);

    size_t
    appendZeroConstruct(size_t count);

    size_t
    append(
        const T* p,
        size_t count
        );

    size_t
    appendReverse(
        const T* p,
        size_t count
        );

    size_t
    append(ValueArg e);

    size_t
    appendMultiply(
        ValueArg e,
        size_t count
        );

    size_t
    append(const ArrayRef& src);

    size_t
    appendReverse(const ArrayRef& src);

    size_t
    insertEmptySpace(
        size_t index,
        size_t count
        );

    size_t
    insertZeroConstruct(
        size_t index,
        size_t count
        );

    size_t
    insert(
        size_t index,
        const T* p,
        size_t count
        );

    size_t
    insertReverse(
        size_t index,
        const T* p,
        size_t count
        );

    size_t
    insert(
        size_t index,
        ValueArg e
        );

    size_t
    insertMultiply(
        size_t index,
        ValueArg e,
        size_t count
        );

    size_t
    insert(
        size_t index,
        const ArrayRef& src
        );

    size_t
    insertReverse(
        size_t index,
        const ArrayRef& src
        );

    size_t
    remove(
        size_t index,
        size_t count = 1
        );

    size_t
    pop(size_t count = 1);

    T
    getBackAndPop();

    void
    reverse(
        size_t index,
        size_t count
        );

    void
    reverse();

    void
    reverseFrom(size_t index);

    void
    reverseUntil(size_t index);

    bool
    isExclusive();

    bool
    ensureExclusive();

    bool
    reserve(size_t count);

    bool
    setCount(size_t count);

    bool
    setCountZeroConstruct(size_t count);

    size_t
    ensureCount(size_t count);

    size_t
    ensureCountZeroConstruct(size_t count);

    size_t
    setBuffer(
        rc::BufKind kind,
        void* p,
        size_t size
        );
};

Inherited Members

public:
    // typedefs

    typedef Details0 Details;
    typedef Details::Hdr Hdr;
    typedef Details::ValueArg ValueArg;

    // methods

    operator const T *() const;

    ArrayRef&
    operator=(const ArrayRef& src);

    const T&
    operator[](intptr_t i) const;

    const T*
    cp() const;

    size_t
    getCount() const;

    Hdr*
    getHdr() const;

    bool
    isEmpty() const;

    const T*
    getBegin() const;

    const T*
    getEnd() const;

    const T&
    getFront() const;

    const T&
    getBack() const;

    size_t
    find(ValueArg e) const;

    size_t
    findReverse(ValueArg e) const;

    void
    release();