libs/xerces-static/xercesc/util/NameIdPool.c
/*
* 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: NameIdPool.c 678409 2008-07-21 13:08:10Z borisk $
*/
// ---------------------------------------------------------------------------
// Includes
// ---------------------------------------------------------------------------
#if defined(XERCES_TMPLSINC)
#include <xercesc/util/NameIdPool.hpp>
#endif
#include <xercesc/util/IllegalArgumentException.hpp>
#include <xercesc/util/NoSuchElementException.hpp>
#include <xercesc/util/RuntimeException.hpp>
#include <new>
#include <assert.h>
XERCES_CPP_NAMESPACE_BEGIN
// ---------------------------------------------------------------------------
// NameIdPool: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem>
NameIdPool<TElem>::NameIdPool( const unsigned int hashModulus
, const unsigned int initSize
, MemoryManager* const manager) :
fMemoryManager(manager)
, fBucketList(hashModulus, manager)
, fIdPtrs(0)
, fIdPtrsCount(initSize)
, fIdCounter(0)
{
if (!hashModulus)
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_ZeroModulus, fMemoryManager);
//
// Allocate the initial id pointers array. We don't have to zero them
// out since the fIdCounter value tells us which ones are valid. The
// zeroth element is never used (and represents an invalid pool id.)
//
if (!fIdPtrsCount)
fIdPtrsCount = 256;
fIdPtrs = (TElem**) fMemoryManager->allocate
(
fIdPtrsCount * sizeof(TElem*)
);
fIdPtrs[0] = 0;
}
template <class TElem> NameIdPool<TElem>::~NameIdPool()
{
//
// Delete the id pointers list. The stuff it points to will be cleaned
// up when we clean the bucket lists.
//
fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
}
// ---------------------------------------------------------------------------
// NameIdPool: Element management
// ---------------------------------------------------------------------------
template <class TElem>
inline bool NameIdPool<TElem>::
containsKey(const XMLCh* const key) const
{
if (fIdCounter == 0) return false;
return fBucketList.containsKey(key);
}
template <class TElem> void NameIdPool<TElem>::removeAll()
{
if (fIdCounter == 0) return;
fBucketList.removeAll();
// Reset the id counter
fIdCounter = 0;
}
// ---------------------------------------------------------------------------
// NameIdPool: Getters
// ---------------------------------------------------------------------------
template <class TElem>
inline TElem* NameIdPool<TElem>::
getByKey(const XMLCh* const key)
{
if (fIdCounter == 0) return 0;
return fBucketList.get(key);
}
template <class TElem>
inline const TElem* NameIdPool<TElem>::
getByKey(const XMLCh* const key) const
{
if (fIdCounter == 0) return 0;
return fBucketList.get(key);
}
template <class TElem>
inline TElem* NameIdPool<TElem>::
getById(const unsigned int elemId)
{
// If its either zero or beyond our current id, its an error
if (!elemId || (elemId > fIdCounter))
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_InvalidId, fMemoryManager);
return fIdPtrs[elemId];
}
template <class TElem>
inline const TElem* NameIdPool<TElem>::
getById(const unsigned int elemId) const
{
// If its either zero or beyond our current id, its an error
if (!elemId || (elemId > fIdCounter))
ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_InvalidId, fMemoryManager);
return fIdPtrs[elemId];
}
template <class TElem>
inline MemoryManager* NameIdPool<TElem>::getMemoryManager() const
{
return fMemoryManager;
}
// ---------------------------------------------------------------------------
// NameIdPool: Setters
// ---------------------------------------------------------------------------
template <class TElem>
unsigned int NameIdPool<TElem>::put(TElem* const elemToAdopt)
{
// First see if the key exists already. If so, its an error
if(containsKey(elemToAdopt->getKey()))
{
ThrowXMLwithMemMgr1
(
IllegalArgumentException
, XMLExcepts::Pool_ElemAlreadyExists
, elemToAdopt->getKey()
, fMemoryManager
);
}
fBucketList.put((void*)elemToAdopt->getKey(), elemToAdopt);
//
// Give this new one the next available id and add to the pointer list.
// Expand the list if that is now required.
//
if (fIdCounter + 1 == fIdPtrsCount)
{
// Create a new count 1.5 times larger and allocate a new array
unsigned int newCount = (unsigned int)(fIdPtrsCount * 1.5);
TElem** newArray = (TElem**) fMemoryManager->allocate
(
newCount * sizeof(TElem*)
); //new TElem*[newCount];
// Copy over the old contents to the new array
memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*));
// Ok, toss the old array and store the new data
fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
fIdPtrs = newArray;
fIdPtrsCount = newCount;
}
const unsigned int retId = ++fIdCounter;
fIdPtrs[retId] = elemToAdopt;
// Set the id on the passed element
elemToAdopt->setId(retId);
// Return the id that we gave to this element
return retId;
}
// ---------------------------------------------------------------------------
// NameIdPoolEnumerator: Constructors and Destructor
// ---------------------------------------------------------------------------
template <class TElem> NameIdPoolEnumerator<TElem>::
NameIdPoolEnumerator(NameIdPool<TElem>* const toEnum
, MemoryManager* const manager) :
XMLEnumerator<TElem>()
, fCurIndex(0)
, fToEnum(toEnum)
, fMemoryManager(manager)
{
Reset();
}
template <class TElem> NameIdPoolEnumerator<TElem>::
NameIdPoolEnumerator(const NameIdPoolEnumerator<TElem>& toCopy) :
XMLEnumerator<TElem>(toCopy)
, XMemory(toCopy)
, fCurIndex(toCopy.fCurIndex)
, fToEnum(toCopy.fToEnum)
, fMemoryManager(toCopy.fMemoryManager)
{
}
template <class TElem> NameIdPoolEnumerator<TElem>::~NameIdPoolEnumerator()
{
// We don't own the pool being enumerated, so no cleanup required
}
// ---------------------------------------------------------------------------
// NameIdPoolEnumerator: Public operators
// ---------------------------------------------------------------------------
template <class TElem> NameIdPoolEnumerator<TElem>& NameIdPoolEnumerator<TElem>::
operator=(const NameIdPoolEnumerator<TElem>& toAssign)
{
if (this == &toAssign)
return *this;
fMemoryManager = toAssign.fMemoryManager;
fCurIndex = toAssign.fCurIndex;
fToEnum = toAssign.fToEnum;
return *this;
}
// ---------------------------------------------------------------------------
// NameIdPoolEnumerator: Enum interface
// ---------------------------------------------------------------------------
template <class TElem> bool NameIdPoolEnumerator<TElem>::
hasMoreElements() const
{
// If our index is zero or past the end, then we are done
if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
return false;
return true;
}
template <class TElem> TElem& NameIdPoolEnumerator<TElem>::nextElement()
{
// If our index is zero or past the end, then we are done
if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager);
// Return the current element and bump the index
return *fToEnum->fIdPtrs[fCurIndex++];
}
template <class TElem> void NameIdPoolEnumerator<TElem>::Reset()
{
//
// Find the next available bucket element in the pool. We use the id
// array since its very easy to enumerator through by just maintaining
// an index. If the id counter is zero, then its empty and we leave the
// current index to zero.
//
fCurIndex = fToEnum->fIdCounter ? 1:0;
}
template <class TElem> unsigned int NameIdPoolEnumerator<TElem>::size() const
{
return fToEnum->fIdCounter;
}
XERCES_CPP_NAMESPACE_END