stream.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef UCOMMON_SYSRUNTIME
#ifndef _UCOMMON_STREAM_H_
#define _UCOMMON_STREAM_H_
 
#ifndef _UCOMMON_CONFIG_H
#include <ucommon/platform.h>
#endif
 
#ifndef _UCOMMON_PROTOCOLS_H_
#include <ucommon/protocols.h>
#endif
 
#ifndef _UCOMMON_THREAD_H_
#include <ucommon/thread.h>
#endif
 
#ifndef _UCOMMON_SOCKET_H_
#include <ucommon/socket.h>
#endif
 
#ifndef _UCOMMON_FSYS_H_
#include <ucommon/fsys.h>
#endif
 
#ifndef _UCOMMON_SHELL_H_
#include <ucommon/shell.h>
#endif
 
#include <iostream>
#include <fstream>
 
namespace ucommon {
 
class __EXPORT StreamBuffer : protected std::streambuf, public std::iostream
{
private:
    __DELETE_COPY(StreamBuffer);
 
protected:
    size_t bufsize;
    char *gbuf, *pbuf;
 
    StreamBuffer();
 
    int uflow() __OVERRIDE;
 
    void release(void);
 
    void allocate(size_t size);
 
public:
    int sync(void);
 
    inline bool is_open(void) const
        {return bufsize > 0;}
 
    inline operator bool() const
        {return bufsize > 0;}
 
    inline bool operator!() const
        {return bufsize == 0;}
};
 
class __EXPORT tcpstream : public StreamBuffer
{
private:
    __LOCAL void allocate(unsigned size);
    __LOCAL void reset(void);
 
protected:
    socket_t so;
    timeout_t timeout;
 
    virtual ssize_t _read(char *buffer, size_t size);
 
    virtual ssize_t _write(const char *buffer, size_t size);
 
    virtual bool _wait(void);
 
    void release(void);
 
    int underflow(void) __OVERRIDE;
 
    int overflow(int ch) __OVERRIDE;
 
    inline socket_t getsocket(void) const {
        return so;
    }
 
public:
    tcpstream(const tcpstream& copy);
 
    tcpstream(const TCPServer *server, unsigned segsize = 536, timeout_t timeout = 0);
 
    tcpstream(int family = PF_INET, timeout_t timeout = 0);
 
    tcpstream(Socket::address& address, unsigned segsize = 536, timeout_t timeout = 0);
 
    virtual ~tcpstream();
 
    inline operator bool() const {
        return so != INVALID_SOCKET && bufsize > 0;
    }
 
    inline bool operator!() const {
        return so == INVALID_SOCKET || bufsize == 0;
    }
 
    void open(Socket::address& address, unsigned segment = 536);
 
    void open(const char *host, const char *service, unsigned segment = 536);
 
    void close(void);
};
 
class __EXPORT pipestream : public StreamBuffer
{
public:
    typedef enum {
        RDONLY,
        WRONLY,
        RDWR
    } access_t;
 
private:
    __LOCAL void allocate(size_t size, access_t mode);
 
    __DELETE_COPY(pipestream);
 
protected:
    fsys_t rd, wr;
    shell::pid_t pid;
 
    void release(void);
 
    int underflow(void) __OVERRIDE;
 
    int overflow(int ch) __OVERRIDE;
 
public:
    pipestream();
 
    pipestream(const char *command, access_t access, char **args, char **env = NULL, size_t size = 512);
 
    virtual ~pipestream();
 
    inline operator bool() const {
        return (bufsize > 0);
    }
 
    inline bool operator!() const {
        return bufsize == 0;
    }
 
    void open(const char *path, access_t access, char **args, char **env = NULL, size_t buffering = 512);
 
    int close(void);
 
    void terminate(void);
 
    inline void cancel(void) {
        terminate();
    }
};
 
class __EXPORT filestream : public StreamBuffer
{
public:
    typedef enum {
        RDONLY,
        WRONLY,
        RDWR
    } access_t;
 
private:
    __LOCAL void allocate(size_t size, fsys::access_t mode);
 
protected:
    fsys_t fd;
    fsys::access_t ac;
 
    int underflow(void) __OVERRIDE;
 
    int overflow(int ch) __OVERRIDE;
 
public:
    filestream();
 
    filestream(const filestream& copy);
 
    filestream(const char *path, unsigned mode, fsys::access_t access, size_t bufsize = 512);
 
    filestream(const char *path, fsys::access_t access, size_t bufsize = 512);
 
    virtual ~filestream();
 
    inline operator bool() const {
        return (bufsize > 0);
    }
 
    inline bool operator!() const {
        return bufsize == 0;
    }
 
    void open(const char *filename, fsys::access_t access, size_t buffering = 512);
 
    void open(const char *filename, unsigned mode, fsys::access_t access, size_t buffering = 512);
 
    void close(void);
 
    void seek(fsys::offset_t offset);
 
    void rewind(void);
 
    inline int err(void) const
        {return fd.err();}
};
 
class __EXPORT imemstream : protected std::streambuf, public std::istream
{
private:
    __DELETE_DEFAULTS(imemstream);
 
    size_t count;
    const uint8_t *pos, *bp;
    
public:
    imemstream(const uint8_t *data, size_t size);
    imemstream(const char *data);
 
    int underflow() __OVERRIDE;
 
    int uflow() __OVERRIDE;
 
    inline size_t remains() const {
        return count;
    }
 
    inline const uint8_t *mem() const {
        return bp;
    }
 
    inline const char *chr() const {
        return (const char *)bp;
    }
 
    inline size_t len() const {
        return (size_t)(pos - bp) + count;
    }
};
 
class __EXPORT omemstream : protected std::streambuf, public std::ostream
{
private:
    __DELETE_DEFAULTS(omemstream);
 
    size_t count;
    uint8_t *pos, *bp;
    bool zb;
    
public:
    explicit omemstream(uint8_t *data, size_t size);
    omemstream(char *data, size_t size);
 
    int overflow(int ch) __OVERRIDE;
 
    inline size_t remains() const {
        return count;
    }
 
    inline uint8_t *mem() const {
        return bp;
    }
 
    inline char *chr() const {
        return (char *)bp;
    }
 
    inline size_t len() const {
        return (size_t)(pos - bp);
    }
};
 
bool __EXPORT getline(std::istream& in, char *buffer, size_t size);
 
bool __EXPORT putline(std::ostream& out, const char *buffer);
 
class __EXPORT _stream_operators
{
private:
    __DELETE_DEFAULTS(_stream_operators);
 
public:
    static std::ostream& print(std::ostream& out, const PrintProtocol& format);
 
    static std::istream& input(std::istream& inp, InputProtocol& format);
 
    static std::ostream& print(std::ostream& out, const string_t& str);
 
    static std::istream& input(std::istream& inp, string_t& str);
 
    static std::ostream& print(std::ostream& out, const stringlist_t& list);
 
    static std::istream& input(std::istream& in, stringlist_t& list);
 
    static std::string& append(std::string& target, String& source);
};
 
inline std::ostream& operator<< (std::ostream& out, const PrintProtocol& format) {
    return _stream_operators::print(out, format);
}
 
inline std::istream& operator>> (std::istream& inp, InputProtocol& format) {
    return _stream_operators::input(inp, format);
}
 
inline std::ostream& operator<< (std::ostream& out, const string_t& str) {
    return _stream_operators::print(out, str);
}
 
inline std::istream& operator>> (std::istream& inp, string_t& str) {
    return _stream_operators::input(inp, str);
}
 
inline std::ostream& operator<< (std::ostream& out, const stringlist_t& list) {
    return _stream_operators::print(out, list);
}
 
inline std::istream& operator>> (std::istream& in, stringlist_t& list) {
    return _stream_operators::input(in, list);
}
 
inline std::string& operator+(std::string& target, String& source) {
    return _stream_operators::append(target, source);
}
 
inline std::string& operator+=(std::string& target, String& source) {
    return _stream_operators::append(target, source);
}
 
inline std::ostream& operator<<(std::ostream& os, Socket::address& addr) {
#ifdef  AF_INET6
    char buf[INET6_ADDRSTRLEN];
#else
    char buf[INET_ADDRSTRLEN];
#endif
    addr.print(buf, sizeof(buf), false, true);
    os << buf;
    return os;
}
 
} // namespace ucommon
 
namespace std {
    extern __EXPORT iostream& null;
}
 
#endif
#endif