Newer
Older
/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2003-2004 The Apache Software Foundation. All rights
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xerces" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache\@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation, and was
* originally based on software copyright (c) 1999, International
* Business Machines, Inc., http://www.ibm.com . For more information
* on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
/*
* $Id$
* $Log$
* Revision 1.18 2004/07/21 14:54:39 peiyongz
* using the supplied memory manager , patch from David Bertoni
*
* Revision 1.17 2004/03/05 22:21:45 peiyongz
* readBytes()/writeBytes between BinOutputStream/BinInputStream and
* XSerializeEngine will always be the full size of the buffer to maintain the exact
* position for aligned data.
*
* Revision 1.16 2004/03/01 23:19:03 peiyongz
* Grant XSerializeEngine access to GrammarPool
*
* Revision 1.15 2004/02/20 20:57:39 peiyongz
* Bug#27046: path from David Bertoni
*
David Abram Cargill
committed
* Revision 1.14 2004/01/29 11:46:30 cargilld
* Code cleanup changes to get rid of various compiler diagnostic messages.
*
* Revision 1.13 2004/01/15 23:42:32 peiyongz
* proper allignment for built-in datatype read/write
*
* Revision 1.12 2004/01/13 16:34:20 cargilld
* Misc memory management changes.
*
* Revision 1.11 2004/01/12 16:27:41 neilg
* remove use of static buffers
*
David Abram Cargill
committed
* Revision 1.10 2003/12/17 00:18:34 cargilld
* Update to memory management so that the static memory manager (one used to call Initialize) is only for static data.
*
* Revision 1.9 2003/11/25 20:37:40 jberry
* Cleanup build errors/warnings from CodeWarrior
*
* Revision 1.8 2003/10/20 17:37:05 amassari
* Removed compiler warning
*
* Revision 1.7 2003/10/17 21:09:03 peiyongz
* renaming methods
*
* Revision 1.6 2003/10/07 19:38:31 peiyongz
* API for Template_Class Object Serialization/Deserialization
*
* Revision 1.5 2003/09/25 22:22:00 peiyongz
* Introduction of readString/writeString
*
* Revision 1.4 2003/09/25 15:21:12 peiyongz
* Loose the assert condition so that Serializable class need NOT to check the
* actual string length before read/write.
*
* Revision 1.3 2003/09/23 18:11:29 peiyongz
* Using HashPtr
PeiYong Zhang
committed
*
* Revision 1.1 2003/09/18 18:31:24 peiyongz
* OSU: Object Serialization Utilities
*
*
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#include <xercesc/internal/XSerializeEngine.hpp>
#include <xercesc/internal/XSerializable.hpp>
#include <xercesc/internal/XProtoType.hpp>
#include <xercesc/framework/XMLGrammarPool.hpp>
#include <xercesc/framework/BinOutputStream.hpp>
#include <xercesc/util/BinInputStream.hpp>
const bool XSerializeEngine::toWriteBufferLen = true;
const bool XSerializeEngine::toReadBufferLen = true;
static const int noDataFollowed = -1;
static const XSerializeEngine::XSerializedObjectId_t fgNullObjectTag = 0; // indicating null ptrs
static const XSerializeEngine::XSerializedObjectId_t fgNewClassTag = 0xFFFFFFFF; // indicating new class
static const XSerializeEngine::XSerializedObjectId_t fgTemplateObjTag = 0xFFFFFFFE; // indicating template object
static const XSerializeEngine::XSerializedObjectId_t fgClassMask = 0x80000000; // indicates class tag
static const XSerializeEngine::XSerializedObjectId_t fgMaxObjectCount = 0x3FFFFFFD;
#define TEST_THROW_ARG1(condition, data, err_msg) \
if (condition) \
{ \
XMLString::binToText(data, value1, 16, 10, getMemoryManager()); \
David Abram Cargill
committed
ThrowXMLwithMemMgr1(XSerializationException \
David Abram Cargill
committed
, value1 \
}
#define TEST_THROW_ARG2(condition, data1, data2, err_msg) \
if (condition) \
{ \
XMLCh value1[17]; \
XMLCh value2[17]; \
XMLString::binToText(data1, value1, 16, 10, getMemoryManager()); \
XMLString::binToText(data2, value2, 16, 10, getMemoryManager()); \
David Abram Cargill
committed
ThrowXMLwithMemMgr2(XSerializationException \
David Abram Cargill
committed
, value2 \
}
// ---------------------------------------------------------------------------
// Constructor and Destructor
// ---------------------------------------------------------------------------
XSerializeEngine::~XSerializeEngine()
{
if (isStoring())
{
flush();
delete fStorePool;
}
else
{
delete fLoadPool;
}
getMemoryManager()->deallocate(fBufStart);
}
XSerializeEngine::XSerializeEngine(BinInputStream* inStream
, XMLGrammarPool* const gramPool
, unsigned long bufSize)
:fStoreLoad(mode_Load)
,fInputStream(inStream)
,fOutputStream(0)
,fBufSize(bufSize)
,fBufStart( (XMLByte*) gramPool->getMemoryManager()->allocate(bufSize))
David Abram Cargill
committed
,fBufCur(fBufStart)
,fBufLoadMax(fBufStart)
,fStorePool(0)
,fLoadPool( new (gramPool->getMemoryManager()) ValueVectorOf<void*>(29, gramPool->getMemoryManager(), false))
,fObjectCount(0)
{
/***
* initialize buffer from the inStream
***/
fillBuffer();
}
XSerializeEngine::XSerializeEngine(BinOutputStream* outStream
, XMLGrammarPool* const gramPool
, unsigned long bufSize)
:fStoreLoad(mode_Store)
,fInputStream(0)
,fOutputStream(outStream)
,fBufSize(bufSize)
,fBufStart((XMLByte*) gramPool->getMemoryManager()->allocate(bufSize))
David Abram Cargill
committed
,fBufCur(fBufStart)
,fStorePool( new (gramPool->getMemoryManager()) RefHashTableOf<XSerializedObjectId>(29, true, new (gramPool->getMemoryManager()) HashPtr(), gramPool->getMemoryManager()) )
,fLoadPool(0)
,fObjectCount(0)
{
//initialize store pool
fStorePool->put(0, new (gramPool->getMemoryManager()) XSerializedObjectId(fgNullObjectTag));
// ---------------------------------------------------------------------------
// Deprecated Constructor
// ---------------------------------------------------------------------------
XSerializeEngine::XSerializeEngine(BinInputStream* inStream
, MemoryManager* const manager
, unsigned long bufSize)
:fStoreLoad(mode_Load)
,fGrammarPool(0)
,fInputStream(inStream)
,fOutputStream(0)
,fBufSize(bufSize)
,fBufStart( (XMLByte*) manager->allocate(bufSize))
,fBufEnd(0)
,fBufCur(fBufStart)
,fBufLoadMax(fBufStart)
,fStorePool(0)
,fLoadPool( new (manager) ValueVectorOf<void*>(29, manager, false))
,fObjectCount(0)
/***
* initialize buffer from the inStream
***/
fillBuffer();
}
XSerializeEngine::XSerializeEngine(BinOutputStream* outStream
, MemoryManager* const manager
, unsigned long bufSize)
:fStoreLoad(mode_Store)
,fGrammarPool(0)
,fInputStream(0)
,fOutputStream(outStream)
,fBufSize(bufSize)
,fBufStart((XMLByte*) manager->allocate(bufSize))
,fBufEnd(fBufStart+bufSize)
,fBufCur(fBufStart)
,fBufLoadMax(0)
,fStorePool( new (manager) RefHashTableOf<XSerializedObjectId>(29, true, new (manager) HashPtr(), manager) )
,fLoadPool(0)
,fObjectCount(0)
{
//initialize store pool
fStorePool->put(0, new (manager) XSerializedObjectId(fgNullObjectTag));
}
void XSerializeEngine::flush()
{
if (isStoring())
flushBuffer();
}
// ---------------------------------------------------------------------------
// Storing
// ---------------------------------------------------------------------------
void XSerializeEngine::write(XSerializable* const objectToWrite)
{
ensureStoring();
//don't ensurePointer here !!!
if (!objectToWrite) // null pointer
{
*this << fgNullObjectTag;
}
else if (0 != (objIndex = lookupStorePool((void*) objectToWrite)))
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
{
// writing an object reference tag
*this << objIndex;
}
else
{
// write protoType first
XProtoType* protoType = objectToWrite->getProtoType();
write(protoType);
// put the object into StorePool
addStorePool((void*)objectToWrite);
// ask the object to serialize itself
objectToWrite->serialize(*this);
}
}
void XSerializeEngine::write(XProtoType* const protoType)
{
ensureStoring();
ensurePointer(protoType);
XSerializedObjectId_t objIndex = lookupStorePool((void*)protoType);
if (objIndex)
{
//protoType seen in the store pool
*this << (fgClassMask | objIndex);
}
else
{
// store protoType
*this << fgNewClassTag;
protoType->store(*this);
addStorePool((void*)protoType);
}
}
/***
*
void XSerializeEngine::write(const XMLCh* const toWrite
, int writeLen)
{
write((XMLByte*)toWrite, (sizeof(XMLCh)/sizeof(XMLByte)) * writeLen);
}
void XSerializeEngine::write(const XMLByte* const toWrite
, int writeLen)
{
ensureStoring();
ensurePointer((void*)toWrite);
ensureBufferLen(writeLen);
ensureStoreBuffer();
if (writeLen == 0)
return;
/***
* If the available space is sufficient, write it up
***/
int bufAvail = fBufEnd - fBufCur;
if (writeLen <= bufAvail)
{
memcpy(fBufCur, toWrite, writeLen);
fBufCur += writeLen;
return;
}
const XMLByte* tempWrite = (const XMLByte*) toWrite;
unsigned int writeRemain = writeLen;
// fill up the avaiable space and flush
memcpy(fBufCur, tempWrite, bufAvail);
tempWrite += bufAvail;
writeRemain -= bufAvail;
flushBuffer();
// write chunks of fBufSize
while (writeRemain >= fBufSize)
{
memcpy(fBufCur, tempWrite, fBufSize);
tempWrite += fBufSize;
writeRemain -= fBufSize;
flushBuffer();
}
// write the remaining if any
if (writeRemain)
{
memcpy(fBufCur, tempWrite, writeRemain);
fBufCur += writeRemain;
}
}
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
/***
*
* Storage scheme (normal):
*
* <
* 1st integer: bufferLen (optional)
* 2nd integer: dataLen
* bytes following:
* >
*
* Storage scheme (special):
* <
* only integer: noDataFollowed
* >
*/
void XSerializeEngine::writeString(const XMLCh* const toWrite
, const int bufferLen
, bool toWriteBufLen)
{
if (toWrite)
{
if (toWriteBufLen)
*this<<bufferLen;
int strLen = XMLString::stringLen(toWrite);
*this<<strLen;
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
write(toWrite, strLen);
}
else
{
*this<<noDataFollowed;
}
}
void XSerializeEngine::writeString(const XMLByte* const toWrite
, const int bufferLen
, bool toWriteBufLen)
{
if (toWrite)
{
if (toWriteBufLen)
*this<<bufferLen;
int strLen = XMLString::stringLen((char*)toWrite);
*this<<strLen;
write(toWrite, strLen);
}
else
{
*this<<noDataFollowed;
}
}
// ---------------------------------------------------------------------------
// Loading
// ---------------------------------------------------------------------------
XSerializable* XSerializeEngine::read(XProtoType* const protoType)
{
ensureLoading();
ensurePointer(protoType);
XSerializedObjectId_t objectTag;
XSerializable* objRet;
if (! read(protoType, &objectTag))
{
/***
* We hava a reference to an existing object in
* load pool, get it.
*/
objRet = lookupLoadPool(objectTag);
}
else
{
// create the object from the prototype
objRet = protoType->fCreateObject(getMemoryManager());
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
Assert((objRet != 0), XMLExcepts::XSer_CreateObject_Fail);
// put it into load pool
addLoadPool(objRet);
// de-serialize it
objRet->serialize(*this);
}
return objRet;
}
bool XSerializeEngine::read(XProtoType* const protoType
, XSerializedObjectId_t* objectTagRet)
{
ensureLoading();
ensurePointer(protoType);
XSerializedObjectId_t obTag;
*this >> obTag;
// object reference tag found
if (!(obTag & fgClassMask))
{
*objectTagRet = obTag;
return false;
}
if (obTag == fgNewClassTag)
{
// what follows fgNewClassTag is the prototype object info
// for the object anticipated, go and verify the info
XProtoType::load(*this, protoType->fClassName, getMemoryManager());
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
addLoadPool((void*)protoType);
}
else
{
// what follows class tag is an XSerializable object
XSerializedObjectId_t classIndex = (obTag & ~fgClassMask);
XSerializedObjectId_t loadPoolSize = (XSerializedObjectId_t)fLoadPool->size();
TEST_THROW_ARG2(((classIndex == 0 ) || (classIndex > loadPoolSize))
, classIndex
, loadPoolSize
, XMLExcepts::XSer_Inv_ClassIndex
)
ensurePointer(lookupLoadPool(classIndex));
}
return true;
}
void XSerializeEngine::read(XMLCh* const toRead
, int readLen)
{
read((XMLByte*)toRead, (sizeof(XMLCh)/sizeof(XMLByte))*readLen);
}
void XSerializeEngine::read(XMLByte* const toRead
, int readLen)
{
ensureLoading();
ensureBufferLen(readLen);
ensurePointer(toRead);
ensureLoadBuffer();
if (readLen == 0)
return;
/***
* If unread is sufficient, read it up
***/
int dataAvail = fBufLoadMax - fBufCur;
if (readLen <= dataAvail)
{
memcpy(toRead, fBufCur, readLen);
fBufCur += readLen;
return;
}
/***
*
* fillBuffer will discard anything left in the buffer
* before it asks the inputStream to fill in the buffer,
* so we need to readup everything in the buffer before
* calling fillBuffer
*
***/
XMLByte* tempRead = (XMLByte*) toRead;
unsigned int readRemain = readLen;
// read the unread
memcpy(tempRead, fBufCur, dataAvail);
tempRead += dataAvail;
readRemain -= dataAvail;
// read chunks of fBufSize
while (readRemain >= fBufSize)
fillBuffer();
memcpy(tempRead, fBufCur, fBufSize);
tempRead += fBufSize;
readRemain -= fBufSize;
}
// read the remaining if any
if (readRemain)
{
fillBuffer();
memcpy(tempRead, fBufCur, readRemain);
fBufCur += readRemain;
}
}
/***
*
* Storage scheme (normal):
*
* <
* 1st integer: bufferLen (optional)
* 2nd integer: dataLen
* bytes following:
* >
*
* Storage scheme (special):
* <
* only integer: noDataFollowed
* >
*/
void XSerializeEngine::readString(XMLCh*& toRead
, int& bufferLen
, int& dataLen
, bool toReadBufLen)
{
/***
* Check if any data written
***/
*this>>bufferLen;
if (bufferLen == noDataFollowed)
{
toRead = 0;
bufferLen = 0;
dataLen = 0;
return;
}
if (toReadBufLen)
{
*this>>dataLen;
}
else
{
dataLen = bufferLen++;
}
toRead = (XMLCh*) getMemoryManager()->allocate(bufferLen * sizeof(XMLCh));
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
read(toRead, dataLen);
toRead[dataLen] = 0;
}
void XSerializeEngine::readString(XMLByte*& toRead
, int& bufferLen
, int& dataLen
, bool toReadBufLen)
{
/***
* Check if any data written
***/
*this>>bufferLen;
if (bufferLen == noDataFollowed)
{
toRead = 0;
bufferLen = 0;
dataLen = 0;
return;
}
if (toReadBufLen)
{
*this>>dataLen;
}
else
{
dataLen = bufferLen++;
}
toRead = (XMLByte*) getMemoryManager()->allocate(bufferLen * sizeof(XMLByte));
read(toRead, dataLen);
toRead[dataLen] = 0;
}
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
// ---------------------------------------------------------------------------
// Insertion
// ---------------------------------------------------------------------------
XSerializeEngine& XSerializeEngine::operator<<(XMLCh xch)
{
checkAndFlushBuffer(sizeof(XMLCh));
*(XMLCh*)fBufCur = xch;
fBufCur += sizeof(XMLCh);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(XMLByte by)
{
checkAndFlushBuffer(sizeof(XMLByte));
*(XMLByte*)fBufCur = by;
fBufCur += sizeof(XMLByte);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(bool b)
{
checkAndFlushBuffer(sizeof(bool));
*(bool*)fBufCur = b;
fBufCur += sizeof(bool);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(char ch)
{
return XSerializeEngine::operator<<((XMLByte)ch);
}
XSerializeEngine& XSerializeEngine::operator<<(short sh)
{
checkAndFlushBuffer(allignAdjust()+sizeof(short));
*(short*)fBufCur = sh;
fBufCur += sizeof(short);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(int i)
{
checkAndFlushBuffer(allignAdjust()+sizeof(int));
allignBufCur();
*(int*)fBufCur = i;
fBufCur += sizeof(int);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(unsigned int ui)
{
checkAndFlushBuffer(allignAdjust()+sizeof(unsigned int));
allignBufCur();
*(unsigned int*)fBufCur = ui;
fBufCur += sizeof(unsigned int);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(long l)
{
checkAndFlushBuffer(allignAdjust()+sizeof(long));
*(long*)fBufCur = l;
fBufCur += sizeof(long);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(unsigned long ul)
{
checkAndFlushBuffer(allignAdjust()+sizeof(unsigned long));
*(unsigned long*)fBufCur = ul;
fBufCur += sizeof(unsigned long);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(float f)
{
checkAndFlushBuffer(allignAdjust()+sizeof(float));
*(float*)fBufCur = *(float*)&f;
fBufCur += sizeof(float);
return *this;
}
XSerializeEngine& XSerializeEngine::operator<<(double d)
{
checkAndFlushBuffer(allignAdjust()+sizeof(double));
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
*(double*)fBufCur = *(double*)&d;
fBufCur += sizeof(double);
return *this;
}
// ---------------------------------------------------------------------------
// Extraction
// ---------------------------------------------------------------------------
XSerializeEngine& XSerializeEngine::operator>>(XMLCh& xch)
{
checkAndFillBuffer(sizeof(XMLCh));
xch = *(XMLCh*)fBufCur;
fBufCur += sizeof(XMLCh);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(XMLByte& by)
{
checkAndFillBuffer(sizeof(XMLByte));
by = *(XMLByte*)fBufCur;
fBufCur += sizeof(XMLByte);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(bool& b)
{
checkAndFillBuffer(sizeof(bool));
b = *(bool*)fBufCur;
fBufCur += sizeof(bool);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(char& ch)
{
return XSerializeEngine::operator>>((XMLByte&)ch);
}
XSerializeEngine& XSerializeEngine::operator>>(short& sh)
{
checkAndFillBuffer(allignAdjust()+sizeof(short));
sh = *(short*)fBufCur;
fBufCur += sizeof(short);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(int& i)
{
checkAndFillBuffer(allignAdjust()+sizeof(int));
allignBufCur();
i = *(int*)fBufCur;
fBufCur += sizeof(int);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(unsigned int& ui)
{
checkAndFillBuffer(allignAdjust()+sizeof(unsigned int));
allignBufCur();
ui = *(unsigned int*)fBufCur;
fBufCur += sizeof(unsigned int);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(long& l)
{
checkAndFillBuffer(allignAdjust()+sizeof(long));
l = *(long*)fBufCur;
fBufCur += sizeof(long);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(unsigned long& ul)
{
checkAndFillBuffer(allignAdjust()+sizeof(unsigned long));
ul = *(unsigned long*)fBufCur;
fBufCur += sizeof(unsigned long);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(float& f)
{
checkAndFillBuffer(allignAdjust()+sizeof(float));
*(float*)&f = *(float*)fBufCur;
fBufCur += sizeof(float);
return *this;
}
XSerializeEngine& XSerializeEngine::operator>>(double& d)
{
checkAndFillBuffer(allignAdjust()+sizeof(double));
*(double*)&d = *(double*)fBufCur;
fBufCur += sizeof(double);
return *this;
}
// ---------------------------------------------------------------------------
// StorePool/LoadPool Opertions
// ---------------------------------------------------------------------------
XSerializeEngine::XSerializedObjectId_t
XSerializeEngine::lookupStorePool(void* const objToLookup) const
{
//0 indicating object is not in the StorePool
XSerializedObjectId* data = fStorePool->get(objToLookup);
return (XSerializeEngine::XSerializedObjectId_t) (data ? data->getValue() : 0);
}
void XSerializeEngine::addStorePool(void* const objToAdd)
{
pumpCount();
fStorePool->put(objToAdd, new (fGrammarPool->getMemoryManager()) XSerializedObjectId(fObjectCount));
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
}
XSerializable* XSerializeEngine::lookupLoadPool(XSerializedObjectId_t objectTag) const
{
/***
* an object tag read from the binary refering to
* an object beyond the upper most boundary of the load pool
***/
TEST_THROW_ARG2( (objectTag > fLoadPool->size())
, objectTag
, fLoadPool->size()
, XMLExcepts::XSer_LoadPool_UppBnd_Exceed
)
if (objectTag == 0)
return 0;
/***
* A non-null object tag starts from 1 while fLoadPool starts from 0
***/
return (XSerializable*) fLoadPool->elementAt(objectTag - 1);
}
void XSerializeEngine::addLoadPool(void* const objToAdd)
{
TEST_THROW_ARG2( (fLoadPool->size() != fObjectCount)
, fObjectCount
, fLoadPool->size()
, XMLExcepts::XSer_LoadPool_NoTally_ObjCnt
)
pumpCount();
fLoadPool->addElement(objToAdd);
}
void XSerializeEngine::pumpCount()
{
TEST_THROW_ARG2( (fObjectCount >= fgMaxObjectCount)
, fObjectCount
, fgMaxObjectCount
, XMLExcepts::XSer_ObjCount_UppBnd_Exceed
)
fObjectCount++;
}
// ---------------------------------------------------------------------------
// Buffer Opertions
// ---------------------------------------------------------------------------
/***
*
* Though client may need only miniBytesNeeded, we always request
* a full size reading from our inputStream.
*
* Whatever possibly left in the buffer is abandoned, such as in
* the case of CheckAndFillBuffer()
void XSerializeEngine::fillBuffer()
{
ensureLoading();
ensureLoadBuffer();
int bytesRead = fInputStream->readBytes(fBufStart, fBufSize);
* InputStream MUST fill in the exact amount of bytes as requested
* to do: combine the checking and create a new exception code later
TEST_THROW_ARG2( (bytesRead < (int)fBufSize)
, fBufSize
, XMLExcepts::XSer_InStream_Read_LT_Req
)
TEST_THROW_ARG2( (bytesRead > (int)fBufSize)
, fBufSize
, XMLExcepts::XSer_InStream_Read_OverFlow
)
fBufLoadMax = fBufStart + fBufSize;
fBufCur = fBufStart;
ensureLoadBuffer();
}