MeVisLab/Standard/Sources/Shared/MLVariant/mlVariant.h

Go to the documentation of this file.

// **InsertLicense** code
//===========================================================================

//===========================================================================

#ifndef __mlVariant_H
#define __mlVariant_H

#include "mlVariantSystem.h"

#include <string>
#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(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 = 0) const;
  MLuint32 toUInt(bool* ok = 0) const;
  MLint64 toInt64(bool* ok = 0) const;
  MLuint64 toUInt64(bool* ok = 0) const;
  MLfloat toFloat(bool* ok = 0) const;
  MLdouble toDouble(bool* ok = 0) const;
  Vector2 toVec2(bool* ok = 0) const;
  Vector3 toVec3(bool* ok = 0) const;
  Vector4 toVec4(bool* ok = 0) const;
  Vector6 toVec6(bool* ok = 0) const;
  Matrix3 toMat3(bool* ok = 0) const;
  Matrix4 toMat4(bool* ok = 0) 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