template class axl::sl::AutoPtrArray

#include <axl_sl_AutoPtrArray.h>

template <
    typename T,
    typename Delete0 = typename mem::StdDelete<T>
    >
class AutoPtrArray: public axl::sl::Array
{
public:
    // typedefs

    typedef Array<T*> BaseType;
    typedef Delete0 Delete;

    // construction

    AutoPtrArray();
    AutoPtrArray(T* e);

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

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

    // methods

    void
    clear();
};

Inherited Members

public:
    // typedefs

    typedef Details0 Details;
    typedef Details::Hdr Hdr;
    typedef Details::ValueArg ValueArg;
    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;

    // 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();

    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
        );