class axl::io::win::NamedPipe

#include <axl_io_win_NamedPipe.h>

class NamedPipe: public axl::io::win::File
{
public:
    // methods

    bool
    create(
        const sl::StringRef_w& name,
        uint_t openMode,
        uint_t pipeMode,
        dword_t maxInstanceCount,
        dword_t txBufferSize,
        dword_t rxBufferSize,
        uint_t timeout,
        SECURITY_ATTRIBUTES* secAttr
        );

    bool
    open(
        const sl::StringRef_w& name,
        uint_t access = GENERIC_READ|GENERIC_WRITE,
        uint_t flags = FILE_FLAG_OVERLAPPED
        );

    bool
    connect();

    bool
    overlappedConnect(OVERLAPPED* overlapped);

    bool
    overlappedConnect();
};

Inherited Members

public:
    // typedefs

    typedef T H;

    // methods

    operator T() const;

    T
    operator->() const;

    const Handle&
    operator=(T h);

    bool
    isOpen() const;

    void
    close();

    void
    attach(T h);

    T
    detach();

    T*
    p();

    static
    T
    getInvalidHandle();

    bool
    create(
        const sl::StringRef_w& fileName,
        uint_t accessMode,
        uint_t shareMode,
        SECURITY_ATTRIBUTES* secAttr,
        uint_t creationDisposition,
        uint_t flagsAttributes = 0
        );

    bool
    duplicate(
        HANDLE sourceProcess,
        HANDLE sourceHandle,
        HANDLE targetProcess,
        dword_t accessMode,
        bool isInheritable,
        dword_t options
        );

    dword_t
    getType() const;

    uint64_t
    getSize() const;

    bool
    setSize(uint64_t size);

    uint64_t
    getPosition() const;

    bool
    setPosition(uint64_t offset) const;

    bool
    flush();

    bool
    read(
        void* p,
        dword_t size,
        dword_t* actualSize
        ) const;

    bool
    write(
        const void* p,
        dword_t size,
        dword_t* actualSize
        );

    bool
    ioctl(
        dword_t code,
        const void* inData,
        dword_t inDataSize,
        void* outData,
        dword_t outDataSize,
        dword_t* actualSize
        );

    bool
    overlappedRead(
        void* p,
        dword_t size,
        OVERLAPPED* overlapped
        ) const;

    bool
    overlappedWrite(
        const void* p,
        dword_t size,
        OVERLAPPED* overlapped
        );

    bool
    overlappedIoctl(
        dword_t code,
        const void* inData,
        dword_t inDataSize,
        void* outData,
        dword_t outDataSize,
        OVERLAPPED* overlapped
        );

    bool
    readEx(
        void* p,
        dword_t size,
        OVERLAPPED* overlapped,
        LPOVERLAPPED_COMPLETION_ROUTINE completionFunc
        ) const;

    bool
    writeEx(
        const void* p,
        dword_t size,
        OVERLAPPED* overlapped,
        LPOVERLAPPED_COMPLETION_ROUTINE completionFunc
        );

    size_t
    read(
        void* p,
        size_t size
        ) const;

    size_t
    write(
        const void* p,
        size_t size
        );

    size_t
    overlappedRead(
        void* p,
        size_t size
        ) const;

    size_t
    overlappedWrite(
        const void* p,
        size_t size
        );

    bool
    overlappedRead(
        void* p,
        dword_t size,
        dword_t* actualSize
        ) const;

    bool
    overlappedWrite(
        const void* p,
        dword_t size,
        dword_t* actualSize
        );

    bool
    overlappedIoctl(
        dword_t code,
        const void* inData,
        dword_t inDataSize,
        void* outData,
        dword_t outDataSize,
        dword_t* actualSize
        );

    bool
    getOverlappedResult(
        OVERLAPPED* overlapped,
        dword_t* actualSize
        ) const;

    size_t
    getOverlappedResult(OVERLAPPED* overlapped) const;

    bool
    cancelIo(OVERLAPPED* overlapped);

    static
    bool
    completeOverlappedRequest(bool_t result);