streamstring.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/iodevice.h>
#include <promeki/textstream.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class StreamStringIODevice : public IODevice {
                PROMEKI_OBJECT(StreamStringIODevice, IODevice)
        public:
                using OnNewLineFunc = 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 = 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
 
#endif // PROMEKI_ENABLE_CORE