Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.9

DOMServices.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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.
 */
#if !defined(DOMSERVICES_HEADER_GUARD_1357924680)
#define DOMSERVICES_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/DOMSupport/DOMSupportDefinitions.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>
#include <xalanc/XalanDOM/XalanAttr.hpp>
#include <xalanc/XalanDOM/XalanComment.hpp>
#include <xalanc/XalanDOM/XalanDocument.hpp>
#include <xalanc/XalanDOM/XalanElement.hpp>
#include <xalanc/XalanDOM/XalanProcessingInstruction.hpp>
#include <xalanc/XalanDOM/XalanText.hpp>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/FormatterListener.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XalanDocument;
class XalanDocumentFragment;



class XALAN_DOMSUPPORT_EXPORT DOMServices
{
public:

    static const XalanDOMString&    s_XMLString;
    static const XalanDOMString&    s_XMLStringWithSeparator;
    static const XalanDOMString&    s_XMLNamespacePrefix;
    static const XalanDOMString&    s_XMLNamespaceURI;
    static const XalanDOMString&    s_XMLNamespace;
    static const XalanDOMString&    s_XMLNamespaceWithSeparator;
    static const XalanDOMString&    s_XMLNamespaceSeparatorString;
    static const XalanDOMString&    s_XMLNamespacePrefixURI;

    static const XalanDOMString::size_type&     s_XMLStringLength;
    static const XalanDOMString::size_type&     s_XMLStringWithSeparatorLength;
    static const XalanDOMString::size_type&     s_XMLNamespacePrefixLength;
    static const XalanDOMString::size_type&     s_XMLNamespaceURILength;
    static const XalanDOMString::size_type&     s_XMLNamespaceLength;
    static const XalanDOMString::size_type&     s_XMLNamespaceWithSeparatorLength;
    static const XalanDOMString::size_type&     s_XMLNamespaceSeparatorStringLength;
    static const XalanDOMString::size_type&     s_XMLNamespacePrefixURILength;


    // A dummy string to return when we need an emtpy string...
    static const XalanDOMString     s_emptyString;


    static void
    initialize(MemoryManagerType&      theManager);

    static void
    terminate();



    static void
    getNodeData(
            const XalanNode&    node,
            XalanDOMString&     data);



    static void
    getNodeData(
            const XalanAttr&    attribute,
            XalanDOMString&     data)
    {
        append(data, attribute.getNodeValue());
    }



    static void
    getNodeData(
            const XalanComment&     comment,
            XalanDOMString&         data)
    {
        append(data, comment.getData());
    }



    static void
    getNodeData(
            const XalanDocument&    document,
            XalanDOMString&         data);



    static void
    getNodeData(
            const XalanDocumentFragment&    documentFragment,
            XalanDOMString&                 data);



    static void
    getNodeData(
            const XalanElement&     element,
            XalanDOMString&         data);


    static void
    getNodeData(
            const XalanProcessingInstruction&   pi,
            XalanDOMString&                     data)
    {
        append(data, pi.getData());
    }



    static void
    getNodeData(
            const XalanText&    text,
            XalanDOMString&     data)
    {
        append(data, text.getData());
    }

    typedef void (FormatterListener::*MemberFunctionPtr)(const XMLCh* const, const unsigned int);

    static void
    getNodeData(
            const XalanNode&    node,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function);

    static void
    getNodeData(
            const XalanAttr&    attribute,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function)
    {
        sendData(formatterListener, function, attribute.getNodeValue());
    }

    static void
    getNodeData(
            const XalanComment&     comment,
            FormatterListener&      formatterListener,
            MemberFunctionPtr       function)
    {
        sendData(formatterListener, function, comment.getData());
    }

    static void
    getNodeData(
            const XalanDocument&    document,
            FormatterListener&      formatterListener,
            MemberFunctionPtr       function);

    static void
    getNodeData(
            const XalanDocumentFragment&    documentFragment,
            FormatterListener&              formatterListener,
            MemberFunctionPtr               function);

    static void
    getNodeData(
            const XalanElement&     element,
            FormatterListener&      formatterListener,
            MemberFunctionPtr       function);

    static void
    getNodeData(
            const XalanProcessingInstruction&   pi,
            FormatterListener&                  formatterListener,
            MemberFunctionPtr                   function)
    {
        sendData(formatterListener, function, pi.getData());
    }

    static void
    getNodeData(
            const XalanText&    text,
            FormatterListener&  formatterListener,
            MemberFunctionPtr   function)
    {
        sendData(formatterListener, function, text.getData());
    }

    static const XalanDOMString&
    getNameOfNode(const XalanNode&  n);

    static const XalanDOMString&
    getNameOfNode(const XalanAttr&  attr)
    {
        const XalanDOMString&   theName = attr.getNodeName();

        if (startsWith(theName, s_XMLNamespaceWithSeparator) == true)
        {
            // Special case for namespace nodes...
            return attr.getLocalName();
        }
        else if (equals(theName, s_XMLNamespace) == true)
        {
            return s_emptyString;
        }
        else
        {
            return theName;
        }
    }

    static const XalanDOMString&
    getNameOfNode(const XalanElement&   element)
    {
        return element.getNodeName();
    }

    static const XalanDOMString&
    getLocalNameOfNode(const XalanNode&     n)
    {
        const XalanDOMString&   theLocalName = n.getLocalName();

        if (length(theLocalName) != 0)
        {
            return theLocalName;
        }
        else
        {
            return n.getNodeName();
        }
    }

    static const XalanDOMString&
    getNamespaceOfNode(const XalanNode& n);

    static bool
    isNamespaceDeclaration(const XalanAttr&     n)
    {
        const XalanDOMString&   theName = n.getNodeName();

        return startsWith(theName, DOMServices::s_XMLNamespaceWithSeparator) == true ||
                equals(theName, DOMServices::s_XMLNamespace) == true;
    }

    static XalanNode*
    getParentOfNode(const XalanNode&    node)
    {
        if(node.getNodeType() == XalanNode::ATTRIBUTE_NODE)
        {
#if defined(XALAN_OLD_STYLE_CASTS)
            return ((const XalanAttr&)node).getOwnerElement();
#else
            return static_cast<const XalanAttr&>(node).getOwnerElement();
#endif
        }
        else
        {
            return node.getParentNode();
        }
    }

    static const XalanDOMString*
    getNamespaceForPrefix(
            const XalanDOMString&   prefix,
            const XalanElement&     namespaceContext);

    static const XalanDOMString*
    getNamespaceForPrefix(
            const XalanDOMChar*     theName,
            const PrefixResolver&   thePrefixResolver,
            bool                    isAttribute,
            XalanDOMString&         thePrefix);

    static bool
    isNodeAfter(
            const XalanNode&    node1,
            const XalanNode&    node2);

    static bool
    isNodeAfterSibling(
            const XalanNode&    parent,
            const XalanNode&    child1,
            const XalanNode&    child2);

private:

    static XalanNode*
    findOwnerElement(const XalanAttr&   attr)
    {
        XalanNode* const    theOwnerElement = attr.getOwnerElement();

        if (theOwnerElement != 0)
        {
            return theOwnerElement;
        }
        else
        {
            return findOwnerElement(attr, *attr.getOwnerDocument()->getDocumentElement());
        }
    }

    static XalanNode*
    findOwnerElement(
            const XalanNode&    attr,
            XalanNode&          element);

    static void
    sendData(
            FormatterListener&      formatterListener,
            MemberFunctionPtr       function,
            const XalanDOMString&   data)
    {
        assert(length(data) == FormatterListener::size_type(length(data)));

        (formatterListener.*function)(c_wstr(data), FormatterListener::size_type(length(data)));
    }
};



XALAN_CPP_NAMESPACE_END



#endif  // DOMSERVICES_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.9 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.