preprocess.h

#ifndef _MBXMLUTILS_PREPROCESS_H_
#define _MBXMLUTILS_PREPROCESS_H_
 
#include <fmatvec/atom.h>
#include <mbxmlutilshelper/dom.h>
#include <mbxmlutils/eval.h>
 
namespace MBXMLUtils {
 
class Preprocess : virtual public fmatvec::Atom {
  public:
    using ParamSet = std::map<std::string, Eval::Value>;
 
    Preprocess(const boost::filesystem::path &inputFile, // a filename of a XML file used as input
               std::variant<
                 std::shared_ptr<MBXMLUtils::DOMParser>, // a direct parser OR
                 xercesc::DOMElement*, // the root element of a DOM tree of a XML catalog file to create a parser OR
                 boost::filesystem::path // a filename of a XML catalog file to create a parser
               > parserVariant,
               bool trackDependencies);
    Preprocess(std::istream &inputStream, // the input stream containing the XML file used as input
               std::variant<
                 std::shared_ptr<MBXMLUtils::DOMParser>, // a direct parser OR
                 xercesc::DOMElement*, // the root element of a DOM tree of a XML catalog file to create a parser OR
                 boost::filesystem::path // a filename of a XML catalog file to create a parser
               > parserVariant,
               bool trackDependencies);
    Preprocess(const std::shared_ptr<xercesc::DOMDocument> &inputDoc, bool trackDependencies);
 
    ~Preprocess();
 
    void setCheckInterruptFunction(const std::function<void()> &func) {
      checkInterruptFunc=func;
    }
 
    void setParam(const std::shared_ptr<ParamSet>& param_);
    std::shared_ptr<ParamSet> getParam() const;
 
    std::shared_ptr<Eval> getEvaluator() const;
 
    const std::vector<boost::filesystem::path>& getDependencies() const;
 
    std::shared_ptr<xercesc::DOMDocument> processAndGetDocument();
 
    std::shared_ptr<xercesc::DOMDocument> getDOMDocument() { return document; }
 
  private:
    std::shared_ptr<xercesc::DOMDocument> document;
    std::unique_ptr<std::vector<boost::filesystem::path>> dependencies;
    std::shared_ptr<Eval> eval;
    std::shared_ptr<ParamSet> param;
    std::shared_ptr<DOMParser> noneValidatingParser;
    static const FQN embedFileNotFound;
 
    std::function<void()> checkInterruptFunc;
    void checkInterrupt() {
      if(checkInterruptFunc)
        checkInterruptFunc();
    }
 
    bool preprocessed { false };
 
    std::shared_ptr<DOMParser> initDependenciesAndParser(std::variant<
                                 std::shared_ptr<MBXMLUtils::DOMParser>, // a direct parser OR
                                 xercesc::DOMElement*, // the root element of a DOM tree of a XML catalog file to create a parser OR
                                 boost::filesystem::path // a filename of a XML catalog file to create a parser
                               > parserVariant,
                               bool trackDependencies);
 
    std::map<boost::filesystem::path, std::shared_ptr<xercesc::DOMDocument>> parsedFiles;//mfmf make this static and check timestemps
    std::shared_ptr<xercesc::DOMDocument> parseCached(const std::shared_ptr<DOMParser> &parser,
                                                      const boost::filesystem::path &inputFile,
                                                      const std::string &msg, bool allowUnknownRootElement=false);
 
    std::map<size_t, std::shared_ptr<xercesc::DOMDocument>> parsedStream;//mfmf make this static
    std::shared_ptr<xercesc::DOMDocument> parseCached(const std::shared_ptr<DOMParser> &parser,
                                                      std::istream &inputStream,
                                                      const std::string &msg, bool allowUnknownRootElement=false);
 
    void extractEvaluator();
 
    bool preprocess(// in: element to process; out: e changes only if e is itself a Embed element
                    xercesc::DOMElement *&e,
                    // out: number of elements added for a Embed element (may be 0), if e is a Embed element or -1 if e is not a Embed element
                    int &nrElementsEmbeded,
                    // in: root level parameters to overwrite; out: root level parameters
                    const std::shared_ptr<ParamSet>& param=std::shared_ptr<ParamSet>(),
 
                    // internal: XPath expression of parent element
                    int embedXPathCount=1
                   );
};
 
}
 
#endif