source: icXML/icXML-0.95/src/icxmlc/XMLNamespaceResolver.c @ 3602

/*
 *  Copyright © 2012 International Characters.
 *  This software is licensed to the public under the Open Software License 3.0.
 *  icXML is a trademark of International Characters.
 */

/*
 * @author Nigel Medforth, nigelm -at- interational-characters.com
 * @version $Id: XMLNamespaceResolver.c 388 2013-10-29 21:25:27Z nigelm $
 *
 */

#include <icxmlc/XMLNamespaceResolver.hpp>
#include <icxmlc/XMLSymbol.hpp>
#include <icxmlc/XMLStringU.hpp>

XERCES_CPP_NAMESPACE_BEGIN

/// -----------------------------------------------------------------------------------------------
// TODO: if we bind a uri to a prefix and the binding is non-canonical but the canonical entry for the prefix is
// empty, should we move the prefix into that entry and rewrite all of the symbols? it would require storing a
// list of symbols per prefix or having a "moved" bitset to tell the resolver to update the symbol's binding.
// would this be worth the effort?

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::bindNamespace(const XMLSymbol & symbol, const XMLCh * uri, const XMLSize_t length, const bool isXMLV1_1, bool & speculatedCorrectly)
{
        // Get the prefix id of the local part of this symbol name, e.g. the prefix id of "ogc" if the symbol is "xmlns:ogc"
        // or fEmptyNamespaceId if the symbol is "xmlns"

    const gid_t prefixId = symbol.getLocalPartId();

    DEBUG_NAMESPACE_MESSAGE("prefixId=" << prefixId)

    gid_t uriId = resolveUri(uri, length, prefixId);

    DEBUG_NAMESPACE_MESSAGE("uriId=" << uriId)

    // test if this prefix/uri pair is an error
    if (unlikely(uriId == XMLNamespaceResolver::fEmptyUriId))
    {
        // in the case that an empty string is used as a URI, assume that we're dealing with an XML 1.1 document.
        if (likely(isXMLV1_1))
        {
            uriId = XMLNamespaceResolver::fUnknownUriId;
        }
        else
        {
            // Namespaces in XML 1.0 (Third Edition)
            //
            // The empty string, though it is a legal URI reference, cannot be used as a namespace name. (2.2)
            // The attribute's normalized value MUST be either a URI reference — the namespace name identifying the namespace — or an empty string. (3)
            // In a namespace declaration for a prefix (i.e., where the NSAttName is a PrefixedAttName), the attribute value MUST NOT be empty. (5)

            if (unlikely(prefixId != XMLNamespaceResolver::fEmptyUriId))
            {
                throw XMLErrs::NoEmptyStrNamespace;
            }
        }
    }
    else
    {
        // is the XML URI being bound to some prefix other than "xml" or vice versa?
        if (unlikely((prefixId == fXMLUriId) ^ (uriId == fXMLUriId)))
        {
            throw (uriId == fXMLUriId) ? XMLErrs::XMLURINotMatchXMLPrefix : XMLErrs::PrefixXMLNotMatchXMLURI;
        }        
        else if (unlikely(uriId == fXMLNSUriId)) // was the XMLNS URI bound to some prefix?
        {            
            throw XMLErrs::NoUseOfxmlnsURI;
        }
    }

    const int namespaceId = resolveNamespaceId(prefixId);

    DEBUG_NAMESPACE_MESSAGE("namespaceId=" << namespaceId)

    if (unlikely(namespaceId == -1))
        {
                // both the prefixId and the uriId exist, but they are not mapped to one another.
        mapPrefixToUri(prefixId, uriId);

        // since we speculated that the prefixId == globalUriId, if we find that this is not
                // true, then we have to re-resolve everything regarding this element.
        speculatedCorrectly &= (prefixId == uriId);
        }
    else
    {
        const gid_t storedUriId = getNamespaceUriId(namespaceId);

        DEBUG_NAMESPACE_MESSAGE("storedUriId=" << storedUriId)

        if (likely(storedUriId != uriId))
        {
            remapPrefixToUri(prefixId, uriId);
            speculatedCorrectly = 0;
        }
    }
    return XMLNamespaceResolver::fXMLNSUriId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolveUriId(const XMLSymbol & symbol, const bool isAttribute) const
{
    bool unknown = 0;
    return resolveUriId(symbol, isAttribute, false, unknown);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolveUriId(const XMLSymbol & symbol, const bool isAttribute, const bool misspeculated, bool & unknown) const
{    
    if (isAttribute && !symbol.isQualified())
        {
        return fEmptyUriId;
        }
    return resolveUriId(symbol.getPrefixId(), (isAttribute && likely(!misspeculated) ? symbol.getPrefixId() : fUnknownUriId), unknown);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolveUriId(const gid_t prefixId, const gid_t defaultUriId, bool & unknown) const
{
    gid_t uriId = defaultUriId;
        // first check canonical set to see if this prefix id is also the uri id.
        if (likely(fCanonicalBindingSet.mask_and_extract(fCurrentlyVisibleNamespaces, prefixId)))
        {
        uriId = prefixId;
        }
        else
        {
                // it's not canonical; resolve which of the possible uri ids this prefix id
                // currently points to
                const int namespaceId = resolveNamespaceId(prefixId);
                // if this prefix has not been mapped to a namespace; assume that it will
                // be mapped to the 'adjacent' uri.

                if (likely(namespaceId != -1))
                {
            uriId = getNamespaceUriId(namespaceId);
            unknown = (uriId == XMLNamespaceResolver::fUnknownUriId);
                }
                else
                {
                        unknown = true;
                }
        }
        return uriId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolveUriId(const XMLCh * uri) const
{
        if (unlikely(!uri || *uri == 0))
        {
                return fEmptyUriId;
        }

        XMLSize_t length = XMLStringU::stringLen(uri);

    const gid_t linkId = fUriPool.find(uri, length);

    gid_t uriId;

    if (unlikely(linkId == XMLNamespaceResolver::fUnknownUriId))
        {
        XMLNamespaceResolver * const self = const_cast<XMLNamespaceResolver*>(this);
        // no, it was already used; claim the next unused link id.
        uriId = self->fUriPool.add(max<size_t>(fPrefixCount, fUriPool.count()), uri, length, self->fGlobalUriPool);
        }
    else
    {
        #ifdef PRINT_DEBUG_MESSAGE
        assert (linkId < fUriPool.count());
        assert (XMLString::compareString(fUriPool[linkId].fKey, uri) == 0);
        #endif
        uriId = fUriPool[linkId].getId();
    }

    return uriId;
}

/// -----------------------------------------------------------------------------------------------

// get the prefix id of the prefix portion of the qName, e.g., the prefix id of "xmlns" if given "xmlns:ogc"
// or the prefix of "" if given "xmlns".

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolvePrefixId(const XMLCh * qName, int & colonPos) const
{
    int length = XMLStringU::stringLenOrIndexOf<chColon>(qName);

    if (unlikely(qName[length] == chNull))
    {
        colonPos = -1;
        }
    else
    {
        colonPos = length;
    }

    const XMLPrefixEntry * entry = findPrefix(qName, length);
    if (likely(entry != 0))
    {
        return entry->getId();
    }

    return XMLNamespaceResolver::fUnknownUriId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t XMLNamespaceResolver::addOrFindPrefixId(const XMLCh * qName, const XMLSize_t length, int & colon)
{
    colon = XMLStringU::indexOf<chColon>(qName, length);
    return (unlikely(colon == -1)) ? XMLNamespaceResolver::fEmptyUriId : addOrFindPrefixId(qName, colon);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t XMLNamespaceResolver::addOrFindPrefixId(const XMLCh * qName, const XMLSize_t length)
{
    const gid_t prefixId = addOrFindPrefix(qName, length)->getId();
    DEBUG_NAMESPACE_MESSAGE(" -- prefixId=" << prefixId)
    return prefixId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::addOrFindPrefix(const XMLCh * qName)
{
        int length = XMLStringU::stringLenOrIndexOf<chColon>(qName);
    if (unlikely(length == -1))
        {
                return XMLUni::fgZeroLenString;
        }
        // get the prefix id of the prefix portion of the qName, e.g., the prefix id of "xmlns" if given "xmlns:ogc"
        // or the prefix of "" if given "xmlns".
        return addOrFindPrefix(qName, length)->getKey();
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLPrefixEntry *
XMLNamespaceResolver::findPrefix(const XMLCh * prefix, const int length) const
{
    DEBUG_NAMESPACE_MESSAGE("XMLNamespaceResolver::findPrefix(" << prefix << ',' << length << ')')
    // resolve the prefix id from the prefix; since this will not be required
    // very often, just iterate through a list.
    for (gid_t index = 0; index < fPrefixCount; index++)
    {
        if (fPrefixList[index].equals(prefix, length))
        {
            DEBUG_NAMESPACE_MESSAGE(" -- found @ " << index)
            return &fPrefixList[index];
        }
    }

    return 0;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getPrefixForId(const gid_t prefixId) const
{
    DEBUG_NAMESPACE_MESSAGE("XMLNamespaceResolver::getPrefixForId(" << prefixId << ") " << fPrefixList.capacity())

    assert (prefixId < fPrefixList.capacity());

    if (likely(prefixId < fPrefixCount))
    {
        const XMLPrefixEntry & prefix = fPrefixList[prefixId];
        DEBUG_MESSAGE(" &(prefix)=" << (size_t)(&prefix))
        if (prefix.id == prefixId)
        {
            return prefix.getKey();
        }
    }

    // resolve the prefix id from the prefix; since this will not be required
    // very often, just iterate through a list.
    for (gid_t index = 0; index < fPrefixCount; index++)
    {
        const XMLPrefixEntry & entry = fPrefixList[index];
        DEBUG_MESSAGE("entry[" << index << "]=" << (size_t)(&entry))
        if (entry.id == prefixId)
        {
            return entry.getKey();
        }
    }

    return XMLUni::fgZeroLenString;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLPrefixEntry *
XMLNamespaceResolver::addOrFindPrefix(const XMLCh * prefix, const int length)
{
    DEBUG_NAMESPACE_MESSAGE("addOrFindPrefix(" << prefix << ',' << length << ')')

        // resolve the prefix id from the prefix; since this will not be required
        // very often, just iterate through a list.
    const XMLPrefixEntry * knownPrefix = findPrefix(prefix, length);
    if (likely(knownPrefix != 0))
    {
        return knownPrefix;
    }

    const gid_t prefixId = max<size_t>(fPrefixCount, fUriPool.count());

    DEBUG_NAMESPACE_MESSAGE(" -- new prefixId=max(" << fPrefixCount << ',' << fUriPool.count() << ")=" << prefixId)

        if (unlikely(fPrefixToNamespaceBindingTable.setCapacity() <= prefixId))
        {
        DEBUG_NAMESPACE_MESSAGE(" *** EXPANDING PREFIX TABLES " << fPrefixToNamespaceBindingTable.setCapacity())
                fCanonicalBindingSet.expand(prefixId);
                fPrefixToNamespaceBindingTable.increaseSetCapacity(prefixId);
                // fLocallyModifiedNamespaces.increaseBitCapacity(prefixId);
        }

    // if our prefix count equals our capacity, then we need to expand all of the related buffers
    if (unlikely(fPrefixCount >= fPrefixList.capacity()))
    {
        DEBUG_NAMESPACE_MESSAGE(" -- resizing fPrefixList");
        fPrefixList.resizeToFit(fPrefixList.capacity() * 2);
    }

    XMLPrefixEntry & newPrefix = fPrefixList[fPrefixCount++];
        // QUESTION: does storing the prefixes in the string pool help or hinder? we can just point to
        // the symbols and store only the prefix's length?
        // NOTE: this may require modifying the TraverseSchema class to do this safely.
    newPrefix.key = fPrefixPool.insert(prefix, length);
    newPrefix.length = length;
    newPrefix.id = prefixId;

    DEBUG_NAMESPACE_MESSAGE(" &(newPrefix)=" << (size_t)(&newPrefix))

        // add this entry to the canonical prefix set since we assume that the prefix and uri ids
        // will match
        fCanonicalBindingSet += prefixId;

    return &newPrefix;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::resolveUri(const XMLCh * uri, const XMLSize_t length, const gid_t prefixId)
{    
    gid_t linkId = fUriPool.find(uri, length);
    if (unlikely(linkId == XMLNamespaceResolver::fUnknownUriId))
        {
        DEBUG_MESSAGE(" -- adding new uriId (prefixId=" << prefixId << " of " << fUriPool.capacity() << ')')
        linkId = prefixId;
        if (unlikely(prefixId > fUriPool.capacity()))
        {
            fUriPool.resizeToFit(prefixId);
        }
                // is the reserved uri slot for this prefix still free?
        else if (unlikely(fUriPool[prefixId].getKey() != NULL))
                {
                        // no, it was already used; claim the next unused uri id.
            linkId = fUriPool.count();
                }

        return fUriPool.add(linkId, uri, length, fGlobalUriPool);
        }
    else
    {
        return fUriPool[linkId].getId();
    }
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
void
XMLNamespaceResolver::mapPrefixToUri(const gid_t prefixId, const gid_t uriId)
{
    // both the prefixId and the uriId exist, but they are not mapped to one another.
    const gid_t namespaceId = bindPrefixToUri(prefixId, uriId);

    assert (fScope < fLocallyModifiedNamespaces.setCapacity());
    assert (namespaceId < fLocallyModifiedNamespaces.bitCapacity());
    assert (namespaceId < fCurrentlyVisibleNamespaces.capacity());

    // add the new namespace to the namespace 'stack'
    fLocallyModifiedNamespaces[fScope] += namespaceId;

    // and mark it as visible
    fCurrentlyVisibleNamespaces += namespaceId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
void
XMLNamespaceResolver::remapPrefixToUri(const gid_t prefixId, const gid_t uriId)
{
    const int namespaceId = bindPrefixToUri(prefixId, uriId);

    BindingSet modified = (fCurrentlyVisibleNamespaces & fPrefixToNamespaceBindingTable[prefixId]);

    modified = modified + namespaceId;
    // mark any modified namespaces in the namespace 'stack'
    fLocallyModifiedNamespaces[fScope] += modified;
    // remove the old namespace/uri binding (if one exists) and add the new binding to the set of
    // currently visible namespaces
    fCurrentlyVisibleNamespaces ^= modified;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::bindPrefixToUri(const gid_t prefixId, const gid_t uriId)
{
    gid_t namespaceId = 0;

    // Reserve the LOCAL uriId slot for this prefix; not the GLOBAL uriId slot!

        BindingSetIterator namespaceItr(fPrefixToNamespaceBindingTable.get(prefixId), fPrefixToNamespaceBindingTable.bitCapacity());

        size_t count = 0;

        while (namespaceItr.next())
        {
                count++;

        if (getNamespaceUriId(namespaceItr.pos()) == uriId)
                {
                        namespaceId = namespaceItr.pos();

            DEBUG_NAMESPACE_MESSAGE(" --- found namespace mapping! " << namespaceId)

                        goto FOUND_NAMESPACE_MAPPING;
                }
        }

        namespaceId = fNextNamespaceId++;

    DEBUG_NAMESPACE_MESSAGE(" --- created new namespace mapping! " << namespaceId)

    if (unlikely(fCurrentlyVisibleNamespaces.capacity() <= namespaceId))
        {
                DEBUG_NAMESPACE_MESSAGE(" *** expanding namespace space due to namespaceId " << fNextNamespaceId);
                fCurrentlyVisibleNamespaces.expand(namespaceId);
                fCanonicalBindingSet.expand(namespaceId);               
        fNamespaceToUriBindingTable.expand(namespaceId);
        fNamespaceToPrefixBindingTable.expand(namespaceId);
        fPrefixToNamespaceBindingTable.increaseBitCapacity(namespaceId);
                fLocallyModifiedNamespaces.increaseBitCapacity(namespaceId);
                fDistinctContextSet.increaseBitCapacity(namespaceId);
        }

FOUND_NAMESPACE_MAPPING:

    // TODO: are declaring (or redeclaring) a namespace binding? or are we undeclaring it?

    // map this prefix to the namespace and the URI back to the namespace
    assert (fPrefixToNamespaceBindingTable.setCapacity() > prefixId);
    assert (fPrefixToNamespaceBindingTable.bitCapacity() > namespaceId);
    assert (fNamespaceToPrefixBindingTable.capacity() > namespaceId);
    assert (fNamespaceToUriBindingTable.capacity() > namespaceId);

    fPrefixToNamespaceBindingTable[prefixId] += namespaceId;
    fNamespaceToPrefixBindingTable[namespaceId] = prefixId;    
    fNamespaceToUriBindingTable[namespaceId] = uriId;

    if (prefixId == uriId)
        {
        // if prefixId == uriId, then this entry is canonical
                fCanonicalBindingSet += prefixId;
        }
        else
        {
        // else remove this prefixId from the canonical binding set
                fCanonicalBindingSet -= prefixId;        
        }

        return namespaceId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
void
XMLNamespaceResolver::addPredefinedPrefix
(
    const gid_t id
        , const XMLCh *         prefix
        , const XMLSize_t       prefixLength
        , const XMLCh *         uri
        , const XMLSize_t       uriLength
)
{
    DEBUG_MESSAGE("addPredefinedPrefix(" << id << ',' << prefix << ',' << uri << ')')


    XMLPrefixEntry & entry = fPrefixList[id];
        // QUESTION: does storing the prefixes in the string pool help or hinder? we can just point to
        // the symbols and store only the prefix's length?
        // NOTE: this may require modifying the TraverseSchema class to do this safely.
    entry.key = prefix; // _prefixAndUriStringPool.insert(prefix, length);
    entry.length = prefixLength;
    entry.id = id;

        // create the namespace entry and add it
    const gid_t uriId = fUriPool.add(id, uri, uriLength, fGlobalUriPool);

    assert (id == uriId);

    mapPrefixToUri(id, id);
}

/// -----------------------------------------------------------------------------------------------
/// NAMESPACE CONTEXT HANDLING
/// -----------------------------------------------------------------------------------------------

void XMLNamespaceResolver::enterScope()
{
    fScope++;
    #ifdef ALLOW_NAMESPACE_SCOPE_SPECULATION
    const binding_t * locallyModified = fLocallyModifiedNamespaces.get(fCurrentScope);
    fSpeculatedNamespaces = locallyModified;
    fCurrentlyVisibleNamespaces ^= locallyModified;
    #endif
    fLocallyModifiedNamespaces[fScope] = 0;
}

gid_t XMLNamespaceResolver::finalizeScope(const bool isEmpty, const bool containedXmlnsAttribute)
{
    size_t contextId;
    if (unlikely(containedXmlnsAttribute))
    {
        for (contextId = 0; contextId < fDistinctContextCount; contextId++)
        {
            if (fDistinctContextSet[contextId] == fCurrentlyVisibleNamespaces)
            {                
                goto FoundExistingContextId;
            }
        }

        if (unlikely(fDistinctContextCount == fDistinctContextSet.setCapacity()))
        {
            fDistinctContextSet.increaseSetCapacity(fDistinctContextSet.setCapacity());
        }
        contextId = fDistinctContextCount++;
        fDistinctContextSet.set(contextId, fCurrentlyVisibleNamespaces);
    }
    else
    {
        contextId = fCurrentContextId;
    }

FoundExistingContextId:

    if (isEmpty)
    {
        if (unlikely(containedXmlnsAttribute))
        {
            // if this empty tag did not contain any xmlns attributes, then it's impossible for
            // it to have modified the visible namespaces.
            fCurrentlyVisibleNamespaces ^= fLocallyModifiedNamespaces.get(fScope);            
        }
        fScope--;
    }
    else
    {        
        fCurrentContextId = contextId;
        assert (fScope < fContextIdStack.capacity());
        fContextIdStack[fScope] = contextId;
    }
    return contextId;
}

gid_t XMLNamespaceResolver::leaveScope(bool & namespaceContextChange)
{
    fCurrentlyVisibleNamespaces ^= fLocallyModifiedNamespaces.get(fScope--);
    const gid_t contextId = fContextIdStack[fScope];
    namespaceContextChange = (contextId != fCurrentContextId);
    fCurrentContextId = contextId;
    return contextId;
}


/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
BindingSetIterator XMLNamespaceResolver::getNamespaceIterator(const gid_t contextId) const
{
    assert (contextId < fDistinctContextSet.setCapacity());

    return BindingSetIterator(fDistinctContextSet[contextId]);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
MaskedBindingSetIterator XMLNamespaceResolver::getNamespaceIterator(const gid_t contextId0, const gid_t contextId1) const
{
    assert (contextId0 < fDistinctContextSet.setCapacity());
    assert (contextId1 < fDistinctContextSet.setCapacity());

    return MaskedBindingSetIterator(fDistinctContextSet[contextId0], fDistinctContextSet[contextId1], true);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::getSchemaNamespaceId()
{
    if (unlikely(fSchemaNamespaceId == XMLNamespaceResolver::fUnknownUriId))
    {
        fSchemaNamespaceId = fGlobalUriPool->addOrFind(SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
    }
    return fSchemaNamespaceId;
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::getNamespaceUriId(const gid_t namespaceId) const
{
    return fNamespaceToUriBindingTable[namespaceId];
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getPrefixForNamespaceId(const gid_t namespaceId) const
{
    assert (namespaceId < fNamespaceToPrefixBindingTable.capacity());
    return getPrefixForId(fNamespaceToPrefixBindingTable[namespaceId]);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getUriForNamespaceId(const gid_t namespaceId) const
{
    assert (namespaceId < fNamespaceToUriBindingTable.capacity());
    return getUriForId(fNamespaceToUriBindingTable[namespaceId]);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
bool
XMLNamespaceResolver::isPrefixVisible(const XMLCh * prefix, const gid_t contextId) const
{
    int colonPos;
    const gid_t prefixId = resolvePrefixId(prefix, colonPos);
        return isPrefixVisible(prefixId, contextId);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
bool
XMLNamespaceResolver::isPrefixVisible(const gid_t prefixId) const
{
    if (unlikely(prefixId == XMLNamespaceResolver::fUnknownUriId))
    {
        return false;
    }   
    const int namespaceId = resolveNamespaceId(prefixId);

    if (unlikely(namespaceId == -1))
    {
        return false;
    }
    else
    {
        return (getNamespaceUriId(namespaceId) != XMLNamespaceResolver::fUnknownUriId);
    }
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
bool
XMLNamespaceResolver::isPrefixVisible(const gid_t prefixId, const gid_t contextId) const
{
    if (unlikely(prefixId == XMLNamespaceResolver::fUnknownUriId))
    {
        return false;
    }

    const gid_t namespaceId = fPrefixToNamespaceBindingTable[prefixId].first(fDistinctContextSet[contextId]);
    if (unlikely(namespaceId == -1))
    {
        return false;
    }
    else
    {
        return (getNamespaceUriId(namespaceId) != XMLNamespaceResolver::fUnknownUriId);
    }
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::getUriIdForQName(const XMLCh * prefix, const gid_t contextId, int & colonPos) const
{
    gid_t prefixId = resolvePrefixId(prefix, colonPos);
    return getUriIdForPrefix(prefixId, contextId);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::getUriIdForPrefix(const XMLCh * prefix, const gid_t contextId) const
{
    int colonPos;
    return getUriIdForPrefix(resolvePrefixId(prefix, colonPos), contextId);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
gid_t
XMLNamespaceResolver::getUriIdForPrefix(const gid_t prefixId, const gid_t contextId) const
{
    if (unlikely(prefixId == fUnknownUriId))
    {
        return fUnknownUriId;
    }
    MaskedBindingSetIterator namespaceItr(fDistinctContextSet[contextId], fPrefixToNamespaceBindingTable[prefixId], false);
        if (unlikely(!namespaceItr.first()))
        {
                return fUnknownUriId;
        }
        return fNamespaceToUriBindingTable[namespaceItr.pos()];
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getUriForQName(const XMLCh * prefix, const gid_t contextId, int & colonPos) const
{
    gid_t uriId = getUriIdForQName(prefix, contextId, colonPos);
    return getUriForId(uriId);
}


/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getUriForPrefix(const XMLCh * prefix, const gid_t contextId) const
{
    int colonPos;
    return getUriForPrefix(resolvePrefixId(prefix, colonPos), contextId);
}

/// -----------------------------------------------------------------------------------------------

IDISA_ALWAYS_INLINE
const XMLCh *
XMLNamespaceResolver::getUriForPrefix(const gid_t prefixId, const gid_t contextId) const
{   
    return getUriForId(getUriIdForPrefix(prefixId, contextId));
}

/// -----------------------------------------------------------------------------------------------

#ifdef PRINT_DEBUG_MESSAGE
static std::ostream & operator << (std::ostream & out, const XMLNamespaceResolver * resolver)
{
        if (resolver)
        {
                char leadingChar = '{';
                const XMLCh * uri;

        for (gid_t uriId = 0; uriId < resolver->getUriCount(); uriId++)
                {
                        if ((uri = (*resolver)[uriId]) != 0)
                        {
                                out << leadingChar << uriId << ':' << uri;
                                leadingChar = ',';
                        }
                }
                if (leadingChar != '{')
                {
                        out << '}';
                }
        }
        return out;
}
#endif

XERCES_CPP_NAMESPACE_END