| /* |
| * 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. |
| */ |
| |
| // Class header file... |
| #include "ResultNamespacesStack.hpp" |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| ResultNamespacesStack::ResultNamespacesStack(MemoryManager& theManager) : |
| m_resultNamespaces(theManager, 1), |
| m_stackBegin(m_resultNamespaces.begin()), |
| m_stackPosition(m_stackBegin), |
| m_createNewContextStack(theManager) |
| { |
| // m_resultNamespaces is initialized to a size of |
| // 1, so we always have a dummy entry at the |
| // beginning. This makes the implementation |
| // much simpler. |
| } |
| |
| |
| |
| ResultNamespacesStack::~ResultNamespacesStack() |
| { |
| } |
| |
| |
| |
| void |
| ResultNamespacesStack::addDeclaration( |
| const XalanDOMString& thePrefix, |
| const XalanDOMChar* theNamespaceURI, |
| XalanDOMString::size_type theLength) |
| { |
| assert(theNamespaceURI != 0); |
| assert(m_createNewContextStack.empty() == false); |
| |
| // Check to see if we need to create a new context and do so if necessary... |
| if (m_createNewContextStack.back() == true) |
| { |
| ++m_stackPosition; |
| |
| if (m_stackPosition == m_resultNamespaces.end()) |
| { |
| m_resultNamespaces.resize(m_resultNamespaces.size() + 1); |
| |
| m_stackPosition = m_resultNamespaces.end() - 1; |
| m_stackBegin = m_resultNamespaces.begin(); |
| } |
| |
| m_createNewContextStack.back() = false; |
| } |
| |
| NamespaceVectorType& theCurrentNamespaces = *m_stackPosition; |
| |
| // Add a new namespace at the end of the current namespaces. |
| theCurrentNamespaces.resize(theCurrentNamespaces.size() + 1); |
| |
| NameSpace& theNewNamespace = theCurrentNamespaces.back(); |
| |
| theNewNamespace.setPrefix(thePrefix); |
| |
| theNewNamespace.setURI(theNamespaceURI, theLength); |
| } |
| |
| |
| |
| void |
| ResultNamespacesStack::pushContext() |
| { |
| if (m_createNewContextStack.empty() == true) |
| { |
| m_createNewContextStack.reserve(eDefaultCreateNewContextStackSize); |
| } |
| |
| m_createNewContextStack.push_back(true); |
| } |
| |
| |
| |
| void |
| ResultNamespacesStack::popContext() |
| { |
| assert(m_createNewContextStack.empty() == false); |
| |
| if (m_createNewContextStack.back() == false) |
| { |
| assert(m_resultNamespaces.empty() == false && |
| m_stackPosition != m_resultNamespaces.begin()); |
| |
| (*m_stackPosition).clear(); |
| |
| --m_stackPosition; |
| } |
| |
| m_createNewContextStack.pop_back(); |
| } |
| |
| |
| |
| const XalanDOMString* |
| ResultNamespacesStack::getNamespaceForPrefix(const XalanDOMString& thePrefix) const |
| { |
| if (m_stackPosition == m_stackBegin) |
| { |
| return 0; |
| } |
| else |
| { |
| return XalanQName::getNamespaceForPrefix( |
| m_stackBegin, |
| m_stackPosition + 1, |
| thePrefix); |
| } |
| } |
| |
| |
| |
| const XalanDOMString* |
| ResultNamespacesStack::getPrefixForNamespace(const XalanDOMString& theNamespaceURI) const |
| { |
| if (m_stackPosition == m_stackBegin) |
| { |
| return 0; |
| } |
| else |
| { |
| return XalanQName::getPrefixForNamespace( |
| m_stackBegin, |
| m_stackPosition + 1, |
| theNamespaceURI); |
| } |
| } |
| |
| |
| |
| bool |
| ResultNamespacesStack::prefixIsPresentLocal(const XalanDOMString& thePrefix) |
| { |
| bool fResult = false; |
| |
| // Check to see if we need to create a new context. If so, there are |
| // no prefixes mapped at this level, so return false... |
| if (m_createNewContextStack.back() == false) |
| { |
| const NamespaceVectorType& theNamespaces = |
| *m_stackPosition; |
| |
| NamespaceVectorType::const_iterator i = theNamespaces.begin(); |
| const NamespaceVectorType::const_iterator theEnd = theNamespaces.end(); |
| |
| while(i != theEnd && fResult == false) |
| { |
| const NameSpace& ns = (*i); |
| |
| const XalanDOMString& thisPrefix = ns.getPrefix(); |
| |
| if(thePrefix == thisPrefix) |
| { |
| fResult = true; |
| } |
| else |
| { |
| ++i; |
| } |
| } |
| } |
| |
| return fResult; |
| } |
| |
| |
| |
| void |
| ResultNamespacesStack::clear() |
| { |
| // Since we always keep one dummy entry at the beginning, |
| // swap with an OutputContextStackType instance of size 1. |
| NamespacesStackType temp(XalanMemMgrs::getDummyMemMgr(), 1); |
| temp.swap(m_resultNamespaces); |
| |
| m_stackBegin = m_resultNamespaces.begin(); |
| |
| m_stackPosition = m_stackBegin; |
| |
| m_createNewContextStack.clear(); |
| } |
| |
| |
| |
| } |