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