ApplicationTools.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_APP_APPLICATIONTOOLS_H
#define BPP_APP_APPLICATIONTOOLS_H


#include "../Io/FileTools.h"
#include "../Io/OutputStream.h"
#include "../Numeric/Matrix/Matrix.h"
#include "../Text/NestedStringTokenizer.h"
#include "../Text/StringTokenizer.h"
#include "../Text/TextTools.h"

// From the STL:
#include <map>
#include <vector>
#include <iostream>
#include <ctime>

namespace bpp
{
class ApplicationTools
{
public:
  static std::shared_ptr<OutputStream> error;
  static std::shared_ptr<OutputStream> message;
  static std::shared_ptr<OutputStream> warning;

  static time_t startTime;

  static size_t terminalWidth;

  static float terminalSplit;

  static bool interactive;

  static int warningLevel;

public:
  ApplicationTools() {}
  virtual ~ApplicationTools() {}

public:
  static bool parameterExists(const std::string& parameterName, const std::map<std::string, std::string>& params)
  {
    std::map<std::string, std::string>::const_iterator it = params.find(parameterName);

    return it != params.end() && !TextTools::isEmpty(it->second);
  }


  static bool parameterExists(const std::string& parameterName, std::vector<std::string>& params)
  {
    for (size_t i = 0; i < params.size(); ++i)
    {
      if (params[i] == parameterName)
        return true;
    }

    return false;
  }

  static std::vector<std::string> matchingParameters(const std::string& pattern, const std::map<std::string, std::string>& params);

  static std::vector<std::string> matchingParameters(const std::string& pattern, std::vector<std::string>& params);

  static double getDoubleParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      double defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0);

  static int getIntParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      int defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0);

  static std::string getStringParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      const std::string& defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0)
  {
    std::string sParam = defaultValue;
    std::map<std::string, std::string>::const_iterator it1 = params.find(parameterName + suffix);
    if (it1 != params.end() && !TextTools::isEmpty(it1->second))
      sParam = it1->second;
    else
    {
      std::map<std::string, std::string>::const_iterator it2 = params.find(parameterName);
      if (suffixIsOptional && it2 != params.end() && !TextTools::isEmpty(it2->second))
        sParam = it2->second;
      else if (warn <= warningLevel)
      {
        displayWarning("Parameter " + parameterName + " not specified. Default used instead: " + defaultValue);
      }
    }

    return sParam;
  }


  static bool getBooleanParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      bool defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0);

  template<class T> static T getParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      T defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0)
  {
    T tParam = defaultValue;
    if (parameterExists(parameterName + suffix, params))
    {
      tParam = TextTools::to<T>(params.at(parameterName + suffix));
    }
    else if (suffixIsOptional && parameterExists(parameterName, params))
    {
      tParam = TextTools::to<T>(params.at(parameterName));
    }
    else if (warn <= warningLevel)
    {
      displayWarning("Parameter " + parameterName + suffix + " not specified. Default used instead: " + TextTools::toString(defaultValue));
    }
    return tParam;
  }


  static std::string getAFilePath(
      const std::string& parameter,
      const std::map<std::string, std::string>& params,
      bool isRequired = true,
      bool mustExist = true,
      const std::string& suffix = "",
      bool suffixIsOptional = false,
      const std::string& defaultPath = "none",
      int warn = 0);

  template<class T> static std::vector<T> getVectorParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      char separator,
      const std::string& defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0)
  {
    if (separator == ' ') throw Exception("ApplicationTools::getVectorParameter(). Separator cannot be a space character.");
    std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn);
    if (TextTools::isEmpty(s)) return std::vector<T>(0);
    if (s[0] == '(' && s[s.size() - 1] == ')')
    {
      // This is a delimited vector:
      s = s.substr(1, s.size() - 2);
      if (TextTools::isEmpty(s)) return std::vector<T>(0);
    }
    NestedStringTokenizer st(s, "(", ")", TextTools::toString(separator));
    size_t n = st.numberOfRemainingTokens();
    std::vector<T> v(n);
    for (size_t i = 0; i < n; ++i)
    {
      v[i] = TextTools::fromString<T>(st.nextToken());
    }
    return v;
  }

  template<class T> static std::vector< std::vector<T>> getVectorOfVectorsParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      char separator,
      const std::string& defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      int warn = 0)
  {
    if (separator == ' ') throw Exception("ApplicationTools::getVectorOfVectorsParameter(). Separator cannot be a space character.");
    std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn);
    if (TextTools::isEmpty(s)) return std::vector< std::vector<T>>(0);
    if (s[0] == '(' && s[s.size() - 1] == ')')
    {
      // This is a delimited vector:
      s = s.substr(1, s.size() - 2);
      if (TextTools::isEmpty(s)) return std::vector< std::vector<T>>(0);
    }
    NestedStringTokenizer st(s, "(", ")", TextTools::toString(separator));
    size_t n = st.numberOfRemainingTokens();
    std::string s2;
    std::vector< std::vector<T>> v(n);
    for (size_t i = 0; i < n; ++i)
    {
      s2 = st.nextToken();
      if (s2[0] == '(' && s2[s2.size() - 1] == ')')
      {
        // This is a delimited vector:
        s2 = s2.substr(1, s2.size() - 2);
      }
      if (!TextTools::isEmpty(s2))
      {
        NestedStringTokenizer st2(s2, "(", ")", TextTools::toString(separator));
        size_t n2 = st2.numberOfRemainingTokens();
        v[i].resize(n2);
        for (size_t j = 0; j < n2; ++j)
        {
          v[i][j] = TextTools::fromString<T>(st2.nextToken());
        }
      }
    }
    return v;
  }

  template<class T> static std::vector<T> getVectorParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      char separator,
      char rangeOperator,
      const std::string& defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool warn = true)
  {
    std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn);
    if (s[0] == '(' && s[s.size() - 1] == ')')
    {
      // This is a delimited vector:
      s = s.substr(1, s.size() - 2);
      if (TextTools::isEmpty(s)) return std::vector<T>(0);
    }
    StringTokenizer st(s, TextTools::toString(separator));
    size_t n = st.numberOfRemainingTokens();
    std::vector<T> v;
    for (size_t i = 0; i < n; ++i)
    {
      std::string token = st.nextToken();
      std::string::size_type pos = token.find(rangeOperator);
      if (pos == std::string::npos)
        v.push_back(TextTools::fromString<T>(token));
      else
      {
        T d1 = TextTools::fromString<T>(token.substr(0, pos));
        T d2 = TextTools::fromString<T>(token.substr(pos + 1));
        for (T j = d1; j < d2; j++)
        {
          v.push_back(j);
        }
        v.push_back(d2);
      }
    }
    return v;
  }

  template<class T> static RowMatrix<T> getMatrixParameter(
      const std::string& parameterName,
      const std::map<std::string, std::string>& params,
      char separator,
      const std::string& defaultValue,
      const std::string& suffix = "",
      bool suffixIsOptional = true,
      bool warn = true)
  {
    RowMatrix<T> mat;

    std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn);
    if (TextTools::isEmpty(s)) return RowMatrix<T>(0, 0);
    if (s[0] == '(' && s[s.size() - 1] == ')')
    {
      // This is a delimited vector:
      s = s.substr(1, s.size() - 2);
      if (TextTools::isEmpty(s)) return RowMatrix<T>(0, 0);
    }

    StringTokenizer st1(s, "()");

    while (st1.hasMoreToken())
    {
      std::string si = st1.nextToken();
      StringTokenizer st2(si, TextTools::toString(separator));
      size_t n = st2.numberOfRemainingTokens();

      std::vector<T> v(n);
      for (size_t i = 0; i < n; i++)
      {
        v[i] = TextTools::fromString<T>(st2.nextToken());
      }

      if (v.size() != 0)
        mat.addRow(v);
    }
    return mat;
  }


  static void displayMessage(const std::string& text);

  static void displayError(const std::string& text);

  static void displayWarning(const std::string& text);

  static void displayTask(const std::string& text, bool eof = false);

  static void displayTaskDone();

  template<class T>
  static void displayResult(const std::string& text, const T& result)
  {
    displayMessage(TextTools::resizeRight(text, static_cast<size_t>(static_cast<float>(terminalWidth) * terminalSplit - 1), '.') + ": " + TextTools::toString<T>(result));
  }

  static void displayBooleanResult(const std::string& text, bool result)
  {
    displayResult(text, result ? std::string("yes") : std::string("no"));
  }

  static void displayGauge(size_t iter, size_t total, char symbol = '>', const std::string& mes = "");

  static void displayUnlimitedGauge(size_t iter, const std::string& mes = "");


  static void startTimer()
  {
    time(&startTime);
  }

  static void displayTime(const std::string& msg);

  static double getTime();
};
} // end of namespace bpp.
#endif // BPP_APP_APPLICATIONTOOLS_H