1 files changed, 69 insertions, 4 deletions

diff --git a/src/components/policy/policy_regular/src/policy_table/types.cc b/src/components/policy/policy_regular/src/policy_table/types.cc
index 017a7e75cb..d3473bb2a7 100644
--- a/src/components/policy/policy_regular/src/policy_table/types.cc
+++ b/src/components/policy/policy_regular/src/policy_table/types.cc
@@ -1,5 +1,8 @@
 // This file is generated, do not edit
 #include "policy/policy_table/types.h"
+
+#include <regex>
+
 #include "rpc_base/rpc_base_json_inl.h"
 
 namespace rpc {
@@ -1676,6 +1679,7 @@ VehicleDataItem::VehicleDataItem(const VehicleDataItem& vehicle_data)
     , until(vehicle_data.until)
     , removed(vehicle_data.removed)
     , deprecated(vehicle_data.deprecated)
+    , defvalue(vehicle_data.defvalue)
     , minvalue(vehicle_data.minvalue)
     , maxvalue(vehicle_data.maxvalue)
     , minsize(vehicle_data.minsize)
@@ -1695,12 +1699,17 @@ VehicleDataItem::VehicleDataItem(const Json::Value* value__)
     , until(impl::ValueMember(value__, "until"))
     , removed(impl::ValueMember(value__, "removed"))
     , deprecated(impl::ValueMember(value__, "deprecated"))
+    , defvalue(static_cast<Json::Value*>(nullptr))
     , minvalue(impl::ValueMember(value__, "minvalue"))
     , maxvalue(impl::ValueMember(value__, "maxvalue"))
     , minsize(impl::ValueMember(value__, "minsize"))
     , maxsize(impl::ValueMember(value__, "maxsize"))
     , minlength(impl::ValueMember(value__, "minlength"))
-    , maxlength(impl::ValueMember(value__, "maxlength")) {}
+    , maxlength(impl::ValueMember(value__, "maxlength")) {
+  if (value__->isMember("defvalue")) {
+    *defvalue = impl::ValueMember(value__, "defvalue")->asString();
+  }
+}
 
 VehicleDataItem::~VehicleDataItem() {}
 
@@ -1726,6 +1735,7 @@ Json::Value VehicleDataItem::ToJsonValue() const {
   impl::WriteJsonField("until", until, &ret);
   impl::WriteJsonField("removed", removed, &ret);
   impl::WriteJsonField("deprecated", deprecated, &ret);
+  impl::WriteJsonField("defvalue", defvalue, &ret);
   impl::WriteJsonField("minvalue", minvalue, &ret);
   impl::WriteJsonField("maxvalue", maxvalue, &ret);
   impl::WriteJsonField("minsize", minsize, &ret);
@@ -1740,9 +1750,10 @@ bool VehicleDataItem::operator==(const VehicleDataItem& vd) {
           mandatory == vd.mandatory && params == vd.params &&
           array == vd.array && since == vd.since && until == vd.until &&
           removed == vd.removed && deprecated == vd.deprecated &&
-          minvalue == vd.minvalue && maxvalue == vd.maxvalue &&
-          minsize == vd.minsize && maxsize == vd.maxsize &&
-          minlength == vd.minlength && maxlength == vd.maxlength);
+          defvalue == vd.defvalue && minvalue == vd.minvalue &&
+          maxvalue == vd.maxvalue && minsize == vd.minsize &&
+          maxsize == vd.maxsize && minlength == vd.minlength &&
+          maxlength == vd.maxlength);
 }
 
 bool VehicleDataItem::is_valid() const {
@@ -1776,6 +1787,9 @@ bool VehicleDataItem::is_valid() const {
   if (!deprecated.is_valid()) {
     return false;
   }
+  if (!(defvalue.is_valid() && ValidateDefault())) {
+    return false;
+  }
   if (!minvalue.is_valid()) {
     return false;
   }
@@ -1832,6 +1846,9 @@ bool VehicleDataItem::struct_not_empty() const {
   if (!deprecated.is_initialized()) {
     return false;
   }
+  if (!defvalue.is_initialized()) {
+    return false;
+  }
   if (!minvalue.is_initialized()) {
     return false;
   }
@@ -1901,6 +1918,13 @@ void VehicleDataItem::ReportErrors(rpc::ValidationReport* report__) const {
   if (!deprecated.is_valid()) {
     deprecated.ReportErrors(&report__->ReportSubobject("deprecated"));
   }
+  if (!defvalue.is_valid()) {
+    defvalue.ReportErrors(&report__->ReportSubobject("defvalue"));
+  }
+  if (!ValidateDefault()) {
+    report__->set_validation_info("Invalid default value: " +
+                                  std::string(*defvalue));
+  }
   if (!minvalue.is_valid()) {
     minvalue.ReportErrors(&report__->ReportSubobject("minvalue"));
   }
@@ -1933,6 +1957,7 @@ void VehicleDataItem::SetPolicyTableType(PolicyTableType pt_type) {
   until.SetPolicyTableType(pt_type);
   removed.SetPolicyTableType(pt_type);
   deprecated.SetPolicyTableType(pt_type);
+  defvalue.SetPolicyTableType(pt_type);
   minvalue.SetPolicyTableType(pt_type);
   maxvalue.SetPolicyTableType(pt_type);
   minsize.SetPolicyTableType(pt_type);
@@ -1976,6 +2001,46 @@ bool VehicleDataItem::ValidateTypes() const {
   return (!(params.is_initialized()) || params->empty());
 }
 
+bool VehicleDataItem::ValidateDefault() const {
+  if (!defvalue.is_initialized()) {
+    return true;
+  }
+  std::string value = std::string(*defvalue);
+  bool valid = false;
+  if (VehicleDataItem::kInteger == std::string(type)) {
+    // Match int
+    std::regex pattern("^-?\\d+$");
+    bool type_matches = std::regex_match(value, pattern);
+    if (type_matches) {
+      size_t int_value = std::stol(value);
+      valid = (!minvalue.is_initialized() || int_value >= *minvalue) &&
+              (!maxvalue.is_initialized() || int_value <= *maxvalue);
+    }
+  } else if (VehicleDataItem::kFloat == std::string(type) ||
+             VehicleDataItem::kDouble == std::string(type)) {
+    // Match double
+    std::regex pattern("^-?\\d+(\\.\\d+)?$");
+    bool type_matches = std::regex_match(value, pattern);
+    if (type_matches) {
+      double dbl_value = std::stod(value);
+      valid = (!minvalue.is_initialized() || dbl_value >= *minvalue) &&
+              (!maxvalue.is_initialized() || dbl_value <= *maxvalue);
+    }
+  } else if (VehicleDataItem::kString == std::string(type)) {
+    size_t length = value.length();
+    valid = (!minsize.is_initialized() || length >= *minsize) &&
+            (!maxsize.is_initialized() || length <= *maxsize);
+  } else if (VehicleDataItem::kBoolean == std::string(type)) {
+    valid = ("false" == value || "true" == value);
+  } else if (VehicleDataItem::kStruct != std::string(type) &&
+             !IsPrimitiveType()) {
+    // Enum values cannot be validated here
+    valid = true;
+  }
+
+  return valid;
+}
+
 bool VehicleDataItem::IsPrimitiveType() const {
   return helpers::in_range(kPODTypes, std::string(type));
 }