/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: XSerializeEngine.hpp 568078 2007-08-21 11:43:25Z amassari $ */ #if !defined(XSERIALIZE_ENGINE_HPP) #define XSERIALIZE_ENGINE_HPP #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN class XSerializable; class XProtoType; class MemoryManager; class XSerializedObjectId; class BinOutputStream; class BinInputStream; class XMLGrammarPool; class XMLGrammarPoolImpl; class XMLStringPool; class XMLUTIL_EXPORT XSerializeEngine { public: enum { mode_Store , mode_Load }; static const bool toReadBufferLen; typedef unsigned int XSerializedObjectId_t; /*** * * Destructor * ***/ ~XSerializeEngine(); /*** * * Constructor for de-serialization(loading) * * Application needs to make sure that the instance of * BinInputStream, persists beyond the life of this * SerializeEngine. * * Param * inStream input stream * gramPool Grammar Pool * bufSize the size of the internal buffer * ***/ XSerializeEngine(BinInputStream* inStream , XMLGrammarPool* const gramPool , unsigned long bufSize = 8192 ); /*** * * Constructor for serialization(storing) * * Application needs to make sure that the instance of * BinOutputStream, persists beyond the life of this * SerializeEngine. * * Param * outStream output stream * gramPool Grammar Pool * bufSize the size of the internal buffer * ***/ XSerializeEngine(BinOutputStream* outStream , XMLGrammarPool* const gramPool , unsigned long bufSize = 8192 ); /*** * * Deprecated * * Constructor for de-serialization(loading) * * Application needs to make sure that the instance of * BinInputStream, persists beyond the life of this * SerializeEngine. * * Param * inStream input stream * manager MemoryManager * bufSize the size of the internal buffer * ***/ XSerializeEngine(BinInputStream* inStream , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager , unsigned long bufSize = 8192 ); /*** * * Deprecated * * Constructor for serialization(storing) * * Application needs to make sure that the instance of * BinOutputStream, persists beyond the life of this * SerializeEngine. * * Param * outStream output stream * manager MemoryManager * bufSize the size of the internal buffer * ***/ XSerializeEngine(BinOutputStream* outStream , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager , unsigned long bufSize = 8192 ); /*** * * When serialization, flush out the internal buffer * * Return: * ***/ void flush(); /*** * * Checking if the serialize engine is doing serialization(storing) * * Return: true, if it is * false, otherwise * ***/ inline bool isStoring() const; /*** * * Checking if the serialize engine is doing de-serialization(loading) * * Return: true, if it is * false, otherwise * ***/ inline bool isLoading() const; /*** * * Get the GrammarPool * * Return: XMLGrammarPool * ***/ XMLGrammarPool* getGrammarPool() const; /*** * * Get the StringPool * * Return: XMLStringPool * ***/ XMLStringPool* getStringPool() const; /*** * * Get the embeded Memory Manager * * Return: MemoryManager * ***/ MemoryManager* getMemoryManager() const; /*** * * Get the storer level (the level of the serialize engine * which created the binary stream that this serialize engine * is loading). * * The level returned is meaningful only when * the engine isLoading. * * Return: level * ***/ inline unsigned short getStorerLevel() const; /*** * * Write object to the internal buffer. * * Param * objectToWrite: the object to be serialized * * Return: * ***/ void write(XSerializable* const objectToWrite); /*** * * Write prototype info to the internal buffer. * * Param * protoType: instance of prototype * * Return: * ***/ void write(XProtoType* const protoType); /*** * * Write a stream of XMLByte to the internal buffer. * * Param * toWrite: the stream of XMLByte to write * writeLen: the length of the stream * * Return: * ***/ void write(const XMLByte* const toWrite , int writeLen); /*** * * Write a stream of XMLCh to the internal buffer. * * Param * toWrite: the stream of XMLCh to write * writeLen: the length of the stream * * Return: * ***/ void write(const XMLCh* const toWrite , int writeLen); /*** * * Write a stream of XMLCh to the internal buffer. * * Write the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toWrite: the stream of XMLCh to write * bufferLen: the maximum size of the buffer * toWriteBufLen: specify if the bufferLen need to be written or not * * Return: * ***/ void writeString(const XMLCh* const toWrite , const int bufferLen = 0 , bool toWriteBufLen = false); /*** * * Write a stream of XMLByte to the internal buffer. * * Write the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toWrite: the stream of XMLByte to write * bufferLen: the maximum size of the buffer * toWriteBufLen: specify if the bufferLen need to be written or not * * Return: * ***/ void writeString(const XMLByte* const toWrite , const int bufferLen = 0 , bool toWriteBufLen = false); static const bool toWriteBufferLen; /*** * * Read/Create object from the internal buffer. * * Param * protoType: an instance of prototype of the object anticipated * * Return: to object read/created * ***/ XSerializable* read(XProtoType* const protoType); /*** * * Read prototype object from the internal buffer. * Verify if the same prototype object found in buffer. * * Param * protoType: an instance of prototype of the object anticipated * objTag: the object Tag to an existing object * * Return: true : if matching found * false : otherwise * ***/ bool read(XProtoType* const protoType , XSerializedObjectId_t* objTag); /*** * * Read XMLByte stream from the internal buffer. * * Param * toRead: the buffer to hold the XMLByte stream * readLen: the length of the XMLByte to read in * * Return: * ***/ void read(XMLByte* const toRead , int readLen); /*** * * Read XMLCh stream from the internal buffer. * * Param * toRead: the buffer to hold the XMLCh stream * readLen: the length of the XMLCh to read in * * Return: * ***/ void read(XMLCh* const toRead , int readLen); /*** * * Read a stream of XMLCh from the internal buffer. * * Read the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toRead: the pointer to the buffer to hold the XMLCh stream * bufferLen: the size of the buffer created * dataLen: the length of the stream * toReadBufLen: specify if the bufferLen need to be read or not * * Return: * ***/ void readString(XMLCh*& toRead , int& bufferLen , int& dataLen , bool toReadBufLen = false); /*** * * Read a stream of XMLCh from the internal buffer. * * Read the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toRead: the pointer to the buffer to hold the XMLCh stream * bufferLen: the size of the buffer created * * Return: * ***/ inline void readString(XMLCh*& toRead , int& bufferLen); /*** * * Read a stream of XMLCh from the internal buffer. * * Param * toRead: the pointer to the buffer to hold the XMLCh stream * * Return: * ***/ inline void readString(XMLCh*& toRead); /*** * * Read a stream of XMLByte from the internal buffer. * * Read the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toRead: the pointer to the buffer to hold the XMLByte stream * bufferLen: the size of the buffer created * dataLen: the length of the stream * toReadBufLen: specify if the bufferLen need to be read or not * * Return: * ***/ void readString(XMLByte*& toRead , int& bufferLen , int& dataLen , bool toReadBufLen = false); /*** * * Read a stream of XMLByte from the internal buffer. * * Read the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toRead: the pointer to the buffer to hold the XMLByte stream * bufferLen: the size of the buffer created * * Return: * ***/ inline void readString(XMLByte*& toRead , int& bufferLen); /*** * * Read a stream of XMLByte from the internal buffer. * * Read the bufferLen first if requested, then the length * of the stream followed by the stream. * * Param * toRead: the pointer to the buffer to hold the XMLByte stream * bufferLen: the size of the buffer created * dataLen: the length of the stream * toReadBufLen: specify if the bufferLen need to be read or not * * Return: * ***/ inline void readString(XMLByte*& toRead); /*** * * Check if the template object has been stored or not * * Param * objectPtr: the template object pointer * * Return: true : the object has NOT been stored yet * false : otherwise * ***/ bool needToStoreObject(void* const templateObjectToWrite); /*** * * Check if the template object has been loaded or not * * Param * objectPtr: the address of the template object pointer * * Return: true : the object has NOT been loaded yet * false : otherwise * ***/ bool needToLoadObject(void** templateObjectToRead); /*** * * In the case of needToLoadObject() return true, the client * application needs to instantiate an expected template object, and * register the address to the engine. * * Param * objectPtr: the template object pointer newly instantiated * * Return: * ***/ void registerObject(void* const templateObjectToRegister); /*** * * Insertion operator for serializable classes * ***/ friend XSerializeEngine& operator<<(XSerializeEngine& , XSerializable* const ); /*** * * Insertion operators for * . basic Xerces data types * . built-in types * ***/ XSerializeEngine& operator<<(XMLByte); XSerializeEngine& operator<<(XMLCh); XSerializeEngine& operator<<(char); XSerializeEngine& operator<<(short); XSerializeEngine& operator<<(int); XSerializeEngine& operator<<(unsigned int); XSerializeEngine& operator<<(long); XSerializeEngine& operator<<(unsigned long); XSerializeEngine& operator<<(float); XSerializeEngine& operator<<(double); XSerializeEngine& operator<<(bool); /*** * * Extraction operators for * . basic Xerces data types * . built-in types * ***/ XSerializeEngine& operator>>(XMLByte&); XSerializeEngine& operator>>(XMLCh&); XSerializeEngine& operator>>(char&); XSerializeEngine& operator>>(short&); XSerializeEngine& operator>>(int&); XSerializeEngine& operator>>(unsigned int&); XSerializeEngine& operator>>(long&); XSerializeEngine& operator>>(unsigned long&); XSerializeEngine& operator>>(float&); XSerializeEngine& operator>>(double&); XSerializeEngine& operator>>(bool&); /*** * * Getters * ***/ inline XMLSize_t getBufSize() const; inline XMLSize_t getBufCur() const; inline XMLSize_t getBufCurAccumulated() const; inline XMLSize_t getBufCount() const; void trace(char*) const; private: // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- XSerializeEngine(); XSerializeEngine(const XSerializeEngine&); XSerializeEngine& operator=(const XSerializeEngine&); /*** * * Store Pool Opertions * ***/ XSerializedObjectId_t lookupStorePool(void* const objectPtr) const; void addStorePool(void* const objectPtr); /*** * * Load Pool Opertions * ***/ XSerializable* lookupLoadPool(XSerializedObjectId_t objectTag) const; void addLoadPool(void* const objectPtr); /*** * * Intenal Buffer Operations * ***/ inline void checkAndFillBuffer(int bytesNeedToRead); inline void checkAndFlushBuffer(int bytesNeedToWrite); void fillBuffer(); void flushBuffer(); void pumpCount(); inline void resetBuffer(); /*** * * Helper * ***/ inline void ensureStoring() const; inline void ensureLoading() const; inline void ensureStoreBuffer() const; inline void ensureLoadBuffer() const; inline void ensurePointer(void* const) const; inline void ensureBufferLen(int bufferLen) const; inline void Assert(bool toEval , const XMLExcepts::Codes toThrow) const; inline XMLSize_t calBytesNeeded(XMLSize_t) const; inline XMLSize_t alignAdjust(XMLSize_t) const; inline void alignBufCur(XMLSize_t); // Make XTemplateSerializer friend of XSerializeEngine so that // we can call lookupStorePool and lookupLoadPool in the case of // annotations. friend class XTemplateSerializer; // ------------------------------------------------------------------------------- // data // // fStoreLoad: // Indicator: storing(serialization) or loading(de-serialization) // // fStorerLevel: // The level of the serialize engine which created the binary // stream that this serialize engine is loading // // It is set by GrammarPool when loading // // fGrammarPool: // Thw owning GrammarPool which instantiate this SerializeEngine // instance // // fInputStream: // Binary stream to read from (de-serialization), provided // by client application, not owned. // // fOutputStream: // Binary stream to write to (serialization), provided // by client application, not owned. // // fBufSize: // The size of the internal buffer // // fBufStart/fBufEnd: // // The internal buffer. // fBufEnd: // one beyond the last valid cell // fBufEnd === (fBufStart + fBufSize) // // fBufCur: // The cursor of the buffer // // fBufLoadMax: // Indicating the end of the valid content in the buffer // // fStorePool: // Object collection for storing // // fLoadPool: // Object collection for loading // // fMapCount: // ------------------------------------------------------------------------------- const short fStoreLoad; short fStorerLevel; XMLGrammarPool* const fGrammarPool; BinInputStream* const fInputStream; BinOutputStream* const fOutputStream; XMLSize_t fBufCount; //buffer const XMLSize_t fBufSize; XMLByte* const fBufStart; XMLByte* const fBufEnd; XMLByte* fBufCur; XMLByte* fBufLoadMax; /*** * Map for storing object * * key: XSerializable* * XProtoType* * * value: XMLInteger*, owned * ***/ RefHashTableOf* fStorePool; /*** * Vector for loading object, objects are NOT owned * * data: XSerializable* * XProtoType* * ***/ ValueVectorOf* fLoadPool; /*** * object counter ***/ XSerializedObjectId_t fObjectCount; //to allow grammar pool to set storer level when loading friend class XMLGrammarPoolImpl; }; inline bool XSerializeEngine::isStoring() const { return (fStoreLoad == mode_Store); } inline bool XSerializeEngine::isLoading() const { return (fStoreLoad == mode_Load); } inline XSerializeEngine& operator<<(XSerializeEngine& serEng , XSerializable* const serObj) { serEng.write(serObj); return serEng; } inline void XSerializeEngine::ensureStoring() const { Assert(isStoring(), XMLExcepts::XSer_Storing_Violation); } inline void XSerializeEngine::ensureLoading() const { Assert(isLoading(), XMLExcepts::XSer_Loading_Violation); } inline void XSerializeEngine::Assert(bool toEval , const XMLExcepts::Codes toThrow) const { if (!toEval) { ThrowXMLwithMemMgr(XSerializationException, toThrow, getMemoryManager()); } } inline void XSerializeEngine::readString(XMLCh*& toRead , int& bufferLen) { int dummyDataLen; readString(toRead, bufferLen, dummyDataLen); } inline void XSerializeEngine::readString(XMLCh*& toRead) { int dummyBufferLen; int dummyDataLen; readString(toRead, dummyBufferLen, dummyDataLen); } inline void XSerializeEngine::readString(XMLByte*& toRead , int& bufferLen) { int dummyDataLen; readString(toRead, bufferLen, dummyDataLen); } inline void XSerializeEngine::readString(XMLByte*& toRead) { int dummyBufferLen; int dummyDataLen; readString(toRead, dummyBufferLen, dummyDataLen); } inline XMLSize_t XSerializeEngine::getBufSize() const { return fBufSize; } inline XMLSize_t XSerializeEngine::getBufCur() const { return XMLSize_t (fBufCur-fBufStart); } inline XMLSize_t XSerializeEngine::getBufCurAccumulated() const { return (fBufCount - (isStoring() ? 0: 1)) * fBufSize + (fBufCur-fBufStart); } inline XMLSize_t XSerializeEngine::getBufCount() const { return fBufCount; } inline unsigned short XSerializeEngine::getStorerLevel() const { return fStorerLevel; } /*** * Ought to be nested class ***/ class XSerializedObjectId : public XMemory { public: ~XSerializedObjectId(){}; private: inline XSerializedObjectId(XSerializeEngine::XSerializedObjectId_t val): fData(val) { }; inline XSerializeEngine::XSerializedObjectId_t getValue() const {return fData; }; friend class XSerializeEngine; private: // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- XSerializedObjectId(); XSerializedObjectId(const XSerializedObjectId&); XSerializedObjectId& operator=(const XSerializedObjectId&); XSerializeEngine::XSerializedObjectId_t fData; }; XERCES_CPP_NAMESPACE_END #endif