1 files changed, 666 insertions, 0 deletions
diff --git a/src/io/stream/inkscapestream.h b/src/io/stream/inkscapestream.h
new file mode 100644
index 0000000..b835a7f
--- /dev/null
+++ b/src/io/stream/inkscapestream.h
@@ -0,0 +1,666 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+#ifndef SEEN_INKSCAPE_IO_INKSCAPESTREAM_H
+#define SEEN_INKSCAPE_IO_INKSCAPESTREAM_H
+/*
+ * Authors:
+ *   Bob Jamison <rjamison@titan.com>
+ *
+ * Copyright (C) 2004 Inkscape.org
+ *
+ * Released under GNU GPL v2+, read the file 'COPYING' for more information.
+ */
+
+#include <cstdio>
+#include <glibmm/ustring.h>
+
+namespace Inkscape
+{
+namespace IO
+{
+
+class StreamException : public std::exception
+{
+public:
+    StreamException(Glib::ustring theReason) noexcept
+        : reason(std::move(theReason))
+    {}
+    ~StreamException() noexcept override
+        = default;
+    char const *what() const noexcept override
+        { return reason.c_str(); }
+        
+private:
+    Glib::ustring reason;
+
+};
+
+//#########################################################################
+//# I N P U T    S T R E A M
+//#########################################################################
+
+/**
+ * This interface is the base of all input stream classes.  Users who wish
+ * to make an InputStream that is part of a chain should inherit from
+ * BasicInputStream.  Inherit from this class to make a source endpoint,
+ * such as a URI or buffer.
+ *
+ */
+class InputStream
+{
+
+public:
+
+    /**
+     * Constructor.
+     */
+    InputStream() = default;
+
+    /**
+     * Destructor
+     */
+    virtual ~InputStream() = default;
+
+    /**
+     * Return the number of bytes that are currently available
+     * to be read
+     */
+    virtual int available() = 0;
+    
+    /**
+     * Do whatever it takes to 'close' this input stream
+     * The most likely implementation of this method will be
+     * for endpoints that use a resource for their data.
+     */
+    virtual void close() = 0;
+    
+    /**
+     * Read one byte from this input stream.  This is a blocking
+     * call.  If no data is currently available, this call will
+     * not return until it exists.  If the user does not want
+     * their code to block,  then the usual solution is:
+     *     if (available() > 0)
+     *         myChar = get();
+     * This call returns -1 on end-of-file.
+     */
+    virtual int get() = 0;
+    
+}; // class InputStream
+
+
+
+
+/**
+ * This is the class that most users should inherit, to provide
+ * their own streams.
+ *
+ */
+class BasicInputStream : public InputStream
+{
+
+public:
+
+    BasicInputStream(InputStream &sourceStream);
+    
+    ~BasicInputStream() override = default;
+    
+    int available() override;
+    
+    void close() override;
+    
+    int get() override;
+    
+protected:
+
+    bool closed;
+
+    InputStream &source;
+    
+private:
+
+
+}; // class BasicInputStream
+
+
+
+/**
+ * Convenience class for reading from standard input
+ */
+class StdInputStream : public InputStream
+{
+public:
+
+    int available() override
+        { return 0; }
+    
+    void close() override
+        { /* do nothing */ }
+    
+    int get() override
+        {  return getchar(); }
+
+};
+
+
+
+
+
+
+//#########################################################################
+//# O U T P U T    S T R E A M
+//#########################################################################
+
+/**
+ * This interface is the base of all input stream classes.  Users who wish
+ * to make an OutputStream that is part of a chain should inherit from
+ * BasicOutputStream.  Inherit from this class to make a destination endpoint,
+ * such as a URI or buffer.
+ */
+class OutputStream
+{
+
+public:
+
+    /**
+     * Constructor.
+     */
+    OutputStream() = default;
+
+    /**
+     * Destructor
+     */
+    virtual ~OutputStream() = default;
+
+    /**
+     * This call should
+     *  1.  flush itself
+     *  2.  close itself
+     *  3.  close the destination stream
+     */
+    virtual void close() = 0;
+    
+    /**
+     * This call should push any pending data it might have to
+     * the destination stream.  It should NOT call flush() on
+     * the destination stream.
+     */
+    virtual void flush() = 0;
+    
+    /**
+     * Send one byte to the destination stream.
+     */
+    virtual int put(char ch) = 0;
+
+
+}; // class OutputStream
+
+
+/**
+ * This is the class that most users should inherit, to provide
+ * their own output streams.
+ */
+class BasicOutputStream : public OutputStream
+{
+
+public:
+
+    BasicOutputStream(OutputStream &destinationStream);
+    
+    ~BasicOutputStream() override = default;
+
+    void close() override;
+    
+    void flush() override;
+    
+    int put(char ch) override;
+
+protected:
+
+    bool closed;
+
+    OutputStream &destination;
+
+
+}; // class BasicOutputStream
+
+
+
+/**
+ * Convenience class for writing to standard output
+ */
+class StdOutputStream : public OutputStream
+{
+public:
+
+    void close() override
+        { }
+    
+    void flush() override
+        { }
+    
+    int put(char ch) override
+        {return  putchar(ch); }
+
+};
+
+
+
+
+//#########################################################################
+//# R E A D E R
+//#########################################################################
+
+
+/**
+ * This interface and its descendants are for unicode character-oriented input
+ *
+ */
+class Reader
+{
+
+public:
+
+    /**
+     * Constructor.
+     */
+    Reader() = default;
+
+    /**
+     * Destructor
+     */
+    virtual ~Reader() = default;
+
+
+    virtual int available() = 0;
+    
+    virtual void close() = 0;
+    
+    virtual char get() = 0;
+    
+    virtual Glib::ustring readLine() = 0;
+    
+    virtual Glib::ustring readWord() = 0;
+    
+    /* Input formatting */
+    virtual const Reader& readBool (bool& val ) = 0;
+    virtual const Reader& operator>> (bool& val ) = 0;
+        
+    virtual const Reader& readShort (short &val) = 0;
+    virtual const Reader& operator>> (short &val) = 0;
+        
+    virtual const Reader& readUnsignedShort (unsigned short &val) = 0;
+    virtual const Reader& operator>> (unsigned short &val) = 0;
+        
+    virtual const Reader& readInt (int &val) = 0;
+    virtual const Reader& operator>> (int &val) = 0;
+        
+    virtual const Reader& readUnsignedInt (unsigned int &val) = 0;
+    virtual const Reader& operator>> (unsigned int &val) = 0;
+        
+    virtual const Reader& readLong (long &val) = 0;
+    virtual const Reader& operator>> (long &val) = 0;
+        
+    virtual const Reader& readUnsignedLong (unsigned long &val) = 0;
+    virtual const Reader& operator>> (unsigned long &val) = 0;
+        
+    virtual const Reader& readFloat (float &val) = 0;
+    virtual const Reader& operator>> (float &val) = 0;
+        
+    virtual const Reader& readDouble (double &val) = 0;
+    virtual const Reader& operator>> (double &val) = 0;
+
+}; // interface Reader
+
+
+
+/**
+ * This class and its descendants are for unicode character-oriented input
+ *
+ */
+class BasicReader : public Reader
+{
+
+public:
+
+    BasicReader(Reader &sourceStream);
+    
+    ~BasicReader() override = default;
+
+    int available() override;
+    
+    void close() override;
+    
+    char get() override;
+    
+    Glib::ustring readLine() override;
+    
+    Glib::ustring readWord() override;
+    
+    /* Input formatting */
+    const Reader& readBool (bool& val ) override;
+    const Reader& operator>> (bool& val ) override
+        { return readBool(val); }
+        
+    const Reader& readShort (short &val) override;
+    const Reader& operator>> (short &val) override
+        { return readShort(val); }
+        
+    const Reader& readUnsignedShort (unsigned short &val) override;
+    const Reader& operator>> (unsigned short &val) override
+        { return readUnsignedShort(val); }
+        
+    const Reader& readInt (int &val) override;
+    const Reader& operator>> (int &val) override
+        { return readInt(val); }
+        
+    const Reader& readUnsignedInt (unsigned int &val) override;
+    const Reader& operator>> (unsigned int &val) override
+        { return readUnsignedInt(val); }
+        
+    const Reader& readLong (long &val) override;
+    const Reader& operator>> (long &val) override
+        { return readLong(val); }
+        
+    const Reader& readUnsignedLong (unsigned long &val) override;
+    const Reader& operator>> (unsigned long &val) override
+        { return readUnsignedLong(val); }
+        
+    const Reader& readFloat (float &val) override;
+    const Reader& operator>> (float &val) override
+        { return readFloat(val); }
+        
+    const Reader& readDouble (double &val) override;
+    const Reader& operator>> (double &val) override
+        { return readDouble(val); }
+ 
+
+protected:
+
+    Reader *source;
+
+    BasicReader()
+        { source = nullptr; }
+
+private:
+
+}; // class BasicReader
+
+
+
+/**
+ * Class for placing a Reader on an open InputStream
+ *
+ */
+class InputStreamReader : public BasicReader
+{
+public:
+
+    InputStreamReader(InputStream &inputStreamSource);
+    
+    /*Overload these 3 for your implementation*/
+    int available() override;
+    
+    void close() override;
+    
+    char get() override;
+
+
+private:
+
+    InputStream &inputStream;
+
+
+};
+
+/**
+ * Convenience class for reading formatted from standard input
+ *
+ */
+class StdReader : public BasicReader
+{
+public:
+
+    StdReader();
+
+    ~StdReader() override;
+    
+    /*Overload these 3 for your implementation*/
+    int available() override;
+    
+    void close() override;
+    
+    char get() override;
+
+
+private:
+
+    InputStream *inputStream;
+
+
+};
+
+
+
+
+
+//#########################################################################
+//# W R I T E R
+//#########################################################################
+
+/**
+ * This interface and its descendants are for unicode character-oriented output
+ *
+ */
+class Writer
+{
+
+public:
+
+    /**
+     * Constructor.
+     */
+    Writer() = default;
+
+    /**
+     * Destructor
+     */
+    virtual ~Writer() = default;
+
+    virtual void close() = 0;
+    
+    virtual void flush() = 0;
+    
+    virtual void put(char ch) = 0;
+    
+    /* Formatted output */
+    virtual Writer& printf(char const *fmt, ...) G_GNUC_PRINTF(2,3) = 0;
+
+    virtual Writer& writeChar(char val) = 0;
+
+    virtual Writer& writeUString(const Glib::ustring &val) = 0;
+
+    virtual Writer& writeStdString(const std::string &val) = 0;
+
+    virtual Writer& writeString(const char *str) = 0;
+
+    virtual Writer& writeBool (bool val ) = 0;
+
+    virtual Writer& writeShort (short val ) = 0;
+
+    virtual Writer& writeUnsignedShort (unsigned short val ) = 0;
+
+    virtual Writer& writeInt (int val ) = 0;
+
+    virtual Writer& writeUnsignedInt (unsigned int val ) = 0;
+
+    virtual Writer& writeLong (long val ) = 0;
+
+    virtual Writer& writeUnsignedLong (unsigned long val ) = 0;
+
+    virtual Writer& writeFloat (float val ) = 0;
+
+    virtual Writer& writeDouble (double val ) = 0;
+
+ 
+
+}; // interface Writer
+
+
+/**
+ * This class and its descendants are for unicode character-oriented output
+ *
+ */
+class BasicWriter : public Writer
+{
+
+public:
+
+    BasicWriter(Writer &destinationWriter);
+
+    ~BasicWriter() override = default;
+
+    /*Overload these 3 for your implementation*/
+    void close() override;
+    
+    void flush() override;
+    
+    void put(char ch) override;
+    
+    
+    
+    /* Formatted output */
+    Writer &printf(char const *fmt, ...) override G_GNUC_PRINTF(2,3);
+
+    Writer& writeChar(char val) override;
+
+    Writer& writeUString(const Glib::ustring &val) override;
+
+    Writer& writeStdString(const std::string &val) override;
+
+    Writer& writeString(const char *str) override;
+
+    Writer& writeBool (bool val ) override;
+
+    Writer& writeShort (short val ) override;
+
+    Writer& writeUnsignedShort (unsigned short val ) override;
+
+    Writer& writeInt (int val ) override;
+
+    Writer& writeUnsignedInt (unsigned int val ) override;
+
+    Writer& writeLong (long val ) override;
+
+    Writer& writeUnsignedLong (unsigned long val ) override;
+
+    Writer& writeFloat (float val ) override;
+
+    Writer& writeDouble (double val ) override;
+
+ 
+protected:
+
+    Writer *destination;
+
+    BasicWriter()
+        { destination = nullptr; }
+    
+private:
+
+}; // class BasicWriter
+
+
+
+Writer& operator<< (Writer &writer, char val);
+
+Writer& operator<< (Writer &writer, Glib::ustring &val);
+
+Writer& operator<< (Writer &writer, std::string &val);
+
+Writer& operator<< (Writer &writer, char const *val);
+
+Writer& operator<< (Writer &writer, bool val);
+
+Writer& operator<< (Writer &writer, short val);
+
+Writer& operator<< (Writer &writer, unsigned short val);
+
+Writer& operator<< (Writer &writer, int val);
+
+Writer& operator<< (Writer &writer, unsigned int val);
+
+Writer& operator<< (Writer &writer, long val);
+
+Writer& operator<< (Writer &writer, unsigned long val);
+
+Writer& operator<< (Writer &writer, float val);
+
+Writer& operator<< (Writer &writer, double val);
+
+
+
+
+/**
+ * Class for placing a Writer on an open OutputStream
+ *
+ */
+class OutputStreamWriter : public BasicWriter
+{
+public:
+
+    OutputStreamWriter(OutputStream &outputStreamDest);
+    
+    /*Overload these 3 for your implementation*/
+    void close() override;
+    
+    void flush() override;
+    
+    void put(char ch) override;
+
+
+private:
+
+    OutputStream &outputStream;
+
+
+};
+
+
+/**
+ * Convenience class for writing to standard output
+ */
+class StdWriter : public BasicWriter
+{
+public:
+    StdWriter();
+
+    ~StdWriter() override;
+
+
+    void close() override;
+
+    
+    void flush() override;
+
+    
+    void put(char ch) override;
+
+
+private:
+
+    OutputStream *outputStream;
+
+};
+
+//#########################################################################
+//# U T I L I T Y
+//#########################################################################
+
+void pipeStream(InputStream &source, OutputStream &dest);
+
+
+
+} // namespace IO
+} // namespace Inkscape
+
+
+#endif // SEEN_INKSCAPE_IO_INKSCAPESTREAM_H