BaseRefVectorOf.c
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:12k
源码类别:

词法分析

开发平台:

Visual C++

  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  56. // ---------------------------------------------------------------------------
  57. //  Includes
  58. // ---------------------------------------------------------------------------
  59. #if defined(XERCES_TMPLSINC)
  60. #include <xercesc/util/BaseRefVectorOf.hpp>
  61. #endif
  62. XERCES_CPP_NAMESPACE_BEGIN
  63. // ---------------------------------------------------------------------------
  64. //  BaseRefVectorOf: Constructors and Destructor
  65. // ---------------------------------------------------------------------------
  66. template <class TElem>
  67. BaseRefVectorOf<TElem>::BaseRefVectorOf( const unsigned int maxElems
  68.                                        , const bool adoptElems
  69.                                        , MemoryManager* const manager) :
  70.     fAdoptedElems(adoptElems)
  71.     , fCurCount(0)
  72.     , fMaxCount(maxElems)
  73.     , fElemList(0)
  74.     , fMemoryManager(manager)
  75. {
  76.     // Allocate and initialize the array
  77.     fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
  78.     for (unsigned int index = 0; index < maxElems; index++)
  79.         fElemList[index] = 0;
  80. }
  81. //implemented so code will link
  82. template <class TElem> BaseRefVectorOf<TElem>::~BaseRefVectorOf()
  83. {
  84. }
  85. // ---------------------------------------------------------------------------
  86. //  BaseRefVectorOf: Element management
  87. // ---------------------------------------------------------------------------
  88. template <class TElem> void BaseRefVectorOf<TElem>::addElement(TElem* const toAdd)
  89. {
  90.     ensureExtraCapacity(1);
  91.     fElemList[fCurCount] = toAdd;
  92.     fCurCount++;
  93. }
  94. template <class TElem> void
  95. BaseRefVectorOf<TElem>::setElementAt(TElem* const toSet, const unsigned int setAt)
  96. {
  97.     if (setAt >= fCurCount)
  98.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  99.     if (fAdoptedElems)
  100.         delete fElemList[setAt];
  101.     fElemList[setAt] = toSet;
  102. }
  103. template <class TElem> void BaseRefVectorOf<TElem>::
  104. insertElementAt(TElem* const toInsert, const unsigned int insertAt)
  105. {
  106.     if (insertAt == fCurCount)
  107.     {
  108.         addElement(toInsert);
  109.         return;
  110.     }
  111.     if (insertAt > fCurCount)
  112.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  113.     ensureExtraCapacity(1);
  114.     // Make room for the newbie
  115.     for (unsigned int index = fCurCount; index > insertAt; index--)
  116.         fElemList[index] = fElemList[index-1];
  117.     // And stick it in and bump the count
  118.     fElemList[insertAt] = toInsert;
  119.     fCurCount++;
  120. }
  121. template <class TElem> TElem* BaseRefVectorOf<TElem>::
  122. orphanElementAt(const unsigned int orphanAt)
  123. {
  124.     if (orphanAt >= fCurCount)
  125.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  126.     // Get the element we are going to orphan
  127.     TElem* retVal = fElemList[orphanAt];
  128.     // Optimize if its the last element
  129.     if (orphanAt == fCurCount-1)
  130.     {
  131.         fElemList[orphanAt] = 0;
  132.         fCurCount--;
  133.         return retVal;
  134.     }
  135.     // Copy down every element above orphan point
  136.     for (unsigned int index = orphanAt; index < fCurCount-1; index++)
  137.         fElemList[index] = fElemList[index+1];
  138.     // Keep unused elements zero for sanity's sake
  139.     fElemList[fCurCount-1] = 0;
  140.     // And bump down count
  141.     fCurCount--;
  142.     return retVal;
  143. }
  144. template <class TElem> void BaseRefVectorOf<TElem>::removeAllElements()
  145. {
  146.     for (unsigned int index = 0; index < fCurCount; index++)
  147.     {
  148.         if (fAdoptedElems)
  149.           delete fElemList[index];
  150.         // Keep unused elements zero for sanity's sake
  151.         fElemList[index] = 0;
  152.     }
  153.     fCurCount = 0;
  154. }
  155. template <class TElem> void BaseRefVectorOf<TElem>::
  156. removeElementAt(const unsigned int removeAt)
  157. {
  158.     if (removeAt >= fCurCount)
  159.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  160.     if (fAdoptedElems)
  161.         delete fElemList[removeAt];
  162.     // Optimize if its the last element
  163.     if (removeAt == fCurCount-1)
  164.     {
  165.         fElemList[removeAt] = 0;
  166.         fCurCount--;
  167.         return;
  168.     }
  169.     // Copy down every element above remove point
  170.     for (unsigned int index = removeAt; index < fCurCount-1; index++)
  171.         fElemList[index] = fElemList[index+1];
  172.     // Keep unused elements zero for sanity's sake
  173.     fElemList[fCurCount-1] = 0;
  174.     // And bump down count
  175.     fCurCount--;
  176. }
  177. template <class TElem> void BaseRefVectorOf<TElem>::removeLastElement()
  178. {
  179.     if (!fCurCount)
  180.         return;
  181.     fCurCount--;
  182.     if (fAdoptedElems)
  183.         delete fElemList[fCurCount];
  184. }
  185. template <class TElem>
  186. bool BaseRefVectorOf<TElem>::containsElement(const TElem* const toCheck) {
  187.     for (unsigned int i = 0; i < fCurCount; i++) {
  188.         if (fElemList[i] == toCheck) {
  189.             return true;
  190.         }
  191.     }
  192.     return false;
  193. }
  194. //
  195. // cleanup():
  196. //   similar to destructor
  197. //   called to cleanup the memory, in case destructor cannot be called
  198. //
  199. template <class TElem> void BaseRefVectorOf<TElem>::cleanup()
  200. {
  201.     if (fAdoptedElems)
  202.     {
  203.         for (unsigned int index = 0; index < fCurCount; index++)
  204.             delete fElemList[index];
  205.     }
  206.     fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  207. }
  208. //
  209. // reinitialize():
  210. //   similar to constructor
  211. //   called to re-construct the fElemList from scratch again
  212. //
  213. template <class TElem> void BaseRefVectorOf<TElem>::reinitialize()
  214. {
  215.     // reinitialize the array
  216.     if (fElemList)
  217.         cleanup();
  218.     fElemList = (TElem**) fMemoryManager->allocate(fMaxCount * sizeof(TElem*));//new TElem*[fMaxCount];
  219.     for (unsigned int index = 0; index < fMaxCount; index++)
  220.         fElemList[index] = 0;
  221. }
  222. template <class TElem>
  223. MemoryManager* BaseRefVectorOf<TElem>::getMemoryManager() const
  224. {
  225.     return fMemoryManager;
  226. }
  227. // ---------------------------------------------------------------------------
  228. //  BaseRefVectorOf: Getter methods
  229. // ---------------------------------------------------------------------------
  230. template <class TElem> unsigned int BaseRefVectorOf<TElem>::curCapacity() const
  231. {
  232.     return fMaxCount;
  233. }
  234. template <class TElem> const TElem* BaseRefVectorOf<TElem>::
  235. elementAt(const unsigned int getAt) const
  236. {
  237.     if (getAt >= fCurCount)
  238.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  239.     return fElemList[getAt];
  240. }
  241. template <class TElem> TElem*
  242. BaseRefVectorOf<TElem>::elementAt(const unsigned int getAt)
  243. {
  244.     if (getAt >= fCurCount)
  245.         ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex);
  246.     return fElemList[getAt];
  247. }
  248. template <class TElem> unsigned int BaseRefVectorOf<TElem>::size() const
  249. {
  250.     return fCurCount;
  251. }
  252. // ---------------------------------------------------------------------------
  253. //  BaseRefVectorOf: Miscellaneous
  254. // ---------------------------------------------------------------------------
  255. template <class TElem> void BaseRefVectorOf<TElem>::
  256. ensureExtraCapacity(const unsigned int length)
  257. {
  258.     unsigned int newMax = fCurCount + length;
  259.     if (newMax < fMaxCount)
  260.         return;
  261.     // Avoid too many reallocations by providing a little more space
  262.     if (newMax < fMaxCount + 32)
  263.         newMax = fMaxCount + 32;
  264.     // Allocate the new array and copy over the existing stuff
  265.     TElem** newList = (TElem**) fMemoryManager->allocate
  266.     (
  267.         newMax * sizeof(TElem*)
  268.     );//new TElem*[newMax];
  269.     unsigned int index = 0;
  270.     for (; index < fCurCount; index++)
  271.         newList[index] = fElemList[index];
  272.     // Zero out the rest of them
  273.     for (; index < newMax; index++)
  274.         newList[index] = 0;
  275.     // Clean up the old array and update our members
  276.     fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  277.     fElemList = newList;
  278.     fMaxCount = newMax;
  279. }
  280. // ---------------------------------------------------------------------------
  281. //  AbstractBaseRefVectorEnumerator: Constructors and Destructor
  282. // ---------------------------------------------------------------------------
  283. template <class TElem> BaseRefVectorEnumerator<TElem>::
  284. BaseRefVectorEnumerator(        BaseRefVectorOf<TElem>* const   toEnum
  285.                     , const bool                        adopt) :
  286.     fAdopted(adopt)
  287.     , fCurIndex(0)
  288.     , fToEnum(toEnum)
  289. {
  290. }
  291. template <class TElem> BaseRefVectorEnumerator<TElem>::~BaseRefVectorEnumerator()
  292. {
  293.     if (fAdopted)
  294.         delete fToEnum;
  295. }
  296. // ---------------------------------------------------------------------------
  297. //  RefBaseRefVectorEnumerator: Enum interface
  298. // ---------------------------------------------------------------------------
  299. template <class TElem> bool BaseRefVectorEnumerator<TElem>::hasMoreElements() const
  300. {
  301.     if (fCurIndex >= fToEnum->size())
  302.         return false;
  303.     return true;
  304. }
  305. template <class TElem> TElem& BaseRefVectorEnumerator<TElem>::nextElement()
  306. {
  307.     return *(fToEnum->elementAt(fCurIndex++));
  308. }
  309. template <class TElem> void BaseRefVectorEnumerator<TElem>::Reset()
  310. {
  311.     fCurIndex = 0;
  312. }
  313. XERCES_CPP_NAMESPACE_END