XsltExecutable.h

// Copyright (c) 2022 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_EXEC_H
#define SAXON_XSLT_EXEC_H
 
 
#include "SaxonProcessor.h"
//#include "XdmValue.h"
#include <string>
 
class SaxonProcessor;
class SaxonApiException;
class Xslt30Processor;
class XdmValue;
class XdmItem;
class XdmNode;
class XdmFunctionItem;
class XdmMap;
class XdmArray;
 
class XsltExecutable {
 
friend class Xslt30Processor;
 
 
public:
 
 
     ~XsltExecutable();
 
    // static base URI for XSLT stylesheets when supplied as lexical string.
   void setcwd(const char* cwd);
 
 
 
      void setBaseOutputURI(const char * baseURI);
 
 
 
 
    void setGlobalContextItem(XdmItem * value);
 
    void setGlobalContextFromFile(const char * filename);
 
 
 
    XsltExecutable *clone();
 
 
 
    void setInitialMode(const char * modeName);
 
 
 
    void setInitialMatchSelection(XdmValue * selection);
 
 
    void setInitialMatchSelectionAsFile(const char * filename);
 
    void setOutputFile(const char* outfile);
 
 
 
 
    void setResultAsRawValue(bool option);
 
    void setParameter(const char* name, XdmValue * value);
 
 
    std::map<std::string,XdmValue*>& getResultDocuments();
 
 
 
     XdmValue* getParameter(const char* name);
 
 
    bool removeParameter(const char* name);
 
 
 
 
    bool removeProperty(const char* name);
 
    void setProperty(const char* name, const char* value);
 
 
    void setInitialTemplateParameters(std::map<std::string,XdmValue*> parameters, bool tunnel);
 
    const char* getProperty(const char* name);
 
 
     std::map<std::string,XdmValue*>& getParameters();
 
 
     std::map<std::string,std::string>& getProperties();
 
 
    void clearParameters(bool deleteValues=false);
 
    void clearProperties();
 
    XdmValue ** createXdmValueArray(int len){
    return (new XdmValue*[len]);
    }
 
    char** createCharArray(int len){
    return (new char*[len]);
    }
 
 
    void deleteXdmValueArray(XdmValue ** arr, int len){
    for(int i =0; i< len; i++) {
        //delete arr[i];
    }
    delete [] arr;
    }
 
 
    void setSaveXslMessage(bool show, const char* filename=nullptr);
 
 
    void setCaptureResultDocuments(bool flag, bool rawResults=false);
 
 
 
    void exportStylesheet(const char * filename);
 
 
 
    void transformFileToFile(const char* sourcefile, const char* outputfile);
 
 
    const char * transformFileToString(const char* sourcefile);
 
    XdmValue * transformFileToValue(const char* sourcefile);
 
 
 
 
    void applyTemplatesReturningFile(const char* outfile);
 
 
    const char* applyTemplatesReturningString();
 
 
    XdmValue * applyTemplatesReturningValue();
 
 
    void callTemplateReturningFile(const char* templateName, const char* outfile);
 
 
    const char* callTemplateReturningString(const char* templateName=nullptr);
 
 
    XdmValue* callTemplateReturningValue(const char* templateName=nullptr);
 
 
 
 
    void callFunctionReturningFile(const char* functionName, XdmValue ** arguments, int argument_length, const char* outfile);
 
 
 
    const char * callFunctionReturningString(const char* functionName, XdmValue ** arguments, int argument_length);
 
 
    XdmValue * callFunctionReturningValue(const char* functionName, XdmValue ** arguments, int argument_length);
 
 
 
 
 
    const char * transformToString(XdmNode * source=nullptr);
 
 
    XdmValue * transformToValue(XdmNode * source=nullptr);
 
 
    void transformToFile(XdmNode * source=nullptr);
 
    bool exceptionOccurred();
 
 
 
 
 
    SaxonApiException* getException();
 
 
    const char * getErrorMessage();
 
 
    void exceptionClear();
 
 
 
private:
 
    XsltExecutable();
 
 
    XsltExecutable(jobject exObject, std::string cwd, std::string resources);
 
    XsltExecutable(const XsltExecutable &other);
 
 
    jclass  cppClass;
    jclass messageListenerClass, resultDocumentClass;
    jobject executableObject, selection, saxonMessageListenerObj, saxonResultDocObj;
    XdmValue * selectionV;
    std::string cwdXE; 
    std::string resources_dir; 
    bool tunnel, jitCompilation, rawResultsFlag;
    std::map<std::string,XdmValue*> parameters; 
    std::map<std::string,std::string> properties; 
    std::map<std::string,XdmValue*> resultDocumentMap;
};
 
 
#endif /* SAXON_XSLT_EXEC_H */