Gearbox.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <libxml/xpath.h>
 
#include <framework/gearbox/Interface.h>
#include <framework/gearbox/InputHandler.h>
 
#include <map>
#include <vector>
#include <string>
 
namespace Belle2 {
  namespace gearbox {
    void* openXmlUri(const char*);
  }
  template <class KEY, class VALUE> class MRUCache;
 
  class Gearbox: public gearbox::Interface {
  public:
    enum { c_DefaultCacheSize = 200 };
 
    struct PathValue {
      PathValue(): numNodes(0), value(""), unit("") {}
      int numNodes;
      std::string value;
      std::string unit;
    };
 
    struct PathOverride {
      std::string path {""};
      std::string value {""};
      std::string unit {""};
      bool multiple {false};
    };
 
    ~Gearbox();
 
    static Gearbox& getInstance();
 
    void setBackends(const std::vector<std::string>& backends);
 
    void clearBackends();
 
    void addOverride(const PathOverride& poverride)
    {
      m_overrides.push_back(poverride);
    }
 
    void clearOverrides()
    {
      m_overrides.clear();
    }
 
    void open(const std::string& name = "Belle2.xml", size_t cacheSize = c_DefaultCacheSize);
 
    void close();
 
    bool isOpen() const { return m_xmlDocument != 0; }
 
    virtual int getNumberNodes(const std::string& path = "") const override
    {
      return getPathValue(path).numNodes;
    }
 
    virtual std::string getString(const std::string& path = "") const noexcept(false) override
    {
      PathValue p = getPathValue(path);
      if (p.numNodes == 0) throw gearbox::PathEmptyError() << path;
      return p.value;
    }
 
    std::string getString(const std::string& path, const std::string& defaultValue) const
    {
      return gearbox::Interface::getString(path, defaultValue);
    }
 
    virtual std::pair<std::string, std::string> getStringWithUnit(const std::string& path = "") const noexcept(false) override
    {
      PathValue p = getPathValue(path);
      if (!p.numNodes) throw gearbox::PathEmptyError() << path;
      return make_pair(p.value, p.unit);
    }
 
    virtual const TObject* getTObject(const std::string& path) const noexcept(false) override;
 
    GearDir getDetectorComponent(const std::string& component);
 
    static void registerInputHandler(const std::string& prefix, gearbox::InputHandler::Factory* factory)
    {
      getInstance().m_registeredHandlers[prefix] = factory;
    }
 
  private:
    Gearbox();
    Gearbox(const Gearbox&) = delete;
    Gearbox& operator=(const Gearbox&) = delete;
 
    gearbox::InputContext* openXmlUri(const std::string& uri) const;
 
    void overridePathValue(const PathOverride& poverride);
    PathValue getPathValue(const std::string& path) const;
 
    xmlDocPtr m_xmlDocument;
    xmlXPathContextPtr m_xpathContext;
    mutable MRUCache<std::string, PathValue>* m_parameterCache;
    mutable std::map<std::string, TObject*> m_ownedObjects;
 
    std::vector<gearbox::InputHandler*> m_handlers;
    std::map<std::string, gearbox::InputHandler::Factory*> m_registeredHandlers;
 
    std::vector<PathOverride> m_overrides;
 
    friend void* gearbox::openXmlUri(const char*);
  };
 
  template<class T> struct InputHandlerFactory {
    explicit InputHandlerFactory(const std::string& prefix)
    {
      Gearbox::registerInputHandler(prefix, factory);
    }
    static gearbox::InputHandler* factory(const std::string& uri)
    {
      return new T(uri);
    }
  };
 
#define B2_GEARBOX_REGISTER_INPUTHANDLER(classname,prefix)\
  InputHandlerFactory<classname> Gearbox_InputHandlerFactory_##classname(prefix)
}