Xslt30Processor.h

 
// Copyright (c) 2022 - 2023 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 "SaxonProcessor.h"
//#include "XdmValue.h"
#include <string>
 
class SaxonProcessor;
class SaxonApiException;
class XsltExecutable;
class XdmValue;
class XdmItem;
class XdmNode;
 
class Xslt30Processor {
 
  friend class XsltExecutable;
 
public:
 
  Xslt30Processor();
 
 
  Xslt30Processor(SaxonProcessor *proc, std::string cwd = "");
 
  Xslt30Processor(const Xslt30Processor &other);
 
  ~Xslt30Processor();
 
 
  SaxonProcessor *getSaxonProcessor() { return proc; }
 
 
  void setcwd(const char *cwd);
 
 
  void setBaseOutputURI(const char *baseURI);
 
 
  void setJustInTimeCompilation(bool jit);
 
 
  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);
 
 
  XdmValue **createXdmValueArray(int len) { return (new XdmValue *[len]); }
 
  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);
 
  /* via the xml-stylesheet processing instruction (see
   * http://www.w3.org/TR/xml-stylesheet/) with the document
   * specified in the source parameter, and that match
   * the given criteria.  If there are several suitable xml-stylesheet
   * processing instructions, then the returned Source will identify
   * a synthesized stylesheet module that imports all the referenced
   * stylesheet module.*/
  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);
 
  void clearProperties();
 
  SaxonProcessor *proc; 
  int64_t cppXT;
  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 */