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"
#include "toolbox/set.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 virtual 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 << concepts::typeOf(*this)<<  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);
 
  // ************************************************************ uintSeqSets **
 
  Sequence<concepts::Set<uint> > uintSeqSets(const std::string s);
 
} // namespace concepts
 
#endif // StringFuns_hh