stringtools.hpp

Go to the documentation of this file.

// $Id: stringtools.hpp 1068 2012-09-18 11:21:53Z perroe $
 
// Copyright (c)  2011, Norwegian Computing Center
// All rights reserved.
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
// •  Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// •  Redistributions in binary form must reproduce the above copyright notice, this list of
//    conditions and the following disclaimer in the documentation and/or other materials
//    provided with the distribution.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
// OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#ifndef NRLIB_STRINGTOOLS_HPP
#define NRLIB_STRINGTOOLS_HPP
 
#include <stdlib.h> // For atoi and atof
 
#include <string>
#include <iomanip>
#include <vector>
#include <sstream>
#include <typeinfo>
 
#include "../exception/exception.hpp"
 
namespace NRLib {
  std::vector<std::string> GetTokens(const std::string& s);
 
  std::vector<std::string> GetQuotedTokens(const std::string& s);
 
  template <typename T>
  bool IsType(const std::string& s);
 
  template <typename T>
  T ParseType(const std::string& s);
 
  template <>
  std::string ParseType<std::string>(const std::string& s);
 
  template <typename T>
  std::string ToString(const T obj, int precision=-99999);
 
  template <typename I>
  I ParseAsciiArrayFast(std::string& s, I begin, size_t n);
 
  std::string GetPath(const std::string& filename);
 
  std::string GetStem(const std::string& filename);
 
  std::string GetExtension(const std::string& filename);
 
  std::string RemovePath(const std::string& filename);
 
  std::string PrependDir(const std::string& prefix,
                         const std::string& str);
 
  std::string ReplaceExtension(const std::string& filename,
                               const std::string& extension);
 
  std::string AddExtension(const std::string& filename,
                           const std::string& extension);
 
  void Substitute(std::string       & text,
                  const std::string & out,
                  const std::string & in);
 
  std::string Uppercase(const std::string& text);
 
  bool IsNumber(const std::string & s);
 
  std::string Chomp(const std::string& s);
 
  inline std::string Whitespace() { return  " \t\n\r\f\v"; }
 
namespace NRLibPrivate {
 
template <class A>
class UnsafeParser
{
public:
  static A ParseType(const char* s) {
    return NRLib::ParseType<A>(s);
  }
};
 
template <>
class UnsafeParser<int>
{
public:
  static int ParseType(const char* s) {
    return atoi(s);
  }
};
 
template <>
class UnsafeParser<double>
{
public:
  static double ParseType(const char* s) {
    return atof(s);
  }
};
 
template <>
class UnsafeParser<float>
{
public:
  static double ParseType(const char* s) {
    return static_cast<float>(atof(s));
  }
};
 
 
} // namespace NRLibPrivate
 
} // namespace NRLib
 
 
 
template <typename T>
bool NRLib::IsType(const std::string& s)
{
  std::istringstream i(s);
  T x;
  char c;
  if (!(i >> x) || i.get(c))
    return false;
  return true;
}
 
 
template <typename T>
T NRLib::ParseType(const std::string& s)
{
  std::istringstream i(s);
  T x;
  char c;
  if (!(i >> x))
    throw Exception("Failed to convert \"" + s + "\" to " + typeid(T).name());
  if (i.get(c))
    throw Exception("Could not convert whole \"" + s + "\" to " + typeid(T).name());
  return x;
}
 
 
template <typename T>
std::string NRLib::ToString(const T obj, int precision)
{
  std::ostringstream o;
  if (precision!=-99999) {
    o << std::fixed << std::setprecision(precision);
  }
  if (!(o << obj)) {
    throw Exception("Bad conversion.");
  }
  return o.str();
}
 
 
template <typename I>
I NRLib::ParseAsciiArrayFast(std::string& s, I begin, size_t n)
{
  typedef typename std::iterator_traits<I>::value_type T;
  std::string whitespace = " \n\r\f\t";
 
  size_t pos = s.find_first_not_of(whitespace, 0);
  size_t next_pos = s.find_first_of(whitespace, pos+1);
  size_t i = 0;
  while (i < n && pos != s.npos) {
    if (next_pos != s.npos) {
      s[next_pos] = '\0';
    }
    *begin = NRLibPrivate::UnsafeParser<T>::ParseType(&s[pos]);
    ++begin;
    pos = s.find_first_not_of(whitespace, next_pos + 1);
    next_pos = s.find_first_of(whitespace, pos + 1);
    ++i;
  }
 
  if (i != n) {
    throw Exception("Not enough elements parsed from string.");
  }
 
  return begin;
}
 
 
#endif // NRLIB_STRINGTOOLS_HPP