streamstring.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/iodevice.h>
#include <promeki/core/textstream.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class StreamStringIODevice : public IODevice {
        PROMEKI_OBJECT(StreamStringIODevice, IODevice)
        public:
                using OnNewLineFunc = std::function<bool(String &)>;
 
                StreamStringIODevice(ObjectBase *parent = nullptr) : IODevice(parent) { }
 
                void setOnNewLine(OnNewLineFunc func) {
                        _onNewLine = std::move(func);
                }
 
                const String &line() const { return _line; }
 
                void clearLine() {
                        _line.clear();
                }
 
                Error open(OpenMode mode) override {
                        if(isOpen()) return Error(Error::AlreadyOpen);
                        setOpenMode(mode);
                        return Error();
                }
 
                Error close() override {
                        setOpenMode(NotOpen);
                        return Error();
                }
 
                bool isOpen() const override {
                        return openMode() != NotOpen;
                }
 
                int64_t read(void *, int64_t) override {
                        return -1;
                }
 
                int64_t write(const void *data, int64_t maxSize) override {
                        if(!isOpen() || !isWritable()) return -1;
                        const char *p = static_cast<const char *>(data);
                        for(int64_t i = 0; i < maxSize; i++) {
                                if(p[i] == '\n') {
                                        flushLine();
                                } else {
                                        _line += p[i];
                                }
                        }
                        return maxSize;
                }
 
                void flush() override {
                        flushLine();
                }
 
                bool isSequential() const override { return true; }
 
        private:
                OnNewLineFunc   _onNewLine;
                String          _line;
 
                void flushLine() {
                        if(!_line.isEmpty() && _onNewLine) {
                                if(_onNewLine(_line)) _line.clear();
                        }
                }
};
 
class StreamString {
        public:
                using OnNewLineFunc = std::function<bool(String &)>;
 
                StreamString() : _stream(&_device) {
                        _device.open(IODevice::WriteOnly);
                }
 
                StreamString(OnNewLineFunc func) : _stream(&_device) {
                        _device.setOnNewLine(std::move(func));
                        _device.open(IODevice::WriteOnly);
                }
 
                StreamString(const StreamString &) = delete;
                StreamString &operator=(const StreamString &) = delete;
                StreamString(StreamString &&) = delete;
                StreamString &operator=(StreamString &&) = delete;
 
                TextStream &stream() { return _stream; }
 
                void setOnNewLine(OnNewLineFunc func) {
                        _device.setOnNewLine(std::move(func));
                        return;
                }
 
                const String &line() const { return _device.line(); }
 
                void clear() {
                        _device.clearLine();
                        return;
                }
 
        private:
                StreamStringIODevice    _device;
                TextStream              _stream;
};
 
PROMEKI_NAMESPACE_END