| /* |
| * 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 "NamespacesHandler.hpp" |
| |
| |
| |
| #include <xalanc/PlatformSupport/StringTokenizer.hpp> |
| #include <xalanc/PlatformSupport/XalanMessageLoader.hpp> |
| |
| |
| |
| #include <xalanc/DOMSupport/DOMServices.hpp> |
| |
| |
| |
| #include "AVT.hpp" |
| #include "Constants.hpp" |
| #include "StylesheetConstructionContext.hpp" |
| #include "StylesheetExecutionContext.hpp" |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| template<class VectorType, class MemberFunctionType> |
| const typename VectorType::value_type* |
| find( |
| const VectorType& theVector, |
| const XalanDOMString& theString, |
| MemberFunctionType theMemberFunction) |
| { |
| const typename VectorType::const_iterator theEnd(theVector.end()); |
| typename VectorType::const_iterator theCurrent(theVector.begin()); |
| |
| while(theCurrent != theEnd) |
| { |
| if (((*theCurrent).*theMemberFunction)() == theString) |
| { |
| return &*theCurrent; |
| } |
| else |
| { |
| ++theCurrent; |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| template<class VectorType, class MemberFunctionType> |
| typename VectorType::value_type* |
| findNonConst( |
| VectorType& theVector, |
| const XalanDOMString& theString, |
| MemberFunctionType theMemberFunction) |
| { |
| const typename VectorType::iterator theEnd(theVector.end()); |
| typename VectorType::iterator theCurrent(theVector.begin()); |
| |
| while(theCurrent != theEnd) |
| { |
| if (((*theCurrent).*theMemberFunction)() == theString) |
| { |
| return &*theCurrent; |
| } |
| else |
| { |
| ++theCurrent; |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| template<class VectorType> |
| const typename VectorType::value_type* |
| findByPrefix( |
| const VectorType& theVector, |
| const XalanDOMString& thePrefix) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| return find(theVector, thePrefix, &value_type::getPrefix); |
| } |
| |
| |
| |
| template<class VectorType> |
| typename VectorType::value_type* |
| findByPrefixNonConst( |
| VectorType& theVector, |
| const XalanDOMString& thePrefix) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| return findNonConst(theVector, thePrefix, &value_type::getPrefix); |
| } |
| |
| |
| |
| template<class VectorType> |
| const typename VectorType::value_type* |
| findByURI( |
| const VectorType& theVector, |
| const XalanDOMString& theNamespaceURI) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| return find(theVector, theNamespaceURI, &value_type::getURI); |
| } |
| |
| |
| |
| template<class VectorType> |
| bool |
| addByPrefix( |
| StylesheetConstructionContext& theConstructionContext, |
| VectorType& theVector, |
| const XalanDOMString& thePrefix, |
| const XalanDOMString& theURI) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| const value_type* const theEntry = |
| findByPrefix(theVector, thePrefix); |
| |
| if (theEntry != 0) |
| { |
| return false; |
| } |
| else |
| { |
| theVector.push_back( |
| value_type( |
| theConstructionContext.getPooledString(thePrefix), |
| theConstructionContext.getPooledString(theURI))); |
| |
| return true; |
| } |
| } |
| |
| |
| |
| template<class VectorType> |
| bool |
| addOrUpdateByPrefix( |
| StylesheetConstructionContext& theConstructionContext, |
| VectorType& theVector, |
| const XalanDOMString& thePrefix, |
| const XalanDOMString& theURI) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| value_type* const theEntry = |
| findByPrefixNonConst(theVector, thePrefix); |
| |
| if (theEntry == 0) |
| { |
| theVector.push_back( |
| value_type( |
| theConstructionContext.getPooledString(thePrefix), |
| theConstructionContext.getPooledString(theURI))); |
| |
| return true; |
| } |
| else |
| { |
| if (theEntry->getURI() == theURI) |
| { |
| return false; |
| } |
| else |
| { |
| theEntry->setURI(theConstructionContext.getPooledString(theURI)); |
| |
| return true; |
| } |
| } |
| } |
| |
| |
| |
| template<class VectorType> |
| const XalanDOMString* |
| findNamespace( |
| const VectorType& theVector, |
| const XalanDOMString& thePrefix) |
| { |
| typedef typename VectorType::value_type value_type; |
| |
| const value_type* const theEntry = |
| findByPrefix(theVector, thePrefix); |
| |
| if (theEntry == 0) |
| { |
| return 0; |
| } |
| else |
| { |
| return &theEntry->getURI(); |
| } |
| } |
| |
| |
| |
| const XalanDOMString NamespacesHandler::Namespace::s_emptyString(XalanMemMgrs::getDummyMemMgr()); |
| |
| |
| |
| NamespacesHandler::PrefixChecker::PrefixChecker() |
| { |
| } |
| |
| |
| |
| NamespacesHandler::PrefixChecker::~PrefixChecker() |
| { |
| } |
| |
| |
| |
| NamespacesHandler::NamespacesHandler(MemoryManager& theManager) : |
| m_excludedResultPrefixes(theManager), |
| m_namespaceDeclarations(theManager), |
| m_extensionNamespaceURIs(theManager), |
| m_namespaceAliases(theManager) |
| { |
| } |
| |
| |
| |
| NamespacesHandler::NamespacesHandler( |
| StylesheetConstructionContext& theConstructionContext, |
| const NamespacesHandler& /* stylesheetNamespacesHandler */, |
| const NamespacesStackType& theCurrentNamespaces, |
| const XalanDOMString& theXSLTNamespaceURI) : |
| m_excludedResultPrefixes(theConstructionContext.getMemoryManager()), |
| m_namespaceDeclarations(theConstructionContext.getMemoryManager()), |
| m_extensionNamespaceURIs(theConstructionContext.getMemoryManager()), |
| m_namespaceAliases(theConstructionContext.getMemoryManager()) |
| { |
| // Go through the namespaces stack in reverse order... |
| const NamespacesStackType::const_reverse_iterator theEnd = |
| theCurrentNamespaces.rend(); |
| |
| NamespacesStackType::const_reverse_iterator i = |
| theCurrentNamespaces.rbegin(); |
| |
| for(; i != theEnd; ++i) |
| { |
| // Process each namespace in the current vector... |
| const NamespaceVectorType::const_iterator theVectorEnd = |
| (*i).end(); |
| |
| NamespaceVectorType::const_iterator j = |
| (*i).begin(); |
| |
| for(; j != theVectorEnd; ++j) |
| { |
| const NameSpace& theNamespace = *j; |
| |
| const XalanDOMString& theURI = theNamespace.getURI(); |
| |
| const XalanDOMString& thePrefix = theNamespace.getPrefix(); |
| |
| if(shouldExcludeResultNamespaceNode( |
| theXSLTNamespaceURI, |
| theURI) == false) |
| { |
| addByPrefix( |
| theConstructionContext, |
| m_namespaceDeclarations, |
| thePrefix, |
| theURI); |
| } |
| else |
| { |
| addByPrefix( |
| theConstructionContext, |
| m_excludedResultPrefixes, |
| thePrefix, |
| theURI); |
| |
| assert(findByPrefix(m_excludedResultPrefixes, thePrefix) != 0 && |
| findByPrefix(m_excludedResultPrefixes, thePrefix)->getURI() == theURI); |
| } |
| } |
| } |
| } |
| |
| |
| |
| NamespacesHandler::~NamespacesHandler() |
| { |
| } |
| |
| |
| |
| void |
| NamespacesHandler::addExtensionNamespaceURI( |
| StylesheetConstructionContext& theConstructionContext, |
| const XalanDOMString& theURI) |
| { |
| m_extensionNamespaceURIs.push_back(&theConstructionContext.getPooledString(theURI)); |
| } |
| |
| |
| |
| const XalanDOMString* |
| NamespacesHandler::getNamespace(const XalanDOMString& thePrefix) const |
| { |
| const NamespacesVectorType::value_type* theNamespace = |
| findByPrefix(m_excludedResultPrefixes, thePrefix); |
| |
| if (theNamespace != 0) |
| { |
| return &theNamespace->getURI(); |
| } |
| else |
| { |
| return findNamespace(m_namespaceDeclarations, thePrefix); |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::copyNamespaceAliases(const NamespacesHandler& parentNamespacesHandler) |
| { |
| copyNamespaceAliases(parentNamespacesHandler.m_namespaceAliases); |
| } |
| |
| |
| |
| const XalanDOMString* |
| NamespacesHandler::getNamespaceAlias(const XalanDOMString& theStylesheetNamespace) const |
| { |
| if (m_namespaceAliases.empty() == true) |
| { |
| return 0; |
| } |
| else |
| { |
| const NamespaceAliasesMapType::const_iterator i = |
| m_namespaceAliases.find(&theStylesheetNamespace); |
| |
| if (i != m_namespaceAliases.end()) |
| { |
| return (*i).second; |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::setNamespaceAlias( |
| StylesheetConstructionContext& theConstructionContext, |
| const XalanDOMString& theStylesheetNamespace, |
| const XalanDOMString& theResultNamespace) |
| { |
| m_namespaceAliases[&theConstructionContext.getPooledString(theStylesheetNamespace)] = |
| &theConstructionContext.getPooledString(theResultNamespace); |
| } |
| |
| |
| |
| typedef StylesheetConstructionContext::GetCachedString GetCachedString; |
| |
| void |
| NamespacesHandler::processExcludeResultPrefixes( |
| StylesheetConstructionContext& theConstructionContext, |
| const XalanDOMChar* theValue, |
| const NamespacesStackType& theCurrentNamespaces) |
| { |
| StringTokenizer tokenizer( |
| theValue, |
| Constants::DEFAULT_WHITESPACE_SEPARATOR_STRING); |
| |
| const GetCachedString theGuard(theConstructionContext); |
| |
| XalanDOMString& thePrefix = theGuard.get(); |
| |
| while(tokenizer.hasMoreTokens() == true) |
| { |
| tokenizer.nextToken(thePrefix); |
| |
| if(equalsIgnoreCaseASCII(thePrefix, Constants::ATTRVAL_DEFAULT_PREFIX) == true) |
| { |
| thePrefix.clear(); |
| } |
| |
| const XalanDOMString* const theNamespaceURI = |
| XalanQName::getNamespaceForPrefix(theCurrentNamespaces, thePrefix); |
| |
| if(theNamespaceURI == 0) |
| { |
| const GetCachedString theGuard(theConstructionContext); |
| |
| theConstructionContext.problem( |
| StylesheetConstructionContext::eXSLTProcessor, |
| StylesheetConstructionContext::eError, |
| XalanMessageLoader::getMessage( |
| theGuard.get(), |
| XalanMessages::PrefixIsNotDeclared_1Param, |
| thePrefix), |
| theConstructionContext.getLocatorFromStack(), |
| 0); |
| } |
| |
| addOrUpdateByPrefix( |
| theConstructionContext, |
| m_excludedResultPrefixes, |
| thePrefix, |
| *theNamespaceURI); |
| |
| assert(findByPrefix(m_excludedResultPrefixes, thePrefix) != 0 && |
| findByPrefix(m_excludedResultPrefixes, thePrefix)->getURI() == *theNamespaceURI); |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::processExtensionElementPrefixes( |
| StylesheetConstructionContext& theConstructionContext, |
| const XalanDOMChar* theValue, |
| const NamespacesStackType& theCurrentNamespaces) |
| { |
| StringTokenizer tokenizer( |
| theValue, |
| Constants::DEFAULT_WHITESPACE_SEPARATOR_STRING); |
| |
| const GetCachedString theGuard(theConstructionContext); |
| |
| XalanDOMString& thePrefix = theGuard.get(); |
| |
| while(tokenizer.hasMoreTokens() == true) |
| { |
| tokenizer.nextToken(thePrefix); |
| |
| if(equalsIgnoreCaseASCII(thePrefix, Constants::ATTRVAL_DEFAULT_PREFIX) == true) |
| { |
| thePrefix.clear(); |
| } |
| |
| const XalanDOMString* const theNamespace = |
| XalanQName::getNamespaceForPrefix(theCurrentNamespaces, thePrefix); |
| |
| if(theNamespace == 0) |
| { |
| const GetCachedString theGuard(theConstructionContext); |
| |
| theConstructionContext.problem( |
| StylesheetConstructionContext::eXSLTProcessor, |
| StylesheetConstructionContext::eError, |
| XalanMessageLoader::getMessage( |
| theGuard.get(), |
| XalanMessages::PrefixIsNotDeclared_1Param, |
| thePrefix), |
| theConstructionContext.getLocatorFromStack(), |
| 0); |
| } |
| |
| assert(theNamespace != 0); |
| |
| m_extensionNamespaceURIs.push_back(&theConstructionContext.getPooledString(*theNamespace)); |
| } |
| } |
| |
| |
| void |
| NamespacesHandler::postConstruction( |
| StylesheetConstructionContext& theConstructionContext, |
| bool fProcessNamespaceAliases, |
| const XalanDOMString& theElementName, |
| const NamespacesHandler* parentNamespacesHandler, |
| const PrefixChecker* prefixChecker) |
| { |
| // Copy everything from the parent handler, if there is one... |
| if (parentNamespacesHandler != 0) |
| { |
| copyNamespaceAliases(parentNamespacesHandler->m_namespaceAliases); |
| |
| copyExtensionNamespaceURIs(parentNamespacesHandler->m_extensionNamespaceURIs); |
| |
| copyExcludeResultPrefixes(parentNamespacesHandler->m_excludedResultPrefixes); |
| } |
| |
| // Figure out the prefix of the owning element, to make sure we |
| // don't exclude its prefix. |
| const XalanDOMString::size_type indexOfNSSep = indexOf(theElementName, XalanUnicode::charColon); |
| |
| const GetCachedString theGuard(theConstructionContext); |
| |
| XalanDOMString& thePrefix = theGuard.get(); |
| |
| if (indexOfNSSep < theElementName.length()) |
| { |
| substring(theElementName, thePrefix, 0, indexOfNSSep); |
| } |
| |
| processExcludeResultPrefixes(theConstructionContext, thePrefix, prefixChecker); |
| |
| if (fProcessNamespaceAliases == true) |
| { |
| // $$ ToDo: Does this happen before or after exclude-result-prefixes? |
| processNamespaceAliases(); |
| } |
| |
| createResultAttributeNames(theConstructionContext); |
| } |
| |
| |
| |
| NamespacesHandler& |
| NamespacesHandler::operator=(const NamespacesHandler& theRHS) |
| { |
| if (&theRHS != this) |
| { |
| m_excludedResultPrefixes = theRHS.m_excludedResultPrefixes; |
| |
| m_namespaceDeclarations = theRHS.m_namespaceDeclarations; |
| |
| m_extensionNamespaceURIs = theRHS.m_extensionNamespaceURIs; |
| |
| m_namespaceAliases = theRHS.m_namespaceAliases; |
| } |
| |
| return *this; |
| } |
| |
| |
| |
| bool |
| NamespacesHandler::shouldExcludeResultNamespaceNode( |
| const XalanDOMString& theXSLTNamespaceURI, |
| const XalanDOMString& theURI) const |
| { |
| // These are commone namespaces that are always excluded... |
| if(equals(theURI, theXSLTNamespaceURI) |
| || isExtensionNamespaceURI(theURI) == true |
| || equals(theURI, DOMServices::s_XMLNamespaceURI)) |
| { |
| return true; |
| } |
| else if (isExcludedNamespaceURI(theURI) == true) |
| { |
| // It was found in the excluded result prefixes URIs... |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::outputResultNamespaces( |
| StylesheetExecutionContext& theExecutionContext, |
| bool supressDefault) const |
| { |
| // Write out the namespace declarations... |
| if (m_namespaceDeclarations.empty() == false) |
| { |
| const NamespaceExtendedVectorType::const_iterator theEnd = |
| m_namespaceDeclarations.end(); |
| |
| NamespaceExtendedVectorType::const_iterator i = |
| m_namespaceDeclarations.begin(); |
| |
| for(; i != theEnd; ++i) |
| { |
| const NamespaceExtended& theNamespace = *i; |
| |
| const XalanDOMString& thePrefix = theNamespace.getPrefix(); |
| |
| // If we're not supposed to suppress the default namespace, or |
| // there's a prefix (so it's not the default), we can continue |
| // to see if we need to add the result namespace. |
| if (supressDefault == false || |
| thePrefix.empty() == false) |
| { |
| const XalanDOMString& theResultURI = theNamespace.getURI(); |
| assert(theNamespace.getResultAttributeName().empty() == false); |
| |
| // Get the any namespace declaration currently active for the |
| // prefix. |
| const XalanDOMString* const desturi = |
| theExecutionContext.getResultNamespaceForPrefix(thePrefix); |
| |
| // Is there already an active namespace declaration? |
| if(desturi == 0 || !equals(theResultURI, *desturi)) |
| { |
| // No, so add one... |
| theExecutionContext.addResultAttribute(theNamespace.getResultAttributeName(), theResultURI); |
| } |
| } |
| } |
| } |
| } |
| |
| |
| |
| bool |
| NamespacesHandler::isExcludedNamespaceURI(const XalanDOMString& theNamespaceURI) const |
| { |
| return findByURI(m_excludedResultPrefixes, theNamespaceURI) != 0 ? true : false; |
| } |
| |
| |
| |
| bool |
| NamespacesHandler::findString( |
| const XalanDOMString& theString, |
| const XalanDOMStringPointerVectorType& theVector) |
| { |
| const XalanDOMStringPointerVectorType::const_iterator theEnd = theVector.end(); |
| XalanDOMStringPointerVectorType::const_iterator theCurrent = theVector.begin(); |
| |
| while(theCurrent != theEnd) |
| { |
| assert(*theCurrent != 0); |
| |
| const XalanDOMString* const theCurrentString = *theCurrent; |
| |
| if (theString == *theCurrentString) |
| { |
| return true; |
| } |
| |
| ++theCurrent; |
| } |
| |
| return false; |
| } |
| |
| |
| |
| void |
| NamespacesHandler::clear() |
| { |
| m_excludedResultPrefixes.clear(); |
| |
| m_namespaceDeclarations.clear(); |
| |
| m_extensionNamespaceURIs.clear(); |
| |
| m_namespaceAliases.clear(); |
| } |
| |
| |
| |
| void |
| NamespacesHandler::swap(NamespacesHandler& theOther) |
| { |
| m_excludedResultPrefixes.swap(theOther.m_excludedResultPrefixes); |
| |
| m_namespaceDeclarations.swap(theOther.m_namespaceDeclarations); |
| |
| m_extensionNamespaceURIs.swap(theOther.m_extensionNamespaceURIs); |
| |
| m_namespaceAliases.swap(theOther.m_namespaceAliases); |
| } |
| |
| |
| |
| void |
| NamespacesHandler::createResultAttributeNames(StylesheetConstructionContext& theConstructionContext) |
| { |
| // Go through all of the result namespaces and create the attribute |
| // name that will be used when they're written to the result tree. |
| // This is more efficient if the stylesheet is used multiple times. |
| if (m_namespaceDeclarations.empty() == false) |
| { |
| const NamespaceExtendedVectorType::iterator theEnd = |
| m_namespaceDeclarations.end(); |
| |
| NamespaceExtendedVectorType::iterator i = |
| m_namespaceDeclarations.begin(); |
| |
| const GetCachedString theGuard(theConstructionContext); |
| XalanDOMString& theName = theGuard.get(); |
| |
| for(; i != theEnd; ++i) |
| { |
| NamespaceExtended& theNamespace = *i; |
| |
| const XalanDOMString& thePrefix = theNamespace.getPrefix(); |
| |
| if (thePrefix.empty() == false) |
| { |
| // Create a name of the form xmlns:prefix, where "prefix" is the |
| // text of the prefix. |
| // Reserve the appropriate amount of space in the string. |
| theName.reserve(DOMServices::s_XMLNamespaceWithSeparatorLength + thePrefix.length() + 1); |
| |
| theName = DOMServices::s_XMLNamespaceWithSeparator; |
| theName += thePrefix; |
| |
| theNamespace.setResultAttributeName(theConstructionContext.getPooledString(theName)); |
| } |
| else |
| { |
| // It's the default namespace... |
| theNamespace.setResultAttributeName(DOMServices::s_XMLNamespace); |
| } |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::processExcludeResultPrefixes( |
| StylesheetConstructionContext& theConstructionContext, |
| const XalanDOMString& theElementPrefix, |
| const PrefixChecker* prefixChecker) |
| { |
| if (m_excludedResultPrefixes.empty() == false) |
| { |
| NamespaceExtendedVectorType::iterator i = |
| m_namespaceDeclarations.begin(); |
| |
| // Check for any result prefixes we should exclude... |
| while(i != m_namespaceDeclarations.end()) |
| { |
| const Namespace& theNamespace = *i; |
| |
| const XalanDOMString& thePrefix = theNamespace.getPrefix(); |
| const XalanDOMString& theURI = theNamespace.getURI(); |
| |
| // We can never exclude the prefix of our owner element, so |
| // check that first... |
| if (equals(thePrefix, theElementPrefix) == false && |
| (prefixChecker == 0 || prefixChecker->isActive(thePrefix) == false) && |
| (isExcludedNamespaceURI(theURI) == true || |
| isExtensionNamespaceURI(theURI) == true)) |
| { |
| // Add it to the excluded prefixes, in case we need it later... |
| m_excludedResultPrefixes.push_back( |
| NamespacesVectorType::value_type( |
| theConstructionContext.getPooledString(thePrefix), |
| theConstructionContext.getPooledString(theURI))); |
| |
| // It's excluded, so remove it... |
| i = m_namespaceDeclarations.erase(i); |
| } |
| else |
| { |
| ++i; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::processNamespaceAliases() |
| { |
| if (m_namespaceDeclarations.empty() == false) |
| { |
| const NamespaceExtendedVectorType::iterator theEnd = |
| m_namespaceDeclarations.end(); |
| |
| NamespaceExtendedVectorType::iterator i = |
| m_namespaceDeclarations.begin(); |
| |
| // Look at everyone of my namespaces for an alias, and substitute the |
| // alias as appropriate... |
| for(; i != theEnd; ++i) |
| { |
| Namespace& theNamespace = *i; |
| |
| const XalanDOMString& theURI = |
| theNamespace.getURI(); |
| |
| const XalanDOMString* const theAlias = |
| getNamespaceAlias(theURI); |
| |
| // Is there a local alias? |
| if (theAlias != 0) |
| { |
| // Yup, so use it... |
| theNamespace.setURI(*theAlias); |
| } |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::copyNamespaceAliases(const NamespaceAliasesMapType& theNamespaceAliases) |
| { |
| if (theNamespaceAliases.empty() == false) |
| { |
| if (m_namespaceAliases.empty() == true) |
| { |
| m_namespaceAliases = theNamespaceAliases; |
| } |
| else |
| { |
| const NamespaceAliasesMapType::const_iterator theEnd = |
| theNamespaceAliases.end(); |
| |
| NamespaceAliasesMapType::const_iterator i = |
| theNamespaceAliases.begin(); |
| |
| // Add them in... |
| while(i != theEnd) |
| { |
| m_namespaceAliases.insert(*i); |
| |
| ++i; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::copyExtensionNamespaceURIs(const XalanDOMStringPointerVectorType& theExtensionNamespaceURIs) |
| { |
| if (theExtensionNamespaceURIs.empty() == false) |
| { |
| if (m_extensionNamespaceURIs.empty() == true) |
| { |
| m_extensionNamespaceURIs = theExtensionNamespaceURIs; |
| } |
| else |
| { |
| const XalanDOMStringPointerVectorType::const_iterator theEnd = |
| theExtensionNamespaceURIs.end(); |
| |
| XalanDOMStringPointerVectorType::const_iterator i = |
| theExtensionNamespaceURIs.begin(); |
| |
| // Add them in... |
| while(i != theEnd) |
| { |
| assert(*i != 0); |
| |
| if (isExtensionNamespaceURI(**i) == false) |
| { |
| m_extensionNamespaceURIs.push_back(*i); |
| } |
| |
| ++i; |
| } |
| } |
| } |
| } |
| |
| |
| |
| void |
| NamespacesHandler::copyExcludeResultPrefixes(const NamespacesVectorType& theExcludeResultPrefixes) |
| { |
| if (theExcludeResultPrefixes.empty() == false) |
| { |
| if (m_excludedResultPrefixes.empty() == true) |
| { |
| m_excludedResultPrefixes = theExcludeResultPrefixes; |
| } |
| else |
| { |
| const NamespacesVectorType::const_iterator theEnd = |
| theExcludeResultPrefixes.end(); |
| |
| NamespacesVectorType::const_iterator i = |
| theExcludeResultPrefixes.begin(); |
| |
| // Add them in... |
| while(i != theEnd) |
| { |
| if (findByPrefix(m_excludedResultPrefixes, (*i).getPrefix()) == 0) |
| { |
| m_excludedResultPrefixes.push_back(*i); |
| } |
| |
| ++i; |
| } |
| } |
| } |
| } |
| |
| |
| |
| } |