xercesc/internal/XSerializeEngine.hpp

0001 /*
0002  * Licensed to the Apache Software Foundation (ASF) under one or more
0003  * contributor license agreements.  See the NOTICE file distributed with
0004  * this work for additional information regarding copyright ownership.
0005  * The ASF licenses this file to You under the Apache License, Version 2.0
0006  * (the "License"); you may not use this file except in compliance with
0007  * the License.  You may obtain a copy of the License at
0008  *
0009  *      http://www.apache.org/licenses/LICENSE-2.0
0010  *
0011  * Unless required by applicable law or agreed to in writing, software
0012  * distributed under the License is distributed on an "AS IS" BASIS,
0013  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0014  * See the License for the specific language governing permissions and
0015  * limitations under the License.
0016  */
0017
0018 /*
0019  * $Id$
0020  */
0021
0022 #if !defined(XERCESC_INCLUDE_GUARD_XSERIALIZE_ENGINE_HPP)
0023 #define XERCESC_INCLUDE_GUARD_XSERIALIZE_ENGINE_HPP
0024
0025 #include <xercesc/util/RefHashTableOf.hpp>
0026 #include <xercesc/util/ValueVectorOf.hpp>
0027 #include <xercesc/util/XMLExceptMsgs.hpp>
0028
0029 #include <xercesc/internal/XSerializationException.hpp>
0030
0031 XERCES_CPP_NAMESPACE_BEGIN
0032
0033 class XSerializable;
0034 class XProtoType;
0035 class MemoryManager;
0036 class XSerializedObjectId;
0037 class BinOutputStream;
0038 class BinInputStream;
0039 class XMLGrammarPool;
0040 class XMLGrammarPoolImpl;
0041 class XMLStringPool;
0042
0043 class XMLUTIL_EXPORT XSerializeEngine
0044 {
0045 public:
0046
0047     enum { mode_Store
0048          , mode_Load
0049     };
0050
0051
0052     static const bool toReadBufferLen;
0053
0054     typedef unsigned int   XSerializedObjectId_t;
0055
0056     /***
0057       *
0058       *  Destructor
0059       *
0060       ***/
0061     ~XSerializeEngine();
0062
0063     /***
0064       *
0065       *  Constructor for de-serialization(loading)
0066       *
0067       *  Application needs to make sure that the instance of
0068       *  BinInputStream, persists beyond the life of this
0069       *  SerializeEngine.
0070       *
0071       *  Param
0072       *     inStream         input stream
0073       *     gramPool         Grammar Pool
0074       *     bufSize          the size of the internal buffer
0075       *
0076       ***/
0077     XSerializeEngine(BinInputStream*         inStream
0078                    , XMLGrammarPool* const   gramPool
0079                    , XMLSize_t               bufSize = 8192 );
0080
0081
0082     /***
0083       *
0084       *  Constructor for serialization(storing)
0085       *
0086       *  Application needs to make sure that the instance of
0087       *  BinOutputStream, persists beyond the life of this
0088       *  SerializeEngine.
0089       *
0090       *  Param
0091       *     outStream        output stream
0092       *     gramPool         Grammar Pool
0093       *     bufSize          the size of the internal buffer
0094       *
0095       ***/
0096     XSerializeEngine(BinOutputStream*        outStream
0097                    , XMLGrammarPool* const   gramPool
0098                    , XMLSize_t               bufSize = 8192 );
0099
0100     /***
0101       *
0102       *  When serialization, flush out the internal buffer
0103       *
0104       *  Return:
0105       *
0106       ***/
0107     void flush();
0108
0109     /***
0110       *
0111       *  Checking if the serialize engine is doing serialization(storing)
0112       *
0113       *  Return: true, if it is
0114       *          false, otherwise
0115       *
0116       ***/
0117     inline bool isStoring() const;
0118
0119     /***
0120       *
0121       *  Checking if the serialize engine is doing de-serialization(loading)
0122       *
0123       *  Return: true, if it is
0124       *          false, otherwise
0125       *
0126       ***/
0127     inline bool isLoading() const;
0128
0129     /***
0130       *
0131       *  Get the GrammarPool
0132       *
0133       *  Return: XMLGrammarPool
0134       *
0135       ***/
0136     XMLGrammarPool* getGrammarPool() const;
0137
0138     /***
0139       *
0140       *  Get the StringPool
0141       *
0142       *  Return: XMLStringPool
0143       *
0144       ***/
0145     XMLStringPool* getStringPool() const;
0146
0147     /***
0148       *
0149       *  Get the embeded Memory Manager
0150       *
0151       *  Return: MemoryManager
0152       *
0153       ***/
0154     MemoryManager* getMemoryManager() const;
0155
0156     /***
0157       *
0158       *  Get the storer level (the level of the serialize engine
0159       *  which created the binary stream that this serialize engine
0160       *  is loading).
0161       *
0162       *  The level returned is meaningful only when
0163       *  the engine isLoading.
0164       *
0165       *  Return: level
0166       *
0167       ***/
0168     inline unsigned int getStorerLevel() const;
0169
0170     /***
0171       *
0172       *  Write object to the internal buffer.
0173       *
0174       *  Param
0175       *     objectToWrite:    the object to be serialized
0176       *
0177       *  Return:
0178       *
0179       ***/
0180            void           write(XSerializable* const objectToWrite);
0181
0182     /***
0183       *
0184       *  Write prototype info to the internal buffer.
0185       *
0186       *  Param
0187       *     protoType:    instance of prototype
0188       *
0189       *  Return:
0190       *
0191       ***/
0192            void           write(XProtoType* const protoType);
0193
0194     /***
0195       *
0196       *  Write a stream of XMLByte to the internal buffer.
0197       *
0198       *  Param
0199       *     toWrite:   the stream of XMLByte to write
0200       *     writeLen:  the length of the stream
0201       *
0202       *  Return:
0203       *
0204       ***/
0205            void           write(const XMLByte* const toWrite
0206                                ,      XMLSize_t      writeLen);
0207
0208     /***
0209       *
0210       *  Write a stream of XMLCh to the internal buffer.
0211       *
0212       *  Param
0213       *     toWrite:   the stream of XMLCh to write
0214       *     writeLen:  the length of the stream
0215       *
0216       *  Return:
0217       *
0218       ***/
0219            void           write(const XMLCh* const toWrite
0220                                ,      XMLSize_t    writeLen);
0221
0222     /***
0223       *
0224       *  Write a stream of XMLCh to the internal buffer.
0225       *
0226       *  Write the bufferLen first if requested, then the length
0227       *  of the stream followed by the stream.
0228       *
0229       *  Param
0230       *     toWrite:        the stream of XMLCh to write
0231       *     bufferLen:      the maximum size of the buffer
0232       *     toWriteBufLen:  specify if the bufferLen need to be written or not
0233       *
0234       *  Return:
0235       *
0236       ***/
0237            void           writeString(const XMLCh* const toWrite
0238                                     , const XMLSize_t    bufferLen = 0
0239                                     , bool               toWriteBufLen = false);
0240
0241     /***
0242       *
0243       *  Write a stream of XMLByte to the internal buffer.
0244       *
0245       *  Write the bufferLen first if requested, then the length
0246       *  of the stream followed by the stream.
0247       *
0248       *  Param
0249       *     toWrite:        the stream of XMLByte to write
0250       *     bufferLen:      the maximum size of the buffer
0251       *     toWriteBufLen:  specify if the bufferLen need to be written or not
0252       *
0253       *  Return:
0254       *
0255       ***/
0256            void           writeString(const XMLByte* const toWrite
0257                                     , const XMLSize_t      bufferLen = 0
0258                                     , bool                 toWriteBufLen = false);
0259
0260     static const bool toWriteBufferLen;
0261
0262     /***
0263       *
0264       *  Read/Create object from the internal buffer.
0265       *
0266       *  Param
0267       *     protoType:    an instance of prototype of the object anticipated
0268       *
0269       *  Return:          to object read/created
0270       *
0271       ***/
0272            XSerializable* read(XProtoType* const protoType);
0273
0274     /***
0275       *
0276       *  Read prototype object from the internal buffer.
0277       *  Verify if the same prototype object found in buffer.
0278       *
0279       *  Param
0280       *     protoType:    an instance of prototype of the object anticipated
0281       *     objTag:       the object Tag to an existing object
0282       *
0283       *  Return:          true  : if matching found
0284       *                   false : otherwise
0285       *
0286       ***/
0287            bool           read(XProtoType* const    protoType
0288                              , XSerializedObjectId_t*       objTag);
0289
0290     /***
0291       *
0292       *  Read XMLByte stream from the internal buffer.
0293       *
0294       *  Param
0295       *     toRead:   the buffer to hold the XMLByte stream
0296       *     readLen:  the length of the XMLByte to read in
0297       *
0298       *  Return:
0299       *
0300       ***/
0301            void           read(XMLByte* const toRead
0302                              , XMLSize_t      readLen);
0303
0304     /***
0305       *
0306       *  Read XMLCh stream from the internal buffer.
0307       *
0308       *  Param
0309       *     toRead:   the buffer to hold the XMLCh stream
0310       *     readLen:  the length of the XMLCh to read in
0311       *
0312       *  Return:
0313       *
0314       ***/
0315            void           read(XMLCh* const toRead
0316                              , XMLSize_t    readLen);
0317
0318     /***
0319       *
0320       *  Read a stream of XMLCh from the internal buffer.
0321       *
0322       *  Read the bufferLen first if requested, then the length
0323       *  of the stream followed by the stream.
0324       *
0325       *  Param
0326       *     toRead:       the pointer to the buffer to hold the XMLCh stream
0327       *     bufferLen:    the size of the buffer created
0328       *     dataLen:       the length of the stream
0329       *     toReadBufLen: specify if the bufferLen need to be read or not
0330       *
0331       *  Return:
0332       *
0333       ***/
0334            void           readString(XMLCh*&        toRead
0335                                    , XMLSize_t&     bufferLen
0336                                    , XMLSize_t&     dataLen
0337                                    , bool           toReadBufLen = false);
0338
0339      /***
0340        *
0341        *  Read a stream of XMLCh from the internal buffer.
0342        *
0343        *  Read the bufferLen first if requested, then the length
0344        *  of the stream followed by the stream.
0345        *
0346        *  Param
0347        *     toRead:       the pointer to the buffer to hold the XMLCh stream
0348        *     bufferLen:    the size of the buffer created
0349        *
0350        *  Return:
0351        *
0352        ***/
0353             inline void     readString(XMLCh*&        toRead
0354                                     , XMLSize_t&      bufferLen);
0355
0356      /***
0357        *
0358        *  Read a stream of XMLCh from the internal buffer.
0359        *
0360        *  Param
0361        *     toRead:       the pointer to the buffer to hold the XMLCh stream
0362        *
0363        *  Return:
0364        *
0365        ***/
0366             inline void      readString(XMLCh*&        toRead);
0367
0368     /***
0369       *
0370       *  Read a stream of XMLByte from the internal buffer.
0371       *
0372       *  Read the bufferLen first if requested, then the length
0373       *  of the stream followed by the stream.
0374       *
0375       *  Param
0376       *     toRead:       the pointer to the buffer to hold the XMLByte stream
0377       *     bufferLen:    the size of the buffer created
0378       *     dataLen:       the length of the stream
0379       *     toReadBufLen: specify if the bufferLen need to be read or not
0380       *
0381       *  Return:
0382       *
0383       ***/
0384            void           readString(XMLByte*&      toRead
0385                                    , XMLSize_t&     bufferLen
0386                                    , XMLSize_t&     dataLen
0387                                    , bool           toReadBufLen = false);
0388
0389
0390      /***
0391        *
0392        *  Read a stream of XMLByte from the internal buffer.
0393        *
0394        *  Read the bufferLen first if requested, then the length
0395        *  of the stream followed by the stream.
0396        *
0397        *  Param
0398        *     toRead:       the pointer to the buffer to hold the XMLByte stream
0399        *     bufferLen:    the size of the buffer created
0400        *
0401        *  Return:
0402        *
0403        ***/
0404             inline void       readString(XMLByte*&      toRead
0405                                        , XMLSize_t&     bufferLen);
0406
0407      /***
0408        *
0409        *  Read a stream of XMLByte from the internal buffer.
0410        *
0411        *  Read the bufferLen first if requested, then the length
0412        *  of the stream followed by the stream.
0413        *
0414        *  Param
0415        *     toRead:       the pointer to the buffer to hold the XMLByte stream
0416        *     bufferLen:    the size of the buffer created
0417        *     dataLen:       the length of the stream
0418        *     toReadBufLen: specify if the bufferLen need to be read or not
0419        *
0420        *  Return:
0421        *
0422        ***/
0423             inline void       readString(XMLByte*&      toRead);
0424
0425     /***
0426       *
0427       *  Check if the template object has been stored or not
0428       *
0429       *  Param
0430       *    objectPtr:     the template object pointer
0431       *
0432       *  Return:          true  : the object has NOT been stored yet
0433       *                   false : otherwise
0434       *
0435       ***/
0436            bool           needToStoreObject(void* const templateObjectToWrite);
0437
0438     /***
0439       *
0440       *  Check if the template object has been loaded or not
0441       *
0442       *  Param
0443       *    objectPtr:     the address of the template object pointer
0444       *
0445       *  Return:          true  : the object has NOT been loaded yet
0446       *                   false : otherwise
0447       *
0448       ***/
0449            bool           needToLoadObject(void**       templateObjectToRead);
0450
0451     /***
0452       *
0453       *  In the case of needToLoadObject() return true, the client
0454       *  application needs to instantiate an expected template object, and
0455       *  register the address to the engine.
0456       *
0457       *  Param
0458       *    objectPtr:     the template object pointer newly instantiated
0459       *
0460       *  Return:
0461       *
0462       ***/
0463            void           registerObject(void* const templateObjectToRegister);
0464
0465     /***
0466       *
0467       *  Insertion operator for serializable classes
0468       *
0469       ***/
0470
0471     friend XSerializeEngine& operator<<(XSerializeEngine&
0472                                       , XSerializable* const );
0473
0474     /***
0475       *
0476       *  Insertion operators for
0477       *     . basic Xerces data types
0478       *     . built-in types
0479       *
0480       ***/
0481            XSerializeEngine& operator<<(XMLByte);
0482            XSerializeEngine& operator<<(XMLCh);
0483
0484            XSerializeEngine& operator<<(char);
0485            XSerializeEngine& operator<<(short);
0486            XSerializeEngine& operator<<(int);
0487            XSerializeEngine& operator<<(unsigned int);
0488            XSerializeEngine& operator<<(long);
0489            XSerializeEngine& operator<<(unsigned long);
0490            XSerializeEngine& operator<<(float);
0491            XSerializeEngine& operator<<(double);
0492            XSerializeEngine& operator<<(bool);
0493
0494     // These cannot be done as operators since on some platforms they
0495     // may collide with int/long types.
0496     //
0497     void writeSize (XMLSize_t);
0498     void writeInt64 (XMLInt64);
0499     void writeUInt64 (XMLUInt64);
0500
0501
0502     /***
0503       *
0504       *  Extraction operators for
0505       *     . basic Xerces data types
0506       *     . built-in types
0507       *
0508       ***/
0509            XSerializeEngine& operator>>(XMLByte&);
0510            XSerializeEngine& operator>>(XMLCh&);
0511
0512            XSerializeEngine& operator>>(char&);
0513            XSerializeEngine& operator>>(short&);
0514            XSerializeEngine& operator>>(int&);
0515            XSerializeEngine& operator>>(unsigned int&);
0516            XSerializeEngine& operator>>(long&);
0517            XSerializeEngine& operator>>(unsigned long&);
0518            XSerializeEngine& operator>>(float&);
0519            XSerializeEngine& operator>>(double&);
0520            XSerializeEngine& operator>>(bool&);
0521
0522     void readSize (XMLSize_t&);
0523     void readInt64 (XMLInt64&);
0524     void readUInt64 (XMLUInt64&);
0525
0526     /***
0527       *
0528       *  Getters
0529       *
0530       ***/
0531     inline
0532     XMLSize_t       getBufSize()    const;
0533
0534     inline
0535     XMLSize_t       getBufCur()     const;
0536
0537     inline
0538     XMLSize_t       getBufCurAccumulated()     const;
0539
0540     inline
0541     unsigned long   getBufCount()    const;
0542
0543     void                  trace(char*)     const;
0544
0545 private:
0546     // -----------------------------------------------------------------------
0547     //  Unimplemented constructors and operators
0548     // -----------------------------------------------------------------------
0549     XSerializeEngine();
0550     XSerializeEngine(const XSerializeEngine&);
0551     XSerializeEngine& operator=(const XSerializeEngine&);
0552
0553     /***
0554       *
0555       *   Store Pool Opertions
0556       *
0557       ***/
0558            XSerializedObjectId_t  lookupStorePool(void* const objectPtr) const;
0559            void                   addStorePool(void* const objectPtr);
0560
0561     /***
0562       *
0563       *   Load Pool Opertions
0564       *
0565       ***/
0566            XSerializable* lookupLoadPool(XSerializedObjectId_t objectTag) const;
0567            void           addLoadPool(void* const objectPtr);
0568
0569     /***
0570       *
0571       *    Intenal Buffer Operations
0572       *
0573       ***/
0574     inline void           checkAndFillBuffer(XMLSize_t bytesNeedToRead);
0575
0576     inline void           checkAndFlushBuffer(XMLSize_t bytesNeedToWrite);
0577
0578            void           fillBuffer();
0579
0580            void           flushBuffer();
0581
0582            void           pumpCount();
0583
0584     inline void           resetBuffer();
0585
0586     /***
0587       *
0588       *    Helper
0589       *
0590       ***/
0591     inline void            ensureStoring()                          const;
0592
0593     inline void            ensureLoading()                          const;
0594
0595     inline void            ensureStoreBuffer()                      const;
0596
0597     inline void            ensureLoadBuffer()                       const;
0598
0599     inline void            ensurePointer(void* const)               const;
0600
0601     inline void            Assert(bool  toEval
0602                                 , const XMLExcepts::Codes toThrow)  const;
0603
0604
0605     inline XMLSize_t       calBytesNeeded(XMLSize_t)  const;
0606
0607     inline XMLSize_t       alignAdjust(XMLSize_t)     const;
0608
0609     inline void            alignBufCur(XMLSize_t);
0610
0611     // Make XTemplateSerializer friend of XSerializeEngine so that
0612     // we can call lookupStorePool and lookupLoadPool in the case of
0613     // annotations.
0614     friend class XTemplateSerializer;
0615
0616     // -------------------------------------------------------------------------------
0617     //  data
0618     //
0619     //  fStoreLoad:
0620     //               Indicator: storing(serialization) or loading(de-serialization)
0621     //
0622     //  fStorerLevel:
0623     //              The level of the serialize engine which created the binary
0624     //              stream that this serialize engine is loading
0625     //
0626     //              It is set by GrammarPool when loading
0627     //
0628     //  fGrammarPool:
0629     //               Thw owning GrammarPool which instantiate this SerializeEngine
0630     //               instance
0631     //
0632     //  fInputStream:
0633     //               Binary stream to read from (de-serialization), provided
0634     //               by client application, not owned.
0635     //
0636     //  fOutputStream:
0637     //               Binary stream to write to (serialization), provided
0638     //               by client application, not owned.
0639     //
0640     //  fBufSize:
0641     //               The size of the internal buffer
0642     //
0643     //  fBufStart/fBufEnd:
0644     //
0645     //               The internal buffer.
0646     //  fBufEnd:
0647     //               one beyond the last valid cell
0648     //               fBufEnd === (fBufStart + fBufSize)
0649     //
0650     //  fBufCur:
0651     //               The cursor of the buffer
0652     //
0653     //  fBufLoadMax:
0654     //               Indicating the end of the valid content in the buffer
0655     //
0656     //  fStorePool:
0657     //                Object collection for storing
0658     //
0659     //  fLoadPool:
0660     //                Object collection for loading
0661     //
0662     //  fMapCount:
0663     // -------------------------------------------------------------------------------
0664     const short                            fStoreLoad;
0665     unsigned int                           fStorerLevel;
0666
0667     XMLGrammarPool*  const                 fGrammarPool;
0668     BinInputStream*  const                 fInputStream;
0669     BinOutputStream* const                 fOutputStream;
0670
0671     unsigned long                          fBufCount;
0672
0673     //buffer
0674     const XMLSize_t                        fBufSize;
0675     XMLByte* const                         fBufStart;
0676     XMLByte* const                         fBufEnd;
0677     XMLByte*                               fBufCur;
0678     XMLByte*                               fBufLoadMax;
0679
0680
0681
0682     /***
0683      *   Map for storing object
0684      *
0685      *   key:   XSerializable*
0686      *          XProtoType*
0687      *
0688      *   value: XMLInteger*, owned
0689      *
0690      ***/
0691     RefHashTableOf<XSerializedObjectId, PtrHasher>*   fStorePool;
0692
0693     /***
0694      *   Vector for loading object, objects are NOT owned
0695      *
0696      *   data:   XSerializable*
0697      *           XProtoType*
0698      *
0699      ***/
0700     ValueVectorOf<void*>*                  fLoadPool;
0701
0702     /***
0703      *   object counter
0704      ***/
0705     XSerializedObjectId_t                  fObjectCount;
0706
0707     //to allow grammar pool to set storer level when loading
0708     friend class XMLGrammarPoolImpl;
0709 };
0710
0711 inline bool XSerializeEngine::isStoring() const
0712 {
0713     return (fStoreLoad == mode_Store);
0714 }
0715
0716 inline bool XSerializeEngine::isLoading() const
0717 {
0718     return (fStoreLoad == mode_Load);
0719 }
0720
0721 inline XSerializeEngine& operator<<(XSerializeEngine&       serEng
0722                                   , XSerializable* const    serObj)
0723 {
0724     serEng.write(serObj);
0725     return serEng;
0726 }
0727
0728 inline void XSerializeEngine::ensureStoring() const
0729 {
0730     Assert(isStoring(), XMLExcepts::XSer_Storing_Violation);
0731 }
0732
0733 inline void XSerializeEngine::ensureLoading() const
0734 {
0735     Assert(isLoading(), XMLExcepts::XSer_Loading_Violation);
0736 }
0737
0738
0739
0740 inline void XSerializeEngine::Assert(bool toEval
0741                                    , const XMLExcepts::Codes toThrow) const
0742 {
0743     if (!toEval)
0744     {
0745         ThrowXMLwithMemMgr(XSerializationException, toThrow, getMemoryManager());
0746     }
0747
0748 }
0749
0750 inline void XSerializeEngine::readString(XMLCh*&        toRead
0751                                        , XMLSize_t&     bufferLen)
0752 {
0753     XMLSize_t dummyDataLen;
0754     readString(toRead, bufferLen, dummyDataLen);
0755 }
0756
0757 inline void XSerializeEngine::readString(XMLCh*&        toRead)
0758 {
0759     XMLSize_t dummyBufferLen;
0760     XMLSize_t dummyDataLen;
0761     readString(toRead, dummyBufferLen, dummyDataLen);
0762 }
0763
0764 inline void XSerializeEngine::readString(XMLByte*&      toRead
0765                                        , XMLSize_t&     bufferLen)
0766 {
0767     XMLSize_t dummyDataLen;
0768     readString(toRead, bufferLen, dummyDataLen);
0769 }
0770
0771 inline void XSerializeEngine::readString(XMLByte*&      toRead)
0772 {
0773     XMLSize_t dummyBufferLen;
0774     XMLSize_t dummyDataLen;
0775     readString(toRead, dummyBufferLen, dummyDataLen);
0776 }
0777
0778 inline
0779 XMLSize_t XSerializeEngine::getBufSize() const
0780 {
0781     return fBufSize;
0782 }
0783
0784 inline
0785 XMLSize_t XSerializeEngine::getBufCur() const
0786 {
0787     return (fBufCur-fBufStart);
0788 }
0789
0790 inline
0791 XMLSize_t XSerializeEngine::getBufCurAccumulated() const
0792 {
0793     return (fBufCount - (isStoring() ? 0: 1)) * fBufSize + (fBufCur-fBufStart);
0794 }
0795
0796 inline
0797 unsigned long XSerializeEngine::getBufCount() const
0798 {
0799     return fBufCount;
0800 }
0801
0802 inline
0803 unsigned int XSerializeEngine::getStorerLevel() const
0804 {
0805     return fStorerLevel;
0806 }
0807
0808 /***
0809  *  Ought to be nested class
0810  ***/
0811 class XSerializedObjectId : public XMemory
0812 {
0813 public:
0814
0815     ~XSerializedObjectId(){};
0816
0817 private:
0818
0819     inline XSerializedObjectId(XSerializeEngine::XSerializedObjectId_t val):
0820         fData(val) { };
0821
0822     inline XSerializeEngine::XSerializedObjectId_t getValue() const {return fData; };
0823
0824     friend class XSerializeEngine;
0825
0826 private:
0827     // -----------------------------------------------------------------------
0828     //  Unimplemented constructors and operators
0829     // -----------------------------------------------------------------------
0830     XSerializedObjectId();
0831     XSerializedObjectId(const XSerializedObjectId&);
0832     XSerializedObjectId& operator=(const XSerializedObjectId&);
0833
0834     XSerializeEngine::XSerializedObjectId_t    fData;
0835
0836 };
0837
0838
0839 XERCES_CPP_NAMESPACE_END
0840
0841 #endif