XsltExecutable.h

 
// Copyright (c) 2022 - 2025 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 "saxonc_export.h"
#include "saxonc/SaxonProcessor.h"
//#include "XdmValue.h"
#include <string>
 
class SaxonProcessor;
class SaxonApiException;
class Xslt30Processor;
class XdmValue;
class XdmItem;
class XdmNode;
class XdmFunctionItem;
 
class SAXONC_EXPORT XsltExecutable {
 
  friend class Xslt30Processor;
 
public:
  ~XsltExecutable();
 
  void setcwd(const char *cwd);
 
 const char * getcwd();
 
  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 withParam=true);
 
  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();
 
 
  char **createCharArray(int len) { return (new char *[len]); }
 
  void deleteXdmValueArray(XdmValue **arr, int len);
 
  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);
 
  XdmValue *getXslMessages();
 
  void clearXslMessages();
 
  bool exceptionOccurred();
 
  SaxonApiException *getException();
 
  const char *getErrorMessage();
 
  void exceptionClear();
 
  SaxonProcessor* getSaxonProcessor() { return proc; }
 
private:
  XsltExecutable();
 
  XsltExecutable(SaxonProcessor *proc, int64_t exObject, std::string cwd,
                 std::string resources);
 
  XsltExecutable(const XsltExecutable &other);
 
 
  void setParameter(const char *name, XdmValue *value, bool withParam);
 
 
  SaxonProcessor *proc; 
                        // jclass  cppClass;
  // jclass messageListenerClass, resultDocumentClass;
  int64_t procRef, executableRef, selectionRef, saxonMessageListenerRef,
      saxonResultDocRef;
  bool selectionStringFlag;  
  std::string cwdXE;         
  std::string resources_dir; 
  bool jitCompilation, rawResultsFlag, exceptionFound;
  std::map<std::string, XdmValue *>
      parameters; 
  std::map<std::string, std::string>
      properties; 
  std::map<std::string, XdmValue *> resultDocumentMap;
};
 
#endif /* SAXON_XSLT_EXEC_H */