iobuf.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_IOBUF_H
#define WFIO_IOBUF_H

#include <wfio/type.h>

WFIO_C_BEGIN

typedef enum wfio_iobuf_flags_t {
    WFIO_IOBUF_FLIPPED = 0x1,
    
    WFIO_IOBUF_SHARED = 0x2,
    
    /* Synthetic flags */
    
    WFIO_IOBUF_SHARED_RD = WFIO_IOBUF_SHARED,
    
    WFIO_IOBUF_SHARED_WR = WFIO_IOBUF_SHARED | WFIO_IOBUF_FLIPPED
} wfio_iobuf_flags_t;

typedef size_t (*wfio_iobuf_source_callback_t)(void* src, void* buf, 
    size_t len, int* error);

typedef size_t (*wfio_iobuf_sink_callback_t)(void* dest, const void* buf,
    size_t len, int* error);

typedef struct wfio_iobuf_t {
    const int flags;
    
    const size_t capacity;
    
    const size_t facet;
    
    const size_t avail;
    
    const size_t start;
    const size_t end;
    
    void* const base;
} wfio_iobuf_t;

WFIO_INLINE void* wfio_iobuf_rawdata(wfio_iobuf_t* buf) {
    return buf ? (buf->base) : NULL;
}

WFIO_ALWAYS_INLINE size_t wfio_iobuf_remain(wfio_iobuf_t* buf) {
    return buf ? buf->capacity - buf->avail : 0;
}

WFIO_ALWAYS_INLINE size_t wfio_iobuf_remainElem(wfio_iobuf_t* buf,
    size_t sz) {
    return buf ? (buf->facet - buf->avail)/sz : 0;
}

WFIO_DLL int wfio_iobuf_clear(wfio_iobuf_t* buf, int* error);

WFIO_DLL wfio_iobuf_t* wfio_iobuf_alloc(size_t capacity, int* error);

WFIO_DLL wfio_iobuf_t* wfio_iobuf_allocSplit(size_t f0, size_t f1, int* error);

WFIO_DLL wfio_iobuf_t* wfio_iobuf_allocShared(size_t capacity, int* error);

WFIO_DLL int wfio_iobuf_acquire(wfio_iobuf_t* buf);

WFIO_DLL void wfio_iobuf_free(wfio_iobuf_t* buf);

WFIO_DLL int wfio_iobuf_flip(wfio_iobuf_t* buf, int* error);

WFIO_ALWAYS_INLINE int wfio_iobuf_notRead(const wfio_iobuf_t* buf) {
    return (buf->flags & WFIO_IOBUF_SHARED_WR) == WFIO_IOBUF_SHARED_WR;
}

WFIO_ALWAYS_INLINE int wfio_iobuf_notWrite(const wfio_iobuf_t* buf) {
    return (buf->flags & WFIO_IOBUF_SHARED_WR) == WFIO_IOBUF_SHARED_RD;
}

WFIO_INLINE int wfio_iobuf_ensureRead(wfio_iobuf_t* buf, int* error) {
    if (wfio_iobuf_notRead(buf)) {
        wfio_iobuf_flip(buf, error);
    }
    return 1;
}

WFIO_INLINE int wfio_iobuf_ensureWrite(wfio_iobuf_t* buf, int* error) {
    if (wfio_iobuf_notWrite(buf)) {
        wfio_iobuf_flip(buf, error);
    }
    return 1;
}

WFIO_DLL size_t wfio_iobuf_read(wfio_iobuf_t* buf, void* dest, 
    size_t sz, size_t elem, int* error);

WFIO_DLL size_t wfio_iobuf_readbV(wfio_iobuf_t* buf, void* dest, 
    size_t len, int* error);

WFIO_INLINE int wfio_iobuf_readb(wfio_iobuf_t* buf, int* error) {
    unsigned char ret = 0;
    if (wfio_iobuf_readbV(buf, &ret, 1, error) == WFIO_NPOS) {
        return -1;
    }
    return ret;
}

WFIO_DLL size_t wfio_iobuf_write(wfio_iobuf_t* buf, const void* src, 
    size_t sz, size_t elem, int* error);

WFIO_DLL size_t wfio_iobuf_writebV(wfio_iobuf_t* buf, const void* src, 
    size_t len, int* error);

WFIO_INLINE int wfio_iobuf_writeb(wfio_iobuf_t* buf, char c, int* error) {
    return wfio_iobuf_writebV(buf, &c, 1, error) != WFIO_NPOS;
}

WFIO_DLL int wfio_iobuf_forceReorganize(wfio_iobuf_t* buf, int* error);

/* Source/Sink functions */

WFIO_DLL size_t wfio_iobuf_source(wfio_iobuf_t* buf, size_t sz, size_t elem,
    void* src, wfio_iobuf_source_callback_t cb, int* error);

WFIO_DLL size_t wfio_iobuf_sourcebV(wfio_iobuf_t* buf, size_t len,
    void* src, wfio_iobuf_source_callback_t cb, int* error);

WFIO_ALWAYS_INLINE size_t wfio_iobuf_fill(wfio_iobuf_t* buf, void* dest,
    wfio_iobuf_source_callback_t cb, int* error) {
    return wfio_iobuf_sourcebV(buf, WFIO_NPOS, dest, cb, error);
}

WFIO_DLL size_t wfio_iobuf_sink(wfio_iobuf_t* buf, size_t sz, size_t elem,
    void* dest, wfio_iobuf_sink_callback_t cb, int* error);

WFIO_DLL size_t wfio_iobuf_sinkbV(wfio_iobuf_t* buf, size_t len,
    void* dest, wfio_iobuf_sink_callback_t cb, int* error);

WFIO_ALWAYS_INLINE size_t wfio_iobuf_empty(wfio_iobuf_t* buf, void* dest,
    wfio_iobuf_sink_callback_t cb, int* error) {
    return wfio_iobuf_sinkbV(buf, WFIO_NPOS, dest, cb, error);
}

WFIO_C_END

#ifdef __cplusplus
namespace wfio {
    WFIO_CXX_DLL class IOBuf {
        mutable ::wfio_iobuf_t* m_buf;
        
        public:
        
        typedef ::wfio_iobuf_t* CType;

        typedef ::wfio_iobuf_source_callback_t SourceCallback;
        
        typedef ::wfio_iobuf_sink_callback_t SinkCallback;

        /* Constructors */
    
        inline IOBuf() : m_buf(NULL) {}
    
        inline IOBuf(::wfio_iobuf_t* buf, bool acquire=true) 
            : m_buf(buf) {
            if (acquire)
                wfio_iobuf_acquire(buf);
        }
        
        inline IOBuf(const IOBuf& buf) : m_buf(buf.m_buf) {
            ::wfio_iobuf_acquire(m_buf);
        }
        
        inline IOBuf(size_t size, int* error = NULL) : 
            m_buf(::wfio_iobuf_alloc(size, error)) {
        }
        
        inline IOBuf(size_t read, size_t write, int* error = NULL) :
            m_buf(::wfio_iobuf_allocSplit(read, write, error)) 
            {}
        
        inline ~IOBuf() {
            ::wfio_iobuf_free(m_buf);
        }
        
        /* Named Constructors */
        
        static IOBuf allocShared(size_t capacity, 
            int* error = NULL) {
            return IOBuf(::wfio_iobuf_allocShared(capacity,
                error), false);
        }
        
        /* Fields */
        
        inline int flags() const throw() {
            return m_buf ? m_buf->flags : 0;
        }
        
        inline size_t capacity() const throw() {
            return m_buf ? m_buf->capacity : 0;
        }
        
        inline size_t facet() const throw() {
            return m_buf ? m_buf->facet : 0;
        }
        
        inline size_t avail() const throw() {
            return m_buf ? m_buf->avail : 0;
        }
        
        inline size_t remain() const throw() {
            return ::wfio_iobuf_remain(m_buf);
        }
        
        inline size_t remainElem(size_t sz) const throw() {
            return ::wfio_iobuf_remainElem(m_buf, sz);
        }
        
        inline size_t start() const throw() {
            return m_buf ? m_buf->start : 0;
        }
        
        inline size_t end() const throw() {
            return m_buf ? m_buf->end : 0;
        }
        
        inline void* base() throw() {
            return m_buf ? m_buf->base : 0;
        }
        
        inline const void* base() const throw() {
            return m_buf ? m_buf->base : 0;
        }
        
        /* Read/Write (Todo: bytewise versions of this)  */
        
        inline size_t read(void* dest, size_t sz, size_t elem,
            int* error = NULL) throw() {
            return ::wfio_iobuf_read(m_buf, dest, sz, elem, 
                error);
        }
        
        inline size_t readbV(void* dest, size_t len,
            int* error = NULL) throw() {
            return ::wfio_iobuf_readbV(m_buf, dest, len, 
                error);
        }
        
        inline int readb(int* error = NULL) throw() {
            unsigned char c;
            if (::wfio_iobuf_readbV(m_buf, &c, 1, error) 
                == WFIO_NPOS) {
                return -1;
            }
            return c;
        }
        
        inline size_t write(const void* src, size_t sz, 
            size_t elem, int* error = NULL) throw() {
            return ::wfio_iobuf_write(m_buf, src, sz, elem, 
                error);
        }
        
        inline size_t writebV(const void* src, size_t len, 
            int* error = NULL) throw() {
            return ::wfio_iobuf_writebV(m_buf, src, len, 
                error);
        }
        
        inline size_t writeb(char c, int* error = NULL) throw() {
            return ::wfio_iobuf_writebV(m_buf, &c, 1, 
                error);
        }
        
        /* Source/Sink */
        
        inline size_t source(size_t sz, size_t elem, 
            void* src, SourceCallback cb, 
            int* error = NULL) throw() {
            return ::wfio_iobuf_source(m_buf, sz, elem, src,
                cb, error);
        }
        
        inline size_t fill(void* src, SourceCallback cb, 
            int* error = NULL) throw() {
            return ::wfio_iobuf_fill(m_buf, src, cb, error);
        }
        
        inline size_t sink(size_t sz, size_t elem, 
            void* src, SinkCallback cb, 
            int* error = NULL) throw() {
            return ::wfio_iobuf_sink(m_buf, sz, elem, src,
                cb, error);
        }
        
        inline size_t empty(void* src, SinkCallback cb, 
            int* error = NULL) throw() {
            return ::wfio_iobuf_empty(m_buf, src, cb, error);
        }
        
        
        /* Split buffer operations */
        
        inline bool flip(int* error = NULL) throw() {
            return ::wfio_iobuf_flip(m_buf, error) != 0;
        }
        
        inline bool notRead() const throw() {
            return ::wfio_iobuf_notRead(m_buf) != 0;
        }
        
        inline bool notWrite() const throw() {
            return ::wfio_iobuf_notWrite(m_buf) != 0;
        }
        
        inline bool ensureRead(int* error = NULL) throw() {
            return ::wfio_iobuf_ensureRead(m_buf, error) != 0;
        }
        
        inline bool ensureWrite(int* error = NULL) throw() {
            return ::wfio_iobuf_ensureWrite(m_buf, error) != 0;
        }
        
        /* Other operations */
        
        inline bool forceReorganize(int* error = NULL) throw() {
            return ::wfio_iobuf_forceReorganize(m_buf, error);
        }
        
        inline int clear(int* error = NULL) throw() {
            return ::wfio_iobuf_clear(m_buf, error) != 0;
        }
        
        inline bool valid() const throw() {
            return m_buf != NULL;
        }
        
        inline operator bool () const {
            return m_buf != NULL;
        }
        
        inline operator ::wfio_iobuf_t* () {
            return m_buf;
        }
        
        WFIO_CXX_DLL IOBuf& operator=(const IOBuf& rhs);
    };
};
#endif

#endif