String.h

Go to the documentation of this file.

#ifndef _utl_String_h_
#define _utl_String_h_

#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/tokenizer.hpp>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <type_traits>


namespace utl {

  template<typename T, typename U>
  inline
  T
  As(const U& x)
  {
    return boost::lexical_cast<T>(x);
  }


  template<typename T>
  inline
  std::string
  AsHex(const T& x, const unsigned int width = 2*sizeof(T))
  {
    std::ostringstream oss;
    oss << "0x" << std::setfill('0') << std::setw(width) << std::hex << x;
    return oss.str();
  }


  template<typename T>
  inline
  std::string
  AsBinary(const T& x, const unsigned int bitWidth = 8*sizeof(T))
  {
    std::ostringstream oss;
    oss << "0b";
    for (int i = bitWidth-1; i >= 0; --i)
       oss << ((x >> i) & 1);
    return oss.str();
  }


  template<class S, class V>
  std::string
  Join(const S& sep, const V& v)
  {
    std::ostringstream oss;
    if (!v.empty()) {
      auto it = v.begin();
      oss << *it++;
      for (const auto end = v.end(); it != end; ++it)
        oss << sep << *it;
    }
    return oss.str();
  }


  namespace String {

    template<class T>
    inline
    std::vector<T>
    AsVectorOf(const std::string& str)
    {
      std::istringstream iss(str);
      return std::vector<T>(std::istream_iterator<T>(iss), std::istream_iterator<T>());
    }


    inline
    std::string
    Strip(std::string str)
    {
      boost::algorithm::trim(str);
      return str;
    }


    std::vector<std::string> Split(const std::string& str, const char* const separators = " ");


    std::string OfSortedIds(std::vector<int> ids);


    std::string OfSortedIds(const std::set<int>& ids);


    template<typename T, typename = typename std::enable_if<std::is_integral<T>::value, T>::type>
    inline const char* Plural(const T n)
    { return (n > 1) ? "s" : ""; }


    template<class Container, typename T = typename Container::value_type>
    inline const char* Plural(const Container& c)
    { return (c.size() > 1) ? "s" : ""; }


    template<typename Map>
    inline
    std::string
    OfMapKeys(const Map& m,
              const std::string& quote = "'",
              const std::string& separator = ", ")
    {
      std::ostringstream os;
      auto it = m.begin();
      const auto end = m.end();
      if (it != end) {
        os << quote << it->first << quote;
        for (++it; it != end; ++it)
          os << separator << quote << it->first << quote;
      }
      return os.str();
    }


    template<typename T>
    std::string
    AsBinary(const T& number, const int maxBits = 8*sizeof(T),
             const char separator = ' ', const int stride = 4)
    {
      std::ostringstream os;
      int bit = std::min(maxBits, int(8*sizeof(T)));
      if (bit) {
        T mask = (T(1) << --bit);
        os << bool(number & mask);
        for (--bit; bit >= 0; --bit) {
          mask >>= 1;
          if (!((bit+1) % stride))
            os << separator;
          os << bool(number & mask);
        }
      }
      return os.str();
    }


    template<typename T>
    std::pair<double, char>
    AsHumanReadable(const T& x, const int thousand = 1000)
    {
      char m;
      const double lnt = std::log(thousand);
      const double r = std::log(x) / lnt;
      const int i = floor(r);
      switch (i) {
      case 8: m = 'Y'; break;
      case 7: m = 'Z'; break;
      case 6: m = 'E'; break;
      case 5: m = 'P'; break;
      case 4: m = 'T'; break;
      case 3: m = 'G'; break;
      case 2: m = 'M'; break;
      case 1: m = 'k'; break;
      case 0: m = '\0'; break;
      case -1: m = 'm'; break;
      case -2: m = 'u'; break;
      case -3: m = 'n'; break;
      case -4: m = 'p'; break;
      case -5: m = 'f'; break;
      case -6: m = 'a'; break;
      case -7: m = 'z'; break;
      case -8: m = 'y'; break;
      default: m = '?'; break;
      }
      const double rem = std::exp(lnt * (r - i));
      return std::make_pair(rem, m);
    }


    template<typename Geo, typename CS>
    inline
    std::string
    Make(const Geo& g, const CS& cs, const double unit = 1, const std::string& sep = " ")
    {
      const auto& x = g.GetCoordinates(cs);
      std::ostringstream os;
      os << x.template get<0>()/unit << sep << x.template get<1>()/unit << sep << x.template get<2>();
      return os.str();
    }

  }

}


#endif