SaxonProcessor.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_PROCESSOR_H
#define SAXON_PROCESSOR_H
 
#if defined __linux__ || defined __APPLE__
 
#include <dlfcn.h>
#include <stdlib.h>
#include <string>
 
#define HANDLE void *
#define LoadLibrary(x) dlopen(x, RTLD_LAZY)
#define GetProcAddress(x, y) dlsym(x, y)
#else
#include <windows.h>
#endif
 
//#define DEBUG //remove
//#define MEM_DEBUG //remove
#define CVERSION_API_NO 1210
 
#include <iostream>
#include <map>
#include <sstream>
#include <stdexcept> // std::logic_error
#include <string>
#include <vector>
 
#include "saxonc_export.h"
#include "saxonc/DocumentBuilder.h"
#include "saxonc/SaxonApiException.h"
#include "saxonc/SaxonCGlue.h"
#include "saxonc/SaxonCXPath.h"
#include "saxonc/SchemaValidator.h"
#include "saxonc/XPathProcessor.h"
#include "saxonc/XQueryProcessor.h"
#include "saxonc/Xslt30Processor.h"
#include "saxonc/XsltExecutable.h"
 
 
//#define MEM_DEBUG
#if defined MEM_DEBUG
 
#include <algorithm>
#include <cstdlib>
#include <new>
 
static std::vector<void *> myAlloc;
 
void *newImpl(std::size_t sz, char const *file, int line);
 
void *operator new(std::size_t sz, char const *file, int line);
 
void *operator new[](std::size_t sz, char const *file, int line);
 
void operator delete(void *ptr) noexcept;
 
void operator delete(void *, std::size_t) noexcept;
 
#endif
 
class Xslt30Processor;
 
class XQueryProcessor;
 
class XPathProcessor;
 
class SchemaValidator;
 
class XdmValue;
 
class XdmNode;
 
class XdmItem;
 
class XdmAtomicValue;
 
class XdmFunctionItem;
 
class XdmArray;
 
class XdmMap;
 
class XsltExecutable;
 
class DocumentBuilder;
 
class SaxonApiException;
 
typedef enum eXdmType {
  XDM_VALUE = 0,
  XDM_ATOMIC_VALUE = 1,
  XDM_NODE = 2,
  XDM_ARRAY = 3,
  XDM_MAP = 4,
  XDM_FUNCTION_ITEM = 5,
  XDM_EMPTY = 6,
  XDM_ITEM = 7,
} XDM_TYPE;
 
//==========================================
 
class SAXONC_EXPORT SaxonProcessor {
 
  friend class DocumentBuilder;
 
  friend class Xslt30Processor;
 
  friend class XsltExecutable;
 
  friend class XQueryProcessor;
 
  friend class SchemaValidator;
 
  friend class XPathProcessor;
 
  friend class XdmValue;
 
  friend class XdmItem;
 
  friend class XdmAtomicValue;
 
  friend class XdmFunctionItem;
 
  friend class XdmNode;
 
  friend class XdmMap;
 
  friend class XdmArray;
 
public:
  SaxonProcessor();
 
  SaxonProcessor(const char *configFile);
 
  SaxonProcessor(bool l);
 
  SaxonProcessor &operator=(const SaxonProcessor &other);
 
  SaxonProcessor(const SaxonProcessor &other);
 
  ~SaxonProcessor();
 
  const char *getErrorMessage();
 
  DocumentBuilder *newDocumentBuilder();
 
  Xslt30Processor *newXslt30Processor();
 
  XQueryProcessor *newXQueryProcessor();
 
  XPathProcessor *newXPathProcessor();
 
  SchemaValidator *newSchemaValidator();
 
 
  void setExtensionLibrary(const char * libraryName);
 
  XdmAtomicValue *makeStringValue(std::string str,
                                  const char *encoding = nullptr);
 
  XdmAtomicValue *makeStringValue(const char *str,
                                  const char *encoding = nullptr);
 
  XdmAtomicValue *makeIntegerValue(int i);
 
  XdmAtomicValue *makeDoubleValue(double d);
 
  XdmAtomicValue *makeFloatValue(float f);
 
  XdmAtomicValue *makeLongValue(long l);
 
  XdmAtomicValue *makeBooleanValue(bool b);
 
  XdmAtomicValue *makeQNameValue(const char *str);
 
  XdmAtomicValue *makeAtomicValue(const char *type, const char *value);
 
  XdmArray *makeArray(char **input, int length);
 
  XdmArray *makeArray(short *input, int length);
 
  XdmArray *makeArray(int *input, int length);
 
  XdmArray *makeArray(long long *input, int length);
 
  XdmArray *makeArray(bool *input, int length);
 
  XdmArray *makeArray(XdmValue **values, int length);
 
 
  static void * makeInternalArray(void **inputs, int length);
 
  XdmMap *makeMap(std::map<XdmAtomicValue *, XdmValue *> dataMap);
 
  static XdmMap *makeMap2(std::map<std::string, XdmValue *> dataMap);
 
  XdmMap *makeMap3(XdmAtomicValue **keys, XdmValue **values, int len);
 
  const char *clarkNameToEQName(const char *name);
 
  const char *EQNameToClarkName(const char *name);
 
  const char *getStringValue(XdmItem *item);
 
  XdmNode *parseXmlFromString(const char *source,
                              const char *encoding = nullptr,
                              SchemaValidator *validator = nullptr);
 
  XdmNode *parseXmlFromFile(const char *source,
                            SchemaValidator *validator = nullptr);
 
  XdmNode *parseXmlFromUri(const char *source,
                           SchemaValidator *validator = nullptr);
 
  XdmValue *parseJsonFromString(const char *source,
                                const char *encoding = NULL);
 
  XdmValue *parseJsonFromFile(const char *source);
 
  int getNodeKind(int64_t obj);
 
  bool isSchemaAwareProcessor();
 
  bool exceptionOccurred();
 
  void exceptionClear();
 
  XdmValue **createXdmValueArray(int len) { return (new XdmValue *[len]); }
 
  void deleteXdmValueArray(XdmValue **arr, int len);
 
  XdmAtomicValue **createXdmAtomicValueArray(int len) {
    return (new XdmAtomicValue *[len]);
  }
 
  void deleteXdmAtomicValueArray(XdmAtomicValue **arr, int len);
 
  static SaxonApiException *checkForExceptionCPP(
      /*JNIEnv *env, jclass callingClass, jobject callingObject*/);
 
 
 static  const char * encodeString(const char * stringValue, const char * toCharSetName);
 
  static void release();
 
  static void attachCurrentThread();
 
  static void detachCurrentThread();
 
  void setcwd(const char *cwd);
 
  const char *getcwd();
 
  const char *getResourcesDirectory();
 
  void setResourcesDirectory(const char *dir);
 
  void setCatalog(const char *catalogFile);
 
  void setCatalogFiles(const char **catalogFiles, int length);
 
  void setConfigurationProperty(const char *name, const char *value);
 
  void clearConfigurationProperties();
 
 bool isLicensed();
 
 const char * getSaxonEdition();
 
  const char *version();
 
 
  static int jvmCreatedCPP; 
  static sxnc_environment
      *sxn_environ; 
  std::string cwd;  
  static void deleteString(const char *data) {
    if (data != nullptr) {
      operator delete((char *)data);
      data = nullptr;
    } 
  }
 
  void createHeapDump(bool live);
 
 
  /*static JavaVM *jvm;*/
 
protected:
  // jclass xdmAtomicClass; /*!< The XdmAtomicValue instance */
  // jclass versionClass; /*!< The Version instance */
  // jclass procClass; /*!< The Saxon Processor instance */
  // jclass saxonCAPIClass; /*!< The SaxonCAPI instance */
  std::string cwdV; 
  // std::string resources_dir; /*!< Saxon resources directory */
  std::string versionStr; 
  std::map<std::string, XdmValue *>
      parameters; 
  //std::map<std::string, std::string>
  // configProperties; /*!< Map of properties used for the transformation as
  //                         (string, string) pairs */
  bool licensei; 
  int64_t procRef; 
  // JNINativeMethod *nativeMethods; /*!< native methods variable used in
  // extension methods */ std::vector<JNINativeMethod> nativeMethodVect; /*!<
  // Vector of native methods defined by user */
  SaxonApiException
      *exception; 
private:
  // void createException(const char *message = nullptr);
 
  void initialize(bool l);
 
  void applyConfigurationProperties();
 
  // SaxonC method for internal use
  static int64_t
  createParameterJArray(std::map<std::string, XdmValue *> parameters,
                        std::map<std::string, std::string> properties,
                        int additions = 0);
 
  static int64_t
  createParameterJArray2(std::map<std::string, XdmValue *> parameters);
 
  static int64_t createJArray(XdmValue **values, int length);
 
  static XdmValue *makeXdmValueFromRef(int64_t valueRef);
 
  static XdmItem *makeXdmItemFromRef(int64_t valueRef);
 
  static const char *checkException();
 
  static void destroyHandle(int64_t handleRef);
 
  static void getInfo();
};
 
//===============================================================================================
 
#endif /* SAXON_PROCESSOR_H */