OWLNext    7.0
Borland's Object Windows Library for the modern age
Loading...
Searching...
No Matches
objstrm.h
Go to the documentation of this file.
1//----------------------------------------------------------------------------
2// ObjectWindows
3// Copyright (c) 1992, 1996 by Borland International, All Rights Reserved
4// Revision by Yura Bidus
5//
6//----------------------------------------------------------------------------
7
8#if !defined(OWL_OBJSTRM_H)
9#define OWL_OBJSTRM_H
10
11#include <owl/defs.h>
12#if defined(BI_HAS_PRAGMA_ONCE)
13# pragma once
14#endif
15
16#include <owl/streambl.h>
17
18
19#include <iostream>
20#include <fstream>
21
22#include <typeinfo>
23
24namespace owl {
25
26#include <owl/preclass.h>
27
28/// \addtogroup base
29/// @{
30
31/*------------------------------------------------------------------------*/
32/* */
33/* The __link() macro forces the compiler to link in a static instance */
34/* of class TStreamableClass, which in turn registers its associated */
35/* TStreamable object with the stream manager. Applications that do */
36/* not use streaming won't use __link(), and that will reduce the amount */
37/* of code that is linked into the application. */
38/* */
39/*------------------------------------------------------------------------*/
40
41/// \cond
42struct fLink
43{
44 struct fLink *f;
45 class TStreamableClass *t;
46};
47
48#define __link( s ) \
49 extern TStreamableClass s; \
50 static fLink force ## s = \
51 { (fLink *)&force ## s, (TStreamableClass *)&s };
52/// \endcond
53
54typedef unsigned P_id_type;
55
56class _OWLCLASS _RTTI TStreamable;
57class _OWLCLASS TStreamableTypes;
58class _OWLCLASS opstream;
59class _OWLCLASS ipstream;
60
61
62
63_OWLCFUNC(ipstream &) operator >> ( ipstream & is, tstring & str );
64
65_OWLCFUNC(opstream &) operator << ( opstream & os,
66 const tstring & str );
67
68/* -----------------------------------------------------------------------*/
69/* */
70/* _OBJ_TYPENAME(obj) provides a macro for getting the type name from a */
71/* pointer to an object. If runtime type information is available, this */
72/* macro uses the typeid of the object to get its name. If runtime type */
73/* information is not available, it uses the CastableID() for the object.*/
74/* */
75/* -----------------------------------------------------------------------*/
76
77
78#define _OBJ_FULLTYPENAME(obj) typeid(*obj).name()
79#if defined(BI_COMP_MSC) && !defined(UNIX) && !defined(__EDG__)
80# if defined(BI_COMPATIBLE_STREAMING)
81# define _OBJ_TYPENAME(obj) typeid(*obj).name() + 6
82# else
83# define _OBJ_TYPENAME(obj) typeid(*obj).raw_name()
84# endif
85#else
86# define _OBJ_TYPENAME(obj) typeid(*obj).name()
87#endif
88/* -----------------------------------------------------------------------*/
89/* */
90/*! \ class TStreamable */
91/* */
92/*! This is the base class from which all streamable objects must be */
93/*! derived. */
94/* */
95/* -----------------------------------------------------------------------*/
96
97
98enum StreamableInit { streamableInit };
99
100/// Classes that inherit from TStreamableBase are known as streamable classes (their
101/// objects can be written to and read from streams). If you develop your own
102/// streamable classes, make sure that TStreamableBase is somewhere in their
103/// ancestry.
104///
105/// Using an existing streamable class as a base is the easiest way to create a
106/// streamable class. If your class must also fit into an existing class hierarchy,
107/// you can use multiple inheritance to derive a class from TStreamableBase .
108class _OWLCLASS _RTTI TStreamableBase {
109 public:
110 virtual ~TStreamableBase();
111
112};
113
114
115class _OWLCLASS _RTTI TStreamable : public TStreamableBase {
116
117 friend class _OWLCLASS _RTTI TOldStreamer;
118
119 protected:
120
121 virtual LPCSTR streamableName() const = 0;
122
123 virtual void * read( ipstream& ) = 0;
124 virtual void write( opstream& ) = 0;
125
126};
127
128//
129/// Provides a base class for all streamable objects.
130class _OWLCLASS _RTTI TStreamer {
131
132 friend class ipstream;
133 friend class opstream;
134
135 public:
136
137 virtual ~TStreamer() {}
138
139/// Returns the address of the TStreamableBase component of the streamable object.
140 TStreamableBase * GetObject() const { return object; }
141
142 protected:
143
144/// Constructs the TStreamer object, and initializes the streamable object pointer.
145 TStreamer( TStreamableBase *obj ) : object(obj) {}
146
147/// This pure virtual member function must be redefined for every streamable class.
148/// It returns the name of the streamable class, which is used by the stream manager
149/// to register the streamable class. The name returned must be a zero-terminated
150/// string.
151 virtual LPCSTR StreamableName() const = 0;
152
153/// This pure virtual member function must be redefined for every streamable class.
154/// It must read the necessary data members for the streamable class from the
155/// supplied ipstream.
156 virtual void * Read( ipstream&, uint32 ) const = 0;
157
158/// This pure virtual function must be redefined for every streamable class. It must
159/// write the necessary streamable class data members to the supplied opstream
160/// object. Write is usually implemented by calling the Write member function (if
161/// available) of a base class, and then inserting any additional data members for
162/// the derived class.
163 virtual void Write( opstream& ) const = 0;
164
165 private:
166
167 virtual uint32 ClassVersion() const = 0;
168
169 TStreamableBase *object;
170
171};
172
173/// Provides a base class for all streamable objects.
174class _OWLCLASS _RTTI TOldStreamer : public TStreamer {
175
176 public:
177
178/// Constructs the TOldStreamer object, and initializes the streamable object
179/// pointer.
180 TOldStreamer( TStreamable *obj ) : TStreamer(obj) {};
181
182 protected:
183
184/// This pure virtual member function must be redefined for every streamable class.
185/// It returns the name of the streamable class, which is used by the stream manager
186/// to register the streamable class. The name returned must be a zero-terminated
187/// string.
188 virtual LPCSTR StreamableName() const
189 {
190 return STATIC_CAST(TStreamable *,GetObject())->streamableName();
191 }
192
193/// This pure virtual member function must be redefined for every streamable class.
194/// It must read the necessary data members for the streamable class from the
195/// supplied ipstream.
196 virtual void * Read( ipstream& is, uint32 ) const
197 {
198 return STATIC_CAST(TStreamable *,GetObject())->read( is );
199 }
200
201/// This pure virtual function must be redefined for every streamable class. It must
202/// write the necessary streamable class data members to the supplied opstream
203/// object. Write is usually implemented by calling the Write member function (if
204/// available) of a base class, and then inserting any additional data members for
205/// the derived class.
206 virtual void Write( opstream& os ) const
207 {
208 STATIC_CAST(TStreamable *,GetObject())->write( os );
209 }
210
211 private:
212
213 virtual uint32 ClassVersion() const
214 {
215 return 0;
216 }
217
218};
219
220class _OWLCLASS _RTTI TNewStreamer : public TStreamer {
221
222 public:
223
224/// Constructs the TNewStreamer object, and initializes the streamable object
225/// pointer.
226 TNewStreamer( TStreamableBase *obj ) : TStreamer(obj) {};
227
228 protected:
229
230 virtual LPCSTR StreamableName() const
231 {
232 const auto p = GetObject();
233 return _OBJ_TYPENAME(p);
234 }
235
236};
237
238
239/* ------------------------------------------------------------------------*/
240/* */
241/*! \class TPWrittenObjects */
242/* */
243/*! Maintains a database of all objects that have been written to the */
244/*! current persistent stream. */
245/* */
246/*! Used by opstream when it writes a pointer from a stream to save the */
247/*! address and ID of the object being written. */
248/* */
249/* ------------------------------------------------------------------------*/
250
251class TSortedTPWObjObjectArray;
252
253class _OWLCLASS TPWrittenObjects {
254
255 friend class opstream;
256
257 public:
258
259 void RemoveAll();
260
261 class _OWLCLASS TPWObj {
262 public:
263
264 TPWObj() : Address(nullptr), Ident(0) {}
265 TPWObj( const void *adr, P_id_type id ) :
266 Address(adr), Ident(id) {}
267
268 bool operator == ( const TPWObj& o) const
269 { return reinterpret_cast<TAddrInt>(Address) == reinterpret_cast<TAddrInt>(o.Address); }
270
271 bool operator < ( const TPWObj& o ) const
272 { return reinterpret_cast<TAddrInt>(Address) < reinterpret_cast<TAddrInt>(o.Address); }
273
274 const void *Address;
275 P_id_type Ident;
276
277 private:
278
279 typedef UINT_PTR TAddrInt;
280 };
281
282 private:
283
284 TPWrittenObjects();
285 ~TPWrittenObjects();
286
287 void RegisterObject( TStreamableBase *adr );
288 void RegisterVB( const TStreamableBase *adr );
289 P_id_type FindObject( TStreamableBase *adr );
290 P_id_type FindVB( TStreamableBase *adr );
291
292 P_id_type CurId;
293 TSortedTPWObjObjectArray* Data;
294};
295
296
297/* ------------------------------------------------------------------------*/
298/* */
299/*! \class TPReadObjects */
300/* */
301/*! Maintains a database of all objects that have been read from the */
302/*! current persistent stream. */
303/* */
304/*! Used by ipstream when it reads a pointer from a stream to determine */
305/*! the address of the object being referred to. */
306/* */
307/* ------------------------------------------------------------------------*/
308
309class TStreamableBaseArray;
310
311class _OWLCLASS TPReadObjects {
312 friend class ipstream;
313 public:
314
315 void RemoveAll();
316
317 private:
318 TPReadObjects();
319 ~TPReadObjects();
320
321 void RegisterObject( TStreamableBase *adr );
322 TStreamableBase * Find( P_id_type id );
323
324 TStreamableBaseArray* Data;
325};
326
327/// \class pstream
328/// Base class for handling streamable objects.
329
330class _OWLCLASS pstream {
331 friend class TStreamableTypes;
332 friend class TStreamableClass;
333 public:
334
335/// Enumerates object pointer types.
336 enum PointerTypes { ptNull, ptIndexed, ptObject };
337
338 pstream( std::streambuf * );
339 virtual ~pstream();
340
341 int rdstate() const;
342 int eof() const;
343 int fail() const;
344 int bad() const;
345 int good() const;
346 void clear( int = 0 );
347 operator void *() const;
348 int operator ! () const;
349
350 std::streambuf * rdbuf() const;
351
352 protected:
353
354 pstream();
355
356 std::streambuf *bp;
357 int state;
358
359 void init( std::streambuf * );
360 void setstate( int );
361
362// static TStreamableTypes *types;
363};
364
365/* ------------------------------------------------------------------------*/
366/* */
367/*! \class ipstream */
368/* */
369/*! Base class for reading streamable objects */
370/* */
371/* ------------------------------------------------------------------------*/
372inline ipstream& operator >> ( ipstream&, int8& );
373inline ipstream& operator >> ( ipstream&, uint8& );
374inline ipstream& operator >> ( ipstream&, char& );
375inline ipstream& operator >> ( ipstream&, signed short& );
376inline ipstream& operator >> ( ipstream&, unsigned short& );
377inline ipstream& operator >> ( ipstream&, signed int& );
378inline ipstream& operator >> ( ipstream&, unsigned int& );
379inline ipstream& operator >> ( ipstream&, bool& );
380inline ipstream& operator >> ( ipstream&, signed long& );
381inline ipstream& operator >> ( ipstream&, unsigned long& );
382inline ipstream& operator >> ( ipstream&, int64& );
383inline ipstream& operator >> ( ipstream&, uint64& );
384inline ipstream& operator >> ( ipstream&, float& );
385inline ipstream& operator >> ( ipstream&, double&);
386inline ipstream& operator >> ( ipstream&, long double&);
387
388
389/// ipstream, a specialized input stream derivative of pstream, is the base class
390/// for reading (extracting) streamable objects.
391class _OWLCLASS ipstream : virtual public pstream {
392 friend class TStreamableClass;
393 public:
394
395 ipstream( std::streambuf * );
396
397 std::streampos tellg();
398 ipstream& seekg( std::streampos );
399 ipstream& seekg( std::streamoff, std::ios::seekdir );
400
401 uint8 readByte();
402 void readBytes( void *, size_t );
403 void freadBytes( void * data, size_t sz );
404
405 uint32 readWord();
406 uint16 readWord16();
407 uint32 readWord32();
408
409 LPSTR readString();
410 LPSTR readString( LPSTR , unsigned );
411 char * freadString();
412 char * freadString( char *buf,
413 unsigned maxLen );
414
415 friend ipstream& operator >> ( ipstream&, int8& );
416 friend ipstream& operator >> ( ipstream&, uint8& );
417 friend ipstream& operator >> ( ipstream&, char& );
418 friend ipstream& operator >> ( ipstream&, signed short& );
419 friend ipstream& operator >> ( ipstream&, unsigned short& );
420 friend ipstream& operator >> ( ipstream&, signed int& );
421 friend ipstream& operator >> ( ipstream&, unsigned int& );
422 friend ipstream& operator >> ( ipstream&, bool& );
423 friend ipstream& operator >> ( ipstream&, signed long& );
424 friend ipstream& operator >> ( ipstream&, unsigned long& );
425 friend ipstream& operator >> ( ipstream&, int64& );
426 friend ipstream& operator >> ( ipstream&, uint64& );
427 friend ipstream& operator >> ( ipstream&, float& );
428 friend ipstream& operator >> ( ipstream&, double& );
429 friend ipstream& operator >> ( ipstream&, long double& );
430 friend ipstream & operator >> ( ipstream&, tstring&);
431
432 uint32 getVersion() const;
433
434 TStreamableBase * readObject( TStreamableBase *&mem, ModuleId mid = GetModuleId() );
435 TStreamableBase * readObjectPointer( TStreamableBase *&mem, ModuleId mid = GetModuleId() );
436
437 TStreamableBase * find( P_id_type );
438 void registerObject( TStreamableBase *adr );
439
440 protected:
441
442 ipstream();
443
444 const ObjectBuilder * readPrefix( ModuleId mid );
445 void readData( const ObjectBuilder *,
446 TStreamableBase *& );
447 void readSuffix();
448
449 void readVersion();
450
451private:
452
453 uint32 readStringLength();
454 TPReadObjects objs;
455 uint32 version;
456};
457
458/// \class opstream
459/// Base class for writing streamable objects
460//
461/// opstream, a specialized derivative of pstream, is the base class for writing
462/// (inserting) streamable objects.
463
464inline opstream& operator << ( opstream&, int8 );
465inline opstream& operator << ( opstream&, uint8 );
466inline opstream& operator << ( opstream&, char );
467inline opstream& operator << ( opstream&, signed short );
468inline opstream& operator << ( opstream&, unsigned short );
469inline opstream& operator << ( opstream&, signed int );
470inline opstream& operator << ( opstream&, unsigned int );
471inline opstream& operator << ( opstream&, bool );
472inline opstream& operator << ( opstream&, signed long );
473inline opstream& operator << ( opstream&, unsigned long );
474inline opstream& operator << ( opstream&, int64);
475inline opstream& operator << ( opstream&, uint64);
476inline opstream& operator << ( opstream&, float );
477inline opstream& operator << ( opstream&, double );
478inline opstream& operator << ( opstream&, long double );
479
480class _OWLCLASS opstream : virtual public pstream {
481 public:
482
483 opstream( std::streambuf * );
484 virtual ~opstream();
485
486 std::streampos tellp();
487 opstream& seekp( std::streampos );
488 opstream& seekp( std::streamoff, std::ios::seekdir );
489 opstream& flush();
490
491 void writeByte( uint8 );
492 void writeBytes( const void *, size_t );
493 void fwriteBytes( const void *data, size_t sz );
494
495 void writeWord( uint32 );
496 void writeWord16( uint16 );
497 void writeWord32( uint32 );
498
499 void writeString( const char * );
500 void fwriteString( const char * str );
501
502 friend opstream& operator << ( opstream&, int8 );
503 friend opstream& operator << ( opstream&, uint8 );
504 friend opstream& operator << ( opstream&, char );
505 friend opstream& operator << ( opstream&, signed short );
506 friend opstream& operator << ( opstream&, unsigned short );
507 friend opstream& operator << ( opstream&, signed int );
508 friend opstream& operator << ( opstream&, unsigned int );
509 friend opstream& operator << ( opstream&, bool );
510 friend opstream& operator << ( opstream&, signed long );
511 friend opstream& operator << ( opstream&, unsigned long );
512 friend opstream& operator << ( opstream&, int64);
513 friend opstream& operator << ( opstream&, uint64);
514 friend opstream& operator << ( opstream&, float );
515 friend opstream& operator << ( opstream&, double );
516 friend opstream& operator << ( opstream&, long double );
517
518 void writeObject( const TStreamableBase *t, int isPtr = 0, ModuleId mid = GetModuleId() );
519 void writeObjectPointer( const TStreamableBase *t, ModuleId mid = GetModuleId() );
520
521 P_id_type findObject( TStreamableBase *adr );
522 void registerObject( TStreamableBase *adr );
523
524 P_id_type findVB( TStreamableBase *adr );
525 void registerVB( TStreamableBase *adr );
526
527 protected:
528
529 opstream();
530
531 void writePrefix( const TStreamableBase * );
532 void writeData( const TStreamableBase *, ModuleId mid );
533 void writeSuffix( const TStreamableBase * );
534
535 void writeVersion();
536
537 private:
538
539 TPWrittenObjects* objs;
540};
541
542/// \class fpbase
543/// Base class for handling streamable objects on file streams
544//
545/// Provides the basic operations common to all object file stream I/O. It is a base
546/// class for handling streamable objects on file streams.
547
548class _OWLCLASS fpbase : virtual public pstream {
549 public:
550
551 enum { openprot = 0666 }; // default open mode
552 fpbase();
553 fpbase( LPCSTR, int, int = openprot );
554 fpbase( LPCWSTR, int, int = openprot );
555
556 void open( LPCSTR, int, int = openprot );
557 void open( LPCWSTR, int, int = openprot );
558
559 void close();
560 void setbuf( LPSTR, int );
561 std::filebuf * rdbuf();
562
563 private:
564
565 std::filebuf buf;
566};
567
568/// \class ifpstream
569/// Base class for reading streamable objects from file streams
570//
571/// ifpstream is a simple "mix" of its bases, fpbase and ipstream. It provides the
572/// base class reading (extracting) streamable objects from file streams.
573
574class _OWLCLASS ifpstream : public fpbase, public ipstream {
575 public:
576
577 ifpstream();
578 ifpstream( LPCSTR,
579 int = std::ios::in,
580 int = fpbase::openprot
581 );
582 ifpstream( LPCWSTR,
583 int = std::ios::in,
584 int = fpbase::openprot
585 );
586
587 std::filebuf * rdbuf();
588
589 void open( LPCSTR ,
590 int = std::ios::in,
591 int = fpbase::openprot
592 );
593 void open( LPCWSTR ,
594 int = std::ios::in,
595 int = fpbase::openprot
596 );
597};
598
599/// \class ofpstream
600/// Base class for writing streamable objects to file streams
601//
602/// Provides the base class for writing (inserting) streamable objects to file
603/// streams.
604
605class _OWLCLASS ofpstream : public fpbase, public opstream {
606 public:
607
608 ofpstream();
609 ofpstream( LPCSTR ,
610 int = std::ios::out,
611 int = fpbase::openprot
612 );
613 ofpstream( LPCWSTR ,
614 int = std::ios::out,
615 int = fpbase::openprot
616 );
617
618 std::filebuf * rdbuf();
619
620 void open( LPCSTR,
621 int = std::ios::out,
622 int = fpbase::openprot
623 );
624 void open( LPCWSTR,
625 int = std::ios::out,
626 int = fpbase::openprot
627 );
628};
629
630#include <owl/posclass.h>
631
632
633/* ------------------------------------------------------------------------*/
634/* */
635/* Inline functions */
636/* */
637/* ------------------------------------------------------------------------*/
638
639/// Creates a buffered pstream with the given buffer. The state is set to 0.
640inline pstream::pstream( std::streambuf *sb ){
641 init( sb );
642}
643
644/// Returns the current state value.
645inline int pstream::rdstate() const {
646 return state;
647}
648
649/// Returns nonzero on end of stream.
650inline int pstream::eof() const {
651 return state & std::ios::eofbit;
652}
653
654/// Returns nonzero if a previous stream operation failed.
655inline int pstream::fail() const {
656 return state & (std::ios::failbit | std::ios::badbit | std::ios::goodbit);
657}
658
659/// Returns nonzero if an error occurs.
660inline int pstream::bad() const {
661 return state & (std::ios::badbit | std::ios::goodbit);
662}
663
664/// Returns nonzero if no error states have been recorded for the stream (that is,
665/// no errors have occurred).
666inline int pstream::good() const {
667 return state == 0;
668}
669
670/// Sets the stream state to the given value (defaults to 0).
671inline void pstream::clear( int i ){
672 state = (i & 0xFF) | (state & std::ios::goodbit);
673}
674
675/// Converts to a void pointer.
676inline pstream::operator void *() const {
677 return fail() ? 0 : (void *)this;
678}
679
680/// Overloads the NOT operator. Returns 0 if the operation has failed (that is, if
681/// pstream::fail returned nonzero); otherwise, returns nonzero.
682inline int pstream::operator! () const {
683 return fail();
684}
685
686/// Returns the pb pointer to the buffer assigned to the stream.
687inline std::streambuf * pstream::rdbuf() const {
688 return bp;
689}
690
691/// Creates a pstream without initializing the buffer pointer bp or state.
692/// Use init to set the buffer and setstate to set the state.
693inline pstream::pstream(){
694}
695
696/// The init member function initializes the stream and sets state to 0 and bp to
697/// sbp.
698inline void pstream::init( std::streambuf *sbp ){
699 state = 0;
700 bp = sbp;
701}
702
703/// Updates the state data member with state |= (b & 0xFF).
704inline void pstream::setstate( int b ){
705 state |= (b&0xFF);
706}
707
708/// Creates a buffered ipstream with the given buffer. The state is set to 0.
709inline ipstream::ipstream( std::streambuf *sb ){
710 pstream::init( sb );
711 readVersion();
712}
713
714/// Creates a buffered ipstream without initializing the buffer pointer, bp.
715/// Use psteam::init to set the buffer and state.
716inline ipstream::ipstream(){
717 if( bp != 0 )
718 readVersion();
719}
720
721/// Returns a pointer to the object corresponding to Id.
722inline TStreamableBase * ipstream::find( P_id_type id ){
723 return objs.Find( id );
724}
725
726/// Registers the object pointed to by adr.
727inline void ipstream::registerObject( TStreamableBase *adr ){
728 objs.RegisterObject( adr );
729}
730
731/// Returns the object version number.
732inline uint32 ipstream::getVersion() const {
733 return version;
734}
735inline opstream::~opstream(){
736 delete objs;
737}
738
739/// Writes the 32-bit word us to the stream.
743
744/// Writes the class name suffix to the stream. The << operator uses this function
745/// to write a prefix and suffix around the data written with writeData. The
746/// prefix/suffix is used to ensure type-safe stream I/O.
747inline void opstream::writeSuffix( const TStreamableBase * ){
748 writeByte( ']' );
749}
750
751/// Returns the type ID for the object pointed to by adr.
752inline P_id_type opstream::findObject( TStreamableBase *adr ){
753 return objs->FindObject( adr );
754}
755
756/// Registers the class of the object pointed to by adr.
757inline void opstream::registerObject( TStreamableBase *adr ){
758 objs->RegisterObject( adr );
759}
760
761/// Returns a pointer to the virtual base.
762inline P_id_type opstream::findVB( TStreamableBase *adr ){
763 return objs->FindVB( adr );
764}
765
766/// Registers a virtual base class.
767inline void opstream::registerVB( TStreamableBase *adr ){
768 objs->RegisterVB( adr );
769}
770
771/// Creates a buffered fpbase object.
772inline fpbase::fpbase(){
773 pstream::init( &buf );
774}
775
776/// Creates a buffered fpbase object. It opens the file specified by name,
777/// using the mode omode and protection prot; and attaches this file to the stream.
778inline fpbase::fpbase( LPCSTR name, int omode, int prot ){
779 pstream::init( &buf );
780 open( name, omode, prot );
781}
782
783/// Creates a buffered fpbase object. It opens the file specified by name,
784/// using the mode omode and protection prot; and attaches this file to the stream.
785inline fpbase::fpbase( LPCWSTR name, int omode, int prot ){
786 pstream::init( &buf );
787 open( name, omode, prot );
788}
789
790/// Returns a pointer to the current file buffer.
791inline std::filebuf * fpbase::rdbuf(){
792 return &buf;
793}
794
795/// Creates a buffered ifpstream object using a default buffer.
796inline ifpstream::ifpstream(){
797}
798
799/// Creates a buffered ifpstream object. It opens the file specified by name
800/// using the mode mode and protection prot; and attaches this file to the stream.
801inline ifpstream::ifpstream( LPCSTR name, int omode, int prot )
802:
803 fpbase( name, omode | std::ios::in | std::ios::binary, prot )
804{
805}
806
807/// Creates a buffered ifpstream object. It opens the file specified by name
808/// using the mode mode and protection prot; and attaches this file to the stream.
809inline ifpstream::ifpstream( LPCWSTR name, int omode, int prot )
810:
811 fpbase( name, omode | std::ios::in | std::ios::binary, prot )
812{
813}
814
815/// Returns a pointer to the current file buffer.
816inline std::filebuf * ifpstream::rdbuf(){
817 return fpbase::rdbuf();
818}
819
820/// It opens the named file in the given mode (app, ate, in, out, binary, trunc,
821/// nocreate, or noreplace) and protection. The default mode for ifpstream is
822/// ios::in (input) with openprot protection. The opened file is attached to this
823/// stream.
824inline void ifpstream::open( LPCSTR name,
825 int omode,
826 int prot )
827{
828 fpbase::open( name, omode | std::ios::in | std::ios::binary, prot );
829 readVersion();
830}
831
832/// It opens the named file in the given mode (app, ate, in, out, binary, trunc,
833/// nocreate, or noreplace) and protection. The default mode for ifpstream is
834/// ios::in (input) with openprot protection. The opened file is attached to this
835/// stream.
836inline void ifpstream::open( LPCWSTR name,
837 int omode,
838 int prot )
839{
840 fpbase::open( name, omode | std::ios::in | std::ios::binary, prot );
841 readVersion();
842}
843
844/// Creates a buffered ofpstream object using a default buffer.
845inline ofpstream::ofpstream(){
846}
847
848/// Creates a buffered ofpstream object. It opens the file specified by
849/// name, using the mode mode, and protection prot; and attaches this file to the
850/// stream
851inline ofpstream::ofpstream( LPCSTR name, int omode, int prot )
852:
853 fpbase( name, omode | std::ios::out | std::ios::binary, prot )
854{
855}
856
857/// Creates a buffered ofpstream object. It opens the file specified by
858/// name, using the mode mode, and protection prot; and attaches this file to the
859/// stream
860inline ofpstream::ofpstream( LPCWSTR name, int omode, int prot )
861:
862 fpbase( name, omode | std::ios::out | std::ios::binary, prot )
863{
864}
865
866inline std::filebuf * ofpstream::rdbuf(){
867 return fpbase::rdbuf();
868}
869
870/// Opens the named file in the given mode (app, ate, in, out, binary, trunc,
871/// nocreate, or noreplace) and protection. The default mode for ofpstream is
872/// ios::out (output) with openprot protection. The opened file is attached to this
873/// stream.
874inline void ofpstream::open( LPCSTR name,
875 int omode,
876 int prot )
877{
878 fpbase::open( name, omode | std::ios::out | std::ios::binary, prot );
879 writeVersion();
880}
881
882/// Returns a pointer to the current file buffer.
883inline void ofpstream::open( LPCWSTR name,
884 int omode,
885 int prot )
886{
887 fpbase::open( name, omode | std::ios::out | std::ios::binary, prot );
888 writeVersion();
889}
890
891/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
892/// given argument. It returns a reference to the stream that lets you chain >>
893/// operations in the usual way.
894/// The data type of the argument determines how the read is performed. For example,
895/// reading a signed char is implemented using readByte.
896inline ipstream& operator >> ( ipstream& ps, int8& ch )
897{
898 ch = ps.readByte();
899 return ps;
900}
901
902/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
903/// given argument. It returns a reference to the stream that lets you chain >>
904/// operations in the usual way.
905/// The data type of the argument determines how the read is performed. For example,
906/// reading a signed char is implemented using readByte.
907inline ipstream& operator >> ( ipstream& ps, uint8& ch ){
908 ch = ps.readByte();
909 return ps;
910}
911
912/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
913/// given argument. It returns a reference to the stream that lets you chain >>
914/// operations in the usual way.
915/// The data type of the argument determines how the read is performed. For example,
916/// reading a signed char is implemented using readByte.
917inline ipstream& operator >> ( ipstream& ps, char &ch ){
918 ch = ps.readByte();
919 return ps;
920}
921
922/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
923/// given argument. It returns a reference to the stream that lets you chain >>
924/// operations in the usual way.
925/// The data type of the argument determines how the read is performed. For example,
926/// reading a signed char is implemented using readByte.
927inline ipstream& operator >> ( ipstream& ps, signed short &sh ){
928 sh = ps.readWord16();
929 return ps;
930}
931
932/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
933/// given argument. It returns a reference to the stream that lets you chain >>
934/// operations in the usual way.
935/// The data type of the argument determines how the read is performed. For example,
936/// reading a signed char is implemented using readByte.
937inline ipstream& operator >> ( ipstream& ps, unsigned short &sh ){
938 sh = ps.readWord16();
939 return ps;
940}
941
942/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
943/// given argument. It returns a reference to the stream that lets you chain >>
944/// operations in the usual way.
945/// The data type of the argument determines how the read is performed. For example,
946/// reading a signed char is implemented using readByte.
947inline ipstream& operator >> ( ipstream& ps, signed int &i ){
948 i = (int)(ps.readWord());
949 return ps;
950}
951
952/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
953/// given argument. It returns a reference to the stream that lets you chain >>
954/// operations in the usual way.
955/// The data type of the argument determines how the read is performed. For example,
956/// reading a signed char is implemented using readByte.
957inline ipstream& operator >> ( ipstream& ps, unsigned int &i ){
958 i = (unsigned int)(ps.readWord());
959 return ps;
960}
961
962/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
963/// given argument. It returns a reference to the stream that lets you chain >>
964/// operations in the usual way.
965/// The data type of the argument determines how the read is performed. For example,
966/// reading a signed char is implemented using readByte.
967inline ipstream& operator >> ( ipstream& ps, signed long &l ){
968 ps.readBytes( &l, sizeof(l) );
969 return ps;
970}
971
972/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
973/// given argument. It returns a reference to the stream that lets you chain >>
974/// operations in the usual way.
975/// The data type of the argument determines how the read is performed. For example,
976/// reading a signed char is implemented using readByte.
977inline ipstream& operator >> ( ipstream& ps, unsigned long &l ){
978 ps.readBytes( &l, sizeof(l) );
979 return ps;
980}
981
982inline ipstream& operator >> (ipstream& ps, int64& v)
983{
984 ps.readBytes(&v, sizeof v);
985 return ps;
986}
987
988inline ipstream& operator >> (ipstream& ps, uint64& v)
989{
990 ps.readBytes(&v, sizeof v);
991 return ps;
992}
993
994/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
995/// given argument. It returns a reference to the stream that lets you chain >>
996/// operations in the usual way.
997/// The data type of the argument determines how the read is performed. For example,
998/// reading a signed char is implemented using readByte.
999inline ipstream& operator >> ( ipstream& ps, float &f ){
1000 ps.readBytes( &f, sizeof(f) );
1001 return ps;
1002}
1003
1004/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
1005/// given argument. It returns a reference to the stream that lets you chain >>
1006/// operations in the usual way.
1007/// The data type of the argument determines how the read is performed. For example,
1008/// reading a signed char is implemented using readByte.
1009inline ipstream& operator >> ( ipstream& ps, double &d ){
1010 ps.readBytes( &d, sizeof(d) );
1011 return ps;
1012}
1013
1014/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
1015/// given argument. It returns a reference to the stream that lets you chain >>
1016/// operations in the usual way.
1017/// The data type of the argument determines how the read is performed. For example,
1018/// reading a signed char is implemented using readByte.
1019inline ipstream& operator >> ( ipstream& ps, long double &l ){
1020 ps.readBytes( &l, sizeof(l) );
1021 return ps;
1022}
1023
1024/// This friend operator of ipstream extracts (reads) from the ipstream ps, to the
1025/// given argument. It returns a reference to the stream that lets you chain >>
1026/// operations in the usual way.
1027/// The data type of the argument determines how the read is performed. For example,
1028/// reading a signed char is implemented using readByte.
1029inline ipstream& operator >> ( ipstream& ps, bool &b ){
1030 b = static_cast<bool>(ps.readWord32());
1031 return ps;
1032}
1033
1034/// This friend operator of opstream inserts (writes) the given argument to the
1035/// given ipstream object.
1036/// The data type of the argument determines the form of write operation employed.
1037inline opstream& operator << ( opstream& ps, int8 ch ){
1038 ps.writeByte( ch );
1039 return ps;
1040}
1041
1042/// This friend operator of opstream inserts (writes) the given argument to the
1043/// given ipstream object.
1044/// The data type of the argument determines the form of write operation employed.
1045inline opstream& operator << ( opstream& ps, uint8 ch ){
1046 ps.writeByte( ch );
1047 return ps;
1048}
1049
1050/// This friend operator of opstream inserts (writes) the given argument to the
1051/// given ipstream object.
1052/// The data type of the argument determines the form of write operation employed.
1053inline opstream& operator << ( opstream& ps, char ch ){
1054 ps.writeByte( ch );
1055 return ps;
1056}
1057
1058/// This friend operator of opstream inserts (writes) the given argument to the
1059/// given ipstream object.
1060/// The data type of the argument determines the form of write operation employed.
1061inline opstream& operator << ( opstream& ps, signed short sh ){
1062 ps.writeWord16( sh );
1063 return ps;
1064}
1065
1066/// This friend operator of opstream inserts (writes) the given argument to the
1067/// given ipstream object.
1068/// The data type of the argument determines the form of write operation employed.
1069inline opstream& operator << ( opstream& ps, unsigned short sh ){
1070 ps.writeWord16( sh );
1071 return ps;
1072}
1073
1074/// This friend operator of opstream inserts (writes) the given argument to the
1075/// given ipstream object.
1076/// The data type of the argument determines the form of write operation employed.
1077inline opstream& operator << ( opstream& ps, signed int i ){
1078 ps.writeWord32( i );
1079 return ps;
1080}
1081
1082/// This friend operator of opstream inserts (writes) the given argument to the
1083/// given ipstream object.
1084/// The data type of the argument determines the form of write operation employed.
1085inline opstream& operator << ( opstream& ps, unsigned int i ){
1086 ps.writeWord32( i );
1087 return ps;
1088}
1089
1090/// This friend operator of opstream inserts (writes) the given argument to the
1091/// given ipstream object.
1092/// The data type of the argument determines the form of write operation employed.
1093inline opstream& operator << ( opstream& ps, signed long l ){
1094 ps.writeBytes( &l, sizeof(l) );
1095 return ps;
1096}
1097
1098/// This friend operator of opstream inserts (writes) the given argument to the
1099/// given ipstream object.
1100/// The data type of the argument determines the form of write operation employed.
1101inline opstream& operator << ( opstream& ps, unsigned long l ){
1102 ps.writeBytes( &l, sizeof(l) );
1103 return ps;
1104}
1105
1106inline opstream& operator << (opstream& ps, int64 v)
1107{
1108 ps.writeBytes(&v, sizeof v);
1109 return ps;
1110}
1111
1112inline opstream& operator << (opstream& ps, uint64 v)
1113{
1114 ps.writeBytes(&v, sizeof v);
1115 return ps;
1116}
1117
1118/// This friend operator of opstream inserts (writes) the given argument to the
1119/// given ipstream object.
1120/// The data type of the argument determines the form of write operation employed.
1121inline opstream& operator << ( opstream& ps, float f ){
1122 ps.writeBytes( &f, sizeof(f) );
1123 return ps;
1124}
1125
1126/// This friend operator of opstream inserts (writes) the given argument to the
1127/// given ipstream object.
1128/// The data type of the argument determines the form of write operation employed.
1129inline opstream& operator << ( opstream& ps, double d ){
1130 ps.writeBytes( &d, sizeof(d) );
1131 return ps;
1132}
1133
1134/// This friend operator of opstream inserts (writes) the given argument to the
1135/// given ipstream object.
1136/// The data type of the argument determines the form of write operation employed.
1137inline opstream& operator << ( opstream& ps, long double l ){
1138 ps.writeBytes( &l, sizeof(l) );
1139 return ps;
1140}
1141
1142/// This friend operator of opstream inserts (writes) the given argument to the
1143/// given ipstream object.
1144/// The data type of the argument determines the form of write operation employed.
1145inline opstream& operator << ( opstream& ps, bool b ){
1146 ps.writeWord32( b );
1147 return ps;
1148}
1149
1150template <class Base> void WriteBaseObject( Base *base, opstream& out )
1151{
1152 typedef typename Base::Streamer Base_Streamer;
1153
1154 Base_Streamer strmr(base);
1155 out << strmr.ClassVersion();
1156 strmr.Write( out );
1157}
1158
1159template <class Base> void ReadBaseObject( Base *base, ipstream& in )
1160{
1161 typedef typename Base::Streamer Base_Streamer;
1162
1163 uint32 version = 0;
1164 if( in.getVersion() > 0 )
1165 in >> version;
1166 Base_Streamer(base).Read( in, version );
1167}
1168
1169template <class Base> void WriteVirtualBase( Base *base, opstream& out )
1170{
1171 typedef typename Base::Streamer Base_Streamer;
1172
1173 if( !out.good() )
1174 return;
1175 if( out.findVB( base ) != 0 ){
1176 out.writeByte( pstream::ptIndexed ); // use ptIndexed to indicate
1177 // that we've already seen
1178 // this virtual base. Don't
1179 // need to actually write it.
1180 }
1181 else{
1182 Base_Streamer strmr(base);
1183 out.registerObject( (TStreamableBase *)((char*)base + 1) );
1184 out.writeByte( pstream::ptObject );
1185 out.writeWord32( strmr.ClassVersion() );
1186 strmr.Write( out );
1187 }
1188}
1189
1190template <class Base> void ReadVirtualBase( Base *base, ipstream& in )
1191{
1192 typedef typename Base::Streamer Base_Streamer;
1193
1194 char ch;
1195 in >> ch;
1196 switch( ch ){
1197 case pstream::ptIndexed:
1198 break; // We've already read this virtual base
1199 case pstream::ptObject: {
1200 uint32 ver = 0;
1201 if( in.getVersion() > 0 )
1202 ver = in.readWord32();
1203 Base_Streamer strmr(base);
1204 // register the address
1205 in.registerObject(strmr.GetObject());
1206 strmr.Read( in, ver );
1207 }
1208 break;
1209 }
1210}
1211
1212//
1213// Individual Components for Streamable Declarations
1214//
1215
1216#if defined(__clang__)
1217#define READBASEOBJECT(cls) ReadBaseObject<cls>( cls *, ::owl::ipstream& )
1218#define WRITEBASEOBJECT(cls) WriteBaseObject<cls>( cls *, ::owl::opstream& )
1219#define READVIRTUALBASE(cls) ReadVirtualBase<cls>( cls *, ::owl::ipstream& )
1220#define WRITEVIRTUALBASE(cls) WriteVirtualBase<cls>( cls *, ::owl::opstream& )
1221#else
1222#define READBASEOBJECT(cls) ReadBaseObject( cls *, ::owl::ipstream& )
1223#define WRITEBASEOBJECT(cls) WriteBaseObject( cls *, ::owl::opstream& )
1224#define READVIRTUALBASE(cls) ReadVirtualBase( cls *, ::owl::ipstream& )
1225#define WRITEVIRTUALBASE(cls) WriteVirtualBase( cls *, ::owl::opstream& )
1226#endif
1227
1228
1229
1230#define DECLARE_STREAMERS(cls, ver ) \
1231public: \
1232 class Streamer : public ::owl::TNewStreamer \
1233 { \
1234 public: \
1235 \
1236 Streamer( ::owl::TStreamableBase *obj ); \
1237 \
1238 virtual ::owl::uint32 ClassVersion() const \
1239 { return ver; } \
1240 \
1241 virtual void Write( ::owl::opstream& ) const; \
1242 virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const; \
1243 \
1244 cls *GetObject() const \
1245 { \
1246 return object; \
1247 } \
1248 \
1249 static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
1250 { \
1251 return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
1252 } \
1253 \
1254 private: \
1255 cls *object; \
1256 \
1257 }; \
1258 friend class Streamer; \
1259 friend void ::owl:: READBASEOBJECT( cls ); \
1260 friend void ::owl:: WRITEBASEOBJECT( cls );\
1261 friend void ::owl:: READVIRTUALBASE( cls );\
1262 friend void ::owl:: WRITEVIRTUALBASE( cls )
1263
1264
1265#define DECLARE_STREAMER( exp, cls, ver ) \
1266public: \
1267 class exp Streamer : public ::owl::TNewStreamer \
1268 { \
1269 public: \
1270 \
1271 Streamer( ::owl::TStreamableBase *obj ); \
1272 \
1273 virtual ::owl::uint32 ClassVersion() const \
1274 { return ver; } \
1275 \
1276 virtual void Write( ::owl::opstream& ) const; \
1277 virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const; \
1278 \
1279 cls *GetObject() const \
1280 { \
1281 return object; \
1282 } \
1283 \
1284 static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
1285 { \
1286 return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
1287 } \
1288 \
1289 private: \
1290 cls *object; \
1291 \
1292 }; \
1293 friend class exp Streamer; \
1294 friend void ::owl:: READBASEOBJECT( cls ); \
1295 friend void ::owl:: WRITEBASEOBJECT( cls ); \
1296 friend void ::owl:: READVIRTUALBASE( cls ); \
1297 friend void ::owl:: WRITEVIRTUALBASE( cls )
1298
1299
1300#define DECLARE_STREAMER_FROM_BASES(cls, base ) \
1301public: \
1302 class Streamer : public base::Streamer \
1303 { \
1304 public: \
1305 \
1306 Streamer( ::owl::TStreamableBase *obj ) : base::Streamer(obj){} \
1307 \
1308 cls *GetObject() const \
1309 { \
1310 return object; \
1311 } \
1312 \
1313 static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
1314 { \
1315 return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
1316 } \
1317 \
1318 private: \
1319 cls *object; \
1320 \
1321 }; \
1322 friend class Streamer; \
1323 friend void ::owl:: READBASEOBJECT( cls ); \
1324 friend void ::owl:: WRITEBASEOBJECT( cls ); \
1325 friend void ::owl:: READVIRTUALBASE( cls ); \
1326 friend void ::owl:: WRITEVIRTUALBASE( cls )
1327
1328
1329#define DECLARE_STREAMER_FROM_BASE( exp, cls, base ) \
1330public: \
1331 class exp Streamer : public base::Streamer \
1332 { \
1333 public: \
1334 \
1335 Streamer( ::owl::TStreamableBase *obj ) : base::Streamer(obj){} \
1336 \
1337 cls *GetObject() const \
1338 { \
1339 return object; \
1340 } \
1341 \
1342 static ::owl::TStreamer *Build( ::owl::TStreamableBase *obj ) \
1343 { \
1344 return new Streamer( obj ? obj : new cls(::owl::streamableInit) ); \
1345 } \
1346 \
1347 private: \
1348 cls *object; \
1349 \
1350 }; \
1351 friend class exp Streamer; \
1352 friend void ::owl:: READBASEOBJECT( cls ); \
1353 friend void ::owl:: WRITEBASEOBJECT( cls );\
1354 friend void ::owl:: READVIRTUALBASE( cls );\
1355 friend void ::owl:: WRITEVIRTUALBASE( cls )
1356
1357#define DECLARE_ABSTRACT_STREAMERS(cls, ver ) \
1358public: \
1359 class Streamer : public ::owl::TNewStreamer \
1360 { \
1361 public: \
1362 \
1363 Streamer( ::owl::TStreamableBase *obj ); \
1364 \
1365 virtual ::owl::uint32 ClassVersion() const \
1366 { return ver; } \
1367 \
1368 virtual void Write( ::owl::opstream& ) const; \
1369 virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const; \
1370 \
1371 cls *GetObject() const \
1372 { \
1373 return object; \
1374 } \
1375 \
1376 private: \
1377 cls *object; \
1378 \
1379 }; \
1380 friend class Streamer; \
1381 friend void ::owl:: READBASEOBJECT( cls ); \
1382 friend void ::owl:: WRITEBASEOBJECT( cls );\
1383 friend void ::owl:: READVIRTUALBASE( cls );\
1384 friend void ::owl:: WRITEVIRTUALBASE( cls )
1385
1386#define DECLARE_ABSTRACT_STREAMER( exp, cls, ver ) \
1387public: \
1388 class exp Streamer : public ::owl::TNewStreamer \
1389 { \
1390 public: \
1391 \
1392 Streamer( ::owl::TStreamableBase *obj ); \
1393 \
1394 virtual ::owl::uint32 ClassVersion() const \
1395 { return ver; } \
1396 \
1397 virtual void Write( ::owl::opstream& ) const; \
1398 virtual void *Read( ::owl::ipstream&, ::owl::uint32 ) const; \
1399 \
1400 cls *GetObject() const \
1401 { \
1402 return object; \
1403 } \
1404 \
1405 private: \
1406 cls *object; \
1407 \
1408 }; \
1409 friend class exp Streamer; \
1410 friend void ::owl:: READBASEOBJECT( cls ); \
1411 friend void ::owl:: WRITEBASEOBJECT( cls );\
1412 friend void ::owl:: READVIRTUALBASE( cls );\
1413 friend void ::owl:: WRITEVIRTUALBASE( cls )
1414
1415
1416#define DECLARE_STREAMABLE_OPS( cls ) \
1417static ::owl::ipstream& readRef( ::owl::ipstream& is, cls& cl ); \
1418friend inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls& cl ) \
1419 { return cls::readRef( is, cl ); } \
1420static ::owl::ipstream& readPtr( ::owl::ipstream& is, cls*& cl ); \
1421friend inline ::owl::ipstream& operator >> ( ::owl::ipstream& is, cls*& cl ) \
1422 { return cls::readPtr( is, cl ); } \
1423static ::owl::opstream& writeRef( ::owl::opstream& is, const cls& cl ); \
1424friend inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls& cl ) \
1425 { return cls::writeRef( os, cl ); } \
1426static ::owl::opstream& writePtr( ::owl::opstream& is, const cls* cl ); \
1427friend inline ::owl::opstream& operator << ( ::owl::opstream& os, const cls* cl ) \
1428 { return cls::writePtr( os, cl ); }
1429
1430#define DECLARE_STREAMABLE_INLINES_I( cls )
1431
1432
1433#define DECLARE_STREAMABLE_CTOR( cls ) \
1434public: \
1435 cls ( ::owl::StreamableInit )
1436
1437//
1438// Castable declaration macros
1439//
1440# define DECLARE_CASTABLE friend class std::type_info
1441
1442//
1443// Streamable declaration macros
1444//
1445#if OWL_PERSISTENT_STREAMS
1446
1447#define DECLARE_STREAMABLE( exp, cls, ver ) \
1448 DECLARE_CASTABLE ; \
1449 DECLARE_STREAMER( exp, cls, ver ); \
1450 DECLARE_STREAMABLE_OPS( cls ); \
1451 DECLARE_STREAMABLE_CTOR( cls )
1452
1453#define DECLARE_STREAMABLES(cls, ver ) \
1454 DECLARE_CASTABLE ; \
1455 DECLARE_STREAMERS(cls, ver ); \
1456 DECLARE_STREAMABLE_OPS( cls ); \
1457 DECLARE_STREAMABLE_CTOR( cls )
1458
1459#define DECLARE_STREAMABLE_FROM_BASE( exp, cls, base ) \
1460 DECLARE_CASTABLE; \
1461 DECLARE_STREAMER_FROM_BASE( exp, cls, base ); \
1462 DECLARE_STREAMABLE_OPS( cls ); \
1463 DECLARE_STREAMABLE_CTOR( cls )
1464
1465#define DECLARE_STREAMABLE_FROM_BASES(cls, base ) \
1466 DECLARE_CASTABLE; \
1467 DECLARE_STREAMER_FROM_BASES(cls, base ); \
1468 DECLARE_STREAMABLE_OPS( cls ); \
1469 DECLARE_STREAMABLE_CTOR( cls )
1470
1471#define DECLARE_ABSTRACT_STREAMABLE( exp, cls, ver ) \
1472 DECLARE_CASTABLE; \
1473 DECLARE_ABSTRACT_STREAMER( exp, cls, ver ); \
1474 DECLARE_STREAMABLE_OPS( cls ); \
1475 DECLARE_STREAMABLE_CTOR( cls )
1476
1477#define DECLARE_ABSTRACT_STREAMABLES(cls, ver ) \
1478 DECLARE_CASTABLE; \
1479 DECLARE_ABSTRACT_STREAMERS(cls, ver ); \
1480 DECLARE_STREAMABLE_OPS( cls ); \
1481 DECLARE_STREAMABLE_CTOR( cls )
1482
1483// only for OWL
1484#if defined(_BUILDOWLDLL) || defined(_OWLDLL)
1485# define DECLARE_STREAMABLE_OWL( cls, ver ) \
1486 DECLARE_STREAMABLE( _OWLCLASS, cls, ver )
1487# define DECLARE_STREAMABLE_FROM_BASE_OWL( cls, base ) \
1488 DECLARE_STREAMABLE_FROM_BASE( _OWLCLASS, cls, base )
1489#define DECLARE_ABSTRACT_STREAMABLE_OWL(cls, ver ) \
1490 DECLARE_ABSTRACT_STREAMABLE( _OWLCLASS, cls, ver )
1491
1492#define DECLARE_STREAMABLE_INLINES( cls ) \
1493 DECLARE_STREAMABLE_INLINES_I( cls )
1494
1495#else
1496# define DECLARE_STREAMABLE_OWL(cls, ver ) \
1497 DECLARE_STREAMABLES( cls, ver )
1498# define DECLARE_STREAMABLE_FROM_BASE_OWL( cls, base ) \
1499 DECLARE_STREAMABLE_FROM_BASES(cls, base )
1500#define DECLARE_ABSTRACT_STREAMABLE_OWL(cls, ver ) \
1501 DECLARE_ABSTRACT_STREAMABLES(cls, ver )
1502
1503#define DECLARE_STREAMABLE_INLINES( cls ) \
1504 DECLARE_STREAMABLE_INLINES_I( cls )
1505
1506#endif
1507
1508
1509#else
1510
1511#define DECLARE_STREAMABLE( exp, cls, ver ) \
1512 DECLARE_CASTABLE
1513
1514#define DECLARE_STREAMABLE_S(cls, ver ) \
1515 DECLARE_CASTABLE
1516
1517#define DECLARE_STREAMABLE_FROM_BASE( exp, cls, base ) \
1518 DECLARE_CASTABLE
1519
1520#define DECLARE_STREAMABLE_FROM_BASE_S( cls, base ) \
1521 DECLARE_CASTABLE
1522
1523#define DECLARE_ABSTRACT_STREAMABLE( exp, cls, ver ) \
1524 DECLARE_CASTABLE
1525
1526#define DECLARE_ABSTRACT_STREAMABLE_S( cls, ver ) \
1527 DECLARE_CASTABLE
1528
1529#define DECLARE_STREAMABLE_OWL(cls, ver ) \
1530 DECLARE_CASTABLE
1531
1532# define DECLARE_STREAMABLE_FROM_BASE_OWL( cls, base ) \
1533 DECLARE_CASTABLE
1534
1535#define DECLARE_ABSTRACT_STREAMABLE_OWL( cls, ver ) \
1536 DECLARE_CASTABLE
1537
1538#define DECLARE_STREAMABLE_INLINES( cls )
1539
1540#endif
1541
1542//
1543// Castable implementation macros
1544//
1545
1546// These macros are obsolete, since all modern compilers support RTTI. They will be moved to backward compatibility section
1547#define IMPLEMENT_CASTABLE( cls )
1548#define IMPLEMENT_CASTABLE1( cls, base1 )
1549#define IMPLEMENT_CASTABLE2( cls, base1, base2 )
1550#define IMPLEMENT_CASTABLE3( cls, base1, base2, base3 )
1551#define IMPLEMENT_CASTABLE4( cls, base1, base2, base3, base4 )
1552#define IMPLEMENT_CASTABLE5( cls, base1, base2, base3, base4, base5 )
1553
1554
1555
1556//
1557// Streamable implementation mactos
1558//
1559#if OWL_PERSISTENT_STREAMS
1560# if defined(BI_COMP_MSC) && !defined(UNIX) && !defined(__EDG__)
1561# if defined(BI_COMPATIBLE_STREAMING)
1562# define IMPLEMENT_STREAMABLE_CLASS( cls ) \
1563 ::owl::TStreamableClass r ## cls( typeid(cls).name() + 6, &cls::Streamer::Build )
1564# else
1565# define IMPLEMENT_STREAMABLE_CLASS( cls ) \
1566 ::owl::TStreamableClass r ## cls( typeid(cls).raw_name(), &cls::Streamer::Build )
1567# endif
1568# else
1569# define IMPLEMENT_STREAMABLE_CLASS( cls ) \
1570 ::owl::TStreamableClass r ## cls( typeid(cls).name(), &cls::Streamer::Build )
1571# endif
1572#else
1573# define IMPLEMENT_STREAMABLE_CLASS( cls )
1574#endif
1575
1576#if OWL_PERSISTENT_STREAMS
1577
1578#define IMPLEMENT_STREAMABLE_POINTER_IMPL(template_prefix, cls)\
1579 template_prefix owl::ipstream& cls::readPtr(::owl::ipstream& is, cls*& cl)\
1580 {::owl::TStreamableBase *t = 0; cl = dynamic_cast<cls*>(is.readObjectPointer(t)); return is;}\
1581 \
1582 template_prefix owl::ipstream& cls::readRef(::owl::ipstream& is, cls& cl)\
1583 {::owl::TStreamableBase* p = &cl; is.readObject(p); return is;}\
1584 \
1585 template_prefix owl::opstream& cls::writeRef(::owl::opstream& os, const cls& cl)\
1586 {os.writeObject(&cl); return os;}\
1587 \
1588 template_prefix owl::opstream& cls::writePtr(::owl::opstream& os, const cls* cl)\
1589 {os.writeObjectPointer(cl); return os;}
1590
1591#define IMPLEMENT_STREAMABLE_POINTER(cls)\
1592 IMPLEMENT_STREAMABLE_POINTER_IMPL(, cls)
1593
1594#else
1595#define IMPLEMENT_STREAMABLE_POINTER_IMPL(template_prefix, cls)
1596#define IMPLEMENT_STREAMABLE_POINTER( cls )
1597#endif
1598
1599#if OWL_PERSISTENT_STREAMS
1600
1601#define IMPLEMENT_STREAMER( cls ) \
1602cls::Streamer::Streamer( ::owl::TStreamableBase *obj ) : \
1603 ::owl::TNewStreamer(obj), object(TYPESAFE_DOWNCAST(obj,cls)){}
1604
1605#define IMPLEMENT_STREAMABLE_CTOR( cls ) \
1606cls::cls ( ::owl::StreamableInit ) {}
1607
1608#define IMPLEMENT_STREAMABLE_CTOR1_IMPL(template_prefix, cls, constructor, base1)\
1609 template_prefix cls::constructor(::owl::StreamableInit) : base1(::owl::streamableInit) {}
1610
1611#define IMPLEMENT_STREAMABLE_CTOR1(cls, base1)\
1612 IMPLEMENT_STREAMABLE_CTOR1_IMPL(, cls, cls, base1)
1613
1614#define IMPLEMENT_STREAMABLE_CTOR2( cls, base1, base2 ) \
1615cls::cls ( ::owl::StreamableInit ) : \
1616 base1 ( ::owl::streamableInit ), \
1617 base2 ( ::owl::streamableInit ) {}
1618
1619#define IMPLEMENT_STREAMABLE_CTOR3( cls, base1, base2, base3 ) \
1620cls::cls ( ::owl::StreamableInit ) : \
1621 base1 ( ::owl::streamableInit ), \
1622 base2 ( ::owl::streamableInit ), \
1623 base3 ( ::owl::streamableInit ) {}
1624
1625#define IMPLEMENT_STREAMABLE_CTOR4( cls, base1, base2, base3, base4 )\
1626cls::cls ( ::owl::StreamableInit ) : \
1627 base1 ( ::owl::streamableInit ), \
1628 base2 ( ::owl::streamableInit ), \
1629 base3 ( ::owl::streamableInit ), \
1630 base4 ( ::owl::streamableInit ) {}
1631
1632#define IMPLEMENT_STREAMABLE_CTOR5( cls, base1,base2,base3,base4,base5)\
1633cls::cls ( ::owl::StreamableInit ) : \
1634 base1 ( ::owl::streamableInit ), \
1635 base2 ( ::owl::streamableInit ), \
1636 base3 ( ::owl::streamableInit ), \
1637 base4 ( ::owl::streamableInit ), \
1638 base5 ( ::owl::streamableInit ) {}
1639
1640#else
1641# define IMPLEMENT_STREAMER( cls )
1642# define IMPLEMENT_STREAMABLE_CTOR( cls )
1643# define IMPLEMENT_STREAMABLE_CTOR1_IMPL(template_prefix, cls, constructor, base1)
1644# define IMPLEMENT_STREAMABLE_CTOR1( cls, base1 )
1645# define IMPLEMENT_STREAMABLE_CTOR2( cls, base1, base2 )
1646# define IMPLEMENT_STREAMABLE_CTOR3( cls, base1, base2, base3 )
1647# define IMPLEMENT_STREAMABLE_CTOR4( cls, base1, base2, base3, base4 )
1648# define IMPLEMENT_STREAMABLE_CTOR5( cls, base1,base2,base3,base4,base5)
1649#endif
1650 \
1651
1652//
1653// Standard Combinations of Streamable Implementations
1654//
1655
1656#if OWL_PERSISTENT_STREAMS
1657#define IMPLEMENT_ABSTRACT_STREAMABLE( cls ) \
1658IMPLEMENT_STREAMER( cls ); \
1659IMPLEMENT_STREAMABLE_CTOR( cls ); \
1660IMPLEMENT_STREAMABLE_POINTER( cls )
1661
1662#define IMPLEMENT_ABSTRACT_STREAMABLE1( cls, base1 ) \
1663IMPLEMENT_STREAMER( cls ); \
1664IMPLEMENT_STREAMABLE_CTOR1( cls, base1 ); \
1665IMPLEMENT_STREAMABLE_POINTER( cls )
1666
1667#define IMPLEMENT_ABSTRACT_STREAMABLE2( cls, base1, base2 ) \
1668IMPLEMENT_STREAMER( cls ); \
1669IMPLEMENT_STREAMABLE_CTOR2( cls, base1, base2 ); \
1670IMPLEMENT_STREAMABLE_POINTER( cls )
1671
1672#define IMPLEMENT_ABSTRACT_STREAMABLE3( cls, base1, base2, base3 ) \
1673IMPLEMENT_STREAMER( cls ); \
1674IMPLEMENT_STREAMABLE_CTOR3( cls, base1, base2, base3 ); \
1675IMPLEMENT_STREAMABLE_POINTER( cls )
1676
1677#define IMPLEMENT_ABSTRACT_STREAMABLE4( cls, base1, base2, base3, base4 )\
1678IMPLEMENT_STREAMER( cls ); \
1679IMPLEMENT_STREAMABLE_CTOR4( cls, base1, base2, base3, base4 ); \
1680IMPLEMENT_STREAMABLE_POINTER( cls )
1681
1682#define IMPLEMENT_ABSTRACT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )\
1683IMPLEMENT_STREAMER( cls ); \
1684IMPLEMENT_STREAMABLE_CTOR5( cls, base1, base2, base3, base4, base5 );\
1685IMPLEMENT_STREAMABLE_POINTER( cls )
1686
1687#define IMPLEMENT_STREAMABLE( cls ) \
1688IMPLEMENT_STREAMABLE_CLASS( cls ); \
1689IMPLEMENT_ABSTRACT_STREAMABLE( cls )
1690
1691#define IMPLEMENT_STREAMABLE1( cls, base1 ) \
1692IMPLEMENT_STREAMABLE_CLASS( cls ); \
1693IMPLEMENT_ABSTRACT_STREAMABLE1( cls, base1 )
1694
1695#define IMPLEMENT_STREAMABLE2( cls, base1, base2 ) \
1696IMPLEMENT_STREAMABLE_CLASS( cls ); \
1697IMPLEMENT_ABSTRACT_STREAMABLE2( cls, base1, base2 )
1698
1699#define IMPLEMENT_STREAMABLE3( cls, base1, base2, base3 ) \
1700IMPLEMENT_STREAMABLE_CLASS( cls ); \
1701IMPLEMENT_ABSTRACT_STREAMABLE3( cls, base1, base2, base3 )
1702
1703#define IMPLEMENT_STREAMABLE4( cls, base1, base2, base3, base4 ) \
1704IMPLEMENT_STREAMABLE_CLASS( cls ); \
1705IMPLEMENT_ABSTRACT_STREAMABLE4( cls, base1, base2, base3, base4 )
1706
1707#define IMPLEMENT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )\
1708IMPLEMENT_STREAMABLE_CLASS( cls ); \
1709IMPLEMENT_ABSTRACT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )
1710
1711#define IMPLEMENT_STREAMABLE_FROM_BASE( cls, base1 ) \
1712IMPLEMENT_STREAMABLE_CLASS( cls ); \
1713IMPLEMENT_STREAMABLE_CTOR1( cls, base1 ); \
1714IMPLEMENT_STREAMABLE_POINTER( cls )
1715
1716#else
1717
1718#define IMPLEMENT_ABSTRACT_STREAMABLE( cls )
1719#define IMPLEMENT_ABSTRACT_STREAMABLE1( cls, base1 )
1720#define IMPLEMENT_ABSTRACT_STREAMABLE2( cls, base1, base2 )
1721#define IMPLEMENT_ABSTRACT_STREAMABLE3( cls, base1, base2, base3 )
1722#define IMPLEMENT_ABSTRACT_STREAMABLE4( cls, base1, base2, base3, base4 )
1723#define IMPLEMENT_ABSTRACT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )
1724#define IMPLEMENT_STREAMABLE( cls )
1725#define IMPLEMENT_STREAMABLE1( cls, base1 )
1726#define IMPLEMENT_STREAMABLE2( cls, base1, base2 )
1727#define IMPLEMENT_STREAMABLE3( cls, base1, base2, base3 )
1728#define IMPLEMENT_STREAMABLE4( cls, base1, base2, base3, base4 )
1729#define IMPLEMENT_STREAMABLE5( cls, base1, base2, base3, base4, base5 )
1730#define IMPLEMENT_STREAMABLE_FROM_BASE( cls, base1 )
1731
1732#endif
1733
1734/// @}
1735
1736} // OWL namespace
1737
1738
1739#endif // OWL_OBJSTRM_H
owl::TNewStreamer::TNewStreamer
TNewStreamer(TStreamableBase *obj)
Constructs the TNewStreamer object, and initializes the streamable object pointer.
Definition objstrm.h:226
owl::TNewStreamer::StreamableName
virtual LPCSTR StreamableName() const
Definition objstrm.h:230
owl::TOldStreamer
Provides a base class for all streamable objects.
Definition objstrm.h:174
owl::TOldStreamer::Read
virtual void * Read(ipstream &is, uint32) const
This pure virtual member function must be redefined for every streamable class.
Definition objstrm.h:196
owl::TOldStreamer::StreamableName
virtual LPCSTR StreamableName() const
This pure virtual member function must be redefined for every streamable class.
Definition objstrm.h:188
owl::TOldStreamer::TOldStreamer
TOldStreamer(TStreamable *obj)
Constructs the TOldStreamer object, and initializes the streamable object pointer.
Definition objstrm.h:180
owl::TOldStreamer::Write
virtual void Write(opstream &os) const
This pure virtual function must be redefined for every streamable class.
Definition objstrm.h:206
owl::TPWrittenObjects::TPWObj::TPWObj
TPWObj(const void *adr, P_id_type id)
Definition objstrm.h:265
owl::TStreamableBase
Classes that inherit from TStreamableBase are known as streamable classes (their objects can be writt...
Definition objstrm.h:108
owl::TStreamableClass
TStreamableClass is used by the private database class and pstream in the registration of streamable ...
Definition streambl.h:75
owl::TStreamable::streamableName
virtual LPCSTR streamableName() const =0
owl::TStreamable::read
virtual void * read(ipstream &)=0
owl::TStreamable::write
virtual void write(opstream &)=0
owl::TStreamer
Provides a base class for all streamable objects.
Definition objstrm.h:130
owl::TStreamer::Write
virtual void Write(opstream &) const =0
This pure virtual function must be redefined for every streamable class.
owl::TStreamer::TStreamer
TStreamer(TStreamableBase *obj)
Constructs the TStreamer object, and initializes the streamable object pointer.
Definition objstrm.h:145
owl::TStreamer::~TStreamer
virtual ~TStreamer()
Definition objstrm.h:137
owl::TStreamer::Read
virtual void * Read(ipstream &, uint32) const =0
This pure virtual member function must be redefined for every streamable class.
owl::TStreamer::GetObject
TStreamableBase * GetObject() const
Returns the address of the TStreamableBase component of the streamable object.
Definition objstrm.h:140
owl::fpbase
Provides the basic operations common to all object file stream I/O.
Definition objstrm.h:548
owl::fpbase::open
void open(LPCSTR, int, int=openprot)
Opens the named file in the given mode (app, ate, in, out, binary, trunc, nocreate,...
Definition objstrm.cpp:909
owl::ifpstream
ifpstream is a simple "mix" of its bases, fpbase and ipstream.
Definition objstrm.h:574
owl::ipstream
ipstream, a specialized input stream derivative of pstream, is the base class for reading (extracting...
Definition objstrm.h:391
owl::ipstream::seekg
ipstream & seekg(std::streamoff, std::ios::seekdir)
owl::ipstream::readVersion
void readVersion()
Reads the version number of the input stream.
Definition objstrm.cpp:540
owl::ipstream::seekg
ipstream & seekg(std::streampos)
owl::ofpstream
Provides the base class for writing (inserting) streamable objects to file streams.
Definition objstrm.h:605
owl::opstream
Base class for writing streamable objects.
Definition objstrm.h:480
owl::opstream::opstream
opstream(std::streambuf *)
owl::opstream::seekp
opstream & seekp(std::streamoff, std::ios::seekdir)
owl::opstream::writeByte
void writeByte(uint8)
Writes the byte ch to the stream.
Definition objstrm.cpp:753
owl::opstream::writeVersion
void writeVersion()
Definition objstrm.cpp:736
owl::opstream::seekp
opstream & seekp(std::streampos)
owl::opstream::writeWord32
void writeWord32(uint32)
Writes the 32-bit word us to the stream.
Definition objstrm.cpp:783
owl::pstream
Base class for handling streamable objects.
Definition objstrm.h:330
owl::pstream::bp
std::streambuf * bp
Definition objstrm.h:356
owl::pstream::PointerTypes
PointerTypes
Enumerates object pointer types.
Definition objstrm.h:336
owl::P_id_type
unsigned P_id_type
Definition objstrm.h:54
owl::pstream::good
int good() const
Returns nonzero if no error states have been recorded for the stream (that is, no errors have occurre...
Definition objstrm.h:666
owl::opstream::registerVB
void registerVB(TStreamableBase *adr)
Registers a virtual base class.
Definition objstrm.h:767
owl::pstream::operator!
int operator!() const
Overloads the NOT operator.
Definition objstrm.h:682
owl::opstream::registerObject
void registerObject(TStreamableBase *adr)
Registers the class of the object pointed to by adr.
Definition objstrm.h:757
owl::fpbase::rdbuf
std::filebuf * rdbuf()
Returns a pointer to the current file buffer.
Definition objstrm.h:791
owl::ipstream::registerObject
void registerObject(TStreamableBase *adr)
Registers the object pointed to by adr.
Definition objstrm.h:727
owl::pstream::rdbuf
std::streambuf * rdbuf() const
Returns the pb pointer to the buffer assigned to the stream.
Definition objstrm.h:687
owl::opstream::findObject
P_id_type findObject(TStreamableBase *adr)
Returns the type ID for the object pointed to by adr.
Definition objstrm.h:752
owl::ifpstream::ifpstream
ifpstream()
Creates a buffered ifpstream object using a default buffer.
Definition objstrm.h:796
owl::opstream::findVB
P_id_type findVB(TStreamableBase *adr)
Returns a pointer to the virtual base.
Definition objstrm.h:762
owl::ofpstream::open
void open(LPCSTR, int=std::ios::out, int=fpbase::openprot)
Opens the named file in the given mode (app, ate, in, out, binary, trunc, nocreate,...
Definition objstrm.h:874
owl::pstream::bad
int bad() const
Returns nonzero if an error occurs.
Definition objstrm.h:660
owl::ofpstream::rdbuf
std::filebuf * rdbuf()
Definition objstrm.h:866
owl::opstream::writeSuffix
void writeSuffix(const TStreamableBase *)
Writes the class name suffix to the stream.
Definition objstrm.h:747
owl::pstream::clear
void clear(int=0)
Sets the stream state to the given value (defaults to 0).
Definition objstrm.h:671
owl::ipstream::ipstream
ipstream()
Creates a buffered ipstream without initializing the buffer pointer, bp.
Definition objstrm.h:716
_OBJ_TYPENAME
#define _OBJ_TYPENAME(obj)
Definition objstrm.h:86
owl::opstream::writeWord
void writeWord(uint32)
Writes the 32-bit word us to the stream.
Definition objstrm.h:740
owl::pstream::pstream
pstream()
Creates a pstream without initializing the buffer pointer bp or state.
Definition objstrm.h:693
owl::ipstream::getVersion
uint32 getVersion() const
Returns the object version number.
Definition objstrm.h:732
owl::ReadBaseObject
void ReadBaseObject(Base *base, ipstream &in)
Definition objstrm.h:1159
owl::ifpstream::open
void open(LPCSTR, int=std::ios::in, int=fpbase::openprot)
It opens the named file in the given mode (app, ate, in, out, binary, trunc, nocreate,...
Definition objstrm.h:824
owl::ipstream::find
TStreamableBase * find(P_id_type)
Returns a pointer to the object corresponding to Id.
Definition objstrm.h:722
owl::pstream::setstate
void setstate(int)
Updates the state data member with state |= (b & 0xFF).
Definition objstrm.h:704
owl::fpbase::fpbase
fpbase()
Creates a buffered fpbase object.
Definition objstrm.h:772
owl::ReadVirtualBase
void ReadVirtualBase(Base *base, ipstream &in)
Definition objstrm.h:1190
owl::WriteVirtualBase
void WriteVirtualBase(Base *base, opstream &out)
Definition objstrm.h:1169
owl::opstream::~opstream
virtual ~opstream()
Definition objstrm.h:735
owl::StreamableInit
StreamableInit
Definition objstrm.h:98
owl::ofpstream::ofpstream
ofpstream()
Creates a buffered ofpstream object using a default buffer.
Definition objstrm.h:845
owl::pstream::eof
int eof() const
Returns nonzero on end of stream.
Definition objstrm.h:650
owl::pstream::rdstate
int rdstate() const
Returns the current state value.
Definition objstrm.h:645
owl::pstream::fail
int fail() const
Returns nonzero if a previous stream operation failed.
Definition objstrm.h:655
owl::ifpstream::rdbuf
std::filebuf * rdbuf()
Returns a pointer to the current file buffer.
Definition objstrm.h:816
owl::WriteBaseObject
void WriteBaseObject(Base *base, opstream &out)
Definition objstrm.h:1150
owl::pstream::init
void init(std::streambuf *)
The init member function initializes the stream and sets state to 0 and bp to sbp.
Definition objstrm.h:698
owl::streamableInit
@ streamableInit
Definition objstrm.h:98
owl
Object Windows Library (OWLNext Core)
Definition animctrl.h:22
owl::int64
__int64 int64
Definition number.h:36
owl::GetModuleId
ModuleId GetModuleId()
Definition streambl.h:53
owl::ModuleId
unsigned ModuleId
Definition streambl.h:52
owl::operator<<
owl::opstream & operator<<(owl::opstream &os, const TColor &c)
Insert the color value into a persistent output stream.
Definition color.h:498
owl::int8
signed char int8
Definition number.h:28
owl::uint8
unsigned char uint8
Definition number.h:32
owl::uint32
unsigned long uint32
Definition number.h:34
owl::uint64
unsigned __int64 uint64
Definition number.h:43
owl::uint16
unsigned short uint16
Definition number.h:33
owl::tstring
std::string tstring
Definition defs.h:79
owl::operator>>
owl::ipstream & operator>>(owl::ipstream &is, TColor &c)
Extract the color value from a persistent input stream.
Definition color.h:489
defs.h
General definitions used by all ObjectWindows programs.
_RTTI
#define _RTTI
Definition defs.h:223
_OWLCFUNC
#define _OWLCFUNC(p)
Definition defs.h:342
_OWLCLASS
#define _OWLCLASS
Definition defs.h:338
STATIC_CAST
#define STATIC_CAST(targetType, object)
Definition defs.h:271
streambl.h
Class definitions for object streaming.