/* * 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. */ #if !defined(STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680) #define STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680 // Base include file. Must be first. #include #include #include #include // Base class header file... #include #include #if defined(XALAN_AUTO_PTR_REQUIRES_DEFINITION) #include #endif #include #include #include #include #include namespace XALAN_CPP_NAMESPACE { using std::FILE; class CountersTable; class ElemTemplate; class ElemTemplateElement; class ElemVariable; class FormatterListener; class FormatterToText; class GenerateEvent; class PrefixResolver; class NodeRefListBase; class NodeSorter; class PrintWriter; class XalanQName; class SelectionEvent; class Stylesheet; class StylesheetRoot; class XalanOutputStream; class TracerEvent; class Writer; class XalanDocument; class XalanDocumentFragment; class XalanElement; class XalanNode; class XalanNumberFormat; class XPath; class XObject; class XObjectPtr; class XResultTreeFrag; // // An abstract class which provides support for executing stylesheets. // class XALAN_XSLT_EXPORT StylesheetExecutionContext : public XPathExecutionContext { public: typedef XalanSize_t tl_size_type; typedef FormatterListener::size_type fl_size_type; typedef std::ostream StreamType; explicit StylesheetExecutionContext( MemoryManager& theMemoryManager, XObjectFactory* theXObjectFactory = 0); virtual ~StylesheetExecutionContext(); // These interfaces are new... /** * Determine whether conflicts should be reported. * * @return true if conflicts should not be warned */ virtual bool getQuietConflictWarnings() const = 0; /** * If this function returns true, only text nodes can * be copied to the result tree. * * @return true or false */ virtual bool getCopyTextNodesOnly() const = 0; /** * Set the flag that determines if only text nodes * can be copied to the result tree. * * @param copyTextNodesOnly The value of the flag */ virtual void pushCopyTextNodesOnly(bool copyTextNodesOnly) = 0; /** * Pop the last flag setting that determines if only text nodes * can be copied to the result tree. */ virtual bool popCopyTextNodesOnly() = 0; /* * A class to manage setting and restoring the flag * for restricting copying only text nodes to the * result tree */ class SetAndRestoreCopyTextNodesOnly { public: SetAndRestoreCopyTextNodesOnly( StylesheetExecutionContext& executionContext, bool fValue) : m_executionContext(executionContext) { executionContext.pushCopyTextNodesOnly(fValue); } ~SetAndRestoreCopyTextNodesOnly() { m_executionContext.popCopyTextNodesOnly(); } private: // Not implemented... SetAndRestoreCopyTextNodesOnly(const SetAndRestoreCopyTextNodesOnly&); SetAndRestoreCopyTextNodesOnly& operator=(const SetAndRestoreCopyTextNodesOnly&); // Data members... StylesheetExecutionContext& m_executionContext; }; #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Set the flag that determines if the current attribute should be executed * @param processAttribute the value of the flag */ virtual void pushProcessCurrentAttribute(bool processAttribute) = 0; /** * Pops the last flag setting that determines if the current attribute should be executed */ virtual bool popProcessCurrentAttribute() = 0; /** * Set the flag that determines if an element's attributes should be skipped * * @param skipAttributes the value of the flag */ virtual void pushSkipElementAttributes(bool skipAttributes) = 0; /** * Get the last flag setting that determines if an element's attributes should be skipped * @returns the value of the flag */ virtual bool getSkipElementAttributes() const = 0; /** * Pops the last flag setting that determines if an element's attributes should be skipped */ virtual bool popSkipElementAttributes() = 0; /** * Set flag that determines if the if test was true * * @param executeIf the value of the flag */ virtual void pushExecuteIf(bool executeIf) = 0; /** * Pop the flag that determines if the if test was true * * @param executeIf the value of the flag */ virtual bool popExecuteIf() = 0; #endif /** * Retrieve root document for stylesheet. Note that * this does not have to be a XalanDocument -- it can * be any node in a document. * * @return root document */ virtual XalanNode* getRootDocument() const = 0; /** * Set root document for stylesheet. Note that * this does not have to be a XalanDocument -- it can * be any node in a document. * * @param theDocument root document */ virtual void setRootDocument(XalanNode* theDocument) = 0; /** * Set root stylesheet for stylesheet. * * @param theStylesheet root stylesheet */ virtual void setStylesheetRoot(const StylesheetRoot* theStylesheet) = 0; /** * Retrieve the current mode. * * @return QName for mode */ virtual const XalanQName* getCurrentMode() const = 0; /** * Set the current mode. * * @param theMode QName for mode */ virtual void pushCurrentMode(const XalanQName* theMode) = 0; /** * Pop the current mode */ virtual void popCurrentMode() =0; /** * Retrieve the current template * * @return The current template instance or null if there is no current template */ virtual const ElemTemplate* getCurrentTemplate() const = 0; /** * Set the current template * * @param theTemplate The current template instance */ virtual void pushCurrentTemplate(const ElemTemplate* theTemplate) = 0; virtual void popCurrentTemplate() = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /* * A class to manage pushing and popping the current * template instance. */ class PushAndPopCurrentTemplate { public: PushAndPopCurrentTemplate( StylesheetExecutionContext& executionContext, const ElemTemplate* theTemplate) : m_executionContext(executionContext) { executionContext.pushCurrentTemplate(theTemplate); } ~PushAndPopCurrentTemplate() { m_executionContext.popCurrentTemplate(); } private: // Data members... StylesheetExecutionContext& m_executionContext; }; #endif /** * See if there is an element pending. */ virtual bool isElementPending() const = 0; /** * Replace the contents of a pending attribute. * * @param theName name of attribute * @param theNewType type of attribute * @param theNewValue new value of attribute */ virtual void replacePendingAttribute( const XalanDOMChar* theName, const XalanDOMChar* theNewType, const XalanDOMChar* theNewValue) = 0; /** * Get the current formatter listener. * * @return pointer to formatter listener */ virtual FormatterListener* getFormatterListener() const = 0; /** * Set the current formatter listener. * * @param flistener pointer to new formatter listener */ virtual void setFormatterListener(FormatterListener* flistener) = 0; virtual void pushOutputContext(FormatterListener* flistener = 0) = 0; virtual void popOutputContext() = 0; class OutputContextPushPop { public: /** * Construct an object to push and pop the current output context. * * @param theExecutionContext a reference to the current execution context * @param theNewListener the new FormatterListener to set. */ OutputContextPushPop( StylesheetExecutionContext& theExecutionContext, FormatterListener* theNewListener = 0) : m_executionContext(theExecutionContext) { m_executionContext.pushOutputContext(theNewListener); } ~OutputContextPushPop() { m_executionContext.popOutputContext(); } private: StylesheetExecutionContext& m_executionContext; }; /** * Add a result attribute to the list of pending attributes. * * @param aname name of attribute * @param value value of attribute */ virtual void addResultAttribute( const XalanDOMString& aname, const XalanDOMString& value) = 0; /** * Add a result attribute to the list of pending attributes. * * @param aname name of attribute * @param value value of attribute */ virtual void addResultAttribute( const XalanDOMString& aname, const XalanDOMChar* value) = 0; /** * Add namespace attributes for a node to the list of pending attributes. * * @param src source node */ virtual void copyNamespaceAttributes(const XalanNode& src) = 0; /** * Retrieve the result prefix corresponding to a namespace. * * @param theNamespace namespace for prefix * * @return A pointer to a string containing the prefix, or 0 if the namespace is not mapped. */ virtual const XalanDOMString* getResultPrefixForNamespace(const XalanDOMString& theNamespace) const = 0; /** * Retrieve the result namespace corresponding to a prefix. * * @param thePrefix prefix for namespace * * @return A pointer to a string containing the namespace, or 0 if the prefix is not mapped. */ virtual const XalanDOMString* getResultNamespaceForPrefix(const XalanDOMString& thePrefix) const = 0; /** * Determine whether or not a prefix is in use on the pending element or * the pending attributes. * * @param thePrefix prefix for namespace * * @return true if the prefix is in use, false if not. */ virtual bool isPendingResultPrefix(const XalanDOMString& thePrefix) = 0; /** * Generate a random namespace prefix guaranteed to be unique. * * @param theValue A string for returning the new prefix */ virtual void getUniqueNamespaceValue(XalanDOMString& theValue) const = 0; /** * Retrieve the current number of spaces to indent. * * @return number of spaces */ virtual int getIndent() const = 0; /** * Set the current number of spaces to indent. * * @param indentAmount The number of spaces to indent. Use -1 for the default amount. */ virtual void setIndent(int indentAmount) = 0; /** * Create and initialize an xpath and return it. This is to be used to * create an XPath that is only used during execution. * * @param str string expression for XPath evaluation * @param resolver resolver for namespace resolution * @return pointer to resulting XPath */ virtual const XPath* createMatchPattern( const XalanDOMString& str, const PrefixResolver& resolver) = 0; /** * Return the XPath created by createMatchPattern(). * * @param xpath The XPath to return. */ virtual void returnXPath(const XPath* xpath) = 0; // A helper class to automatically return an XPath instance. class XPathGuard { public: XPathGuard( StylesheetExecutionContext& context, const XPath* xpath = 0) : m_context(context), m_xpath(xpath) { } ~XPathGuard() { if (m_xpath != 0) { m_context.returnXPath(m_xpath); } } const XPath* get() const { return m_xpath; } const XPath* release() { const XPath* const temp = m_xpath; m_xpath = 0; return temp; } void reset(const XPath* xpath) { if (m_xpath != 0) { m_context.returnXPath(m_xpath); } m_xpath = xpath; } private: StylesheetExecutionContext& m_context; const XPath* m_xpath; }; typedef XalanVector ParamVectorType; /** * Set a list of top level variables in the specified execution context * stylesheet. * * @param topLevelParams list of top level parameters */ virtual void pushTopLevelVariables(const ParamVectorType& topLevelParams) = 0; /** * Execute the supplied XPath and and create a * variable in the current context. * * @param str string expression for XPath evaluation * @param contextNode current node in the source tree * @param resolver resolver for namespace resolution * @return a pointer to the XObject result */ virtual const XObjectPtr createVariable( const XPath& xpath, XalanNode* contextNode, const PrefixResolver& resolver) = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Create an ResultTreeFragment as a variable and push it * on to the stack with the current context. * * @param templateChild result tree fragment to use. * @param sourceNode source node * @return a pointer to the XObject result */ virtual const XObjectPtr createVariable( const ElemTemplateElement& templateChild, XalanNode* sourceNode) = 0; #endif /** * Execute an XPath using the provided expression, * and push the result as a variable in the context of * the supplied element. * * @param name name of variable * @param element element marker for variable * @param str string expression for XPath evaluation * @param contextNode current node in the source tree * @param resolver resolver for namespace resolution * @return nothing */ virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const XalanDOMString& str, XalanNode* contextNode, const PrefixResolver& resolver) = 0; /** * Execute the supplied XPath and push the result as a * variable in the current context. * * @param name name of variable * @param element element marker for variable * @param str string expression for XPath evaluation * @param contextNode current node in the source tree * @param resolver resolver for namespace resolution * @return nothing */ virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const XPath& xpath, XalanNode* contextNode, const PrefixResolver& resolver) = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Create an ResultTreeFragment as a variable and push it * on to the stack with the current context. * * @param name name of variable * @param element element marker for variable * @param templateChild result tree fragment to use. * @param sourceNode source node */ virtual void pushVariable( const XalanQName& name, const ElemTemplateElement* element, const ElemTemplateElement& templateChild, XalanNode* sourceNode) = 0; #endif /** * Push a named variable onto the variables stack. * The variable has already been evaluated. * * @param name name of variable * @param val pointer to XObject value * @param element element marker for variable */ virtual void pushVariable( const XalanQName& name, const XObjectPtr val, const ElemTemplateElement* element) = 0; /** * Push a named variable onto the processor variable stack * The variable will be evaluated when first referenced. * * @param name name of variable * @param var pointer to ElemVariable instance * @param element element marker for variable */ virtual void pushVariable( const XalanQName& name, const ElemVariable* var, const ElemTemplateElement* element) = 0; /** * Push a context marker onto the stack to let us know when to stop * searching for a var. */ virtual void pushContextMarker() = 0; /** * Pop the current context from the current context stack. */ virtual void popContextMarker() = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /* * A class to manage pushing and popping an element's stack * frame context. */ class PushAndPopContextMarker { public: PushAndPopContextMarker(StylesheetExecutionContext& executionContext) : m_executionContext(executionContext) { executionContext.pushContextMarker(); } PushAndPopContextMarker( StylesheetExecutionContext& executionContext, int& currentStackFrameIndex) : m_executionContext(executionContext) { currentStackFrameIndex = executionContext.getCurrentStackFrameIndex(); executionContext.pushContextMarker(); } ~PushAndPopContextMarker() { m_executionContext.popContextMarker(); } StylesheetExecutionContext& getExecutionContext() const { return m_executionContext; } private: StylesheetExecutionContext& m_executionContext; }; #endif /** * Resolve the params that were pushed by the caller. */ virtual void resolveTopLevelParams() = 0; /** * Reset the vector of top level parameters. */ virtual void clearTopLevelParams() = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) class ResolveAndClearTopLevelParams { public: ResolveAndClearTopLevelParams(StylesheetExecutionContext& executionContext) : m_executionContext(executionContext) { m_executionContext.resolveTopLevelParams(); } ~ResolveAndClearTopLevelParams() { m_executionContext.clearTopLevelParams(); } private: StylesheetExecutionContext& m_executionContext; }; /** * Given a template, search for the arguments and push them on the stack. * Also, push default arguments on the stack. * * @param xslCallTemplateElement "call-template" element */ virtual void pushParams(const ElemTemplateElement& xslCallTemplateElement) = 0; #else /** * Initiate context to accept a new set of parameters */ virtual void beginParams() = 0; /** * Indicate parameter set is complete */ virtual void endParams() = 0; /** * Push a single paramter onto the latest initialized paramter set * @param qName the name of the parameter * @param theValue the value of the parameter */ virtual void pushParam(const XalanQName& qName,const XObjectPtr& theValue) = 0; #endif /** * Given a name, return a string representing the value, but don't look in * the global space. * * @param theName name of variable * @return An XObjectPtr instance. Call XObjectPtr::null() on the instance * to determine if the variable was found. If XObjectPtr::null() * returns true, the variable was not found, and no other operations * on the XObject instance are permitted. */ virtual const XObjectPtr getParamVariable(const XalanQName& theName) = 0; /** * Push a frame marker for an element. * * @param elem the element */ virtual void pushElementFrame(const ElemTemplateElement* elem) = 0; /** * Pop a frame marker for an element. * * @param elem the element */ virtual void popElementFrame() = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /* * A class to manage pushing and popping an element's stack * frame context. */ class PushAndPopElementFrame { public: PushAndPopElementFrame( StylesheetExecutionContext& executionContext, const ElemTemplateElement* element) : m_executionContext(executionContext) { executionContext.pushElementFrame(element); } ~PushAndPopElementFrame() { m_executionContext.popElementFrame(); } private: StylesheetExecutionContext& m_executionContext; }; #endif /** * Get the top of the global stack frame. * * @return current value of index */ virtual int getGlobalStackFrameIndex() const = 0; /** * Get the top of the stack frame from where a search * for a variable or param should take place. * * @return current value of index */ virtual int getCurrentStackFrameIndex() const = 0; /** * Set the top of the stack frame from where a search * for a variable or param should take place. * * @param currentStackFrameIndex new value of index */ virtual void pushCurrentStackFrameIndex(int currentStackFrameIndex = -1) = 0; /** * Pop the last stack frame index setting */ virtual void popCurrentStackFrameIndex() = 0; /* * A class to manage the state of the variable stacks frame index. */ class SetAndRestoreCurrentStackFrameIndex { public: SetAndRestoreCurrentStackFrameIndex( StylesheetExecutionContext& executionContext, int newIndex) : m_executionContext(executionContext), m_savedIndex(executionContext.getCurrentStackFrameIndex()) { executionContext.pushCurrentStackFrameIndex(newIndex); } ~SetAndRestoreCurrentStackFrameIndex() { m_executionContext.popCurrentStackFrameIndex(); } private: StylesheetExecutionContext& m_executionContext; const int m_savedIndex; }; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /* * A class to manage stack state during execution. */ class ParamsPushPop : public PushAndPopContextMarker { public: ParamsPushPop( StylesheetExecutionContext& executionContext, const ElemTemplateElement& xslCallTemplateElement) : PushAndPopContextMarker(executionContext) { doPush(xslCallTemplateElement); } ParamsPushPop( StylesheetExecutionContext& executionContext, const ElemTemplateElement& xslCallTemplateElement, int& savedStackFrameIndex) : PushAndPopContextMarker(executionContext, savedStackFrameIndex) { doPush( xslCallTemplateElement, savedStackFrameIndex); } ~ParamsPushPop() { } private: void doPush( const ElemTemplateElement& xslCallTemplateElement, int stackFrameIndex); void doPush(const ElemTemplateElement& xslCallTemplateElement); }; #endif /** * Receive notification of the beginning of a document. * *

The SAX parser will invoke this method only once, before any * other methods in this interface or in DTDHandler (except for * setDocumentLocator).

* * @exception SAXException */ virtual void startDocument() = 0; /** * Receive notification of the end of a document. * *

The SAX parser will invoke this method only once, and it will * be the last method invoked during the parse. The parser shall * not invoke this method until it has either abandoned parsing * (because of an unrecoverable error) or reached the end of * input.

* * @exception SAXException */ virtual void endDocument() = 0; /** * Receive notification of the beginning of an element. * * @param name element type name */ virtual void startElement(const XalanDOMChar* name) = 0; /** * Receive notification of the end of an element. * * @param name element type name */ virtual void endElement(const XalanDOMChar* name) = 0; /** * Receive notification of character data. * * @param ch pointer to characters from the XML document * @param start start position in the array * @param length number of characters to read from the array */ virtual void characters( const XalanDOMChar* ch, fl_size_type start, fl_size_type length) = 0; /** * Receive notification of character data. If available, when the * disable-output-escaping attribute is used, output raw text without * escaping. * * @param ch pointer to characters from the XML document * @param start start position in the array * @param length number of characters to read from the array */ virtual void charactersRaw( const XalanDOMChar* ch, fl_size_type start, fl_size_type length) = 0; /** * Called when a Comment is to be constructed. * * @param data pointer to comment data */ virtual void comment(const XalanDOMChar* data) = 0; /** * Receive notification of a processing instruction. * * @param target processing instruction target * @param data processing instruction data, or null if none was supplied */ virtual void processingInstruction( const XalanDOMChar* target, const XalanDOMChar* data) = 0; /** * Flush the pending element. */ virtual void flushPending() = 0; /** * Clone a node to the result tree * * @param node node to clone * @param locator The Locator, if any */ virtual void cloneToResultTree( const XalanNode& node, const Locator* locator) = 0; /** * Clone a node to the result tree * * @param node node to clone * @param nodeType the type of the node * @param overrideStrip false if white space stripping should be done * @param shouldCloneAttributes true if attributes should be cloned * @param locator The Locator, if any */ virtual void cloneToResultTree( const XalanNode& node, XalanNode::NodeType nodeType, bool overrideStrip, bool shouldCloneAttributes, const Locator* locator) = 0; #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Initiate creation of a result tree fragment * @param sourceNode the source Node */ virtual void beginCreateXResultTreeFrag( XalanNode* sourceNode) = 0; /** * Indicate sthe completion of result tree fragment * @return a pointer to the result tree fragment */ virtual const XObjectPtr endCreateXResultTreeFrag() = 0; /** * Initiate to put execution result in string * * @param theResult the string to contain the result */ virtual void beginFormatToText( XalanDOMString& theResult) = 0; /** * Indicates the completion of the result string * */ virtual void endFormatToText() = 0; #else /** * Create an XObject that represents a Result tree fragment. * * @param templateChild result tree fragment to use. * @param sourceNode source node * @return XObject instance */ virtual const XObjectPtr createXResultTreeFrag( const ElemTemplateElement& templateChild, XalanNode* sourceNode) = 0; #endif /** * Output an object to the result tree by doing the right conversions. * This is public for access by extensions. * * @param obj the XObject to output * @param locator The Locator, if any */ virtual void outputToResultTree( const XObject& xobj, const Locator* locator) = 0; /** * Given a result tree fragment, walk the tree and * output it to the result stream. * * @param theTree result tree fragment * @param locator The Locator, if any */ virtual void outputResultTreeFragment( const XObject& theTree, const Locator* locator) = 0; /** * Determine the full XSLT Namespace URI. * * @return Xalan namespace URI */ virtual const XalanDOMString& getXSLNameSpaceURL() const = 0; /** * Special Xalan namespace for built-in extensions. * * @return Xalan namespace for extensions */ virtual const XalanDOMString& getXalanXSLNameSpaceURL() const = 0; /** * Determine if an element is on the recursion stack. * * @return true if element on stack */ virtual bool findOnElementRecursionStack(const ElemTemplateElement* theElement) const = 0; /** * Push an element onto the recursion stack. * * @param theElement pointer to element to push */ virtual void pushOnElementRecursionStack(const ElemTemplateElement* theElement) = 0; /** * Pop an element off the recursion stack. * * @return pointer to element popped */ virtual const ElemTemplateElement* popElementRecursionStack() = 0; /** * Class for keeping track of elements pushed on the element recursion stack */ class ElementRecursionStackPusher { public: /** * Construct an instance of the recursion stack pusher. * * @param executionContext current execution context * @param element pointer to element to push */ ElementRecursionStackPusher( StylesheetExecutionContext& executionContext, const ElemTemplateElement* element) : m_executionContext(executionContext) { m_executionContext.pushOnElementRecursionStack(element); } ~ElementRecursionStackPusher() { m_executionContext.popElementRecursionStack(); } private: StylesheetExecutionContext& m_executionContext; }; /** * This is a hook that XResultTreeFrag instances (which are reference * counted), can notify the owning StylesheetExecutionContext instance * when they are dereferenced and can be cleaned up. * * @param theXResultTreeFrag The instance that is being returned. * * @return true if the XResultTreeFrag instance belongs to the execution context. false if not. */ virtual bool returnXResultTreeFrag(XResultTreeFrag* theXResultTreeFrag) = 0; enum eDummy { eDefaultXMLIndentAmount = 0, eDefaultHTMLIndentAmount = 0 }; /** * Enums to determine whether or not run-time escaping of URLs has been set. */ enum eEscapeURLs { eEscapeURLsDefault, // Use the value in the stylesheet eEscapeURLsNo, // Don't escape URLs eEscapeURLsYes // Escape URLs }; /** * Get the value for run-time escaping of URLs. This can * override the property specified by the stylesheet. The * default behavior is to honor the property in the stylesheet. * * @return The value of the enum */ virtual eEscapeURLs getEscapeURLs() const = 0; /** * Set the value for run-time escaping of URLs. This can * override the property specified by the stylesheet. The * default behavior is to honor the property in the stylesheet. * * @param value The value of the enum */ virtual void setEscapeURLs(eEscapeURLs value) = 0; /** * Enums to determine whether or not run-time omission of the META tag has been set. */ enum eOmitMETATag { eOmitMETATagDefault, // Use the value in the stylesheet eOmitMETATagNo, // Don't omit the META tag eOmitMETATagYes // Omit the META tag }; /** * Get the value for run-time omission of URLs. This can * override the property specified by the stylesheet. The * default behavior is to honor the property in the stylesheet. * * @return The value of the enum */ virtual eOmitMETATag getOmitMETATag() const = 0; /** * Get the value for run-time omission of URLs. This can * override the property specified by the stylesheet. The * default behavior is to honor the property in the stylesheet. * * @param value The value of the enum */ virtual void setOmitMETATag(eOmitMETATag value) = 0; /** * Create a new FormatterToXML instance. The execution context * owns the instance and will delete it when reset. * * @param writer character output stream to use * @param version version of the output method * @param doIndent true if output is to be indented * @param indent number of spaces to indent at each nesting level * @param encoding character encoding for the writer * @param mediaType media type (MIME content type) of the data * @param doctypeSystem system identifier to be used in the document * type declaration * @param doctypePublic public identifier to be used in the document * type declaration * @param xmlDecl true if the XSLT processor should output an XML * declaration * @param standalone true if the XSLT processor should output a * standalone document declaration * @return a pointer to the new instance. */ virtual FormatterListener* createFormatterToXML( Writer& writer, const XalanDOMString& version = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool doIndent = false, int indent = eDefaultXMLIndentAmount, const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool xmlDecl = true, const XalanDOMString& standalone = XalanDOMString(XalanMemMgrs::getDummyMemMgr())) = 0; /** * Create a new FormatterToHTML instance. The execution context * owns the instance and will delete it when reset. * * @param writer character output stream to use * @param encoding character encoding for the writer * @param mediaType media type (MIME content type) of the data * @param doctypeSystem system identifier to be used in the document * type declaration * @param doctypePublic public identifier to be used in the document * type declaration * @param doIndent true if output is to be indented * @param indent number of spaces to indent at each nesting level * @param escapeURLs Whether or not to escape URLs according to the recommendation. The default is true. * @param omitMetaTag Whether or not to output a META TAG according to the recommendation. The default is false. * @return a pointer to the new instance. */ virtual FormatterListener* createFormatterToHTML( Writer& writer, const XalanDOMString& encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), const XalanDOMString& doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()), bool doIndent = true, int indent = eDefaultHTMLIndentAmount, bool escapeURLs = true, bool omitMetaTag = false) = 0; /** * FormatterToText instance constructor. * * @param writer writer for output * @param encoding character encoding for the writer */ virtual FormatterListener* createFormatterToText( Writer& writer, const XalanDOMString& encoding) = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) class BorrowReturnFormatterToText { public: BorrowReturnFormatterToText( StylesheetExecutionContext& executionContext, Writer& writer, bool normalizeLinefeed = true, bool handleIgnorableWhitespace = true); ~BorrowReturnFormatterToText() { assert(m_formatter != 0); m_executionContext.returnFormatterToText(m_formatter); } FormatterToText& operator*() const { assert(m_formatter != 0); return *m_formatter; } FormatterToText* get() const { assert(m_formatter != 0); return m_formatter; } FormatterToText* operator->() const { return get(); } private: StylesheetExecutionContext& m_executionContext; FormatterToText* m_formatter; }; friend class BorrowReturnFormatterToText; #endif #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /** * Get node sorter instance */ virtual NodeSorter* getNodeSorter() = 0; #else /** * Borrow a cached NodeSorter instance. * * @return A pointer to the instance. */ virtual NodeSorter* borrowNodeSorter() = 0; /** * Return a previously borrowed NodeSorter instance. * * @param theSorter A pointer the to previously borrowed instance. * @return true if the instance was previously borrowed, false if not. */ virtual bool returnNodeSorter(NodeSorter* theSorter) = 0; class BorrowReturnNodeSorter { public: BorrowReturnNodeSorter(StylesheetExecutionContext& executionContext) : m_executionContext(executionContext), m_sorter(executionContext.borrowNodeSorter()) { assert(m_sorter != 0); } ~BorrowReturnNodeSorter() { assert(m_sorter != 0); m_executionContext.returnNodeSorter(m_sorter); } NodeSorter& operator*() const { assert(m_sorter != 0); return *m_sorter; } NodeSorter* get() const { assert(m_sorter != 0); return m_sorter; } NodeSorter* operator->() const { return get(); } private: StylesheetExecutionContext& m_executionContext; NodeSorter* m_sorter; }; #endif typedef XalanMemMgrAutoPtr XalanNumberFormatAutoPtr; /** * Create a new XalanNumberFormat instance. * * @return an XalanNumberFormatAutoPtr that owns a new * XalanNumberFormat instance. */ virtual XalanNumberFormatAutoPtr createXalanNumberFormat() = 0; #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) /* * A class to manage the attribute sets that have been executed * by an element */ struct UseAttributeSetIndexes { UseAttributeSetIndexes() : attributeSetNameIndex(0), matchingAttributeSetIndex(0) {} size_type attributeSetNameIndex; size_type matchingAttributeSetIndex; }; virtual void createUseAttributeSetIndexesOnStack() = 0; virtual UseAttributeSetIndexes& getUseAttributeSetIndexes() = 0; virtual void popUseAttributeSetIndexesFromStack() = 0; /** * Push the element that will invoke * non children elements (i.e templates, attribute-sets) * * @param invokers the element that will invoke non children elements */ virtual void pushInvoker(const ElemTemplateElement * invoker) = 0; /** * Pop the element that invoked non children elements */ virtual void popInvoker() = 0; /** * Get the lastest element that has invoked * a non-child element */ virtual const ElemTemplateElement* getInvoker() const = 0; #endif /** * Determine the number of trace listeners. * * @return number of listeners */ virtual tl_size_type getTraceListeners() const = 0; /** * Fire a generate event. * * @param ge generate event to fire */ virtual void fireGenerateEvent(const GenerateEvent& ge) = 0; /** * Fire a trace event. * * @param te trace event to fire */ virtual void fireTraceEvent(const TracerEvent& te) = 0; /** * Fire a selection event. * * @param se selection event to fire */ virtual void fireSelectEvent(const SelectionEvent& se) = 0; /** * If this is set to true, simple traces of template calls are made. * * @return true if traces made */ virtual bool getTraceSelects() const = 0; /** * Compose a diagnostic trace of the current selection * * @param theStylesheetElement The executing stylesheet element * @param nl The list of selected nodes * @param xpath A pointer to the XPath which generated the list of nodes, if any. */ virtual void traceSelect( const ElemTemplateElement& theStylesheetElement, const NodeRefListBase& nl, const XPath* xpath) = 0; /** * Compare two strings using the collation of the * current locale. * * @param theLHS a string to compare * @param theRHS a string to compare * @param theCaseOrder the case order for the comparison * @return < 0 if theLHS is before theRHS, 0 if they are equal, or > 0 if theLHS is after theRHS */ virtual int collationCompare( const XalanDOMString& theLHS, const XalanDOMString& theRHS, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; /** * Compare two strings using the collation of the * supplied locale. * * @param theLHS a string to compare * @param theRHS a string to compare * @param theLocal a string that specifies the locale * @param theCaseOrder the case order for the comparison * @return < 0 if theLHS is before theRHS, 0 if they are equal, or > 0 if theLHS is after theRHS */ virtual int collationCompare( const XalanDOMString& theLHS, const XalanDOMString& theRHS, const XalanDOMString& theLocale, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; /** * Compare two strings using the collation of the * current locale. * * @param theLHS a string to compare * @param theRHS a string to compare * @param theCaseOrder the case order for the comparison * @return < 0 if theLHS is before theRHS, 0 if they are equal, or > 0 if theLHS is after theRHS */ virtual int collationCompare( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; /** * Compare two strings using the collation of the * current locale. * * @param theLHS a string to compare * @param theRHS a string to compare * @param theLocal a string that specifies the locale * @param theCaseOrder the case order for the comparison * @return < 0 if theLHS is before theRHS, 0 if they are equal, or > 0 if theLHS is after theRHS */ virtual int collationCompare( const XalanDOMChar* theLHS, const XalanDOMChar* theRHS, const XalanDOMChar* theLocale, XalanCollationServices::eCaseOrder theCaseOrder = XalanCollationServices::eDefault) = 0; /** * Create a PrintWriter for the provided stream. * * @param theTextOutputStream The output stream for the PrintWriter. * @return The new instance. */ virtual PrintWriter* createPrintWriter(XalanOutputStream* theTextOutputStream) = 0; /** * Create a PrintWriter. Create an appropriate output stream * using the provided file name and encoding. * * @param theFileName The file name for the output stream * @param theEncoding The encoding for the output stream * @return The new instance. */ virtual PrintWriter* createPrintWriter( const XalanDOMString& theFileName, const XalanDOMString& theEncoding) = 0; /** * Create a PrintWriter using the provided ostream instance. * * @param theStream The output stream for the PrintWriter. * @return The new instance. */ virtual PrintWriter* createPrintWriter(StreamType& theStream) = 0; /** * Create a PrintWriter using the provided FILE instance. * * @param theStream The output stream for the PrintWriter. * @return The new instance. */ virtual PrintWriter* createPrintWriter(FILE* theStream) = 0; /** * Get the counters table, which is a table of cached * results that is used by ElemNumber. * * @return A reference to the counters table. */ virtual CountersTable& getCountersTable() = 0; /** * Send character data from a node to the result tree. * * @param node The node to send. */ virtual void characters(const XalanNode& node) = 0; /** * Send character data from an XObject to the result tree. * * @param node The xobject to send. */ virtual void characters(const XObjectPtr& xobject) = 0; /** * Send raw character data from a node to the result tree. * * @param node The node to send. * @param length number of characters to read from the array */ virtual void charactersRaw(const XalanNode& node) = 0; /** * Send raw character data from an XObject to the result tree. * * @param node The xobject to send. */ virtual void charactersRaw(const XObjectPtr& xobject) = 0; // These interfaces are inherited from XPathExecutionContext... virtual void reset() = 0; virtual XalanNode* getCurrentNode() const = 0; virtual void pushCurrentNode(XalanNode* theCurrentNode) = 0; virtual void popCurrentNode() = 0; virtual bool isNodeAfter( const XalanNode& node1, const XalanNode& node2) const = 0; virtual void pushContextNodeList(const NodeRefListBase& theList) = 0; virtual void popContextNodeList() = 0; virtual const NodeRefListBase& getContextNodeList() const = 0; virtual size_type getContextNodeListLength() const = 0; virtual size_type getContextNodeListPosition(const XalanNode& contextNode) const = 0; /** * Determine if an external element is available. * * @param theQName The QName of the element * * @return whether the given element is available or not */ virtual bool elementAvailable(const XalanQName& theQName) const = 0; /** * Determine if an external element is available by resolving * a string to a QName. * * @param theName The name of the element * @param locator A Locator instance for error reporting * * @return whether the given element is available or not */ virtual bool elementAvailable( const XalanDOMString& theName, const Locator* locator) const = 0; /** * Determine if a function is available. * * @param theQName The QName of the function * * @return whether the function is available or not */ virtual bool functionAvailable(const XalanQName& theQName) const = 0; /** * Determine if a function is available. * * @param theName The name of the function * @param locator A Locator instance for error reporting * * @return whether the function is available or not */ virtual bool functionAvailable( const XalanDOMString& theName, const Locator* locator) const = 0; virtual const XObjectPtr extFunction( const XalanDOMString& theNamespace, const XalanDOMString& functionName, XalanNode* context, const XObjectArgVectorType& argVec, const Locator* locator) = 0; virtual XalanDocument* parseXML( MemoryManager& theManager, const XalanDOMString& urlString, const XalanDOMString& base, ErrorHandler* theErrorHandler = 0) const = 0; virtual MutableNodeRefList* borrowMutableNodeRefList() = 0; virtual bool returnMutableNodeRefList(MutableNodeRefList* theList) = 0; virtual MutableNodeRefList* createMutableNodeRefList(MemoryManager& theManager) const = 0; #if !defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) virtual MutableNodeRefList& createAndPushMutableNodeRefList() = 0; virtual void releaseAndPopMutableNodeRefList() = 0; virtual void pushXObjectPtr(const XObjectPtr& xobjectPtr) = 0; virtual void popXObjectPtr() = 0; virtual void createAndPushNodesToTransformList(const NodeRefListBase* nodeList) = 0; virtual XalanNode* getNextNodeToTransform() = 0; virtual void popNodesToTransformList() = 0; /** * Get a string that is cached on a stack * @returns a cached string */ virtual XalanDOMString& getAndPushCachedString() = 0; /** * Gets the last string that was cached on the stack * @returns the last string to be cached */ virtual XalanDOMString& getLastCachedString() = 0; /** * Gets the last string to be cached on the stack and * pops it from the stack. The reference is valid until * the next request is made for a cached string * * @returns the last string to be cached */ virtual XalanDOMString& getAndPopCachedString() = 0; #endif virtual XalanDOMString& getCachedString() = 0; virtual bool releaseCachedString(XalanDOMString& theString) = 0; virtual void getNodeSetByKey( XalanNode* context, const XalanQName& qname, const XalanDOMString& ref, const Locator* locator, MutableNodeRefList& nodelist) = 0; virtual void getNodeSetByKey( XalanNode* context, const XalanDOMString& name, const XalanDOMString& ref, const Locator* locator, MutableNodeRefList& nodelist) = 0; virtual const XObjectPtr getVariable( const XalanQName& name, const Locator* locator = 0) = 0; virtual const PrefixResolver* getPrefixResolver() const = 0; virtual void setPrefixResolver(const PrefixResolver* thePrefixResolver) = 0; virtual const XalanDOMString* getNamespaceForPrefix(const XalanDOMString& prefix) const = 0; virtual const XalanDOMString& findURIFromDoc(const XalanDocument* owner) const = 0; virtual const XalanDOMString& getUnparsedEntityURI( const XalanDOMString& theName, const XalanDocument& theDocument) const = 0; virtual bool shouldStripSourceNode(const XalanText& node) = 0; virtual XalanDocument* getSourceDocument(const XalanDOMString& theURI) const = 0; virtual void setSourceDocument( const XalanDOMString& theURI, XalanDocument* theDocument) = 0; virtual void formatNumber( double number, const XalanDOMString& pattern, XalanDOMString& theResult, const XalanNode* context = 0, const Locator* locator = 0) = 0; virtual void formatNumber( double number, const XalanDOMString& pattern, const XalanDOMString& dfsName, XalanDOMString& theResult, const XalanNode* context = 0, const Locator* locator = 0) = 0; // These interfaces are inherited from ExecutionContext... virtual void problem( eSource source, eClassification classification, const XalanDOMString& msg, const Locator* locator, const XalanNode* sourceNode) = 0; virtual void problem( eSource source, eClassification classification, const XalanDOMString& msg, const XalanNode* sourceNode) = 0; #if defined(XALAN_RECURSIVE_STYLESHEET_EXECUTION) protected: /** * Borrow a cached FormatterToText instance. * * @return A pointer to the instance. */ virtual FormatterToText* borrowFormatterToText() = 0; /** * Return a previously borrowed FormatterToText instance. * * @param theFormatter A pointer the to previously borrowed instance. * @return true if the instance was previously borrowed, false if not. */ virtual bool returnFormatterToText(FormatterToText* theFormatter) = 0; #endif }; } #endif // STYLESHEETEXECUTIONCONTEXT_HEADER_GUARD_1357924680