ConfigService.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/MantidVersion.h"
#include "MantidKernel/ParaViewVersion.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/FilterChannel.h"
#include "MantidKernel/StdoutChannel.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"

#include <Poco/Util/LoggingConfigurator.h>
#include <Poco/Util/SystemConfiguration.h>
#include <Poco/Util/PropertyFileConfiguration.h>
#include <Poco/LoggingFactory.h>
#include <Poco/Path.h>
#include <Poco/File.h>
#include <Poco/StringTokenizer.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/Notification.h>
#include <Poco/Environment.h>
#include <Poco/Process.h>
#include <Poco/String.h>
#ifdef _WIN32
  #pragma warning( disable: 4250 )
#endif
#include <Poco/PipeStream.h>
#include <Poco/StreamCopier.h>

#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/regex.hpp>

#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
#include <algorithm>

#ifdef __APPLE__
  #include <mach-o/dyld.h>
#endif

namespace Mantid
{
/**
 * Get the welcome message for Mantid.
 * @returns A string containing the welcome message for Mantid.
 */
std::string welcomeMessage()
{
    return "Welcome to Mantid version " + std::string(Mantid::Kernel::MantidVersion::version()) + " - Manipulation and Analysis Toolkit for Instrument Data\n" +
           "Please cite Mantid in your publications using: " + Mantid::Kernel::MantidVersion::doi();
}

namespace Kernel
{

namespace { // anonymous namespace for some utility functions

/**
 * Split the supplied string on semicolons.
 *
 * @param path The path to split.
 * @param splitted vector to put the splitted path into.
 */
void splitPath(const std::string &path, std::vector<std::string> &splitted)
{
  if (path.find(";") == std::string::npos)
  {  // don't bother tokenizing
    splitted.push_back(path);
    return;
  }

  int options = Poco::StringTokenizer::TOK_TRIM + Poco::StringTokenizer::TOK_IGNORE_EMPTY;

  splitted.clear();
  Poco::StringTokenizer tokenizer(path, ";,", options);
  Poco::StringTokenizer::Iterator iend = tokenizer.end();
  splitted.reserve(tokenizer.count());
  for (Poco::StringTokenizer::Iterator itr = tokenizer.begin(); itr != iend; ++itr)
  {
    if (!itr->empty())
    {
      splitted.push_back(*itr);
    }
  }
}

} // end of anonymous namespace

/** Inner templated class to wrap the poco library objects that have protected
 *  destructors and expose them as public.
 */
template<typename T>
class ConfigServiceImpl::WrappedObject: public T
{
public:
  /// The template type of class that is being wrapped
  typedef T element_type;
  /// Simple constructor
  WrappedObject() :
    T()
  {
    m_pPtr = static_cast<T*> (this);
  }

  /** Constructor with a class to wrap
   *  @param F :: The object to wrap
   */
  template<typename Field>
  WrappedObject(Field& F) :
    T(F)
  {
    m_pPtr = static_cast<T*> (this);
  }

  /// Copy constructor
  WrappedObject(const WrappedObject<T>& A) :
    T(A)
  {
    m_pPtr = static_cast<T*> (this);
  }

  /// Virtual destructor
  virtual ~WrappedObject()
  {
  }

  /// Overloaded * operator returns the wrapped object pointer
  const T& operator*() const
  {
    return *m_pPtr;
  }
  /// Overloaded * operator returns the wrapped object pointer
  T& operator*()
  {
    return m_pPtr;
  }
  /// Overloaded -> operator returns the wrapped object pointer
  const T* operator->() const
  {
    return m_pPtr;
  }
  /// Overloaded -> operator returns the wrapped object pointer
  T* operator->()
  {
    return m_pPtr;
  }

private:
  /// Private pointer to the wrapped class
  T* m_pPtr;
};

//Back to the ConfigService class itself...

//-------------------------------
// Private member functions
//-------------------------------

/// Private constructor for singleton class
ConfigServiceImpl::ConfigServiceImpl() :
  m_pConf(NULL), m_pSysConfig(NULL), g_log(Logger::get("ConfigService")), m_changed_keys(),
  m_ConfigPaths(), m_AbsolutePaths(), m_strBaseDir(""), m_PropertyString(""),
  m_properties_file_name("Mantid.properties"),
#ifdef MPI_BUILD
  // Use a different user properties file for an mpi-enabled build to avoid confusion if both are used on the same filesystem
  m_user_properties_file_name("Mantid-mpi.user.properties"),
#else
  m_user_properties_file_name("Mantid.user.properties"),
#endif
  m_DataSearchDirs(), m_UserSearchDirs(), m_instr_prefixes(), m_removedFlag("@@REMOVED@@")
{
  //getting at system details
  m_pSysConfig = new WrappedObject<Poco::Util::SystemConfiguration> ;
  m_pConf = 0;

  //Register the FilterChannel with the Poco logging factory
  Poco::LoggingFactory::defaultFactory().registerChannelClass("FilterChannel", new Poco::Instantiator<
      Poco::FilterChannel, Poco::Channel>);
  //Register StdChannel with Poco
  Poco::LoggingFactory::defaultFactory().registerChannelClass("StdoutChannel", new Poco::Instantiator<
      Poco::StdoutChannel, Poco::Channel>);

  // Define the directory to search for the Mantid.properties file.
  Poco::File f;

  // First directory: the current working
  m_strBaseDir = Poco::Path::current();
  f = Poco::File(m_strBaseDir + m_properties_file_name);
  if (!f.exists())
  {
    // Check the executable directory to see if it includes a mantid.properties file
    m_strBaseDir = getDirectoryOfExecutable();