peer.h

Go to the documentation of this file.

/*  WFIO - the Wheefun IO Library
    Copyright (C) 2018  Phillip Kilgore

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
    
    Additionally, you should have recieved a copy of the GNU Classpath 
    exception, which amends the license to generally permit linking against
    the software provided herein.
*/

#ifndef WFIO_PEER_H
#define WFIO_PEER_H

#include <wfio/type.h>
#include <wfio/device.h>

WFIO_C_BEGIN

typedef struct wfio_peer_t {
    const wfio_peer_type_t type;
    union {
        void* const any;
        struct wfio_device_t* const device;
        struct wfio_binstream_t* const bin;
    } impl;
} wfio_peer_t;

WFIO_DLL int wfio_peer_fromDeviceEx(wfio_peer_t* peer, 
    struct wfio_device_t* device, int ioshare, int* error);

WFIO_ALWAYS_INLINE int wfio_peer_fromDevice(wfio_peer_t* peer, 
    struct wfio_device_t* device, int* error) {
    return wfio_peer_fromDeviceEx(peer, device, 
        WFIO_IOSHARE_O_ACQUIRE, error);
}

WFIO_DLL int wfio_peer_fromBinstreamEx(wfio_peer_t* peer, 
    struct wfio_binstream_t* bin, int ioshare, int* error);

WFIO_ALWAYS_INLINE int wfio_peer_fromBinstream(wfio_peer_t* peer, 
    struct wfio_binstream_t* bin, int* error) {
    return wfio_peer_fromBinstreamEx(peer, bin, 
        WFIO_IOSHARE_O_ACQUIRE, error);
}

WFIO_DLL_FASTCALL wfio_peer_t wfio_peer_ioshare(wfio_peer_t* peer, 
    wfio_ioshare_t ioshare, int* error);
 
WFIO_DLL int wfio_peer_acquire(wfio_peer_t* peer, int* error);
 
 
WFIO_DLL void wfio_peer_close(wfio_peer_t* peer);

/* Basic I/O functions */

WFIO_DLL size_t wfio_peer_read(wfio_peer_t* peer, void* buf,
    size_t sz, size_t elem, int* error);

WFIO_ALWAYS_INLINE size_t wfio_peer_readbV(wfio_peer_t* peer, void* buf,
    size_t len, int* error) {
    return wfio_peer_read(peer, buf, 1, len, error);
}

WFIO_ALWAYS_INLINE int wfio_peer_readb(wfio_peer_t* peer, int* error) {
    unsigned char c;
    if (wfio_peer_read(peer, &c, 1, 1, error) == WFIO_NPOS) {
        return -1;
    }
    return c;
}

WFIO_DLL size_t wfio_peer_write(wfio_peer_t* peer, const void* buf,
    size_t sz, size_t elem, int* error);

WFIO_ALWAYS_INLINE size_t wfio_peer_writebV(wfio_peer_t* peer,
    const void* buf, size_t len, int* error) {
    return wfio_peer_write(peer, buf, 1, len, error);
}

WFIO_ALWAYS_INLINE int wfio_peer_writeb(wfio_peer_t* peer, char c,
    int* error) {
    return wfio_peer_write(peer, &c, 1, 1, error) == 1;
}

WFIO_DLL int wfio_peer_vdcntl(wfio_peer_t* peer, 
    wfio_dcntl_t cmd, int* error, va_list va);

WFIO_ALWAYS_INLINE int wfio_peer_dcntl(wfio_peer_t* peer,
    wfio_dcntl_t cmd, int*error, ...) {
    va_list va;
    register int ret;
    va_start(va, cmd);
    ret = wfio_peer_vdcntl(peer, cmd, error, va);
    va_end(va);
    return ret;
}

WFIO_DLL int wfio_peer_vioctl(wfio_peer_t* peer, int cmd, int* error,
    va_list va);

WFIO_ALWAYS_INLINE int wfio_peer_ioctl(wfio_peer_t* peer, int* error,
    int cmd, ...) {
    va_list va;
    register int ret;
    va_start(va, cmd);
    ret = wfio_peer_vioctl(peer, cmd, error, va);
    va_end(va);
    return ret;
}

WFIO_DLL int wfio_peer_seek(wfio_peer_t* peer, wfio_off_t offset, 
    wfio_whence_t whence, int* error);

WFIO_DLL_FASTCALL int wfio_peer_canSeek(wfio_peer_t* peer);

WFIO_DLL_FASTCALL wfio_off_t wfio_peer_tell(wfio_peer_t* peer, int* error);

WFIO_DLL_FASTCALL int wfio_peer_flush(wfio_peer_t* peer, int* error);

WFIO_DLL_FASTCALL size_t wfio_peer_getbufsz(wfio_peer_t* peer, int* error);

WFIO_DLL size_t wfio_peer_setbufsz(wfio_peer_t* peer, size_t sz,
    int* error);

WFIO_C_END

#ifdef __cplusplus
namespace wfio {
    class Peer {
        public:

        typedef ::wfio_peer_t CType;

        enum Type {
            UNKNOWN = ::WFIO_PEER_UNKNOWN,
            DEVICE = ::WFIO_PEER_DEVICE,
            BINSTREAM = ::WFIO_PEER_BINSTREAM
        };

        private:

        Type m_type;
        void* m_impl;

        public:

        /* Constructors */
        
        inline Peer() : m_type(UNKNOWN), m_impl(NULL) {}
        
        inline Peer(CType& ctype, int* error = 0) : 
            m_type((Type) ctype.type),
            m_impl(ctype.impl.any) {
            wfio_peer_acquire(&ctype, error);
        }
        
        inline Peer(CType& ctype, IOShare share, int* error = 0) {
            CType ret = wfio_peer_ioshare(&ctype, share,
                error);
            this->m_type = (Type) ret.type;
            this->m_impl = ret.impl.any;
        }
        
        inline Peer(CType* ctype, int* error = 0) {
            CType ret = wfio_peer_ioshare(ctype,
                ::WFIO_IOSHARE_O_ACQUIRE,
                error);
            this->m_type = (Type) ret.type;
            this->m_impl = ret.impl.any;
        }
        
        inline Peer(CType* ctype, IOShare share, int* error = 0) {
            CType ret = wfio_peer_ioshare(ctype, share,
                error);
            this->m_type = (Type) ret.type;
            this->m_impl = ret.impl.any;
        }
        
        inline Peer(Device& device, int* error = 0) {
            ::wfio_peer_fromDevice((CType*) this,
                *((::wfio_device_t**) &device),
                error);
        }
        
        inline Peer(Device& device, IOShare share, 
            int* error = 0) {
            ::wfio_peer_fromDeviceEx((CType*) this,
                *((::wfio_device_t**) &device),
                share, error);
        }
        
        Peer(BinStream& bin, int* error = 0) {
            ::wfio_peer_fromBinstream((CType*) this,
                *((::wfio_binstream_t**) &bin),
                error);
        }
        
        Peer(BinStream& bin, IOShare share, int* error = 0) {
            ::wfio_peer_fromBinstreamEx((CType*) this,
                *((::wfio_binstream_t**) &bin),
                share, error);
        }

        inline ~Peer() {
            ::wfio_peer_close(
                reinterpret_cast<CType*>(this));
        }
        
        /* Fields */
        
        inline Type type() const throw() {
            return m_type;
        }

        /* Operations */
        
        inline size_t read(void* buf, size_t sz, size_t elem,
            int* error = 0) throw() {
            return ::wfio_peer_read(
                reinterpret_cast<CType*>(this), buf, 
                sz, elem, error);
        }

        size_t read(void* buf, size_t len, int* error) throw() {
            return read(buf, 1, len, error);
        }

        int read(int* error = 0) {
            unsigned char c;
            if (!read(&c, 1, 1, error) == WFIO_NPOS) {
                return -1;
            }
            return c;
        }
    
        size_t write(const void* buf, size_t sz, size_t elem, 
            int* error = 0) {
            return ::wfio_peer_write(
                reinterpret_cast<CType*>(this), buf, sz, 
                elem, error);
        }
        
        
        size_t write(const void* buf, size_t len, int* error = 0) {
            return write(buf, 1, len, error);
        }
        
        int write(char c, int* error = 0) {
            return write(&c, 1, 1, error) == 1;
        }
        
        /* Seek */
        
        bool seek(off_t offset, wfio_whence_t whence,
            int* error = 0) {
            return ::wfio_peer_seek((CType*) this, offset,
                whence, error) != 0;
        }
        
        bool canSeek() const throw() {
            return ::wfio_peer_canSeek((CType*) this);
        }
        
        off_t tell(int* error = 0) throw() {
            return ::wfio_peer_tell((CType*) this, error);
        }
        
        /* Buffering */
        
        bool flush(int* error = 0) {
            return ::wfio_peer_flush((CType*) this, error)
                != 0;
        }
        
        
        size_t bufsz(int* error = 0) const throw() {
            return ::wfio_peer_getbufsz((CType*) this, error);
        }
        
        size_t bufsz(size_t sz, int* error = 0) throw() {
            return ::wfio_peer_setbufsz((CType*) this, sz,
                error);
        }
        
        /* I/O Control */

        inline int vdcntl(DCntl cmd, va_list va) {
            return ::wfio_peer_vdcntl(
                reinterpret_cast<CType*>(this), 
                cmd, NULL, va);
        }
        
        inline int vdcntlEx(int* error, DCntl cmd, 
            va_list va) {
            return ::wfio_peer_vdcntl   (
                reinterpret_cast<CType*>(this), 
                cmd, error, va);
        }
        
        inline int dcntl(DCntl cmd, ...) {
            va_list va;
            register int ret;
            va_start(va, cmd);
            ret = this->vdcntl(cmd, va);
            va_end(va);
            return ret;
        }
        
        inline int dcntl(int* error, DCntl cmd, ...) {
            va_list va;
            register int ret;
            va_start(va, cmd);
            ret = this->vdcntlEx(error, cmd, va);
            va_end(va);
            return ret;
        }
        
        inline int vioctl(int cmd, va_list va) {
            return ::wfio_peer_vioctl(
                reinterpret_cast<CType*>(this), 
                cmd, NULL, va);
        }
        
        inline int vioctlEx(int* error, int cmd, 
            va_list va) {
            return ::wfio_peer_vioctl(
                reinterpret_cast<CType*>(this), 
                cmd, error, va);
        }
        
        inline int ioctl(int cmd, ...) {
            va_list va;
            register int ret;
            va_start(va, cmd);
            ret = this->vioctl(cmd, va);
            va_end(va);
            return ret;
        }
        
        inline int ioctlExt(int* error, int cmd, ...) {
            va_list va;
            register int ret;
            va_start(va, cmd);
            ret = this->vioctlEx(error, cmd, va);
            va_end(va);
            return ret;
        }
        
        /* Conversion Operations */
        
        inline operator ::wfio_peer_t*() {
            return reinterpret_cast<CType*>(this);
        }
        
        WFIO_DLL_FASTCALL Device toDevice(int* error = 0);
        
        inline operator Device() {
            return this->toDevice(NULL);
        }
        
        WFIO_DLL_FASTCALL BinStream toBinStream(int* error = 0);
        
        inline operator BinStream() {
            return this->toBinStream(NULL);
        }
    };
}
#endif

#endif