Value.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_VALUE_H
#define MATERIALX_VALUE_H
 
 
#include <MaterialXCore/Exception.h>
 
#include <MaterialXCore/Types.h>
#include <MaterialXCore/Util.h>
 
MATERIALX_NAMESPACE_BEGIN
 
using IntVec = vector<int>;
using BoolVec = vector<bool>;
using FloatVec = vector<float>;
 
class Value;
 
using ValuePtr = shared_ptr<Value>;
using ConstValuePtr = shared_ptr<const Value>;
 
template <class T> class TypedValue;
 
class MX_CORE_API ExceptionTypeError : public Exception
{
  public:
    using Exception::Exception;
};
 
class MX_CORE_API Value
{
  public:
    enum FloatFormat
    {
        FloatFormatDefault = 0,
        FloatFormatFixed = 1,
        FloatFormatScientific = 2
    };
 
  public:
    Value()
    {
    }
    virtual ~Value() { }
 
    template <class T> static ValuePtr createValue(const T& data)
    {
        return std::make_shared<TypedValue<T>>(data);
    }
 
    // Create a new value from a C-style string.
    static ValuePtr createValue(const char* data)
    {
        return createValue(data ? string(data) : EMPTY_STRING);
    }
 
    static ValuePtr createValueFromStrings(const string& value, const string& type);
 
    virtual ValuePtr copy() const = 0;
 
 
    template <class T> bool isA() const;
 
    template <class T> const T& asA() const;
 
    virtual const string& getTypeString() const = 0;
 
    virtual string getValueString() const = 0;
 
    static void setFloatFormat(FloatFormat format)
    {
        _floatFormat = format;
    }
 
    static void setFloatPrecision(int precision)
    {
        _floatPrecision = precision;
    }
 
    static FloatFormat getFloatFormat()
    {
        return _floatFormat;
    }
 
    static int getFloatPrecision()
    {
        return _floatPrecision;
    }
 
  protected:
    template <class T> friend class ValueRegistry;
 
    using CreatorFunction = ValuePtr (*)(const string&);
    using CreatorMap = std::unordered_map<string, CreatorFunction>;
 
  private:
    static CreatorMap _creatorMap;
    static FloatFormat _floatFormat;
    static int _floatPrecision;
};
 
template <class T> class MX_CORE_API TypedValue : public Value
{
  public:
    TypedValue() :
        _data{}
    {
    }
    explicit TypedValue(const T& value) :
        _data(value)
    {
    }
    virtual ~TypedValue() { }
 
    ValuePtr copy() const override
    {
        return Value::createValue<T>(_data);
    }
 
    void setData(const T& value)
    {
        _data = value;
    }
 
    void setData(const TypedValue<T>& value)
    {
        _data = value._data;
    }
 
    const T& getData() const
    {
        return _data;
    }
 
    const string& getTypeString() const override;
 
    string getValueString() const override;
 
    //
    // Static helper methods
    //
 
    static ValuePtr createFromString(const string& value);
 
  public:
    static const string TYPE;
 
  private:
    T _data;
};
 
class MX_CORE_API ScopedFloatFormatting
{
  public:
    explicit ScopedFloatFormatting(Value::FloatFormat format, int precision = -1);
    ~ScopedFloatFormatting();
 
  private:
    Value::FloatFormat _format;
    int _precision;
};
 
template <class T> MX_CORE_API const string& getTypeString();
 
template <class T> MX_CORE_API string toValueString(const T& data);
 
template <class T> MX_CORE_API T fromValueString(const string& value);
 
MX_CORE_EXTERN_TEMPLATE(TypedValue<int>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<bool>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<float>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Color3>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Color4>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Vector2>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Vector3>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Vector4>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Matrix33>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<Matrix44>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<string>);
 
MX_CORE_EXTERN_TEMPLATE(TypedValue<IntVec>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<BoolVec>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<FloatVec>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<StringVec>);
 
MX_CORE_EXTERN_TEMPLATE(TypedValue<long>);
MX_CORE_EXTERN_TEMPLATE(TypedValue<double>);
 
MATERIALX_NAMESPACE_END
 
#endif