ConfigService.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/ProxyInfo.h"
#include "MantidKernel/SingletonHolder.h"
#include <optional>
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include <Poco/Notification.h>
#include <Poco/NotificationCenter.h>
 
//----------------------------------------------------------------------
// Forward declarations
//----------------------------------------------------------------------
namespace Poco {
class AbstractObserver;
class Channel;
template <class C> class AutoPtr;
namespace Util {
class PropertyFileConfiguration;
class SystemConfiguration;
} // namespace Util
} // namespace Poco
 
namespace Mantid {
 
MANTID_KERNEL_DLL std::string welcomeMessage();
 
namespace Kernel {
//----------------------------------------------------------------------
// More forward declarations
//----------------------------------------------------------------------
class FacilityInfo;
class InstrumentInfo;
 
class MANTID_KERNEL_DLL ConfigServiceImpl final {
public:
  class ConfigServiceNotification : public Poco::Notification {
  public:
    ConfigServiceNotification() : Poco::Notification() {}
  };
 
  class ValueChanged : public ConfigServiceNotification {
  public:
    ValueChanged(const std::string &name, const std::string &newvalue, const std::string &prevvalue)
        : ConfigServiceNotification(), m_name(name), m_value(newvalue), m_prev(prevvalue) {}
    const std::string &key() const { return this->m_name; } 
    const std::string &curValue() const { return this->m_value; } 
    const std::string &preValue() const { return this->m_prev; } 
  private:
    std::string m_name;  
    std::string m_value; 
    std::string m_prev;  
  };
 
  void setBaseDirectory();
  void reset();
  void updateConfig(const std::string &filename, const bool append = false, const bool update_caches = true);
  void saveConfig(const std::string &filename) const;
  std::string getString(const std::string &keyName, bool pathAbsolute = true) const;
  std::vector<std::string> getKeys(const std::string &keyName) const;
  std::vector<std::string> keys() const;
  void remove(const std::string &rootName);
  bool hasProperty(const std::string &rootName) const;
  bool isExecutable(const std::string &target) const;
  void launchProcess(const std::string &programFilePath, const std::vector<std::string> &programArguments) const;
  void setString(const std::string &key, const std::string &value);
  // Searches for a configuration property and returns its value
  template <typename T> std::optional<T> getValue(const std::string &keyName);
  std::string getLocalFilename() const;
  std::string getUserFilename() const;
 
  std::string getEnvironment(const std::string &keyName);
  std::string getOSName();
  std::string getComputerName();
  std::string getOSArchitecture();
  std::string getOSVersion();
  std::string getOSVersionReadable();
  std::string getUsername();
  std::string getCurrentDir();
  std::string getCurrentDir() const;
  std::string getTempDir();
  std::string getAppDataDir();
  // Return the executable path
  std::string getDirectoryOfExecutable() const;
  // Return the full path to the executable
  std::string getPathToExecutable() const;
  // Check if the path is on a network drive
  bool isNetworkDrive([[maybe_unused]] const std::string &path);
 
  std::string getPropertiesDir() const;
  std::string getUserPropertiesDir() const;
 
  const std::vector<std::string> &getDataSearchDirs() const;
  void setDataSearchDirs(const std::vector<std::string> &searchDirs);
  void setDataSearchDirs(const std::string &searchDirs);
  void appendDataSearchDir(const std::string &path);
  void appendDataSearchSubDir(const std::string &subdir);
  void setInstrumentDirectories(const std::vector<std::string> &directories);
  const std::vector<std::string> &getInstrumentDirectories() const;
  const std::string getInstrumentDirectory() const;
  const std::string getVTPFileDirectory();
 
  void updateFacilities(const std::string &fName = "");
  const std::vector<FacilityInfo *> getFacilities() const;
  const std::vector<std::string> getFacilityNames() const;
  const FacilityInfo &getFacility() const;
  const FacilityInfo &getFacility(const std::string &facilityName) const;
  void setFacility(const std::string &facilityName);
  void setLogLevel(int logLevel, bool quiet = false);
  void setLogLevel(std::string const &logLevel, bool quiet = false);
  // return the string name for the log level
  std::string getLogLevel();
 
  const InstrumentInfo &getInstrument(const std::string &instrumentName = "") const;
 
  // Find the longest matching instrument prefix for the given hint.
  const std::string findLongestInstrumentPrefix(const std::string &hint) const;
 
  void addObserver(const Poco::AbstractObserver &observer) const;
 
  void removeObserver(const Poco::AbstractObserver &observer) const;
 
  // Starts up the logging
  void configureLogging();
 
  Kernel::ProxyInfo &getProxy(const std::string &url);
 
  std::string getFullPath(const std::string &filename, const bool ignoreDirs, const int options) const;
 
private:
  friend struct Mantid::Kernel::CreateUsingNew<ConfigServiceImpl>;
  mutable Poco::NotificationCenter m_notificationCenter;
 
  // Private constructors and destructor for singleton class
  ConfigServiceImpl();
  ConfigServiceImpl(const ConfigServiceImpl &);
 
  virtual ~ConfigServiceImpl();
 
  void loadConfig(const std::string &filename, const bool append = false);
  bool readFile(const std::string &filename, std::string &contents) const;
 
  void createUserPropertiesFile() const;
  std::string makeAbsolute(const std::string &dir, const std::string &key) const;
  void cacheDataSearchPaths();
  void cacheInstrumentPaths();
  bool isInDataSearchList(const std::string &path) const;
  void clearFacilities();
  const std::vector<std::string> getFacilityFilenames(const std::string &fName);
  bool addDirectoryifExists(const std::string &directoryName, std::vector<std::string> &directoryList);
  void getKeysRecursive(const std::string &root, std::vector<std::string> &allKeys) const;
 
  Poco::AutoPtr<Poco::Util::PropertyFileConfiguration> m_pConf;
  Poco::AutoPtr<Poco::Util::SystemConfiguration> m_pSysConfig;
 
  mutable std::set<std::string> m_changed_keys;
 
  std::string m_strBaseDir;
  std::string m_propertyString;
  const std::string m_properties_file_name;
  const std::string m_user_properties_file_name;
  std::vector<std::string> m_dataSearchDirs;
  std::vector<std::string> m_instrumentDirs;
 
  std::vector<FacilityInfo *> m_facilities;
 
  std::set<std::string> m_configPaths;
 
  Kernel::ProxyInfo m_proxyInfo;
  bool m_isProxySet = false;
 
  // cache for longest matching instrument prefix
  mutable std::vector<std::string> m_instrumentPrefixesCache;
  mutable bool m_isInstrumentPrefixesCached = false;
};
 
EXTERN_MANTID_KERNEL template class MANTID_KERNEL_DLL Mantid::Kernel::SingletonHolder<ConfigServiceImpl>;
using ConfigService = Mantid::Kernel::SingletonHolder<ConfigServiceImpl>;
 
using ConfigValChangeNotification = Mantid::Kernel::ConfigServiceImpl::ValueChanged;
using ConfigValChangeNotification_ptr = const Poco::AutoPtr<Mantid::Kernel::ConfigServiceImpl::ValueChanged> &;
 
} // namespace Kernel
} // namespace Mantid