iotype.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_IOTYPE_H
#define WFIO_IOTYPE_H

#include <stddef.h>

WFIO_C_BEGIN


#if defined(WFIO_COMPILER_DJGPP) | defined(WFIO_OS_BEOS) | defined(WFIO_OS_HAIKU)
#include <sys/types.h>
typedef off_t wfio_off_t;
/* Todo: under what circumstances can we assume this? */
#elif defined(WFIO_COMPILER_GCC)
#include <bits/types.h>
typedef __off_t wfio_off_t;
#else 
typedef long int wfio_off_t;
#endif

typedef enum wfio_whence_t {
    WFIO_SEEK_SET,
    WFIO_SEEK_CUR,
    WFIO_SEEK_END
} wfio_whence_t;

typedef enum wfio_openflag_t {
    WFIO_OPEN_READ = 0x1,
    WFIO_OPEN_WRITE = 0x2,
    WFIO_OPEN_APPEND = 0x4,
    WFIO_OPEN_CREATE = 0x8,
    WFIO_OPEN_TRUNCATE = 0x10,
    WFIO_OPEN_NONBLOCK = 0x30,
    WFIO_OPEN_NOTEXIST = 0x40,
    
    /* Synthetic flags */
    WFIO_OPEN_EXCL = WFIO_OPEN_NOTEXIST,
    
    WFIO_OPEN_RW = WFIO_OPEN_READ | WFIO_OPEN_WRITE
} wfio_openflag_t;

typedef int wfio_openmode_t;

typedef int wfio_fd_t;
enum {
    WFIO_BAD_FD = -1
};

/* Bounded types */

struct wfio_device_t;

struct wfio_iobuf_t;

struct wfio_binstream_t;

typedef enum wfio_peer_type_t {
    WFIO_PEER_UNKNOWN,
    WFIO_PEER_DEVICE,
    WFIO_PEER_BINSTREAM
} wfio_peer_type_t;

struct wfio_peer_t;

enum {
    WFIO_IOSHARE_O_WEAK = 0x0,
    
    WFIO_IOSHARE_O_ACQUIRE = 0x1,
    
    WFIO_IOSHARE_O_DUP = 0x2,
    
    /* Masks */
    
    WFIO_IOSHARE_M_OWNERSHIP = 0x3
};

typedef int wfio_ioshare_t;

typedef enum {
    WFIO_DCNTL_NOP,
    
    WFIO_DCNTL_GETFD,
    
    WFIO_DCNTL_SETFLAGS,
    
    WFIO_DCNTL_GETFLAGS,
    
    WFIO_DCNTL_TRUNCATE
} wfio_dcntl_t;

enum {
    WFIO_NPOS = (size_t) -1,
};

WFIO_C_END

#ifdef __cplusplus
namespace wfio {
    typedef ::wfio_off_t off_t;
    
    typedef ::wfio_fd_t fd_t;

    class Device;
    
    class IOBuf;

    class Peer;
    
    enum {
        NPOS = ::WFIO_NPOS
    };

    struct IOShare {
        typedef ::wfio_ioshare_t CType;
    
        enum {
            O_WEAK = ::WFIO_IOSHARE_O_WEAK,
            O_ACQUIRE = ::WFIO_IOSHARE_O_ACQUIRE,
            O_DUP = ::WFIO_IOSHARE_O_DUP,
            
            /* Flags */
            
            M_OWNERSHIP = ::WFIO_IOSHARE_M_OWNERSHIP
        };
        
        enum Ownership {
            WEAK = ::WFIO_IOSHARE_O_WEAK,
            ACQUIRE = ::WFIO_IOSHARE_O_ACQUIRE,
            DUP = ::WFIO_IOSHARE_O_WEAK
        };
        
        int value;
        
        IOShare() throw() : value(0) {}
        
        IOShare(int value) throw() : value(value) {}
        
        /* Flags */
        
        Ownership ownership() const throw() {
            return static_cast<Ownership>(value & M_OWNERSHIP);
        }
        
        void ownership(Ownership ownership) throw() {
            value &= ~M_OWNERSHIP;
            value |= ownership;
        }
        
        /* Conversion */
        
        inline operator int() const throw() {
            return value;
        }
    };

    struct DCntl {
        
        enum Value {
            DCNTL_NOP,
            DCNTL_GETFD,
            DCNTL_SETFD,
            DCNTL_GETFLAGS,
            DCNTL_TRUNCATE
        };
        
        Value value;
        
        typedef ::wfio_dcntl_t CType;
        
        inline DCntl() throw() : value(DCNTL_GETFD) {}
        
        inline DCntl(Value value) throw() : value(value) {}
        
        inline DCntl(CType value) throw() : 
            value(static_cast<Value>(value)) {}
        
        inline bool operator == (DCntl rhs) const throw() {
            return value == rhs.value;
        }
        
        inline bool operator != (DCntl rhs) const throw() {
            return value != rhs.value;
        }
        
        inline operator CType() const throw() {
            return static_cast<CType>(value);
        }
    };
}

#endif

#endif