device.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_DEVICE_H
#define WFIO_DEVICE_H

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

WFIO_C_BEGIN

typedef struct wfio_device_vtable_t {
    void (*close)(struct wfio_device_t* dev);
    
    size_t (*read)(struct wfio_device_t* dev, void* buf, size_t sz, 
        size_t elem);
    
    size_t (*write)(struct wfio_device_t* dev, const void* buf, 
        size_t sz, size_t elem);
    
    int (*seek)(struct wfio_device_t* dev, wfio_off_t offset, 
        wfio_whence_t whence);
    
    wfio_off_t (*tell)(struct wfio_device_t* dev);
    
    struct wfio_device_t* (*dup)(struct wfio_device_t* dev);
    
    int (*flush)(struct wfio_device_t* dev);
    
    size_t (*setbufsz)(struct wfio_device_t* dev, size_t len);
     
    size_t (*getbufsz)(struct wfio_device_t* dev);
    
    int (*dcntl)(struct wfio_device_t* dev, int cmd, va_list args);
    
    int (*ioctl)(struct wfio_device_t* dev, int cmd, va_list args);
} wfio_device_vtable_t;

typedef enum wfio_device_flag_t {
    WFIO_DEVICE_CLASSIFIED = 0x1,
    
    WFIO_DEVICE_READABLE = 0x2,
    WFIO_DEVICE_WRITABLE = 0x4,
    WFIO_DEVICE_SEEKABLE = 0x8,
    
    WFIO_DEVICE_NONBLOCK = 0x10,
    
    WFIO_DEVICE_RESERVED = 0x800,
    
    WFIO_DEVICE_USRBASE = 0x1000,
    
    /* Convenience Flags */
    
    WFIO_DEVICE_READWRITE = WFIO_DEVICE_READABLE | 
        WFIO_DEVICE_WRITABLE
} wfio_device_flag_t;

typedef struct wfio_device_t {
    const struct wfio_device_vtable_t* vtable;
    
    size_t refcount;
    
    int flags;
    
    int ecode;
    
    union {
        signed int sint;
        unsigned int uint;
        wfio_fd_t fd;
        struct wfio_iobuf_t* iobuf;
        struct wfio_device_t* slave;
        struct wfio_binstream_t* bin;
        void* other;
        
        /* Buffered versions */
        
        struct {
            signed int sint;
            struct wfio_iobuf_t* buf;
        } b_sint;
        
        struct {
            unsigned int uint;
            struct wfio_iobuf_t* buf;
        } b_uint;
        
        struct {
            wfio_fd_t fd;
            struct wfio_iobuf_t* buf;
        } b_fd;
    } impl;
} wfio_device_t;

WFIO_DLL wfio_device_t* wfio_device_from_voidp(
    const wfio_device_vtable_t* vtable, void* data, int* error);

WFIO_DLL wfio_device_t* wfio_device_from_int(
    const wfio_device_vtable_t* vtable, int data, int* error);

WFIO_DLL_FASTCALL wfio_device_t* wfio_device_ioshare(wfio_device_t* dev, 
    int ioshare);

WFIO_ALWAYS_INLINE int wfio_device_acquire(wfio_device_t* dev) {
    return wfio_device_ioshare(dev, WFIO_IOSHARE_O_ACQUIRE) != NULL;
}

WFIO_DLL void wfio_device_close(wfio_device_t* dev);

WFIO_DLL int wfio_device_forceClassify(wfio_device_t* dev);

WFIO_INLINE int wfio_device_classify(wfio_device_t* dev) {
    if (!dev) {
        return 0;
    }
    else if (!dev->flags)
        return wfio_device_forceClassify(dev);
    else
        return 1;
}

WFIO_INLINE size_t wfio_device_read(wfio_device_t* dev, void* buf,
    size_t sz, size_t elem) {
    if (dev)
        return dev->vtable->read(dev, buf, sz, elem);
    return WFIO_NPOS;
}

WFIO_INLINE size_t wfio_device_readbV(wfio_device_t* dev, void* buf,
    size_t len) {
    if (dev)
        return dev->vtable->read(dev, buf, 1, len);
    return WFIO_NPOS;
}

WFIO_INLINE int wfio_device_readb(wfio_device_t* dev) {
    unsigned char ret;
    if (wfio_device_read(dev, &ret, 1, 1) != -1)
        return ret;
    else
        return -1;
}

WFIO_INLINE size_t wfio_device_write(wfio_device_t* dev, const void* buf,
    size_t sz, size_t elem) {
    if (dev)
        return dev->vtable->write(dev, buf, sz, elem);
    return WFIO_NPOS;
}

WFIO_INLINE size_t wfio_device_writebV(wfio_device_t* dev, 
    const void* buf, size_t len) {
    if (dev)
        return dev->vtable->write(dev, buf, 1, len);
    return WFIO_NPOS;
}

WFIO_INLINE size_t wfio_device_writeb(wfio_device_t* dev, 
    char c) {
    return wfio_device_write(dev, &c, 1, 1) == 1;
}

WFIO_INLINE int wfio_device_seek(wfio_device_t* dev, wfio_off_t offset,
    wfio_whence_t whence) {
    if (dev)
        return dev->vtable->seek(dev, offset, whence);
    return -1;
}

WFIO_INLINE int wfio_device_canSeek(wfio_device_t* dev) {
    if (!dev) {
        return 0;
    }
    else if (!dev->flags)
        wfio_device_forceClassify(dev);
    return dev->flags & WFIO_DEVICE_SEEKABLE;
}

WFIO_INLINE wfio_off_t wfio_device_tell(wfio_device_t* dev) {
    if (dev)
        return dev->vtable->tell(dev);
    return -1;
}

WFIO_INLINE wfio_device_t* wfio_device_dup(wfio_device_t* dev) {
    if (dev)
        return dev->vtable->dup(dev);
    return 0;
}

WFIO_INLINE size_t wfio_device_setbufsz(wfio_device_t* dev, 
    size_t sz) {
    if (dev)
        return dev->vtable->setbufsz(dev, sz);
    return WFIO_NPOS;
}

WFIO_INLINE size_t wfio_device_getbufsz(wfio_device_t* dev) {
    if (dev)
        return dev->vtable->getbufsz(dev);
    return WFIO_NPOS;
}

WFIO_ALWAYS_INLINE int wfio_device_isBuffered(wfio_device_t* dev) {
    return wfio_device_getbufsz(dev) != 0;
}

WFIO_INLINE int wfio_device_flush(wfio_device_t* dev) {
    if (dev)
        return dev->vtable->flush(dev);
    return 0;
}

WFIO_DLL int wfio_device_vdcntl(wfio_device_t* dev, 
    wfio_dcntl_t cmd, va_list va);

WFIO_INLINE int wfio_device_dcntl(wfio_device_t* dev, 
    wfio_dcntl_t cmd, ...) {
    register int ret;
    va_list va;
    va_start(va, cmd);
    ret = wfio_device_vdcntl(dev, cmd, va);
    va_end(va);
    return ret;
}

WFIO_DLL int wfio_device_vioctl(wfio_device_t* dev, int cmd,
    va_list va);

WFIO_INLINE int wfio_device_ioctl(wfio_device_t* dev,
    int cmd, ...) {
    register int ret;
    va_list va;
    va_start(va, cmd);
    ret = wfio_device_vioctl(dev, cmd, va);
    va_end(va);
    return ret;
}

WFIO_DLL int wfio_device_sink(wfio_device_t* src, wfio_device_t* dest,
    size_t* copied);

WFIO_DLL_FASTCALL size_t wfio_device_readbuf(wfio_device_t* dev,
    struct wfio_iobuf_t* buf);

WFIO_DLL_FASTCALL size_t wfio_device_writebuf(wfio_device_t* dev,
    struct wfio_iobuf_t* buf);

/* dcntl Functions */

WFIO_ALWAYS_INLINE wfio_fd_t wfio_device_getfd(wfio_device_t* dev) {
    return wfio_device_dcntl(dev, WFIO_DCNTL_GETFD);
}

WFIO_ALWAYS_INLINE int wfio_device_setflags(wfio_device_t* dev, 
    int flags) {
    return wfio_device_dcntl(dev, WFIO_DCNTL_SETFLAGS, flags);
}

WFIO_ALWAYS_INLINE int wfio_device_getflags(wfio_device_t* dev) {
    return wfio_device_dcntl(dev, WFIO_DCNTL_GETFLAGS);
}

WFIO_ALWAYS_INLINE int wfio_device_truncate(wfio_device_t* dev, 
    size_t len) {
    return wfio_device_dcntl(dev, WFIO_DCNTL_TRUNCATE, len);
}

WFIO_C_END

#ifdef __cplusplus
namespace wfio {
    WFIO_CXX_DLL class Device {
        mutable ::wfio_device_t* m_dev;
        
        public:
        
        typedef ::wfio_device_t* CType;

        class CXXStrategy {
            public:
            
            virtual size_t read(CType dev, void* buf, 
                size_t sz, size_t elem) = 0;
            
            virtual size_t write(CType dev, const void* buf, 
                size_t sz, size_t elem) = 0;
            
            virtual int seek(CType dev, off_t offset, 
                wfio_whence_t whence) = 0;
    
            
            virtual off_t tell(CType dev) = 0;  
    
            
            virtual int flush(CType dev) = 0;
    
            
            virtual size_t setbufsz(CType dev, size_t len) = 0;
     
            
            virtual size_t getbufsz(CType dev) const = 0;
    
            
            virtual int dcntl(CType dev, int cmd, 
                va_list args) = 0;
    
            
            virtual int ioctl(CType dev, int cmd, 
                va_list args) = 0;

            virtual ~CXXStrategy();
        };
        
        inline Device() : m_dev(NULL) {}
        
        inline Device(CType dev, bool acquire=true) 
            : m_dev(dev) {
            if (acquire)
                ::wfio_device_acquire(dev);
        }
        
        inline Device(CType dev, IOShare ioshare) :
            m_dev(::wfio_device_ioshare(dev, ioshare)) {}
        
        WFIO_CXX_DLL Device(CXXStrategy* strategy);
        
        inline Device(const Device& dev) : m_dev(dev.m_dev) {
            ::wfio_device_acquire(m_dev);
        }
        
        inline ~Device() {
            ::wfio_device_close(m_dev);
        }
        
        /* Read */
        
        
        inline size_t read(void* buf, size_t sz, size_t elem) {
            return ::wfio_device_read(m_dev, buf, sz, elem);
        }
        
        inline size_t read(void* buf, size_t len) {
            return ::wfio_device_read(m_dev, buf, 1, len);
        }
        
        inline int read() {
            return ::wfio_device_readb(m_dev);
        }
        
        /* Write */
        
        inline size_t write(const void* buf, size_t sz, 
            size_t elem) {
            return ::wfio_device_write(m_dev, buf, sz, elem);
        }
        
        inline size_t write(const void* buf, size_t len) {
            return ::wfio_device_write(m_dev, buf, 1, len);
        }
        
        inline bool write(char c) {
            return ::wfio_device_writeb(m_dev, c) == 1;
        }
        
        /* Seek */
        
        inline bool seek(wfio_off_t offset, wfio_whence_t whence) {
            return ::wfio_device_seek(m_dev, offset, whence);
        }
        
        inline wfio_off_t tell() const {
            return ::wfio_device_tell(m_dev);
        }
        
        /* Dup */
        
        inline Device dup() {
            return Device(::wfio_device_dup(m_dev), false);
        }
        
        /* Buffering */
        
        inline bool flush() {
            return ::wfio_device_flush(m_dev);
        }
        
        inline size_t bufsz(size_t len) {
            return ::wfio_device_setbufsz(m_dev, len);
        }
        
        inline size_t bufsz() const {
            return ::wfio_device_getbufsz(m_dev);
        }
        
        inline bool buffered() const {
            return bufsz() == 0;
        }
        
        /* dcntl */
        
        inline int dcntl(::wfio_dcntl_t cmd, ...) {
            register int ret;
            va_list va;
            va_start(va, cmd);
            ret = ::wfio_device_dcntl(m_dev, cmd, va);
            va_end(va);
            return ret;
        }
        
        /* ioctl */
        
        inline int ioctl(int cmd, ...) {
            register int ret;
            va_list va;
            va_start(va, cmd);
            ret = ::wfio_device_ioctl(m_dev, cmd, va);
            va_end(va);
            return ret;
        }
        
        /* Other */
        
        inline int flags() const throw() {
            return m_dev->flags;
        }
        
        inline int ecode() const throw() {
            return m_dev->ecode;
        }
        
        inline void ecode(int ecode) throw() {
            if (m_dev)
                m_dev->ecode = ecode;
        }
        
        inline bool valid() const throw() {
            return m_dev != NULL;
        }
        
        inline operator bool() const throw() {
            return m_dev != 0;
        }
        
        inline operator ::wfio_device_t*() throw() {
            return m_dev;
        }
        
        WFIO_CXX_DLL Device& operator=(const Device& rhs);
    };
};
#endif
    
#endif