src/xalanc/XalanTransformer/XalanDefaultParsedSource.cpp

/*
 * 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.
 */
#include "XalanDefaultParsedSource.hpp"



#include <xercesc/sax/InputSource.hpp>



#include <xalanc/XalanDOM/XalanDocument.hpp>



#include <xalanc/PlatformSupport/URISupport.hpp>



#include <xalanc/DOMSupport/DOMServices.hpp>



#include <xalanc/XalanSourceTree/XalanSourceTreeDocument.hpp>



namespace XALAN_CPP_NAMESPACE {



XalanDefaultParsedSourceDOMSupport::XalanDefaultParsedSourceDOMSupport(
            const XalanSourceTreeParserLiaison&     theParserLiaison,
            const XalanSourceTreeDOMSupport&        theDOMSupport) :
    XalanSourceTreeDOMSupport(theParserLiaison),
    m_domSupport(theDOMSupport)
{
}



XalanDefaultParsedSourceDOMSupport::~XalanDefaultParsedSourceDOMSupport()
{
}



void
XalanDefaultParsedSourceDOMSupport::reset()
{
}



const XalanDOMString&
XalanDefaultParsedSourceDOMSupport::getUnparsedEntityURI(
            const XalanDOMString&   theName,
            const XalanDocument&    theDocument) const
{
    // Check the wrapped XalanSourceTreeDOMSupport instance...
    const XalanDOMString&   theURI =
            m_domSupport.getUnparsedEntityURI(
                    theName,
                    theDocument);

    if (theURI.empty() == false)
    {
        return theURI;
    }
    else
    {
        // Chain up to our parent...
        return XalanSourceTreeDOMSupport::getUnparsedEntityURI(
                    theName,
                    theDocument);
    }
}



bool
XalanDefaultParsedSourceDOMSupport::isNodeAfter(
            const XalanNode&    node1,
            const XalanNode&    node2) const
{
    return m_domSupport.isNodeAfter(
                    node1, 
                    node2);
}



XalanDefaultParsedSourceHelper::XalanDefaultParsedSourceHelper(
            const XalanSourceTreeDOMSupport&    theSourceDOMSupport,
            MemoryManager&                      theManager) :
    m_parserLiaison(theManager),
    m_domSupport(m_parserLiaison, theSourceDOMSupport)
{
}



XalanDefaultParsedSourceHelper*
XalanDefaultParsedSourceHelper::create(
            const XalanSourceTreeDOMSupport&    theSourceDOMSupport,
            MemoryManager&                      theManager)
{
    typedef XalanDefaultParsedSourceHelper  ThisType;

    XalanAllocationGuard    theGuard(theManager, theManager.allocate(sizeof(ThisType)));

    ThisType* const     theResult =
        new (theGuard.get()) ThisType(
                                theSourceDOMSupport,
                                theManager);

    theGuard.release();

    return theResult;
}



XalanDefaultParsedSourceHelper::~XalanDefaultParsedSourceHelper()
{
}



DOMSupport&
XalanDefaultParsedSourceHelper::getDOMSupport()
{
    return m_domSupport;
}



XMLParserLiaison&
XalanDefaultParsedSourceHelper::getParserLiaison()
{
    return m_parserLiaison;
}



XalanDefaultParsedSource::XalanDefaultParsedSource(
            const InputSource&      theInputSource,
            bool                    fValidate,
            ErrorHandler*           theErrorHandler,
            EntityResolver*         theEntityResolver,
            XMLEntityResolver*      theXMLEntityResolver,
            const XalanDOMChar*     theExternalSchemaLocation,
            const XalanDOMChar*     theExternalNoNamespaceSchemaLocation,
            bool                    fPoolAllTextNodes,
            MemoryManager&          theManager) :
    XalanParsedSource(),
    m_parserLiaison(theManager),
    m_domSupport(m_parserLiaison),
    m_parsedSource(0),
    m_uri(theManager)
{
    m_parserLiaison.setUseValidation(fValidate);
    m_parserLiaison.setEntityResolver(theEntityResolver);
    m_parserLiaison.setXMLEntityResolver(theXMLEntityResolver);
    m_parserLiaison.setErrorHandler(theErrorHandler);
    m_parserLiaison.setExternalSchemaLocation(theExternalSchemaLocation);
    m_parserLiaison.setExternalNoNamespaceSchemaLocation(theExternalNoNamespaceSchemaLocation);
    m_parserLiaison.setPoolAllText(fPoolAllTextNodes);

    m_parsedSource = m_parserLiaison.mapDocument(m_parserLiaison.parseXMLStream(theInputSource));
    assert(m_parsedSource != 0);

    m_domSupport.setParserLiaison(&m_parserLiaison);

    const XalanDOMChar* const   theSystemID = theInputSource.getSystemId();

    if (theSystemID != 0)
    {
        try
        {
            URISupport::getURLStringFromString(theSystemID, m_uri);
        }
        catch(const xercesc::XMLException&)
        {
            // Assume that any exception here relates to get the url from
            // the system ID.  We'll assume that it's just a fake base identifier
            // since the parser would have thrown an error if the system ID
            // wasn't resolved.
            m_uri = theSystemID;
        }
    }
}


    
XalanDefaultParsedSource*
XalanDefaultParsedSource::create(
            MemoryManager&          theManager,
            const InputSource&      theInputSource,
            bool                    fValidate,
            ErrorHandler*           theErrorHandler,
            EntityResolver*         theEntityResolver,
            XMLEntityResolver*      theXMLEntityResolver,
            const XalanDOMChar*     theExternalSchemaLocation,
            const XalanDOMChar*     theExternalNoNamespaceSchemaLocation,
            bool                    fPoolAllTextNodes)
{
    typedef XalanDefaultParsedSource ThisType;

    XalanAllocationGuard    theGuard(
                                theManager,
                                theManager.allocate(sizeof(ThisType)));

    ThisType* theResult =
        new (theGuard.get()) ThisType(
                                theInputSource,
                                fValidate,
                                theErrorHandler,
                                theEntityResolver,
                                theXMLEntityResolver,
                                theExternalSchemaLocation,
                                theExternalNoNamespaceSchemaLocation,
                                fPoolAllTextNodes,
                                theManager);

    theGuard.release();

    return theResult;
}



XalanDefaultParsedSource::~XalanDefaultParsedSource()
{
}



XalanDocument*  
XalanDefaultParsedSource::getDocument() const
{
    return m_parsedSource;
}



XalanParsedSourceHelper*
XalanDefaultParsedSource::createHelper(MemoryManager& theManager) const
{
    return XalanDefaultParsedSourceHelper::create(m_domSupport, theManager);
}



const XalanDOMString&
XalanDefaultParsedSource::getURI() const
{
    return m_uri;
}



}