BTH/axyz-deps
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added Xerces-C++ 3.1.2

Browse Source
This commit is contained in:
sippeangelo
2015-12-01 10:23:50 +01:00
parent 65d3f3bc31
commit 1b478d3159
815 changed files with 262638 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/xercesc/util/QName.cpp
+426
View File
@@ -0,0 +1,426 @@
/*
* 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: QName.cpp 810580 2009-09-02 15:52:22Z amassari $
*/
#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/QName.hpp>
#include <xercesc/util/OutOfMemoryException.hpp>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// QName: Constructors and Destructor
// ---------------------------------------------------------------------------
QName::QName(MemoryManager* const manager)
:fPrefixBufSz(0)
,fLocalPartBufSz(0)
,fRawNameBufSz(0)
,fURIId(0)
,fPrefix(0)
,fLocalPart(0)
,fRawName(0)
,fMemoryManager(manager)
{
}
typedef JanitorMemFunCall<QName> CleanupType;
QName::QName( const XMLCh* const prefix
, const XMLCh* const localPart
, const unsigned int uriId
, MemoryManager* const manager)
:fPrefixBufSz(0)
,fLocalPartBufSz(0)
,fRawNameBufSz(0)
,fURIId(0)
,fPrefix(0)
,fLocalPart(0)
,fRawName(0)
,fMemoryManager(manager)
{
CleanupType cleanup(this, &QName::cleanUp);
try
{
//
// Just call the local setters to set up everything. Too much
// work is required to replicate that functionality here.
//
setName(prefix, localPart, uriId);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
}
QName::QName( const XMLCh* const rawName
, const unsigned int uriId
, MemoryManager* const manager)
:fPrefixBufSz(0)
,fLocalPartBufSz(0)
,fRawNameBufSz(0)
,fURIId(0)
,fPrefix(0)
,fLocalPart(0)
,fRawName(0)
,fMemoryManager(manager)
{
CleanupType cleanup(this, &QName::cleanUp);
try
{
//
// Just call the local setters to set up everything. Too much
// work is required to replicate that functionality here.
//
setName(rawName, uriId);
}
catch(const OutOfMemoryException&)
{
cleanup.release();
throw;
}
cleanup.release();
}
QName::~QName()
{
cleanUp();
}
// ---------------------------------------------------------------------------
// QName: Copy Constructors
// ---------------------------------------------------------------------------
QName::QName(const QName& qname)
:XSerializable(qname)
,XMemory(qname)
,fPrefixBufSz(0)
,fLocalPartBufSz(0)
,fRawNameBufSz(0)
,fURIId(0)
,fPrefix(0)
,fLocalPart(0)
,fRawName(0)
,fMemoryManager(qname.fMemoryManager)
{
XMLSize_t newLen;
newLen = XMLString::stringLen(qname.getLocalPart());
fLocalPartBufSz = newLen + 8;
fLocalPart = (XMLCh*) fMemoryManager->allocate
(
(fLocalPartBufSz + 1) * sizeof(XMLCh)
); //new XMLCh[fLocalPartBufSz + 1];
XMLString::moveChars(fLocalPart, qname.getLocalPart(), newLen + 1);
newLen = XMLString::stringLen(qname.getPrefix());
fPrefixBufSz = newLen + 8;
fPrefix = (XMLCh*) fMemoryManager->allocate
(
(fPrefixBufSz + 1) * sizeof(XMLCh)
); //new XMLCh[fPrefixBufSz + 1];
XMLString::moveChars(fPrefix, qname.getPrefix(), newLen + 1);
fURIId = qname.getURI();
}
// ---------------------------------------------------------------------------
// QName: Getter methods
// ---------------------------------------------------------------------------
const XMLCh* QName::getRawName() const
{
//
// If there is no buffer, or if there is but we've not faulted in the
// value yet, then we have to do that now.
//
if (!fRawName || !*fRawName)
{
//
// If we have a prefix, then do the prefix:name version. Else, its
// just the name.
//
if (*fPrefix)
{
//
// Calculate the worst case size buffer we will need. We use the
// current high water marks of the prefix and name buffers, so it
// might be a little wasteful of memory but we don't have to do
// string len operations on the two strings.
//
const XMLSize_t neededLen = fPrefixBufSz + fLocalPartBufSz + 1;
//
// If no buffer, or the current one is too small, then allocate one
// and get rid of any old one.
//
if (!fRawName || (neededLen > fRawNameBufSz))
{
fMemoryManager->deallocate(fRawName); //delete [] fRawName;
((QName*)this)->fRawName = 0;
// We have to cast off the const'ness to do this
((QName*)this)->fRawNameBufSz = neededLen;
((QName*)this)->fRawName = (XMLCh*) fMemoryManager->allocate
(
(neededLen + 1) * sizeof(XMLCh)
); //new XMLCh[neededLen + 1];
// Make sure its initially empty
*fRawName = 0;
}
const XMLSize_t prefixLen = XMLString::stringLen(fPrefix);
XMLString::moveChars(fRawName, fPrefix, prefixLen);
fRawName[prefixLen] = chColon;
XMLString::copyString(&fRawName[prefixLen+1], fLocalPart);
}
else
{
return fLocalPart;
}
}
return fRawName;
}
XMLCh* QName::getRawName()
{
//
// If there is no buffer, or if there is but we've not faulted in the
// value yet, then we have to do that now.
//
if (!fRawName || !*fRawName)
{
//
// If we have a prefix, then do the prefix:name version. Else, its
// just the name.
//
if (*fPrefix)
{
//
// Calculate the worst case size buffer we will need. We use the
// current high water marks of the prefix and name buffers, so it
// might be a little wasteful of memory but we don't have to do
// string len operations on the two strings.
//
const XMLSize_t neededLen = fPrefixBufSz + fLocalPartBufSz + 1;
//
// If no buffer, or the current one is too small, then allocate one
// and get rid of any old one.
//
if (!fRawName || (neededLen > fRawNameBufSz))
{
fMemoryManager->deallocate(fRawName); //delete [] fRawName;
fRawName = 0;
// We have to cast off the const'ness to do this
((QName*)this)->fRawNameBufSz = neededLen;
((QName*)this)->fRawName = (XMLCh*) fMemoryManager->allocate
(
(neededLen + 1) * sizeof(XMLCh)
); //new XMLCh[neededLen + 1];
// Make sure its initially empty
*fRawName = 0;
}
const XMLSize_t prefixLen = XMLString::stringLen(fPrefix);
XMLString::moveChars(fRawName, fPrefix, prefixLen);
fRawName[prefixLen] = chColon;
XMLString::copyString(&fRawName[prefixLen+1], fLocalPart);
}
else
{
return fLocalPart;
}
}
return fRawName;
}
// ---------------------------------------------------------------------------
// QName: Setter methods
// ---------------------------------------------------------------------------
void QName::setName(const XMLCh* const prefix
, const XMLCh* const localPart
, const unsigned int uriId)
{
setPrefix(prefix);
setLocalPart(localPart);
// And clean up any QName and leave it undone until/if asked for again
if (fRawName)
*fRawName = 0;
// And finally store the URI id parameter
fURIId = uriId;
}
void QName::setName(const XMLCh* const rawName
, const unsigned int uriId)
{
//set the rawName
XMLSize_t newLen = XMLString::stringLen(rawName);
//find out the prefix and localPart from the rawName
const int colonInd = XMLString::indexOf(rawName, chColon);
if (colonInd >= 0)
{
if (!fRawNameBufSz || (newLen > fRawNameBufSz))
{
fMemoryManager->deallocate(fRawName); //delete [] fRawName;
fRawName = 0;
fRawNameBufSz = newLen + 8;
fRawName = (XMLCh*) fMemoryManager->allocate
(
(fRawNameBufSz + 1) * sizeof(XMLCh)
); //new XMLCh[fRawNameBufSz + 1];
}
XMLString::moveChars(fRawName, rawName, newLen + 1);
setNPrefix(rawName, colonInd);
}
else
{
// No colon, so we just have a name with no prefix
setNPrefix(XMLUni::fgZeroLenString, 0);
// And clean up any QName and leave it undone until/if asked for again
if (fRawName)
*fRawName = 0;
}
setNLocalPart(&rawName[colonInd+1], newLen-colonInd-1);
// And finally store the URI id parameter
fURIId = uriId;
}
void QName::setNPrefix(const XMLCh* prefix, const XMLSize_t newLen)
{
if (!fPrefixBufSz || (newLen > fPrefixBufSz))
{
fMemoryManager->deallocate(fPrefix); //delete [] fPrefix;
fPrefix = 0;
fPrefixBufSz = newLen + 8;
fPrefix = (XMLCh*) fMemoryManager->allocate
(
(fPrefixBufSz + 1) * sizeof(XMLCh)
); //new XMLCh[fPrefixBufSz + 1];
}
XMLString::moveChars(fPrefix, prefix, newLen);
fPrefix[newLen] = chNull;
}
void QName::setNLocalPart(const XMLCh* localPart, const XMLSize_t newLen)
{
if (!fLocalPartBufSz || (newLen > fLocalPartBufSz))
{
fMemoryManager->deallocate(fLocalPart); //delete [] fLocalPart;
fLocalPart = 0;
fLocalPartBufSz = newLen + 8;
fLocalPart = (XMLCh*) fMemoryManager->allocate
(
(fLocalPartBufSz + 1) * sizeof(XMLCh)
); //new XMLCh[fLocalPartBufSz + 1];
}
XMLString::moveChars(fLocalPart, localPart, newLen);
fLocalPart[newLen] = chNull;
}
void QName::setValues(const QName& qname)
{
setPrefix(qname.getPrefix());
setLocalPart(qname.getLocalPart());
setURI(qname.getURI());
}
// -----------------------------------------------------------------------
// comparison
// -----------------------------------------------------------------------
bool QName::operator==(const QName& qname) const
{
// if we are an unitialized QName, check that the other is unitialized too
if (!fLocalPart && !fPrefix)
return !qname.fLocalPart && !qname.fPrefix;
if (fURIId == 0) // null URI
return (XMLString::equals(getRawName(),qname.getRawName()));
return ((fURIId == qname.getURI()) &&
(XMLString::equals(fLocalPart, qname.getLocalPart())));
}
// ---------------------------------------------------------------------------
// QName: Private, helper methods
// ---------------------------------------------------------------------------
void QName::cleanUp()
{
fMemoryManager->deallocate(fLocalPart); //delete [] fLocalPart;
fMemoryManager->deallocate(fPrefix); //delete [] fPrefix;
fMemoryManager->deallocate(fRawName); //delete [] fRawName;
fLocalPart = fPrefix = fRawName = 0;
}
/***
* Support for Serialization/De-serialization
***/
IMPL_XSERIALIZABLE_TOCREATE(QName)
void QName::serialize(XSerializeEngine& serEng)
{
if (serEng.isStoring())
{
serEng.writeString(fPrefix, fPrefixBufSz, XSerializeEngine::toWriteBufferLen);
serEng.writeString(fLocalPart, fLocalPartBufSz, XSerializeEngine::toWriteBufferLen);
//do not serialize rawName
serEng<<fURIId;
}
else
{
XMLSize_t dataLen = 0;
serEng.readString(fPrefix, fPrefixBufSz, dataLen, XSerializeEngine::toReadBufferLen);
serEng.readString(fLocalPart, fLocalPartBufSz, dataLen, XSerializeEngine::toReadBufferLen);
//force raw name rebuilt
fRawNameBufSz = 0;
fRawName = 0;
serEng>>fURIId;
}
}
XERCES_CPP_NAMESPACE_END