src/dom/domstream.h

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