class axl::io::psx::Socket

#include <axl_io_psx_Socket.h>

class Socket: public axl::io::psx::File
{
public:
    // methods

    bool
    open(
        int addressFamily,
        int sockKind,
        int protocol
        );

    bool
    setBlockingMode(bool isBlocking);

    int
    getError();

    bool
    bind(const sockaddr* addr);

    bool
    getAddress(SockAddr* addr);

    bool
    getPeerAddress(SockAddr* addr);

    bool
    getOption(
        int level,
        int option,
        void* p,
        socklen_t size
        );

    bool
    setOption(
        int level,
        int option,
        const void* p,
        socklen_t size
        );

    bool
    listen(size_t backLog);

    int
    accept(SockAddr* addr = NULL);

    bool
    connect(const sockaddr* addr);

    bool
    shutdown(int mode = SHUT_RDWR);

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

    size_t
    recv(
        void* p,
        size_t size
        );

    size_t
    sendTo(
        void* p,
        size_t size,
        const sockaddr* addr
        );

    size_t
    recvFrom(
        void* p,
        size_t size,
        SockAddr* addr
        );
};

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
    open(
        const sl::StringRef& fileName,
        uint_t openFlags = O_RDWR|O_CREAT,
        mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
        );

    bool
    duplicate(int fd);

    bool
    setBlockingMode(bool isBlocking);

    uint64_t
    getSize() const;

    bool
    setSize(uint64_t size);

    uint64_t
    getPosition() const;

    bool
    setPosition(uint64_t offset) const;

    size_t
    getIncomingDataSize();

    bool
    flush();

    int
    ioctl(uint_t code);

    template <typename T>
    int
    ioctl(
        uint_t code,
        T param
        );

    int
    fcntl(uint_t code);

    template <typename T>
    int
    fcntl(
        uint_t code,
        T param
        );

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

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