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