src/io/inkscapestream.h

   1 #ifndef __INKSCAPE_IO_INKSCAPESTREAM_H__
   2 #define __INKSCAPE_IO_INKSCAPESTREAM_H__
   3 /**
   4  * Our base basic stream classes.
   5  *
   6  * Authors:
   7  *   Bob Jamison <rjamison@titan.com>
   8  *
   9  * Copyright (C) 2004 Inkscape.org
  10  *
  11  * Released under GNU GPL, read the file 'COPYING' for more information
  12  */
  13
  14
  15 #include <cstdio>
  16 #include <glibmm.h>
  17
  18 namespace Inkscape
  19 {
  20 namespace IO
  21 {
  22
  23 class StreamException : public std::exception
  24 {
  25 public:
  26
  27     StreamException(const char *theReason) throw()
  28         { reason = theReason; }
  29     StreamException(Glib::ustring &theReason) throw()
  30         { reason = theReason; }
  31     virtual ~StreamException() throw()
  32         {  }
  33     char const *what() const throw()
  34         { return reason.c_str(); }
  35
  36 private:
  37     Glib::ustring reason;
  38
  39 };
  40
  41 //#########################################################################
  42 //# I N P U T    S T R E A M
  43 //#########################################################################
  44
  45 /**
  46  * This interface is the base of all input stream classes.  Users who wish
  47  * to make an InputStream that is part of a chain should inherit from
  48  * BasicInputStream.  Inherit from this class to make a source endpoint,
  49  * such as a URI or buffer.
  50  *
  51  */
  52 class InputStream
  53 {
  54
  55 public:
  56
  57     /**
  58      * Constructor.
  59      */
  60     InputStream() {}
  61
  62     /**
  63      * Destructor
  64      */
  65     virtual ~InputStream() {}
  66
  67     /**
  68      * Return the number of bytes that are currently available
  69      * to be read
  70      */
  71     virtual int available() = 0;
  72
  73     /**
  74      * Do whatever it takes to 'close' this input stream
  75      * The most likely implementation of this method will be
  76      * for endpoints that use a resource for their data.
  77      */
  78     virtual void close() = 0;
  79
  80     /**
  81      * Read one byte from this input stream.  This is a blocking
  82      * call.  If no data is currently available, this call will
  83      * not return until it exists.  If the user does not want
  84      * their code to block,  then the usual solution is:
  85      *     if (available() > 0)
  86      *         myChar = get();
  87      * This call returns -1 on end-of-file.
  88      */
  89     virtual int get() = 0;
  90
  91 }; // class InputStream
  92
  93
  94
  95
  96 /**
  97  * This is the class that most users should inherit, to provide
  98  * their own streams.
  99  *
 100  */
 101 class BasicInputStream : public InputStream
 102 {
 103
 104 public:
 105
 106     BasicInputStream(InputStream &sourceStream);
 107
 108     virtual ~BasicInputStream() {}
 109
 110     virtual int available();
 111
 112     virtual void close();
 113
 114     virtual int get();
 115
 116 protected:
 117
 118     bool closed;
 119
 120     InputStream &source;
 121
 122 private:
 123
 124
 125 }; // class BasicInputStream
 126
 127
 128
 129 /**
 130  * Convenience class for reading from standard input
 131  */
 132 class StdInputStream : public InputStream
 133 {
 134 public:
 135
 136     int available()
 137         { return 0; }
 138
 139     void close()
 140         { /* do nothing */ }
 141
 142     int get()
 143         {  return getchar(); }
 144
 145 };
 146
 147
 148
 149
 150
 151
 152 //#########################################################################
 153 //# O U T P U T    S T R E A M
 154 //#########################################################################
 155
 156 /**
 157  * This interface is the base of all input stream classes.  Users who wish
 158  * to make an OutputStream that is part of a chain should inherit from
 159  * BasicOutputStream.  Inherit from this class to make a destination endpoint,
 160  * such as a URI or buffer.
 161  */
 162 class OutputStream
 163 {
 164
 165 public:
 166
 167     /**
 168      * Constructor.
 169      */
 170     OutputStream() {}
 171
 172     /**
 173      * Destructor
 174      */
 175     virtual ~OutputStream() {}
 176
 177     /**
 178      * This call should
 179      *  1.  flush itself
 180      *  2.  close itself
 181      *  3.  close the destination stream
 182      */
 183     virtual void close() = 0;
 184
 185     /**
 186      * This call should push any pending data it might have to
 187      * the destination stream.  It should NOT call flush() on
 188      * the destination stream.
 189      */
 190     virtual void flush() = 0;
 191
 192     /**
 193      * Send one byte to the destination stream.
 194      */
 195     virtual void put(int ch) = 0;
 196
 197
 198 }; // class OutputStream
 199
 200
 201 /**
 202  * This is the class that most users should inherit, to provide
 203  * their own output streams.
 204  */
 205 class BasicOutputStream : public OutputStream
 206 {
 207
 208 public:
 209
 210     BasicOutputStream(OutputStream &destinationStream);
 211
 212     virtual ~BasicOutputStream() {}
 213
 214     virtual void close();
 215
 216     virtual void flush();
 217
 218     virtual void put(int ch);
 219
 220 protected:
 221
 222     bool closed;
 223
 224     OutputStream &destination;
 225
 226
 227 }; // class BasicOutputStream
 228
 229
 230
 231 /**
 232  * Convenience class for writing to standard output
 233  */
 234 class StdOutputStream : public OutputStream
 235 {
 236 public:
 237
 238     void close()
 239         { }
 240
 241     void flush()
 242         { }
 243
 244     void put(int ch)
 245         {  putchar(ch); }
 246
 247 };
 248
 249
 250
 251
 252 //#########################################################################
 253 //# R E A D E R
 254 //#########################################################################
 255
 256
 257 /**
 258  * This interface and its descendants are for unicode character-oriented input
 259  *
 260  */
 261 class Reader
 262 {
 263
 264 public:
 265
 266     /**
 267      * Constructor.
 268      */
 269     Reader() {}
 270
 271     /**
 272      * Destructor
 273      */
 274     virtual ~Reader() {}
 275
 276
 277     virtual int available() = 0;
 278
 279     virtual void close() = 0;
 280
 281     virtual gunichar get() = 0;
 282
 283     virtual Glib::ustring readLine() = 0;
 284
 285     virtual Glib::ustring readWord() = 0;
 286
 287     /* Input formatting */
 288     virtual const Reader& readBool (bool& val ) = 0;
 289     virtual const Reader& operator>> (bool& val ) = 0;
 290
 291     virtual const Reader& readShort (short &val) = 0;
 292     virtual const Reader& operator>> (short &val) = 0;
 293
 294     virtual const Reader& readUnsignedShort (unsigned short &val) = 0;
 295     virtual const Reader& operator>> (unsigned short &val) = 0;
 296
 297     virtual const Reader& readInt (int &val) = 0;
 298     virtual const Reader& operator>> (int &val) = 0;
 299
 300     virtual const Reader& readUnsignedInt (unsigned int &val) = 0;
 301     virtual const Reader& operator>> (unsigned int &val) = 0;
 302
 303     virtual const Reader& readLong (long &val) = 0;
 304     virtual const Reader& operator>> (long &val) = 0;
 305
 306     virtual const Reader& readUnsignedLong (unsigned long &val) = 0;
 307     virtual const Reader& operator>> (unsigned long &val) = 0;
 308
 309     virtual const Reader& readFloat (float &val) = 0;
 310     virtual const Reader& operator>> (float &val) = 0;
 311
 312     virtual const Reader& readDouble (double &val) = 0;
 313     virtual const Reader& operator>> (double &val) = 0;
 314
 315 }; // interface Reader
 316
 317
 318
 319 /**
 320  * This class and its descendants are for unicode character-oriented input
 321  *
 322  */
 323 class BasicReader : public Reader
 324 {
 325
 326 public:
 327
 328     BasicReader(Reader &sourceStream);
 329
 330     virtual ~BasicReader() {}
 331
 332     virtual int available();
 333
 334     virtual void close();
 335
 336     virtual gunichar get();
 337
 338     virtual Glib::ustring readLine();
 339
 340     virtual Glib::ustring readWord();
 341
 342     /* Input formatting */
 343     virtual const Reader& readBool (bool& val );
 344     virtual const Reader& operator>> (bool& val )
 345         { return readBool(val); }
 346
 347     virtual const Reader& readShort (short &val);
 348     virtual const Reader& operator>> (short &val)
 349         { return readShort(val); }
 350
 351     virtual const Reader& readUnsignedShort (unsigned short &val);
 352     virtual const Reader& operator>> (unsigned short &val)
 353         { return readUnsignedShort(val); }
 354
 355     virtual const Reader& readInt (int &val);
 356     virtual const Reader& operator>> (int &val)
 357         { return readInt(val); }
 358
 359     virtual const Reader& readUnsignedInt (unsigned int &val);
 360     virtual const Reader& operator>> (unsigned int &val)
 361         { return readUnsignedInt(val); }
 362
 363     virtual const Reader& readLong (long &val);
 364     virtual const Reader& operator>> (long &val)
 365         { return readLong(val); }
 366
 367     virtual const Reader& readUnsignedLong (unsigned long &val);
 368     virtual const Reader& operator>> (unsigned long &val)
 369         { return readUnsignedLong(val); }
 370
 371     virtual const Reader& readFloat (float &val);
 372     virtual const Reader& operator>> (float &val)
 373         { return readFloat(val); }
 374
 375     virtual const Reader& readDouble (double &val);
 376     virtual const Reader& operator>> (double &val)
 377         { return readDouble(val); }
 378
 379
 380 protected:
 381
 382     Reader *source;
 383
 384     BasicReader()
 385         { source = NULL; }
 386
 387 private:
 388
 389 }; // class BasicReader
 390
 391
 392
 393 /**
 394  * Class for placing a Reader on an open InputStream
 395  *
 396  */
 397 class InputStreamReader : public BasicReader
 398 {
 399 public:
 400
 401     InputStreamReader(InputStream &inputStreamSource);
 402
 403     /*Overload these 3 for your implementation*/
 404     virtual int available();
 405
 406     virtual void close();
 407
 408     virtual gunichar get();
 409
 410
 411 private:
 412
 413     InputStream &inputStream;
 414
 415
 416 };
 417
 418 /**
 419  * Convenience class for reading formatted from standard input
 420  *
 421  */
 422 class StdReader : public BasicReader
 423 {
 424 public:
 425
 426     StdReader();
 427
 428     virtual ~StdReader();
 429
 430     /*Overload these 3 for your implementation*/
 431     virtual int available();
 432
 433     virtual void close();
 434
 435     virtual gunichar get();
 436
 437
 438 private:
 439
 440     InputStream *inputStream;
 441
 442
 443 };
 444
 445
 446
 447
 448
 449 //#########################################################################
 450 //# W R I T E R
 451 //#########################################################################
 452
 453 /**
 454  * This interface and its descendants are for unicode character-oriented output
 455  *
 456  */
 457 class Writer
 458 {
 459
 460 public:
 461
 462     /**
 463      * Constructor.
 464      */
 465     Writer() {}
 466
 467     /**
 468      * Destructor
 469      */
 470     virtual ~Writer() {}
 471
 472     virtual void close() = 0;
 473
 474     virtual void flush() = 0;
 475
 476     virtual void put(gunichar ch) = 0;
 477
 478     /* Formatted output */
 479     virtual Writer& printf(char const *fmt, ...) G_GNUC_PRINTF(2,3) = 0;
 480
 481     virtual Writer& writeChar(char val) = 0;
 482
 483     virtual Writer& writeUString(Glib::ustring &val) = 0;
 484
 485     virtual Writer& writeStdString(std::string &val) = 0;
 486
 487     virtual Writer& writeString(const char *str) = 0;
 488
 489     virtual Writer& writeBool (bool val ) = 0;
 490
 491     virtual Writer& writeShort (short val ) = 0;
 492
 493     virtual Writer& writeUnsignedShort (unsigned short val ) = 0;
 494
 495     virtual Writer& writeInt (int val ) = 0;
 496
 497     virtual Writer& writeUnsignedInt (unsigned int val ) = 0;
 498
 499     virtual Writer& writeLong (long val ) = 0;
 500
 501     virtual Writer& writeUnsignedLong (unsigned long val ) = 0;
 502
 503     virtual Writer& writeFloat (float val ) = 0;
 504
 505     virtual Writer& writeDouble (double val ) = 0;
 506
 507
 508
 509 }; // interface Writer
 510
 511
 512 /**
 513  * This class and its descendants are for unicode character-oriented output
 514  *
 515  */
 516 class BasicWriter : public Writer
 517 {
 518
 519 public:
 520
 521     BasicWriter(Writer &destinationWriter);
 522
 523     virtual ~BasicWriter() {}
 524
 525     /*Overload these 3 for your implementation*/
 526     virtual void close();
 527
 528     virtual void flush();
 529
 530     virtual void put(gunichar ch);
 531
 532
 533
 534     /* Formatted output */
 535     virtual Writer &printf(char const *fmt, ...) G_GNUC_PRINTF(2,3);
 536
 537     virtual Writer& writeChar(char val);
 538
 539     virtual Writer& writeUString(Glib::ustring &val);
 540
 541     virtual Writer& writeStdString(std::string &val);
 542
 543     virtual Writer& writeString(const char *str);
 544
 545     virtual Writer& writeBool (bool val );
 546
 547     virtual Writer& writeShort (short val );
 548
 549     virtual Writer& writeUnsignedShort (unsigned short val );
 550
 551     virtual Writer& writeInt (int val );
 552
 553     virtual Writer& writeUnsignedInt (unsigned int val );
 554
 555     virtual Writer& writeLong (long val );
 556
 557     virtual Writer& writeUnsignedLong (unsigned long val );
 558
 559     virtual Writer& writeFloat (float val );
 560
 561     virtual Writer& writeDouble (double val );
 562
 563
 564 protected:
 565
 566     Writer *destination;
 567
 568     BasicWriter()
 569         { destination = NULL; }
 570
 571 private:
 572
 573 }; // class BasicWriter
 574
 575
 576
 577 Writer& operator<< (Writer &writer, char val);
 578
 579 Writer& operator<< (Writer &writer, Glib::ustring &val);
 580
 581 Writer& operator<< (Writer &writer, std::string &val);
 582
 583 Writer& operator<< (Writer &writer, char const *val);
 584
 585 Writer& operator<< (Writer &writer, bool val);
 586
 587 Writer& operator<< (Writer &writer, short val);
 588
 589 Writer& operator<< (Writer &writer, unsigned short val);
 590
 591 Writer& operator<< (Writer &writer, int val);
 592
 593 Writer& operator<< (Writer &writer, unsigned int val);
 594
 595 Writer& operator<< (Writer &writer, long val);
 596
 597 Writer& operator<< (Writer &writer, unsigned long val);
 598
 599 Writer& operator<< (Writer &writer, float val);
 600
 601 Writer& operator<< (Writer &writer, double val);
 602
 603
 604
 605
 606 /**
 607  * Class for placing a Writer on an open OutputStream
 608  *
 609  */
 610 class OutputStreamWriter : public BasicWriter
 611 {
 612 public:
 613
 614     OutputStreamWriter(OutputStream &outputStreamDest);
 615
 616     /*Overload these 3 for your implementation*/
 617     virtual void close();
 618
 619     virtual void flush();
 620
 621     virtual void put(gunichar ch);
 622
 623
 624 private:
 625
 626     OutputStream &outputStream;
 627
 628
 629 };
 630
 631
 632 /**
 633  * Convenience class for writing to standard output
 634  */
 635 class StdWriter : public BasicWriter
 636 {
 637 public:
 638     StdWriter();
 639
 640     virtual ~StdWriter();
 641
 642
 643     virtual void close();
 644
 645
 646     virtual void flush();
 647
 648
 649     virtual void put(gunichar ch);
 650
 651
 652 private:
 653
 654     OutputStream *outputStream;
 655
 656 };
 657
 658 //#########################################################################
 659 //# U T I L I T Y
 660 //#########################################################################
 661
 662 void pipeStream(InputStream &source, OutputStream &dest);
 663
 664
 665
 666 } // namespace IO
 667 } // namespace Inkscape
 668
 669
 670 #endif /* __INKSCAPE_IO_INKSCAPESTREAM_H__ */