SchemaValidator.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_SCHEMA_H
#define SAXON_SCHEMA_H
 
#include "saxonc_export.h"
#include "saxonc/SaxonProcessor.h"
 
#include <string>
 
class SaxonProcessor;
class XdmValue;
class XdmNode;
class XdmItem;
class XsdSchema;
 
class SAXONC_EXPORT SchemaValidator {
public:
  SchemaValidator();
 
  SchemaValidator(SaxonProcessor *proc, std::string cwd = "");
 
  SchemaValidator(const SchemaValidator &other);
 
  ~SchemaValidator();
 
  SchemaValidator &operator=(const SchemaValidator &other);
 
  void setcwd(const char *cwd);
 
 const char * getcwd();
 
  void registerSchemaFromFile(const char *xsd);
 
  void registerSchemaFromString(const char *schemaStr,
                                const char *systemID = nullptr);
 
  void registerSchemaFromNode(XdmNode *node);
 
  void exportSchema(const char *fileName);
 
  void setOutputFile(const char *outputFile);
 
 const char *getOutputFile();
 
  void validate(const char *sourceFile = nullptr);
 
    void validateFromString(const char *content);
 
  XdmNode *validateToNode(const char *sourceFile = nullptr);
 
  void setSourceNode(XdmNode *source);
 
  XdmNode *getValidationReport();
 
  void setParameter(const char *name, XdmValue *value, bool withParam=true);
 
  bool removeParameter(const char *name);
 
  void setProperty(const char *name, const char *value);
 
  void clearParameters(bool deleteValues = false);
 
  void clearProperties();
 
  XdmValue *getParameter(const char *name, bool withParam=true);
 
  std::map<std::string, XdmValue *> &getParameters();
 
  std::map<std::string, std::string> &getProperties();
 
 
  void setLax(bool l);
 
  bool isLax();
 
    XsdSchema * getSchema();
 
    void setUseXsiSchemaLocation(bool recognize);
 
    bool isUseXsiSchemaLocation();
 
    void setDocumentElementName(const char * eqname);
 
    const char * getDocumentElementName();
 
    void validateMultiple(const char **sourceFile);
 
    bool isExpandAttributeDefaults();
 
    void setExpandAttributeDefaults(bool expand);
  int64_t getUnderlyingValidator() { return cppV; }
 
  SaxonProcessor* getSaxonProcessor();
 
private:
 
  friend class XsdSchema;
  friend class DocumentBuilder;
 
 
  SchemaValidator(std::string cwd, int64_t p, int64_t schemaValidatorObject);
 
  bool lax; 
  int64_t cppV, procRef;     
  std::string cwdV; 
  std::string
      outputFile; 
  std::map<std::string, XdmValue *>
      parameters; 
  std::map<std::string, std::string>
      properties; 
};
 
#endif /* SAXON_SCHEMA_H */