buffet: GCD command defintion. Compound object type support.
Added support for "object" type. Refactored parameter validation
to make sure we have object schema context when we validate
a value of parameter.
Parameter |schema| was used in two different contexts, as both
a base parameter definition and as a custom object definition.
Renamed the former to be 'base_schema' and latter as
'object_schema' to remove the confusion.
Extracted common data type manipulation functions into
schema_utils.cc/.h files.
BUG=chromium:374860
TEST=All unit tests pass.
Change-Id: I6c3549849a258bcc94b3d754acd14e072438d140
Reviewed-on: https://chromium-review.googlesource.com/204793
Tested-by: Alex Vakulenko <avakulenko@chromium.org>
Reviewed-by: Christopher Wiley <wiley@chromium.org>
Commit-Queue: Alex Vakulenko <avakulenko@chromium.org>
diff --git a/buffet/commands/prop_values.h b/buffet/commands/prop_values.h
index e03d39b..adaa91d 100644
--- a/buffet/commands/prop_values.h
+++ b/buffet/commands/prop_values.h
@@ -9,7 +9,8 @@
#include <memory>
#include <string>
-#include "buffet/commands/prop_constraints.h"
+#include "buffet/any.h"
+#include "buffet/commands/schema_utils.h"
#include "buffet/error.h"
namespace base {
@@ -24,38 +25,52 @@
Int,
Double,
String,
- Boolean
+ Boolean,
+ Object
};
+class PropValue;
+class IntValue;
+class DoubleValue;
+class StringValue;
+class BooleanValue;
+class ObjectValue;
+
+class PropType;
+
// Helper methods to get the parameter type enum value for the given
// native C++ data representation.
// The generic GetValueType<T>() is undefined, however particular
// type specializations return the appropriate ValueType.
template<typename T> ValueType GetValueType(); // Undefined.
-template<> ValueType GetValueType<int>();
-template<> ValueType GetValueType<double>();
-template<> ValueType GetValueType<std::string>();
-template<> ValueType GetValueType<bool>();
+template<>
+inline ValueType GetValueType<int>() { return ValueType::Int; }
+template<>
+inline ValueType GetValueType<double>() { return ValueType::Double; }
+template<>
+inline ValueType GetValueType<std::string>() { return ValueType::String; }
+template<>
+inline ValueType GetValueType<bool>() { return ValueType::Boolean; }
+template<>
+inline ValueType GetValueType<native_types::Object>() {
+ return ValueType::Object;
+}
-class ObjectSchema;
-
-class PropValue;
-class IntPropType;
-class DoublePropType;
-class StringPropType;
-class BooleanPropType;
-
-class IntValue;
-class DoubleValue;
-class StringValue;
-class BooleanValue;
-
-// The base class for parameter values.
+// The base class for property values.
// Concrete value classes of various types will be derived from this base.
+// A property value is the actual command parameter value (or a concrete value
+// that can be used in constraints and presets). The PropValue is mostly
+// just parsed content of base::Value when a command is dispatched, however
+// it does have some additional functionality:
+// - it has a reference to the type definition (PropType) which is used
+// when validating the value, especially for "object" types.
+// - it can be compared with another instances of values of the same type.
+// This is used to validate the values against "enum"/"one of" constraints.
class PropValue {
public:
- PropValue() = default;
- virtual ~PropValue();
+ explicit PropValue(const PropType* type)
+ : type_(type) {}
+ virtual ~PropValue() = default;
// Gets the type of the value.
virtual ValueType GetType() const = 0;
@@ -69,6 +84,8 @@
virtual StringValue const* GetString() const { return nullptr; }
virtual BooleanValue* GetBoolean() { return nullptr; }
virtual BooleanValue const* GetBoolean() const { return nullptr; }
+ virtual ObjectValue* GetObject() { return nullptr; }
+ virtual ObjectValue const* GetObject() const { return nullptr; }
// Makes a full copy of this value class.
virtual std::shared_ptr<PropValue> Clone() const = 0;
@@ -80,7 +97,19 @@
// Parses a value from JSON.
// If it fails, it returns false and provides additional information
// via the |error| parameter.
- virtual bool FromJson(const base::Value* value, ErrorPtr* error) = 0;
+ virtual bool FromJson(const base::Value* value,
+ ErrorPtr* error) = 0;
+
+ // Returns the contained C++ value as Any.
+ virtual Any GetValueAsAny() const = 0;
+
+ // Return the type definition of this value.
+ const PropType* GetPropType() const { return type_; }
+ // Compares two values and returns true if they are equal.
+ virtual bool IsEqual(const PropValue* value) const = 0;
+
+ protected:
+ const PropType* type_; // weak pointer
};
// A helper template base class for implementing simple (non-Object) value
@@ -88,6 +117,12 @@
template<typename Derived, typename T>
class TypedValueBase : public PropValue {
public:
+ // To help refer to this base class from derived classes, define _Base to
+ // be this class.
+ using _Base = TypedValueBase<Derived, T>;
+ // Expose the non-default constructor of the base class.
+ using PropValue::PropValue;
+
// Overrides from PropValue base class.
virtual ValueType GetType() const override { return GetValueType<T>(); }
virtual std::shared_ptr<PropValue> Clone() const override {
@@ -95,15 +130,24 @@
}
virtual std::unique_ptr<base::Value> ToJson(ErrorPtr* error) const override {
- (void)error; // unused.
- return TypedValueToJson(value_);
+ return TypedValueToJson(value_, error);
}
- virtual bool FromJson(const base::Value* value, ErrorPtr* error) override {
- return TypedValueFromJson(value, &value_, error);
+ virtual bool FromJson(const base::Value* value,
+ ErrorPtr* error) override {
+ return TypedValueFromJson(value, GetPropType()->GetObjectSchemaPtr(),
+ &value_, error);
}
- // Helper method to get and set the C++ representation of the value.
+ virtual bool IsEqual(const PropValue* value) const override {
+ if (GetType() != value->GetType())
+ return false;
+ const _Base* value_base = static_cast<const _Base*>(value);
+ return CompareValue(GetValue(), value_base->GetValue());
+ }
+
+ // Helper methods to get and set the C++ representation of the value.
+ virtual Any GetValueAsAny() const override { return value_; }
const T& GetValue() const { return value_; }
void SetValue(T value) { value_ = std::move(value); }
@@ -114,6 +158,7 @@
// Value of type Integer.
class IntValue final : public TypedValueBase<IntValue, int> {
public:
+ using _Base::_Base; // Expose the custom constructor of the base class.
virtual IntValue* GetInt() override { return this; }
virtual IntValue const* GetInt() const override { return this; }
};
@@ -121,6 +166,7 @@
// Value of type Number.
class DoubleValue final : public TypedValueBase<DoubleValue, double> {
public:
+ using _Base::_Base; // Expose the custom constructor of the base class.
virtual DoubleValue* GetDouble() override { return this; }
virtual DoubleValue const* GetDouble() const override { return this; }
};
@@ -128,6 +174,7 @@
// Value of type String.
class StringValue final : public TypedValueBase<StringValue, std::string> {
public:
+ using _Base::_Base; // Expose the custom constructor of the base class.
virtual StringValue* GetString() override { return this; }
virtual StringValue const* GetString() const override { return this; }
};
@@ -135,10 +182,19 @@
// Value of type Boolean.
class BooleanValue final : public TypedValueBase<BooleanValue, bool> {
public:
+ using _Base::_Base; // Expose the custom constructor of the base class.
virtual BooleanValue* GetBoolean() override { return this; }
virtual BooleanValue const* GetBoolean() const override { return this; }
};
+// Value of type Object.
+class ObjectValue final : public TypedValueBase<ObjectValue,
+ native_types::Object> {
+ public:
+ using _Base::_Base; // Expose the custom constructor of the base class.
+ virtual ObjectValue* GetObject() override { return this; }
+ virtual ObjectValue const* GetObject() const override { return this; }
+};
} // namespace buffet
#endif // BUFFET_COMMANDS_PROP_VALUES_H_
