mlVariant.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2011, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_VARIANT_H
#define ML_VARIANT_H
 
 
 
#include "mlVariantSystem.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <string>
#include <ThirdPartyWarningsRestore.h>
#include <mlVector2.h>
#include <mlVector3.h>
#include <mlVector4.h>
#include <mlVector6.h>
#include <mlMatrix3.h>
#include <mlMatrix4.h>
 
ML_UTILS_START_NAMESPACE
 
class MLVARIANT_EXPORT Variant
{
public:
  enum Type {Invalid, Bool, String,
             Int, UInt, Int64, UInt64, Float, Double,
             Vec2, Vec3, Vec4, Vec6, Mat3, Mat4,
             FilePath, PngImageData, JpgImageData,
             TypeCount
  };
 
  Variant();
  ~Variant();
  Variant(const Variant& value);
  Variant(const std::string& value);
  Variant(Type type, const std::string& value); 
  Variant(bool value);
  Variant(MLint32 value);
  Variant(MLuint32 value);
  Variant(MLint64 value);
  Variant(MLuint64 value);
  Variant(MLfloat value);
  Variant(MLdouble value);
  Variant(const Vector2& value);
  Variant(const Vector3& value);
  Variant(const Vector4& value);
  Variant(const Vector6& value);
  Variant(const Matrix3& value);
  Variant(const Matrix4& value);
 
  Variant(Type type, const void* valuePtr);
 
  Type type() const { return _type; }
 
  bool isValid() const { return _type != Invalid; }
 
  bool canConvert(Type t) const;
 
  template<typename T>
  const T& asType() const { return *static_cast<T*>(_data); }
 
  void clear();
 
  std::string toString() const;
  bool toBool() const;
  MLint32 toInt(bool* ok = nullptr) const;
  MLuint32 toUInt(bool* ok = nullptr) const;
  MLint64 toInt64(bool* ok = nullptr) const;
  MLuint64 toUInt64(bool* ok = nullptr) const;
  MLfloat toFloat(bool* ok = nullptr) const;
  MLdouble toDouble(bool* ok = nullptr) const;
  Vector2 toVec2(bool* ok = nullptr) const;
  Vector3 toVec3(bool* ok = nullptr) const;
  Vector4 toVec4(bool* ok = nullptr) const;
  Vector6 toVec6(bool* ok = nullptr) const;
  Matrix3 toMat3(bool* ok = nullptr) const;
  Matrix4 toMat4(bool* ok = nullptr) const;
 
  Variant& operator= (const Variant& v);
  bool operator== (const Variant& v) const;
  bool operator!= (const Variant& v) const;
 
  std::ostream& write(std::ostream& out, bool asBinary, bool writeType = true) const;
  std::istream& read(std::istream& in, bool asBinary);
 
 
  static std::ostream& writeEscapedString(std::ostream& out, const std::string& s);
  static std::string readEscapedString(std::istream& in);
 
  template<typename T>
  static void writeValue(std::ostream& out, const T& value, bool binary, bool last = true);
  template<typename T>
  static void readValue(std::istream& in, T& value, bool binary, bool last = true);
 
  template<typename T>
  static void writeValueAsText(std::ostream& out, const T& value);
 
  static MLuint32 getCodeForType(Type t);
  static Type getTypeForCode(MLuint32);
 
private:
  void copyValue(Type type, const void* valuePtr);
 
  template<typename T>
  void copyValueTyped(const void* valuePtr) { _data = new T(*(static_cast<const T*>(valuePtr))); }
 
  template<typename T>
  void clearValueTyped() { delete static_cast<T*>(_data); }
 
  template<typename T>
  T asNumericType(bool* ok) const;
 
  static MLuint32 _typeCodes[];
 
  Type _type;
 
  void* _data;
};
 
 
template<typename T>
inline void Variant::writeValueAsText(std::ostream& out, const T& value)
{
  out << value;
}
 
template<>
inline void Variant::writeValueAsText<float>(std::ostream& out, const float& value)
{
  // set sufficient precision
  std::streamsize oldPrecision = out.precision(8);
  out << value;
  out.precision(oldPrecision);
}
 
template<>
inline void Variant::writeValueAsText<double>(std::ostream& out, const double& value)
{
  // set sufficient precision
  std::streamsize oldPrecision = out.precision(16);
  out << value;
  out.precision(oldPrecision);
}
 
template<typename T>
void Variant::writeValue(std::ostream& out, const T& value, bool binary, bool last)
{
  if (binary) {
    out.write(reinterpret_cast<const char*>(&value), sizeof(T));
  } else {
    writeValueAsText (out, value);
    if (!last) {
      out << ",";
    }
  }
}
 
template<typename T>
void Variant::readValue(std::istream& in, T& value, bool binary, bool last)
{
  if (binary) {
    in.read(reinterpret_cast<char*>(&value), sizeof(T));
  } else if (last) {
    in >> value;
  } else {
    std::string component;
    std::getline(in, component, ',');
    std::stringstream strstream;
    strstream << component;
    strstream >> value;
  }
}
 
 
ML_UTILS_END_NAMESPACE
 
 
inline std::ostream& operator<<(std::ostream& out, const ML_UTILS_NAMESPACE::Variant& variant)
{
  return variant.write(out, /*asBinary=*/false);
}
 
inline std::istream& operator>>(std::istream& in, ML_UTILS_NAMESPACE::Variant& variant)
{
  return variant.read(in, /*asBinary=*/false);
}
 
 
 
#endif // __mlVariant_H