Xslt30Processor.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_XSLT30_H
#define SAXON_XSLT30_H
 
#include "saxonc_export.h"
#include "saxonc/SaxonProcessor.h"
//#include "XdmValue.h"
#include <string>
 
class SaxonProcessor;
class SaxonApiException;
class XsltExecutable;
class XdmValue;
class XdmItem;
class XdmNode;

class SAXONC_EXPORT Xslt30Processor {
 
  friend class XsltExecutable;
 
public:
  Xslt30Processor();

  Xslt30Processor(SaxonProcessor *proc, std::string cwd = "");

  Xslt30Processor(const Xslt30Processor &other);
 
  ~Xslt30Processor();

  SaxonProcessor *getSaxonProcessor();

  void setcwd(const char *cwd);
 

 const char * getcwd();

  void setBaseOutputURI(const char *baseURI);

  void setJustInTimeCompilation(bool jit);

 bool getJustInTimeCompilation();

  void setTargetEdition(const char *edition);

  void setXsltLanguageVersion(const char *version);

  void setFastCompilation(bool fast);

  void setRelocatable(bool relocatable);

  void setParameter(const char *name, XdmValue *value);

  XdmValue *getParameter(const char *name);

  bool removeParameter(const char *name);

  std::map<std::string, XdmValue *> &getParameters();

  void clearParameters(bool deleteValues = false);
 

  char **createCharArray(int len) { return (new char *[len]); }

  void deleteXdmValueArray(XdmValue **arr, int len) {
    delete[] arr;
  }

  void transformFileToFile(const char *sourcefile, const char *stylesheetfile,
                           const char *outputfile);

  const char *transformFileToString(const char *sourcefile,
                                    const char *stylesheetfile);

  XdmValue *transformFileToValue(const char *sourcefile,
                                 const char *stylesheetfile);

  void importPackage(const char *packageFile);

  XsltExecutable *compileFromFile(const char *stylesheet);

  XsltExecutable *compileFromString(const char *stylesheet,
                                    const char *encoding = nullptr);

  XsltExecutable *compileFromAssociatedFile(const char *sourceFile);

  void compileFromStringAndSave(const char *stylesheet, const char *filename,
                                const char *encoding = nullptr);

  void compileFromFileAndSave(const char *xslFilename, const char *filename);

  void compileFromXdmNodeAndSave(XdmNode *node, const char *filename);

  XsltExecutable *compileFromXdmNode(XdmNode *node);

  bool exceptionOccurred();

  SaxonApiException *getException();

  void exceptionClear();

  const char *getErrorMessage();

  const char *getErrorCode();
 
private:
  void createException(const char *message = nullptr);

  void setProperty(const char *name, const char *value);

 std::map<std::string, std::string> &getProperties();

  void clearProperties();
 
  //SaxonProcessor *proc; /*!< Pointer to the SaxonProcessor object which created this Xslt30Processor */
 
  int64_t cppXT, procRef;
  int64_t importPackageValue;
  std::string cwdXT;   
  bool jitCompilation; 
  std::map<std::string, XdmValue *>
      parameters; 
  std::map<std::string, std::string>
      properties; 
  SaxonApiException *exception;
};
 
#endif /* SAXON_XSLT30_H */