class axl::err::Error

#include <axl_err_Error.h>

class Error: public axl::rc::Buf
{
public:
    // construction

    Error();
    Error(const Error& src);
    Error(const ErrorRef& src);
    Error(const ErrorHdr* src);
    Error(uint_t code);

    Error(
        const sl::Guid& guid,
        uint_t code
        );

    Error(const sl::StringRef& string);
    Error(const char* string);

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

    // methods

    Error&
    operator=(const Error& src);

    Error&
    operator=(const ErrorRef& src);

    Error&
    operator=(const ErrorHdr* src);

    Error&
    operator=(uint_t code);

    size_t
    push(const ErrorRef& error);

    template <typename Pack>
    size_t
    pack_va(
        const sl::Guid& guid,
        uint_t code,
        axl_va_list va
        );

    template <typename Pack>
    size_t
    pack(
        const sl::Guid& guid,
        uint_t code,
        ...
        );

    template <typename Pack>
    size_t
    pushPack_va(
        const sl::Guid& guid,
        uint_t code,
        axl_va_list va
        );

    template <typename Pack>
    size_t
    pushPack(
        const sl::Guid& guid,
        uint_t code,
        ...
        );

    size_t
    format_va(
        const sl::Guid& guid,
        uint_t code,
        const char* formatString,
        axl_va_list va
        );

    size_t
    format(
        const sl::Guid& guid,
        uint_t code,
        const char* formatString,
        ...
        );

    size_t
    pushFormat_va(
        const sl::Guid& guid,
        uint_t code,
        const char* formatString,
        axl_va_list va
        );

    size_t
    pushFormat(
        const sl::Guid& guid,
        uint_t code,
        const char* formatString,
        ...
        );

    size_t
    createSystemError(uint_t code);

    size_t
    createSimpleError(
        const sl::Guid& guid,
        uint_t code
        );

    size_t
    pushSimpleError(
        const sl::Guid& guid,
        uint_t code
        );

    size_t
    createStringError(const sl::StringRef& string);

    size_t
    pushStringError(const sl::StringRef& string);

    size_t
    formatStringError_va(
        const char* formatString,
        axl_va_list va
        );

    size_t
    formatStringError(
        const char* formatString,
        ...
        );

    size_t
    pushFormatStringError_va(
        const char* formatString,
        axl_va_list va
        );

    size_t
    pushFormatStringError(
        const char* formatString,
        ...
        );
};

Inherited Members

public:
    // classes

    class Hdr;

    // methods

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

    const T*
    operator->() const;

    T*
    operator->();

    Buf&
    operator=(const Buf& src);

    Buf&
    operator=(const Ref& src);

    Buf&
    operator=(const T* p);

    T*
    p();

    void
    clear();

    size_t
    copy(const Ref& src);

    size_t
    copy(
        const T* p,
        size_t size = -1
        );

    bool
    isExclusive();

    bool
    ensureExclusive();

    T*
    getBuffer(size_t* size = NULL);

    T*
    createBuffer(
        size_t size = sizeof(T),
        bool saveContents = false
        );

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