textstream.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstdio>
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/iodevice.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class Buffer;
class Variant;
 
class TextStream {
        public:
                enum Status {
                        Ok,          
                        ReadPastEnd, 
                        WriteFailed  
                };
 
                enum FieldAlignment {
                        Left,  
                        Right, 
                        Center 
                };
 
                enum RealNumberNotation {
                        SmartNotation, 
                        Fixed,         
                        Scientific     
                };
 
                explicit TextStream(IODevice *device);
 
                explicit TextStream(Buffer *buffer);
 
                explicit TextStream(String *string);
 
                explicit TextStream(FILE *file);
 
                ~TextStream();
 
                // ============================================================
                // Status
                // ============================================================
 
                Status status() const { return _status; }
 
                void resetStatus() { _status = Ok; }
 
                bool atEnd() const;
 
                void flush();
 
                IODevice *device() const { return _device; }
 
                // ============================================================
                // Encoding
                // ============================================================
 
                void setEncoding(const String &encoding);
 
                String encoding() const { return _encoding; }
 
                // ============================================================
                // Formatting controls
                // ============================================================
 
                void setFieldWidth(int width) { _fieldWidth = width; }
 
                int fieldWidth() const { return _fieldWidth; }
 
                void setFieldAlignment(FieldAlignment align) { _fieldAlignment = align; }
 
                FieldAlignment fieldAlignment() const { return _fieldAlignment; }
 
                void setPadChar(char c) { _padChar = c; }
 
                char padChar() const { return _padChar; }
 
                void setIntegerBase(int base) { _integerBase = base; }
 
                int integerBase() const { return _integerBase; }
 
                void setRealNumberPrecision(int precision) { _realNumberPrecision = precision; }
 
                int realNumberPrecision() const { return _realNumberPrecision; }
 
                void setRealNumberNotation(RealNumberNotation notation) { _realNumberNotation = notation; }
 
                RealNumberNotation realNumberNotation() const { return _realNumberNotation; }
 
                // ============================================================
                // Write operators
                // ============================================================
 
                TextStream &operator<<(const String &val);
                TextStream &operator<<(const char *val);
                TextStream &operator<<(char val);
                TextStream &operator<<(int val);
                TextStream &operator<<(unsigned int val);
                TextStream &operator<<(int64_t val);
                TextStream &operator<<(uint64_t val);
                TextStream &operator<<(float val);
                TextStream &operator<<(double val);
                TextStream &operator<<(bool val);
                TextStream &operator<<(const Variant &val);
 
                TextStream &operator<<(TextStream &(*manip)(TextStream &));
 
                // ============================================================
                // Read operators
                // ============================================================
 
                TextStream &operator>>(String &val);
                TextStream &operator>>(char &val);
                TextStream &operator>>(int &val);
                TextStream &operator>>(int64_t &val);
                TextStream &operator>>(double &val);
 
                // ============================================================
                // Read methods
                // ============================================================
 
                String readLine();
 
                String readAll();
 
                String read(size_t maxLength);
 
        private:
                void writeString(const String &str);
 
                String applyPadding(const String &str);
 
                bool readChar(char &ch);
 
                void unreadChar(char ch);
 
                void skipWhitespace();
 
                String readToken();
 
                IODevice      *_device = nullptr;
                IODevice::UPtr _ownedDevice;
 
                // Encoding
                String _encoding{"UTF-8"};
 
                // Formatting state
                int                _fieldWidth = 0;
                FieldAlignment     _fieldAlignment = Right;
                char               _padChar = ' ';
                int                _integerBase = 10;
                int                _realNumberPrecision = 6;
                RealNumberNotation _realNumberNotation = SmartNotation;
 
                // Status
                Status _status = Ok;
};
 
// ============================================================================
// Manipulators
// ============================================================================
 
inline TextStream &endl(TextStream &s) {
        s << '\n';
        s.flush();
        return s;
}
 
inline TextStream &flush(TextStream &s) {
        s.flush();
        return s;
}
 
inline TextStream &hex(TextStream &s) {
        s.setIntegerBase(16);
        return s;
}
 
inline TextStream &dec(TextStream &s) {
        s.setIntegerBase(10);
        return s;
}
 
inline TextStream &oct(TextStream &s) {
        s.setIntegerBase(8);
        return s;
}
 
inline TextStream &bin(TextStream &s) {
        s.setIntegerBase(2);
        return s;
}
 
inline TextStream &fixed(TextStream &s) {
        s.setRealNumberNotation(TextStream::Fixed);
        return s;
}
 
inline TextStream &scientific(TextStream &s) {
        s.setRealNumberNotation(TextStream::Scientific);
        return s;
}
 
inline TextStream &left(TextStream &s) {
        s.setFieldAlignment(TextStream::Left);
        return s;
}
 
inline TextStream &right(TextStream &s) {
        s.setFieldAlignment(TextStream::Right);
        return s;
}
 
inline TextStream &center(TextStream &s) {
        s.setFieldAlignment(TextStream::Center);
        return s;
}
 
// ============================================================================
// Stream operators for foundational generic types
//
// These templated operators live here (rather than alongside their
// respective class definitions) so the @ref TextStream definition is
// fully visible at template-parse time.  The corresponding class
// header (atomic.h, pair.h, span.h) is forward-declared below — actual
// usage requires both the class header and this header to be included.
// ============================================================================
 
template <typename T> class Atomic;
template <typename A, typename B> class Pair;
template <typename T> class Span;
 
template <typename T> inline TextStream &operator<<(TextStream &s, const Atomic<T> &a) {
        s << a.value();
        return s;
}
 
template <typename A, typename B> inline TextStream &operator<<(TextStream &s, const Pair<A, B> &p) {
        s << "(" << p.first() << ", " << p.second() << ")";
        return s;
}
 
template <typename T> inline TextStream &operator<<(TextStream &s, const Span<T> &span) {
        s << "[";
        for (size_t i = 0; i < span.size(); ++i) {
                if (i != 0) s << ", ";
                s << span[i];
        }
        s << "]";
        return s;
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE