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>
#include <vector>
 
#ifdef INTELCOMP
#pragma  warning(disable:2586) // Disable warning about name length
#endif
 
namespace std {
    class any;
}
 
namespace base {
    class Property;
 
    class PropArray : public std::vector<Property> {
    public:
        using std::vector<Property>::vector;
    };
 
    BASE_EXPORT UVect2 size(const PropArray &p);
    template <> string ts(const PropArray &p, int width, char notation, int precision, char fill);
 
    using PropBase = std::variant<int64,   double,   bool,     string,      DVect2,
                                  DVect3,  I64Vect2, I64Vect3, itasca::Mat, DAVect2,
                                  DAVect3, Quat2,    Quat3,    SymTensor,   std::nullptr_t,
                                  PropArray>;
 
    namespace PropertyConcepts {
        // These are used to allow Property Contructors without the peril of directly using
        //   the variant (PropBase) constructors, which have problems with implicit conversions.
        // I specifically allow integer implicit conversion, despite my qualms about that 
        //   in general, because for now we have to accept is a C++ standard....
        template <class T, class V>
        concept IsIn = requires { 
            std::holds_alternative<T>(std::declval<V>()); 
        };
        template <class T>
        concept IntNoBool = std::integral<T> and (not std::same_as<T, bool>);
        template <class T>
        concept NonInt = IsIn<T, PropBase> and (not IntNoBool<T>);
    }
 
    class Property : public PropBase {
    public:
        using PropBase::PropBase; // TODO: JBC: It is unsafe to inherit parent constructors from
                                  //            std::variant. Implicit class conversion is possible
                                  //            and results in unpredictable behavior, e.g.,
                                  //            Property::setValue(uint64) will create a Quat2 !!!
 
        enum class Type { Int,     Double,   Bool,     String, DVect2,
                          DVect3,  I64Vect2, I64Vect3, Matrix, DAVect2,
                          DAVect3, Quat2 ,   Quat3,    Tensor, Null,
                          Array };
 
        Property(): PropBase(nullptr) {}
        template <class T> requires PropertyConcepts::NonInt<T> Property(const T &t) : PropBase(t) { }  
        template <class T> requires PropertyConcepts::IntNoBool<T> Property(const T &t) : PropBase(::to<int64>(t)) { }
        BASE_EXPORT std::partial_ordering operator<=>(const Property &p) const;
        template <class T> requires PropertyConcepts::NonInt<T> Property &operator=(const T &t) { PropBase::operator=(t);  return *this; }
        template <class T> requires PropertyConcepts::IntNoBool<T> Property &operator=(const T &t) { PropBase::operator=(::to<int64>(t));  return *this; }
 
        inline Type type() const;
        BASE_EXPORT std::tuple<Type,UVect2> desc() const;
        BASE_EXPORT const Property &reset(); // Keep type but set value to default construction.
        inline bool isNull() const { return type()==Type::Null; }
        inline bool isValid() const { return not isNull(); }
 
        // 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
 
        template <typename T>
        bool canConvertVec() const;
 
        // 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
        template <typename T>
        std::vector<T> toVec() const;
 
        // 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;
 
        template <typename T>
        void setValue(const T &t) { *this = t; }
        template <typename T>
        void setVec(const std::vector<T> &v);
 
        template <typename T>
        T value() const { return to<T>(); }
 
        BASE_EXPORT static string nameFromType(Type t);
        inline double toDouble() const;
        inline string toString() const;
        inline int64  toInt() const;
        inline uint32 toUInt() const;
        inline double toDouble(bool *ok) const;
        inline int64  toInt(bool *ok) const;
 
        static constexpr Type DVectType(uint32 dim) { return dim==2 ? Type::DVect2 : Type::DVect3; }
        static constexpr Type DAVectType(uint32 dim) { return dim==2 ? Type::DAVect2 : Type::DAVect3; }
        static constexpr Type IVectType(uint32 dim) { return dim==2 ? Type::I64Vect2 : Type::I64Vect3; }
    };
 
    Property::Type Property::type() const { 
        return static_cast<Type>(index());  
    }
 
    constexpr auto operator<=>(const base::PropArray &lhs,const base::PropArray &rhs) { 
        auto &vl = static_cast<const std::vector<base::Property> &>(lhs);
        auto &vr = static_cast<const std::vector<base::Property> &>(rhs);
        return vl <=> vr;
    }
 
    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 bool Property::canConvert<PropArray>() 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 <> BASE_EXPORT PropArray   Property::to<PropArray>() const;
 
    class PropertyConvertException : public Exception {
    public:
        PropertyConvertException(Property::Type from,Property::Type to) :
            Exception("Error converting Property from {} to {}.",
                Property::nameFromType(from),Property::nameFromType(to)) {
        }
    };
 
    template <typename T>
    void Property::setVec(const std::vector<T> &v) {
        PropArray pa;
        Type t{};
        for (size_t i=0;i<v.size();++i) {
            pa.push_back({});
            pa.back().setValue(v[i]);
            if (not i) t = pa.back().type();
            else if (t!=pa.back().type()) throw Exception("All elements of a property array must be of the same type.");
        }
        operator=(pa);
    }
 
    double Property::toDouble() const { return to<double>(); }
    string Property::toString() const { return to<string>(); }
    int64  Property::toInt() const { return to<int64>();}
    uint32 Property::toUInt() const { return static_cast<uint32>(to<int64>()); }
 
    double Property::toDouble(bool *ok) const { 
        *ok = canConvert<double>(); 
        if (*ok) return to<double>();  
        return 0.0; 
    }
 
    int64  Property::toInt(bool *ok) const { 
        *ok = canConvert<int64>();  
        if (*ok) return to<int64>();  
        return 0; 
    }
 
    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>
    bool Property::canConvertVec() const {
        if (type()!=Type::Array) return false;
        auto &a = std::get<PropArray>(*this);
        if (not a.size()) return true;
        return a[0].canConvert<T>();
    }
 
    template <typename T>
    std::vector<T> Property::toVec() const {
        if (type()!=Type::Array) throw PropertyConvertException(type(),Type::Array);
        auto &a = std::get<PropArray>(*this);
        if (not a.size()) return {};
        std::vector<T> ret;
        for (auto &v : a)
            ret.push_back(v.to<T>());
        return ret;
    }
 
    // 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);
        auto operator<=>(const PropDesc &p) const = default;
    };
 
    BASE_EXPORT Property toProperty(const std::any &a);
    BASE_EXPORT std::any toAny(const Property &p);
 
} // namespace base
 
// This allows you to send Properties to a std::format
template <>
struct std::formatter<base::Property> : public std::formatter<string> {
    template <typename ParseContext>
    constexpr auto parse(ParseContext &ctx) { return std::formatter<string>::parse(ctx); }
 
    template <typename FormatContext>
    constexpr auto format(base::Property const &val, FormatContext &ctx) const {
        return std::formatter<string>::format(val.to<string>(), ctx);
    }
};
 
// EoF