serialize.h

Go to the documentation of this file.

#ifndef ION_BASE_SERIALIZE_H_
#define ION_BASE_SERIALIZE_H_

#include <sstream>
#include <string>
#include <utility>

#include "ion/base/stringutils.h"

namespace ion {
namespace base {





template <typename T>
inline bool StringToValue(std::istringstream& in, T* val) {  // NOLINT
  T value;
  in >> value;
  if (!in.fail()) {
    *val = value;
    return true;
  } else {
    return false;
  }
}

template <>
inline bool StringToValue(std::istringstream& in, bool* val) {  // NOLINT
  std::string value;
  in >> value;
  if (!in.fail() && (value == "true" || value == "false")) {
    *val = value == "true";
    return true;
  } else {
    return false;
  }
}

template <typename T, typename U, typename V>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          std::basic_string<T, U, V>* val) {
  std::string v;
  bool done = false;
  bool escaping = false;
  if (GetExpectedChar<'"'>(in)) {
    char c = 0;
    do {
      c = static_cast<char>(in.get());
      done = !escaping && c == '"';
      escaping = !escaping && c == '\\';
      if (!done && !escaping)
        v.push_back(c);
    } while (!in.fail() && !done);
  }
  if (!in.fail() && done) {
    *val = v;
    return true;
  } else {
    return false;
  }
}

template <typename T, typename U>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          std::pair<const T, U>* val) {
  T key;
  U value;
  if (StringToValue(in, &key) && GetExpectedChar<':'>(in) &&
      StringToValue(in, &value)) {
    *const_cast<T*>(&val->first) = key;
    val->second = value;
    return true;
  } else {
    return false;
  }
}

template <typename ContainerType>
inline bool StringToStlContainer(std::istringstream& in,  // NOLINT
                                 ContainerType* val) {
  if (GetExpectedChar<'{'>(in)) {
    ContainerType v;
    while (!in.fail()) {
      typename ContainerType::value_type value;
      if (StringToValue(in, &value)) {
        v.insert(v.end(), value);
      } else {
        in.setstate(std::ios_base::failbit);
        break;
      }
      if (GetExpectedChar<'}'>(in)) {
        *val = v;
        break;
      } else {
        in.clear();
        if (!GetExpectedChar<','>(in))
          break;
      }
    }
  }
  return !in.fail();
}

template <typename T, typename U, typename V, typename W, typename X, bool B,
          template <class, class, class, class, class, bool>
          class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          ContainerType<T, U, V, W, X, B>* val) {
  return StringToStlContainer(in, val);
}

template <typename T, typename U, typename V, typename W, typename X,
          template <class, class, class, class, class> class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                ContainerType<T, U, V, W, X>* val) {
  return StringToStlContainer(in, val);
}

template <typename T, typename U, typename V, typename W, bool B,
          template <class, class, class, class, bool> class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          ContainerType<T, U, V, W, B>* val) {
  return StringToStlContainer(in, val);
}

template <typename T, typename U, typename V, typename W,
          template <class, class, class, class> class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          ContainerType<T, U, V, W>* val) {
  return StringToStlContainer(in, val);
}

template <typename T, typename U, typename V,
          template <class, class, class> class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          ContainerType<T, U, V>* val) {
  return StringToStlContainer(in, val);
}

template <typename T, typename U, template <class, class> class ContainerType>
inline bool StringToValue(std::istringstream& in,  // NOLINT
                          ContainerType<T, U>* val) {
  return StringToStlContainer(in, val);
}

template <typename T>
inline bool StringToValue(const std::string& s, T* val) {
  std::istringstream in(s);
  return StringToValue(in, val);
}




template <typename T>
inline std::string ValueToString(const T& val) {
  std::ostringstream out;
  out << val;
  return out.str();
}

template <>
inline std::string ValueToString(const bool& val) {
  std::ostringstream out;
  out << (val ? "true" : "false");
  return out.str();
}

template <>
inline std::string ValueToString(const float& val) {
  std::ostringstream out;
  out.precision(6);
  out << val;
  return out.str();
}
template <>
inline std::string ValueToString(const double& val) {
  std::ostringstream out;
  out.precision(12);
  out << val;
  return out.str();
}

template <typename T, typename U, typename V>
inline std::string ValueToString(const std::basic_string<T, U, V>& val) {
  std::ostringstream out;
  out << '"' << EscapeString(val) << '"';
  return out.str();
}

template <>
inline std::string ValueToString(const char* const& val) {
  return ValueToString(std::string(val));
}

template <typename T, typename U>
inline std::string ValueToString(const std::pair<const T, U>& val) {
  std::ostringstream out;
  out << ValueToString(val.first) << " : " << ValueToString(val.second);
  return out.str();
}

template <typename ContainerType>
inline std::string StlContainerToString(const ContainerType& c) {
  std::ostringstream out;
  out << "{ ";
  for (typename ContainerType::const_iterator it = c.begin(); it != c.end();
       ++it) {
    if (it != c.begin())
      out << ", ";
    out << ValueToString(*it);
  }
  out << " }";
  return out.str();
}

template <typename T, typename U, typename V, typename W, typename X, bool B,
          template <class, class, class, class, class, bool>
          class ContainerType>
inline std::string ValueToString(
    const ContainerType<T, U, V, W, X, B>& val) {
  return StlContainerToString(val);
}

template <typename T, typename U, typename V, typename W, typename X,
          template <class, class, class, class, class>
          class ContainerType>
inline std::string ValueToString(
    const ContainerType<T, U, V, W, X>& val) {
  return StlContainerToString(val);
}

template <typename T, typename U, typename V, typename W, bool B,
          template <class, class, class, class, bool> class ContainerType>
inline std::string ValueToString(
    const ContainerType<T, U, V, W, B>& val) {
  return StlContainerToString(val);
}

template <typename T, typename U, typename V, typename W,
          template <class, class, class, class> class ContainerType>
inline std::string ValueToString(
    const ContainerType<T, U, V, W>& val) {
  return StlContainerToString(val);
}

template <typename T, typename U, typename V,
          template <class, class, class> class ContainerType>
inline std::string ValueToString(const ContainerType<T, U, V>& val) {
  return StlContainerToString(val);
}

template <typename T, typename U, template <class, class> class ContainerType>
inline std::string ValueToString(const ContainerType<T, U>& val) {
  return StlContainerToString(val);
}

}  // namespace base
}  // namespace ion

#endif  // ION_BASE_SERIALIZE_H_