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 */