bin.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_BIN_H
#define WFIO_BIN_H

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

WFIO_C_BEGIN

typedef struct wfio_binstream_t {
    wfio_endian_t endian;
    wfio_endian_t floatEndian;
    int ecode;
    const size_t refcount;
} wfio_binstream_t;
 
/* Creation and destruction */

#if 0

WFIO_DLL wfio_binstream_t* wfio_binstream_createEx(
    struct wfio_peer_t peer, wfio_endian_t endian, int* error);

WFIO_ALWAYS_INLINE wfio_binstream_t* wfio_binstream_create(
    struct wfio_peer_t peer, int* error) {
    return wfio_binstream_fromPeerEx(peer, WFIO_ENDIAN_HOST, error);
}
#endif

WFIO_DLL wfio_binstream_t* wfio_binstream_fromDeviceEx(
    struct wfio_device_t* device, wfio_endian_t endian, int* error);

WFIO_ALWAYS_INLINE wfio_binstream_t* wfio_binstream_fromDevice(
    struct wfio_device_t* device, int* error) {
    return wfio_binstream_fromDeviceEx(device, WFIO_ENDIAN_HOST, 
        error);
}

WFIO_DLL_FASTCALL wfio_binstream_t* wfio_binstream_ioshare(
    wfio_binstream_t* bin, int ioshare);

WFIO_DLL int wfio_binstream_acquire(wfio_binstream_t* bin);

WFIO_DLL void wfio_binstream_close(wfio_binstream_t* bin);

WFIO_DLL struct wfio_device_t* wfio_binstream_toDevice(
    wfio_binstream_t* bin);

WFIO_DLL_FASTCALL int wfio_binstream_flush(wfio_binstream_t* bin);

WFIO_DLL int wfio_binstream_seek(wfio_binstream_t* bin,
    wfio_off_t offset, wfio_whence_t whence);

WFIO_DLL_FASTCALL int wfio_binstream_canSeek(wfio_binstream_t* bin);

WFIO_DLL_FASTCALL wfio_off_t wfio_binstream_tell(wfio_binstream_t* bin);



WFIO_DLL int wfio_binstream_vdcntl(wfio_binstream_t* bin, 
    wfio_dcntl_t cmd, va_list va);

WFIO_ALWAYS_INLINE int wfio_binstream_dcntl(wfio_binstream_t* bin,
    wfio_dcntl_t cmd, ...) {
    register int ret;
    va_list va;
    va_start(va, cmd);
    ret = wfio_binstream_dcntl(bin, cmd, va);
    va_end(va);
    return ret;
}

WFIO_DLL int wfio_binstream_vioctl(wfio_binstream_t* bin, 
    int cmd, va_list va);

WFIO_ALWAYS_INLINE int wfio_binstream_ioctl(wfio_binstream_t* bin,
    int cmd, ...) {
    register int ret;
    va_list va;
    va_start(va, cmd);
    ret = wfio_binstream_ioctl(bin, cmd, va);
    va_end(va);
    return ret;
}

WFIO_DLL_FASTCALL size_t wfio_binstream_getbufsz(wfio_binstream_t* bin);

WFIO_DLL_FASTCALL size_t wfio_binstream_setbufsz(wfio_binstream_t* bin,
    size_t sz);

/* Basic operations */

WFIO_DLL size_t wfio_binstream_read(wfio_binstream_t* bin, void* buf,
    size_t sz, size_t elem);

WFIO_ALWAYS_INLINE size_t wfio_binstream_readbV(wfio_binstream_t* bin,
    void* buf, size_t len) {
    return wfio_binstream_read(bin, buf, 1, len);
}

WFIO_ALWAYS_INLINE int wfio_binstream_readb(wfio_binstream_t* bin) {
    unsigned char ret;
    if (wfio_binstream_read(bin, &ret, 1, 1) != -1)
        return ret;
    else
        return -1;
}

WFIO_DLL size_t wfio_binstream_write(struct wfio_binstream_t* bin,
    const void* buf, size_t sz, size_t elem);

WFIO_ALWAYS_INLINE size_t wfio_binstream_writebV(wfio_binstream_t* bin,
    const void* buf, size_t len) {
    return wfio_binstream_write(bin, buf, 1, len);
}

WFIO_ALWAYS_INLINE int wfio_binstream_writeb(wfio_binstream_t* bin,
    char c) {
    return wfio_binstream_write(bin, &c, 1, 1) == 1;
}

/* Integer Operations */

WFIO_DLL size_t wfio_binstream_readSI16V(wfio_binstream_t* bin,
    wfio_sint16_t* buf, size_t len);

WFIO_DLL size_t wfio_binstream_writeSI16V(wfio_binstream_t* bin,
    const wfio_sint16_t* buf, size_t len);

WFIO_ALWAYS_INLINE int wfio_binstream_writeSI16(wfio_binstream_t* bin, 
    wfio_sint16_t si16) {
    return wfio_binstream_writeSI16V(bin, &si16, 1) ? 1 : WFIO_NPOS; 
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_readUI16V(wfio_binstream_t* bin,
    wfio_uint16_t* buf, size_t len) {
    return wfio_binstream_readSI16V(bin, (wfio_sint16_t*) buf, len);
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_writeUI16V(wfio_binstream_t* bin,
    const wfio_uint16_t* buf, size_t len) {
    return wfio_binstream_writeSI16V(bin, (const wfio_sint16_t*) buf,
        len);
}

WFIO_ALWAYS_INLINE int wfio_binstream_writeUI16(wfio_binstream_t* bin, 
    wfio_uint16_t ui16) {
    return wfio_binstream_writeSI16(bin, (wfio_sint16_t) ui16);
}

WFIO_DLL size_t wfio_binstream_readSI32V(wfio_binstream_t* bin,
    wfio_sint32_t* buf, size_t len);

WFIO_DLL size_t wfio_binstream_writeSI32V(wfio_binstream_t* bin,
    const wfio_sint32_t* buf, size_t len);

WFIO_ALWAYS_INLINE int wfio_binstream_writeSI32(wfio_binstream_t* bin, 
    wfio_sint32_t si32) {
    return wfio_binstream_writeSI32V(bin, &si32, 1) ? 1 : WFIO_NPOS; 
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_readUI32V(wfio_binstream_t* bin,
    wfio_uint32_t* buf, size_t len) {
    return wfio_binstream_readSI32V(bin, (wfio_sint32_t*) buf, len);
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_writeUI32V(wfio_binstream_t* bin,
    const wfio_uint32_t* buf, size_t len) {
    return wfio_binstream_writeSI32V(bin, (const wfio_sint32_t*) buf,
        len);
}

WFIO_ALWAYS_INLINE int wfio_binstream_writeUI32(wfio_binstream_t* bin, 
    wfio_uint32_t ui32) {
    return wfio_binstream_writeSI32(bin, (wfio_sint32_t) ui32);
}

WFIO_DLL size_t wfio_binstream_readSI64V(wfio_binstream_t* bin,
    wfio_sint64_t* buf, size_t len);

WFIO_DLL size_t wfio_binstream_writeSI64V(wfio_binstream_t* bin,
    const wfio_sint64_t* buf, size_t len);

WFIO_ALWAYS_INLINE int wfio_binstream_writeSI64(wfio_binstream_t* bin, 
    wfio_sint64_t si64) {
    return wfio_binstream_writeSI64V(bin, &si64, 1) ? 1 : WFIO_NPOS; 
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_readUI64V(wfio_binstream_t* bin,
    wfio_uint64_t* buf, size_t len) {
    return wfio_binstream_readSI64V(bin, (wfio_sint64_t*) buf, len);
}

WFIO_ALWAYS_INLINE size_t wfio_binstream_writeUI64V(wfio_binstream_t* bin,
    const wfio_uint64_t* buf, size_t len) {
    return wfio_binstream_writeSI64V(bin, (const wfio_sint64_t*) buf,
        len);
}

WFIO_ALWAYS_INLINE int wfio_binstream_writeUI64(wfio_binstream_t* bin, 
    wfio_uint64_t ui64) {
    return wfio_binstream_writeSI64(bin, (wfio_sint64_t) ui64);
}

/* IEEE 754 Operations */

WFIO_DLL size_t wfio_binstream_readB32V(wfio_binstream_t* bin,
    wfio_flt32_t* buf, size_t len);

WFIO_DLL size_t wfio_binstream_writeB32V(wfio_binstream_t* bin,
    const wfio_flt32_t* buf, size_t len);

WFIO_ALWAYS_INLINE int wfio_binstream_writeB32(wfio_binstream_t* bin,
    wfio_flt32_t f32) {
    return wfio_binstream_writeB32V(bin, &f32, 1) != 0;
}

WFIO_DLL size_t wfio_binstream_readB64V(wfio_binstream_t* bin,
    wfio_flt64_t* buf, size_t len);

WFIO_DLL size_t wfio_binstream_writeB64V(wfio_binstream_t* bin,
    const wfio_flt64_t* buf, size_t len);

WFIO_ALWAYS_INLINE int wfio_binstream_writeB64(wfio_binstream_t* bin,
    wfio_flt64_t f64) {
    return wfio_binstream_writeB64V(bin, &f64, 1) != 0;
}

WFIO_C_END

#ifdef __cplusplus
namespace wfio {
    class BinStream {
        ::wfio_binstream_t* m_bin;

        public:

        typedef ::wfio_binstream_t CType;

        /* Constructors and Destructors */

        inline BinStream() : m_bin(NULL) {}

        inline BinStream(::wfio_binstream_t* bin, 
            bool acquire = true) : m_bin(bin) {
            if (acquire)
                ::wfio_binstream_acquire(m_bin);
        }

        inline BinStream(const BinStream& bin) : 
            m_bin(bin.m_bin) {
            ::wfio_binstream_acquire(m_bin);
        }
        
        inline BinStream(Device& dev, int* error = NULL) :
            m_bin(::wfio_binstream_fromDevice(dev, error)) {}
        

        inline ~BinStream() {
            ::wfio_binstream_close(m_bin);
        }
        
        /* Properties */
        
        endian_t endian() const throw() {
            return m_bin->endian;
        }
        
        void endian(endian_t endian) {
            if (m_bin)
                m_bin->endian = endian;
        }
        
        endian_t floatEndian() const throw() {
            return m_bin->floatEndian;
        }
        
        void floatEndian(endian_t endian) {
            if (m_bin)
                m_bin->floatEndian = endian;
        }
        
        /* I/O - bytewise */
        
        inline size_t read(void* buf, size_t sz, size_t elem) {
            return ::wfio_binstream_read(m_bin, buf, sz,  elem);
        }
        
        inline size_t read(void* buf, size_t len) {
            return ::wfio_binstream_readbV(m_bin, buf, len);
        }
        
        inline int read() {
            return ::wfio_binstream_readb(m_bin) != -1;
        }

        inline size_t write(const void* buf, size_t sz, 
            size_t elem) {
            return ::wfio_binstream_write(m_bin, buf, sz, 
                elem);
        }
        
        inline size_t write(const void* buf, size_t len) {
            return ::wfio_binstream_writebV(m_bin, buf, len);
        }
        
        inline bool write(char c) {
            return ::wfio_binstream_writeb(m_bin, c) != 0;
        }

        /* Integer Operations */

        inline size_t readSI16V(sint16_t* buf, size_t len) {
            return ::wfio_binstream_readSI16V(m_bin, buf, len);
        }

        inline size_t writeSI16V(const sint16_t* buf, size_t len) {
            return ::wfio_binstream_writeSI16V(m_bin, buf, len);
        }

        inline bool writeSI16(wfio_sint16_t si16) {
            return ::wfio_binstream_writeSI16(m_bin, si16) != 0; 
        }

        inline size_t readUI16V(uint16_t* buf, size_t len) {
            return ::wfio_binstream_readUI16V(m_bin, buf, len);
        }

        inline size_t writeUI16V(const uint16_t* buf, size_t len) {
            return ::wfio_binstream_writeUI16V(m_bin, buf, len);
        }

        inline bool writeUI16(uint16_t ui16) {
            return ::wfio_binstream_writeUI16(m_bin, ui16);
        }

        inline size_t readSI32V(sint32_t* buf, size_t len) {
            return ::wfio_binstream_readSI32V(m_bin, buf, len);
        }

        inline size_t writeSI32V(const sint32_t* buf, size_t len) {
            return ::wfio_binstream_writeSI32V(m_bin, buf, len);
        }

        inline bool writeSI32(sint32_t si32) {
            return ::wfio_binstream_writeSI32(m_bin, si32) != 0;
        }

        inline size_t readUI32V(uint32_t* buf, size_t len) {
            return ::wfio_binstream_readUI32V(m_bin, buf, len);
        }

        inline size_t writeUI32V(const uint32_t* buf, size_t len) {
            return ::wfio_binstream_writeUI32V(m_bin, buf, len);
        }

        inline bool writeUI32(uint32_t ui32) {
            return ::wfio_binstream_writeUI32(m_bin, ui32) != 0;
        }

        inline size_t readSI64V(sint64_t* buf, size_t len) {
            return ::wfio_binstream_readSI64V(m_bin, buf, len);
        }

        inline size_t writeSI64V(const sint64_t* buf, size_t len) {
            return ::wfio_binstream_writeSI64V(m_bin,
                buf, len);
        }

        inline bool writeSI64(sint64_t si64) {
            return ::wfio_binstream_writeSI64(m_bin, si64) != 0;
        }

        inline size_t readUI64V(uint64_t* buf, size_t len) {
            return ::wfio_binstream_readUI64V(m_bin, buf, len);
        }

        inline size_t writeUI64V(const uint64_t* buf, size_t len) {
            return ::wfio_binstream_writeUI64V(m_bin, 
                buf, len);
        }

        inline bool writeUI64(uint64_t ui64) {
            return ::wfio_binstream_writeUI64(m_bin,
                ui64) != 0;
        }
        
        /* IEEE 754 */
        
        inline size_t readB32V(wfio_flt32_t* buf, size_t len) {
            return ::wfio_binstream_readB32V(m_bin, buf, len);
        }

        inline size_t writeB32V(const wfio_flt32_t* buf, 
            size_t len) {
            return ::wfio_binstream_writeB32V(m_bin, buf, len);
        }

        inline bool writeB32(wfio_flt32_t f32) {
            return ::wfio_binstream_writeB32(m_bin, f32) != 0;
        }
        
        inline size_t readB64V(wfio_flt64_t* buf, size_t len) {
            return ::wfio_binstream_readB64V(m_bin, buf, len);
        }

        inline size_t writeB64V(const wfio_flt64_t* buf, 
            size_t len) {
            return ::wfio_binstream_writeB64V(m_bin, buf, len);
        }

        inline bool writeB64(wfio_flt64_t f64) {
            return ::wfio_binstream_writeB64(m_bin, f64) != 0;
        }
        
        /* Buffering */
        
        bool flush() {
            return ::wfio_binstream_flush(m_bin) != 0;
        }
        
        size_t bufSz() const {
            return ::wfio_binstream_getbufsz(m_bin);
        }
        
        size_t bufSz(size_t sz) {
            return ::wfio_binstream_setbufsz(m_bin, sz);
        }
        
        /* Ioctl */
        
        inline int vdcntl(wfio_dcntl_t cmd, va_list va) {
            return ::wfio_binstream_vdcntl(m_bin, cmd, va);
        }

        inline int dcntl(wfio_dcntl_t cmd, ...) {
            register int ret;
            va_list va;
            va_start(va, cmd);
            ret = ::wfio_binstream_vdcntl(m_bin, cmd, va);
            va_end(va);
            return ret;
        }

        inline int vioctl(int cmd, va_list va) {
            return ::wfio_binstream_vioctl(m_bin, cmd, va);
        }

        inline int ioctl(wfio_binstream_t* bin,
            int cmd, ...) {
            register int ret;
            va_list va;
            va_start(va, cmd);
            ret = ::wfio_binstream_vioctl(m_bin, cmd, va);
            va_end(va);
            return ret;
        }
        
        /* Other */
        
        int ecode() const throw() {
            return m_bin ? m_bin->ecode : 1;
        }
        
        void ecode(int ecode) throw() {
            if (m_bin)
                m_bin->ecode = ecode;
        }
        
        inline bool valid() const throw() {
            return m_bin != NULL;
        }
        
        inline operator bool() const throw() {
            return m_bin != NULL;
        }
        
        inline operator ::wfio_binstream_t*() throw() {
            return m_bin;
        }
    };
}
#endif

#endif