toolbox/stringFunc.hh

Go to the documentation of this file.

#ifndef StringFuns_hh
#define StringFuns_hh

#include <string>
#include <vector>
#include <iomanip>
#include "basics/outputOperator.hh"
#include "basics/typedefs.hh"
#include "toolbox/sequence.hh"

namespace concepts {

  // *************************************************************** tolower **

  char tolower(const char ch);

  // ********************************************************* stringtolower **

  std::string stringtolower(const std::string s);

  // ******************************************************** removeAllWhite **

  std::string removeAllWhite(const std::string str);

  // *********************************************************** getFilename **

  std::string getFilename(const std::string str);

  // ***************************************************** getFilenamePrefix **

  std::string getFilenamePrefix(const std::string str);

  // ********************************************************** getDirectory **

  std::string getDirectory(const std::string str);

  // *********************************************************** splitString **

  std::vector<std::string> splitString(const std::string text,
                                       const std::string separators);


  // ************************************************* splitStringNameParams **

  std::vector<std::string> splitStringNameParams(const std::string text);

  // **************************************************** splitStringByComma **

  std::vector<std::string> splitStringByComma(const std::string text);

  // ************************************************************ stringSubs **

  template<class F>
  std::string stringSubs(const std::string str,
                         const std::string var, F value) {
    std::stringstream s;
    s << std::setprecision(16) << value;
    std::string sNew = str;
    
    std::string::size_type i;
    while((i = sNew.find(var)) != std::string::npos)
      sNew.replace(i, var.size(), s.str());
    return sNew;
  }


  // ************************************************* ParseObjectFromString **

  template<class F>
  class ParseObjectFromString : public OutputOperator {
  public:
    ParseObjectFromString(const char* name = "",
                          const Sequence<F> data = Sequence<F>())
      : name_(name), data_ (data) {}
    ParseObjectFromString(const char* name, const F data)
      : name_(name), data_(1) { data_[0] = data; }
    ParseObjectFromString(const char* name, const F data1, const F data2)
      : name_(name), data_(2) { data_[0] = data1; data_[1] = data2; }
    ParseObjectFromString(const char* name,
                          const F data1, const F data2, const F data3)
      : name_(name), data_(3) { 
      data_[0] = data1;
      data_[1] = data2;
      data_[2] = data3;
    }

    std::string& name() { return name_; }
    Sequence<F>& data() { return data_; }

    bool parse(const std::string s);
  protected:
    std::ostream& info(std::ostream& os) const;
  private:
    std::string name_;
    Sequence<F> data_;
  };

  template<class F>
  bool ParseObjectFromString<F>::parse(const std::string s) {
    Sequence<std::string> seq = splitStringNameParams(s);
    if (seq.size() == 0) return false;

    // remove white spaces
    for(Sequence<std::string>::iterator i = seq.begin(); i != seq.end(); ++i) {
      std::string t = removeAllWhite(*i); *i = t;
    }
    std::stringstream st; st << seq[0];
    st >> name_;
    data_.resize(seq.size()-1);
    for(uint i = 0; i < data_.size(); ++i) {
      std::stringstream st; st << seq[i+1];
      st >> data_[i];
    }

    return true;
  }

  template<class F>
  std::ostream& ParseObjectFromString<F>::info(std::ostream& os) const {
    os << name_ << '(';
    for(typename Sequence<F>::const_iterator i = data_.begin(); 
        i != data_.end();) {
      os << *i++;
      if (i != data_.end())
        os << ", ";
    }
    return os << ')';
  }

  // ******************************************** realSeqFromStringWithPower **

  Sequence<Real> realSeqFromStringWithPower(const std::string s);

} // namespace concepts

#endif // StringFuns_hh