variantspec.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/variant.h>
#include <promeki/enum.h>
#include <promeki/list.h>
#include <promeki/string.h>
#include <promeki/uniqueptr.h>
#include <promeki/error.h>
#include <promeki/textstream.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class VariantSpec {
        public:
                using Type = DataTypeID;
 
                using TypeList = ::promeki::List<Type>;
 
                VariantSpec() = default;
 
                VariantSpec &setType(Type type) {
                        _types.clear();
                        _types.pushToBack(type);
                        return *this;
                }
 
                VariantSpec &setTypes(std::initializer_list<Type> types) {
                        _types.clear();
                        for (auto t : types) _types.pushToBack(t);
                        return *this;
                }
 
                VariantSpec &setDefault(const Variant &val) {
                        _default = val;
                        return *this;
                }
 
                VariantSpec &setRange(const Variant &min, const Variant &max) {
                        _min = min;
                        _max = max;
                        return *this;
                }
 
                VariantSpec &setMin(const Variant &min) {
                        _min = min;
                        return *this;
                }
 
                VariantSpec &setMax(const Variant &max) {
                        _max = max;
                        return *this;
                }
 
                VariantSpec &setEnumType(Enum::Type enumType) {
                        _enumType = enumType;
                        return *this;
                }
 
                VariantSpec &setDescription(const String &desc) {
                        _description = desc;
                        return *this;
                }
 
                VariantSpec &setElementSpec(const VariantSpec &spec);
 
                VariantSpec &setValueSpec(const VariantSpec &spec);
 
                const TypeList &types() const { return _types; }
 
                bool isPolymorphic() const { return _types.size() > 1; }
 
                bool acceptsType(Type type) const;
 
                const Variant &defaultValue() const { return _default; }
 
                bool hasMin() const { return _min.isValid(); }
 
                bool hasMax() const { return _max.isValid(); }
 
                bool hasRange() const { return _min.isValid() || _max.isValid(); }
 
                const Variant &rangeMin() const { return _min; }
 
                const Variant &rangeMax() const { return _max; }
 
                bool hasEnumType() const { return _enumType.isValid(); }
 
                Enum::Type enumType() const { return _enumType; }
 
                const String &description() const { return _description; }
 
                bool hasElementSpec() const { return _elementSpec.isValid(); }
 
                const VariantSpec *elementSpec() const;
 
                bool hasValueSpec() const { return _valueSpec.isValid(); }
 
                const VariantSpec *valueSpec() const;
 
                bool isValid() const { return !_types.isEmpty() || _default.isValid(); }
 
                bool validate(const Variant &value, Error *err = nullptr) const;
 
                // ============================================================
                // Formatting
                // ============================================================
 
                String typeName() const;
 
                String rangeString() const;
 
                String defaultString() const;
 
                // ============================================================
                // String parsing
                // ============================================================
 
                Variant coerce(const Variant &val, Error *err = nullptr) const;
 
                Variant parseString(const String &str, Error *err = nullptr) const;
 
                // ============================================================
                // Help output
                // ============================================================
 
                String detailsString() const;
 
                // ============================================================
                // Conversion
                // ============================================================
 
                operator Variant() const { return _default; }
 
                VariantSpec(const VariantSpec &other);
                VariantSpec(VariantSpec &&other) noexcept = default;
                VariantSpec &operator=(const VariantSpec &other);
                VariantSpec &operator=(VariantSpec &&other) noexcept = default;
                ~VariantSpec() = default;
 
        private:
                TypeList                _types;
                Variant                 _default;
                Variant                 _min;
                Variant                 _max;
                Enum::Type              _enumType;
                String                  _description;
                UniquePtr<VariantSpec>  _elementSpec; // for TypeVariantList
                UniquePtr<VariantSpec>  _valueSpec;   // for TypeVariantMap
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE