..
/
download
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2015 Saxonica Limited.
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef SAXON_XSLT_H
#define SAXON_XSLT_H
#include "SaxonProcessor.h"
//#include "XdmValue.h"
#include <string>
class SaxonProcessor;
class XdmValue;
class XdmItem;
class XdmNode;
/*! An <code>XsltProcessor</code> represents factory to compile, load and execute a stylesheet.
* It is possible to cache the context and the stylesheet in the <code>XsltProcessor</code>.
*/
class XsltProcessor {
public:
//! Default constructor.
/*!
Creates a Saxon-HE product
*/
XsltProcessor();
//! Constructor with the SaxonProcessor supplied.
/*!
@param proc - Supplied pointer to the SaxonProcessor object
cwd - The current working directory
*/
XsltProcessor(SaxonProcessor* proc, std::string cwd="");
~XsltProcessor(){
clearProperties();
clearParameters();
}
//! Get the SaxonProcessor object
/**
* @return SaxonProcessor - Pointer to the object
*/
SaxonProcessor * getSaxonProcessor(){return proc;}
//!set the current working directory
/**
* @param cwd - Current working directory
*/
void setcwd(const char* cwd);
//!Set the source document from an XdmNode for the transformation.
/**
* @param value - The source to the stylesheet as a pointer to the XdmNode object.
*/
void setSourceFromXdmNode(XdmNode * value);
/**
* Set the source from file for the transformation.
*/
void setSourceFromFile(const char * filename);
/**
* Set the output file of where the transformation result is sent
*/
void setOutputFile(const char* outfile);
/**
* Say whether just-in-time compilation of template rules should be used.
* @param jit true if just-in-time compilation is to be enabled. With this option enabled,
* static analysis of a template rule is deferred until the first time that the
* template is matched. This can improve performance when many template
* rules are rarely used during the course of a particular transformation; however,
* it means that static errors in the stylesheet will not necessarily cause the
* {@link #compile(Source)} method to throw an exception (errors in code that is
* actually executed will still be notified to the registered <code>ErrorListener</code>
* or <code>ErrorList</code>, but this may happen after the {@link #compile(Source)}
* method returns). This option is enabled by default in Saxon-EE, and is not available
* in Saxon-HE or Saxon-PE.
* <p><b>Recommendation:</b> disable this option unless you are confident that the
* stylesheet you are compiling is error-free.</p>
*/
void setJustInTimeCompilation(bool jit);
/**
* Set the value of a stylesheet parameter
*
* @param name the name of the stylesheet parameter, as a string. For namespaced parameter use the JAXP solution i.e. "{uri}name"
* @param value the value of the stylesheet parameter, or null to clear a previously set value
*/
void setParameter(const char* name, XdmValue*value);
/**
* Get a parameter value by name
* @param name - Specified paramater name to get
* @return XdmValue
*/
XdmValue* getParameter(const char* name);
/**
* Remove a parameter (name, value) pair from a stylesheet
*
* @param name the name of the stylesheet parameter
* @return bool - outcome of the romoval
*/
bool removeParameter(const char* name);
/**
* Set a property specific to the processor in use.
* XsltProcessor: set serialization properties (names start with '!' i.e. name "!method" -> "xml")
* 'o':outfile name, 'it': initial template, 'im': initial mode, 's': source as file name
* 'm': switch on message listener for xsl:message instructions (TODO: this feature should be event based), 'item'| 'node' : source supplied as an XdmNode object
* @param name of the property
* @param value of the property
*/
void setProperty(const char* name, const char* value);
/**
* Get a property value by name
* @param name - Specified paramater name to get
* @return string - Get string of the property as char pointer array
*/
const char* getProperty(const char* name);
//! Get all parameters as a std::map
/**
*
* Please note that the key name has been prefixed with 'param:', for example 'param:name'
* @return std:map with key as string name mapped to XdmValue.
*
*/
std::map<std::string,XdmValue*>& getParameters();
//! Get all properties as a std::map
/**
*
* @return std:map with key as string name mapped to string values.
*/
std::map<std::string,std::string>& getProperties();
//!Clear parameter values set
/**
* Default behaviour (false) is to leave XdmValues in memory
* true then XdmValues are deleted
* @param deleteValues. Individual pointers to XdmValue objects have to be deleted in the calling program
*/
void clearParameters(bool deleteValues=false);
//! Clear property values set
void clearProperties();
/**
* Get the messages written using the <code>xsl:message</code> instruction
* @return XdmValue - Messages returned as an XdmValue.
*/
XdmValue * getXslMessages();//TODO allow notification of message as they occur
//!Perform a one shot transformation.
/**
* The result is stored in the supplied outputfile.
*
* @param sourcefile - The file name of the source document
* @param stylesheetfile - The file name of the stylesheet document. If NULL the most recently compiled stylesheet is used
* @param outputfile - The file name where results will be stored
*/
void transformFileToFile(const char* sourcefile, const char* stylesheetfile, const char* outputfile);
//!Perform a one shot transformation.
/**
* The result is returned as a string
*
* @param sourcefile - The file name of the source document
* @param stylesheetfile - The file name of the stylesheet document. If NULL the most recently compiled stylesheet is used
* @return char array - result of the transformation
*/
const char * transformFileToString(const char* sourcefile, const char* stylesheetfile);
/**
* Perform a one shot transformation. The result is returned as an XdmValue
*
* @param sourcefile - The file name of the source document
* @param stylesheetfile - The file name of the stylesheet document. If NULL the most recently compiled stylesheet is used
* @return XdmValue - result of the transformation
*/
XdmValue * transformFileToValue(const char* sourcefile, const char* stylesheetfile);
//! compile a stylesheet file.
/**
* The compiled stylesheet is cached and available for execution later.
* @param stylesheet - The file name of the stylesheet document.
*/
void compileFromFile(const char* stylesheet);
//!compile a stylesheet received as a string.
/**
*
* The compiled stylesheet is cached and available for execution later.
* @param stylesheet as a lexical string representation
*/
void compileFromString(const char* stylesheet);
//!compile a stylesheet received as a string and save to an exported file (SEF).
/**
*
* The compiled stylesheet is saved as SEF to file store
* @param stylesheet as a lexical string representation
* @param filename - the file to which the compiled package should be saved
*/
void compileFromStringAndSave(const char* stylesheet, const char* filename);
//!compile a stylesheet received as a file and save to an exported file (SEF).
/**
*
* The compiled stylesheet is saved as SEF to file store
* @param xslFilename - file name of the stylesheet
* @param filename - the file to which the compiled package should be saved
*/
void compileFromFileAndSave(const char* xslFilename, const char* filename);
//!compile a stylesheet received as an XdmNode.
/**
* The compiled stylesheet is cached and available for execution later.
* @param stylesheet as a lexical string representation
* @param filename - the file to which the compiled package should be saved
*/
void compileFromXdmNodeAndSave(XdmNode * node, const char* filename);
//!compile a stylesheet received as an XdmNode.
/**
* The compiled stylesheet is cached and available for execution later.
* @param stylesheet as a lexical string representation
*/
void compileFromXdmNode(XdmNode * node);
//! Internal method to release cached stylesheet
/**
*
* @param void
*/
void releaseStylesheet();
//! Execute transformation to string. Properties supplied in advance.
/**
* Perform the transformation based upon what has been cached.
* @return char*. Pointer to Array of chars. Result returned as a string.
*
*/
const char * transformToString();
//! Execute transformation to Xdm Value. Properties supplied in advance.
/**
* Perform the transformation based upon cached stylesheet and any source document.
* @return as an XdmValue.
*
*/
XdmValue * transformToValue();
//! Execute transformation to file. Properties supplied in advance.
/**
* Perform the transformation based upon cached stylesheet and source document.
* Assume the outputfile has been set in advance
* @return as an XdmValue.
*
*/
void transformToFile();
/**
* Checks for pending exceptions without creating a local reference to the exception object
* @return bool - true when there is a pending exception; otherwise return false
*/
bool exceptionOccurred();
//! Check for exception thrown.
/**
* @return cha*. Returns the exception message if thrown otherwise return NULL
*/
const char* checkException();
//! Clear any exception thrown
void exceptionClear();
//!Get number of errors reported during execution or evaluate of stylesheet
/**
* A transformation may have a number of errors reported against it.
* @return int - Count of the exceptions recorded against the transformation
*/
int exceptionCount();
//! Get the ith error message if there are any error
/**
* A transformation may have a number of errors reported against it.
* @return char* - The message of the i'th exception
*/
const char * getErrorMessage(int i);
//! Get the ith error code if there are any error
/**
* A transformation may have a number of errors reported against it.
* @return char* - The error code of the i'th exception. The error code are related to the specific specification
*/
const char * getErrorCode(int i);
private:
SaxonProcessor* proc;/*! */
jclass cppClass;
jobject cppXT, stylesheetObject, xdmValuei;
std::string cwdXT; /*!< current working directory */
std::string outputfile1; /*!< output file where result will be saved */
std::string failure; //for testing
bool nodeCreated;
std::map<std::string,XdmValue*> parameters; /*!< map of parameters used for the transformation as (string, value) pairs */
std::map<std::string,std::string> properties; /*!< map of properties used for the transformation as (string, string) pairs */
};
#endif /* SAXON_XSLT_H */
gopher://khzae.net/0/s1kd/s1kd-tools/src/tools/s1kd-brexcheck/saxon/Saxon.C.API/XsltProcessor.h