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;
class AggregateValue;

using ValuePtr = shared_ptr<Value>;
using ConstValuePtr = shared_ptr<const Value>;

using AggregateValuePtr = shared_ptr<AggregateValue>;
using ConstAggregateValuePtr = shared_ptr<const AggregateValue>;
 
class TypeDef;
using ConstTypeDefPtr = shared_ptr<const TypeDef>;
 
template <class T> class TypedValue;

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, ConstTypeDefPtr typeDef = nullptr);

    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 AggregateValue : public Value
{
  public:
    AggregateValue(const string& typeName) :
        _typeName(typeName)
    {
    }
    virtual ~AggregateValue() { }

    ValuePtr copy() const override
    {
        auto result = createAggregateValue(_typeName);
        for (const auto& val : _data)
        {
            result->appendValue(val->copy());
        }
        return result;
    }

    void appendValue(ConstValuePtr valuePtr)
    {
        _data.emplace_back(valuePtr);
    }
 
    const vector<ConstValuePtr>& getMembers() const
    {
        return _data;
    }

    ConstValuePtr getMemberValue(size_t index) const
    {
        return _data[index];
    }

    const string& getTypeString() const override { return _typeName; }

    string getValueString() const override;
 
    //
    // Static helper methods
    //

    static AggregateValuePtr createAggregateValue(const string& typeName)
    {
        return std::make_shared<AggregateValue>(typeName);
    }
 
    static AggregateValuePtr createAggregateValueFromString(const string& value, const string& type, ConstTypeDefPtr typeDefPtr);
 
  private:
    const string _typeName;
 
    vector<ConstValuePtr> _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_API StringVec parseStructValueString(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