property.h

#pragma once
 
// This is intended to replace Variant as a property container in constitutive models
//   in a way that makes more use of modern C++ (and is also less complex)
 
#include "basestring.h"
#include "mat.h"
#include "quat.h"
#include "vect.h"
#include <variant>
 
#ifdef INTELCOMP
#pragma  warning(disable:2586) // Disable warning about name length
#endif
 
namespace std {
    class any;
}
 
namespace base {
    using PropBase = std::variant<int64,   double,   bool,     string,      DVect2,
                                  DVect3,  I64Vect2, I64Vect3, itasca::Mat, DAVect2,
                                  DAVect3, Quat2,    Quat3,    SymTensor>;
 
    class Property : public PropBase {
    public:
        using PropBase::PropBase;
 
        enum class Type { Int,     Double,   Bool,     String, DVect2,
                          DVect3,  I64Vect2, I64Vect3, Matrix, DAVect2,
                          DAVect3, Quat2 ,   Quat3,    Tensor };
 
        Type type() const { return static_cast<Type>(index());  }
        BASE_EXPORT std::tuple<Type,UVect2> desc() const;
        BASE_EXPORT const Property &reset(); // Keep type but set value to default construction.
 
        // Returns TRUE if the type can be converted to the provided type.  Does minimal computation.
        // In theory we can add more type specializations (int, float, etc) based on existing.
        template <typename T>
        bool canConvert() const { static_assert(sizeof(T)==0);  return false; } // Default
        BASE_EXPORT bool canConvert(Type type) const; // Runtime type conversion query
 
        // Same as canConvert but takes a Type enum as a template argument.
        template <Type t>
        bool canConvertType() const { return canConvert<decltype(std::get<static_cast<int>(t)>(*this))>(); }
 
        // Converts to the type - throws exeption if not able to convert.
        template <typename T>
        T to() const { static_assert(sizeof(T)==0);  return false; } // DEFAULT
 
        // Save as to<>() but uses the Type enum as the template argument.
        template <Type t>
        auto toType() const { return to<decltype(std::get<static_cast<int>(t)>(*this))>(); }
 
        // Single call test, returns both value and success boolean.  Value is default init if
        //   success is false.
        template <typename T>
        typename std::tuple<T,bool> toTest() const;
 
        // Same as toTest<>() but using Type enum.
        template <Type t>
        typename std::variant_alternative_t<static_cast<int>(t),Property> toTestType() const;
 
        BASE_EXPORT static string nameFromType(Type t);
 
    };
 
    template <> BASE_EXPORT bool Property::canConvert<int64>() const;
    template <> BASE_EXPORT bool Property::canConvert<double>() const;
    template <> BASE_EXPORT bool Property::canConvert<bool>() const;
    template <> BASE_EXPORT bool Property::canConvert<string>() const;
    template <> BASE_EXPORT bool Property::canConvert<DVect2>() const;
    template <> BASE_EXPORT bool Property::canConvert<DVect3>() const;
    template <> BASE_EXPORT bool Property::canConvert<I64Vect2>() const;
    template <> BASE_EXPORT bool Property::canConvert<I64Vect3>() const;
    template <> BASE_EXPORT bool Property::canConvert<itasca::Mat>() const;
    template <> BASE_EXPORT bool Property::canConvert<DAVect2>() const;
    template <> BASE_EXPORT bool Property::canConvert<DAVect3>() const;
    template <> BASE_EXPORT bool Property::canConvert<Quat2>() const;
    template <> BASE_EXPORT bool Property::canConvert<Quat3>() const;
    template <> BASE_EXPORT bool Property::canConvert<SymTensor>() const;
 
    template <> BASE_EXPORT int64       Property::to<int64>() const;
    template <> BASE_EXPORT double      Property::to<double>() const;
    template <> BASE_EXPORT bool        Property::to<bool>() const;
    template <> BASE_EXPORT string      Property::to<string>() const;
    template <> BASE_EXPORT DVect2      Property::to<DVect2>() const;
    template <> BASE_EXPORT DVect3      Property::to<DVect3>() const;
    template <> BASE_EXPORT I64Vect2    Property::to<I64Vect2>() const;
    template <> BASE_EXPORT I64Vect3    Property::to<I64Vect3>() const;
    template <> BASE_EXPORT itasca::Mat Property::to<itasca::Mat>() const;
    template <> BASE_EXPORT DAVect2     Property::to<DAVect2>() const;
    template <> BASE_EXPORT DAVect3     Property::to<DAVect3>() const;
    template <> BASE_EXPORT Quat2       Property::to<Quat2>() const;
    template <> BASE_EXPORT Quat3       Property::to<Quat3>() const;
    template <> BASE_EXPORT SymTensor   Property::to<SymTensor>() const;
 
 
 
    template <typename T>
    typename std::tuple<T,bool> Property::toTest() const {
        bool b = canConvert<T>();
        if (b)
            return {to<T>(),b};
        return {T{},false};
    }
 
    template <Property::Type t>
    typename std::variant_alternative_t<static_cast<int>(t),Property> Property::toTestType() const {
        using target_type = decltype(std::get<static_cast<int>(t)>(*this));
        using return_type = std::tuple<target_type,bool>;
        bool b = canConvert<target_type>();
        if (b) return return_type(to<target_type>(),true);
        return return_type(target_type{},false);
    }
 
    //template <typename T>
    //T Property::to() const {
    //     auto [val,ok] = is<T>();
    //     if (ok==false)
    //         throw Exception("Unable to convert Property index {} to type {}.",index(),typeid(T).name());
    //     return val;
    //}
 
    // This allows using the Type enum as a selector in a get, so
    //      get<Property::Bool>(p);
    template <Property::Type t>
    const auto &get(const Property &v) { return std::get<static_cast<int>(t)>(v); }
 
    // String conversion, using the base::ts standard
    template <>
    BASE_EXPORT string ts<base::Property>(const base::Property &p, int width, char notation, int precision, char fill);
 
    // Description of a property type.  The information necessary to parse.
    struct PropDesc {
        PropDesc() { }
        PropDesc(const string &name,Property::Type type,UVect2 size) : name_(name), type_(type), size_(size) { }
        BASE_EXPORT PropDesc(const string &name,const Property &prop);
        string         name_;
        Property::Type type_ = Property::Type::Int;
        UVect2         size_ = UVect2(0);
        BASE_EXPORT bool operator<(const PropDesc &p) const;
    };
 
    BASE_EXPORT Property toProperty(const std::any &a);
    BASE_EXPORT std::any toAny(const Property &p);
} // namespace base
// EoF