From 0892c1e3d3a76136ea6188ad06cab5498e4a4e56 Mon Sep 17 00:00:00 2001
From: Igor Kozyrenko <IKozyrenko@luxoft.com>
Date: Tue, 1 Apr 2014 17:14:06 +0300
Subject: [PATCH] APPLINK-6532, Null state for types in rpc_base

---
 .../rpc_base/include/rpc_base/rpc_base.h           |  23 +++-
 .../rpc_base/include/rpc_base/rpc_base_inl.h       |  97 +++++++++++------
 .../rpc_base/include/rpc_base/rpc_base_json_inl.h  | 117 +++++++++++++++------
 test/components/rpc_base/rpc_base_json_test.cc     |  49 +++++++++
 4 files changed, 217 insertions(+), 69 deletions(-)

diff --git a/src/components/rpc_base/include/rpc_base/rpc_base.h b/src/components/rpc_base/include/rpc_base/rpc_base.h
index e7cdd63..8e62936 100644
--- a/src/components/rpc_base/include/rpc_base/rpc_base.h
+++ b/src/components/rpc_base/include/rpc_base/rpc_base.h
@@ -84,11 +84,20 @@ class PrimitiveType {
  public:
   bool is_initialized() const;
   bool is_valid() const;
+  bool is_null() const;
+  void set_to_null();
  protected:
-  PrimitiveType(bool initialized, bool valid);
+  enum ValueState {
+    kUninitialized,
+    kNull,
+    kInvalid,
+    kValid
+  };
+  PrimitiveType(ValueState value_state);
+  static ValueState InitHelper(const Json::Value* value,
+                               bool (Json::Value::*type_check)() const);
  protected:
-  bool initialized_;
-  bool valid_;
+  ValueState value_state_;
 };
 
 /*
@@ -242,6 +251,10 @@ class Array : public std::vector<T> {
 
   bool is_valid() const;
   bool is_initialized() const;
+  bool is_null() const;
+  void set_to_null();
+ private:
+  bool marked_as_null_;
 };
 
 template<typename T, size_t minsize, size_t maxsize>
@@ -266,6 +279,10 @@ class Map : public std::map<std::string, T> {
 
   bool is_valid() const;
   bool is_initialized() const;
+  bool is_null() const;
+  void set_to_null();
+ private:
+  bool marked_as_null_;
 };
 
 template<typename T>
diff --git a/src/components/rpc_base/include/rpc_base/rpc_base_inl.h b/src/components/rpc_base/include/rpc_base/rpc_base_inl.h
index 615acf9..6f20afd 100644
--- a/src/components/rpc_base/include/rpc_base/rpc_base_inl.h
+++ b/src/components/rpc_base/include/rpc_base/rpc_base_inl.h
@@ -64,33 +64,41 @@ bool Range<T>::Includes(U val) const {
   return min() <= val && val <= max();
 }
 
-inline PrimitiveType::PrimitiveType(bool initialized, bool valid)
-    : initialized_(initialized), valid_(valid) {
+inline PrimitiveType::PrimitiveType(ValueState value_state)
+    : value_state_(value_state) {
 }
 
 inline bool PrimitiveType::is_initialized() const {
-  return initialized_;
+  return value_state_ != kUninitialized;
 }
 
 inline bool PrimitiveType::is_valid() const {
-  return valid_;
+  return value_state_ == kValid;
+}
+
+inline bool PrimitiveType::is_null() const {
+  return value_state_ == kNull;
+}
+
+inline void PrimitiveType::set_to_null() {
+  value_state_ = kNull;
 }
 
 /*
  * Boolean class
  */
 inline Boolean::Boolean()
-    : PrimitiveType(false, false), value_(false) {
+    : PrimitiveType(kUninitialized),
+      value_(false) {
 }
 
 inline Boolean::Boolean(bool value)
-    : PrimitiveType(true, true), value_(value) {
+    : PrimitiveType(kValid), value_(value) {
 }
 
 inline Boolean& Boolean::operator=(bool new_val) {
   value_ = new_val;
-  initialized_ = true;
-  valid_ = true;
+  value_state_ = kValid;
   return *this;
 }
 
@@ -106,21 +114,20 @@ const Range<T> Integer<T, minval, maxval>::range_(minval, maxval);
 
 template<typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer()
-    : PrimitiveType(false, false),
+    : PrimitiveType(kUninitialized),
       value_(range_.min()) {
 }
 
 template<typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(IntType value)
-    : PrimitiveType(true, range_.Includes(value)),
+    : PrimitiveType(range_.Includes(value) ? kValid : kInvalid),
       value_(value) {
 }
 
 template<typename T, T minval, T maxval>
 Integer<T, minval, maxval>& Integer<T, minval, maxval>::operator=(IntType new_val) {
   value_ = new_val;
-  initialized_ = true;
-  valid_ = range_.Includes(value_);
+  value_state_ = range_.Includes(value_) ? kValid : kInvalid;
   return *this;
 }
 
@@ -139,13 +146,13 @@ const Range<double> Float<minnum, maxnum, minden, maxden>::range_(
 
 template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>::Float()
-    : PrimitiveType(false, false),
+    : PrimitiveType(kUninitialized),
       value_(range_.min()) {
 }
 
 template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>::Float(double value)
-    : PrimitiveType(true, range_.Includes(value)),
+    : PrimitiveType(range_.Includes(value) ? kValid : kInvalid),
       value_(value) {
 }
 
@@ -153,8 +160,7 @@ template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>&
 Float<minnum, maxnum, minden, maxden>::operator=(double new_val) {
   value_ = new_val;
-  initialized_ = true;
-  valid_ = range_.Includes(new_val);
+  value_state_ = range_.Includes(new_val) ? kValid : kInvalid;
   return *this;
 }
 
@@ -171,27 +177,26 @@ const Range<size_t> String<minlen, maxlen>::length_range_(minlen, maxlen);
 
 template<size_t minlen, size_t maxlen>
 String<minlen, maxlen>::String()
-    : PrimitiveType(false, false) {
+    : PrimitiveType(kUninitialized) {
 }
 
 template<size_t minlen, size_t maxlen>
 String<minlen, maxlen>::String(const std::string& value)
-    : PrimitiveType(true, length_range_.Includes(value.length())),
+    : PrimitiveType(length_range_.Includes(value.length()) ? kValid : kInvalid),
       value_(value) {
 }
 
 template<size_t minlen, size_t maxlen>
 String<minlen, maxlen>::String(const char* value)
-    : PrimitiveType(true, true),
+    : PrimitiveType(kUninitialized),
       value_(value) {
-  valid_ = length_range_.Includes(value_.length());
+  value_state_ = length_range_.Includes(value_.length()) ? kValid : kInvalid;
 }
 
 template<size_t minlen, size_t maxlen>
 String<minlen, maxlen>& String<minlen, maxlen>::operator=(const std::string& new_val) {
   value_ = new_val;
-  initialized_ = true;
-  valid_ = length_range_.Includes(new_val.length());
+  value_state_ = length_range_.Includes(new_val.length()) ? kValid : kInvalid;
   return *this;
 }
 
@@ -205,21 +210,20 @@ String<minlen, maxlen>::operator const std::string&() const {
  */
 template<typename T>
 Enum<T>::Enum()
-    : PrimitiveType(false, false),
+    : PrimitiveType(kUninitialized),
       value_(EnumType()) {
 }
 
 template<typename T>
 Enum<T>::Enum(EnumType value)
-    : PrimitiveType(true, IsValidEnum(value_)),
+    : PrimitiveType(IsValidEnum(value_) ? kValid : kInvalid),
       value_(value) {
 }
 
 template<typename T>
 Enum<T>& Enum<T>::operator=(EnumType new_val) {
   value_ = new_val;
-  initialized_ = true;
-  valid_ = IsValidEnum(value_);
+  value_state_ = IsValidEnum(value_) ? kValid : kInvalid;
   return *this;
 }
 
@@ -232,13 +236,15 @@ Enum<T>::operator EnumType() const {
  * Array class
  */
 template<typename T, size_t minsize, size_t maxsize>
-Array<T, minsize, maxsize>::Array() {
+Array<T, minsize, maxsize>::Array()
+  : marked_as_null_(false) {
 }
 
 template<typename T, size_t minsize, size_t maxsize>
 template<typename U>
 Array<T, minsize, maxsize>::Array(const U& value)
-    : ArrayType(value.begin(), value.end() ){
+    : ArrayType(value.begin(), value.end()),
+      marked_as_null_(false) {
 }
 
 template<typename T, size_t minsize, size_t maxsize>
@@ -257,6 +263,9 @@ void Array<T, minsize, maxsize>::push_back(const U& value) {
 
 template<typename T, size_t minsize, size_t maxsize>
 bool Array<T, minsize, maxsize>::is_valid() const {
+  if (is_null()) {
+    return false;
+  }
   if (!Range<size_t>(minsize, maxsize).Includes(this->size()))
     return false;
   for (typename ArrayType::const_iterator i = this->begin();
@@ -269,19 +278,31 @@ bool Array<T, minsize, maxsize>::is_valid() const {
 
 template<typename T, size_t minsize, size_t maxsize>
 bool Array<T, minsize, maxsize>::is_initialized() const {
-  return !this->empty();
+  return is_null() || !this->empty();
+}
+
+template<typename T, size_t minsize, size_t maxsize>
+bool Array<T, minsize, maxsize>::is_null() const {
+  return marked_as_null_;
+}
+
+template<typename T, size_t minsize, size_t maxsize>
+void Array<T, minsize, maxsize>::set_to_null() {
+  marked_as_null_ = true;
 }
 
 /*
  * Map class
  */
 template<typename T, size_t minsize, size_t maxsize>
-Map<T, minsize, maxsize>::Map() {
+Map<T, minsize, maxsize>::Map()
+    : marked_as_null_(false) {
 }
 
 template<typename T, size_t minsize, size_t maxsize>
 template<typename U>
-Map<T, minsize, maxsize>::Map(const U& value) {
+Map<T, minsize, maxsize>::Map(const U& value)
+    : marked_as_null_(false) {
   for (typename U::const_iterator i = value.begin(), e = value.end(); i != e;
       ++i) {
     // Explicitly convert that value to T because all rpc_types have explicit
@@ -312,6 +333,8 @@ void Map<T, minsize, maxsize>::insert(const std::pair<std::string, U>& value) {
 
 template<typename T, size_t minsize, size_t maxsize>
 bool Map<T, minsize, maxsize>::is_valid() const {
+  if (is_null())
+    return false;
   if (!Range<size_t>(minsize, maxsize).Includes(this->size()))
     return false;
   for (typename Map::const_iterator i = this->begin();
@@ -324,7 +347,17 @@ bool Map<T, minsize, maxsize>::is_valid() const {
 
 template<typename T, size_t minsize, size_t maxsize>
 bool Map<T, minsize, maxsize>::is_initialized() const {
-  return !this->empty();
+  return is_null() || !this->empty();
+}
+
+template<typename T, size_t minsize, size_t maxsize>
+bool Map<T, minsize, maxsize>::is_null() const {
+  return marked_as_null_;
+}
+
+template<typename T, size_t minsize, size_t maxsize>
+void Map<T, minsize, maxsize>::set_to_null() {
+  marked_as_null_ = true;
 }
 
 /*
diff --git a/src/components/rpc_base/include/rpc_base/rpc_base_json_inl.h b/src/components/rpc_base/include/rpc_base/rpc_base_json_inl.h
index 1064daa..aa95682 100644
--- a/src/components/rpc_base/include/rpc_base/rpc_base_json_inl.h
+++ b/src/components/rpc_base/include/rpc_base/rpc_base_json_inl.h
@@ -38,6 +38,22 @@
 
 namespace rpc {
 
+// static
+inline PrimitiveType::ValueState PrimitiveType::InitHelper(
+    const Json::Value* value,
+    bool (Json::Value::*type_check)() const) {
+  if (!value) {
+    return kInvalid;
+  }
+  if (value->isNull()) {
+    return kNull;
+  } else if ((value->*type_check)()) {
+    return kValid;
+  } else {
+    return kInvalid;
+  }
+}
+
 /*
  * Composite type
  */
@@ -80,13 +96,17 @@ void CompositeType::WriteJsonField(const char* field_name,
 
 
 inline Boolean::Boolean(const Json::Value& value)
-    : PrimitiveType(!value.isNull(), value.isBool()),
-      value_(valid_ ? value.asBool() : bool()) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isBool)),
+      value_(is_valid() ? value.asBool() : bool()) {
 }
 
 inline Boolean::Boolean(const Json::Value& value, bool def_value)
-    : PrimitiveType(true, value.isBool() || value.isNull()),
-      value_(value.isBool() ? value.asBool() : def_value) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isBool)),
+      value_(is_valid() ? value.asBool() : def_value) {
+  // If there is no value, mark it as valid and use def_value
+  if (!is_initialized()) {
+    value_state_ = kValid;
+  }
 }
 
 inline Json::Value Boolean::ToJsonValue() const {
@@ -95,16 +115,34 @@ inline Json::Value Boolean::ToJsonValue() const {
 
 template<typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(const Json::Value& value)
-    : PrimitiveType(!value.isNull(),
-                    value.isInt() && range_.Includes(value.asInt64())),
-      value_(valid_ ? value.asInt64() : IntType()) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isInt)),
+      value_() {
+  if (is_valid()) {
+    Json::Value::Int64 intval = value.asInt64();
+    if (range_.Includes(intval)) {
+      value_ = intval;
+      value_state_ = kValid;
+    } else {
+      value_state_ = kInvalid;
+    }
+  }
 }
 
 template<typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(const Json::Value& value, IntType def_value)
-    : PrimitiveType(true, (value.isInt() && range_.Includes(value.asInt64()))
-                           || value.isNull()),
-      value_(value.isInt() ? value.asInt64() : def_value) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isInt)),
+      value_(def_value) {
+  if (!is_initialized()) {
+    value_state_ = kValid;
+  } else if (is_valid()) {
+    Json::Value::Int64 intval = value.asInt64();
+    if (range_.Includes(intval)) {
+      value_ = intval;
+      value_state_ = kValid;
+    } else {
+      value_state_ = kInvalid;
+    }
+  }
 }
 
 template<typename T, T minval, T maxval>
@@ -114,9 +152,12 @@ Json::Value Integer<T, minval, maxval>::ToJsonValue() const {
 
 template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>::Float(const Json::Value& value)
-    : PrimitiveType(!value.isNull(),
-                    value.isDouble() && range_.Includes(value.asDouble())),
-      value_(valid_ ? value.asDouble() : double()) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isDouble)),
+      value_() {
+  if (is_valid()) {
+    value_ = value.asDouble();
+    value_state_ = range_.Includes(value_) ? kValid : kInvalid;
+  }
 }
 
 template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
@@ -135,10 +176,12 @@ Json::Value Float<minnum, maxnum, minden, maxden>::ToJsonValue() const {
 
 template<size_t minlen, size_t maxlen>
 String<minlen, maxlen>::String(const Json::Value& value)
-    : PrimitiveType(!value.isNull(),
-                    (value.isString() &&
-                        length_range_.Includes(value.asString().length()))),
-      value_(valid_ ? value.asString() : std::string()) {
+    : PrimitiveType(InitHelper(&value, &Json::Value::isString)),
+      value_(is_valid() ? value.asString() : std::string()) {
+  if (is_valid()) {
+    value_ = value.asString();
+    value_state_ = length_range_.Includes(value_.length()) ? kValid : kInvalid;
+  }
 }
 
 template<size_t minlen, size_t maxlen>
@@ -156,19 +199,23 @@ Json::Value String<minlen, maxlen>::ToJsonValue() const {
 
 template<typename T>
 Enum<T>::Enum(const Json::Value& value)
-    : PrimitiveType(!value.isNull(), value.isString()),
+    : PrimitiveType(InitHelper(&value, &Json::Value::isString)),
       value_(EnumType()) {
-  if (valid_) {
-    valid_ = EnumFromJsonString(value.asString(), &value_);
+  if (is_valid()) {
+    value_state_ =
+        EnumFromJsonString(value.asString(), &value_) ? kValid : kInvalid;
   }
 }
 
 template<typename T>
 Enum<T>::Enum(const Json::Value& value, EnumType def_value)
-    : PrimitiveType(true, value.isString() || value.isNull()),
+    : PrimitiveType(InitHelper(&value, &Json::Value::isString)),
       value_(def_value) {
-  if (value.isString()) {
-    valid_ = EnumFromJsonString(value.asString(), &value_);
+  if (!is_initialized()) {
+    value_state_ = kValid;
+  } else if (is_valid()) {
+    value_state_ =
+        EnumFromJsonString(value.asString(), &value_) ? kValid : kInvalid;
   }
 }
 
@@ -178,18 +225,19 @@ Json::Value Enum<T>::ToJsonValue() const {
 }
 
 template<typename T, size_t minsize, size_t maxsize>
-Array<T, minsize, maxsize>::Array(const Json::Value& value) {
-  if (value.isArray()) {
+Array<T, minsize, maxsize>::Array(const Json::Value& value)
+    : marked_as_null_(value.isNull()) {
+  if (marked_as_null_) {
+    // Do nothing
+  } else if (value.isArray()) {
     this->reserve(value.size());
     for (Json::Value::const_iterator i = value.begin(); i != value.end(); ++i) {
       push_back(*i);
     }
-  } else if (value.isNull()) {
-    // Do nothing, keep array empty and uninitialized
   } else {
-    // In case of non-array value initialize array with null value
+    // In case of non-array value initialize array with non-initialized value
     // so it handled as initialized but invalid
-    push_back(Json::Value());
+    push_back(T());
   }
 }
 
@@ -204,17 +252,18 @@ Json::Value Array<T, minsize, maxsize>::ToJsonValue() const {
 }
 
 template<typename T, size_t minsize, size_t maxsize>
-Map<T, minsize, maxsize>::Map(const Json::Value& value) {
-  if (value.isObject()) {
+Map<T, minsize, maxsize>::Map(const Json::Value& value)
+    : marked_as_null_(value.isNull()) {
+  if (marked_as_null_) {
+    // Do nothing
+  } else if (value.isObject()) {
     for (Json::Value::const_iterator i = value.begin(); i != value.end(); ++i) {
       this->insert(typename MapType::value_type(i.key().asString(), T(*i)));
     }
-  } else if (value.isNull()) {
-    // Do nothing, keep array empty and uninitialized
   } else {
     // In case of non-array value initialize array with null value
     // so it handled as initialized but invalid
-    this->insert(typename MapType::value_type("", T(Json::Value())));
+    this->insert(typename MapType::value_type("", T()));
   }
 }
 
diff --git a/test/components/rpc_base/rpc_base_json_test.cc b/test/components/rpc_base/rpc_base_json_test.cc
index 63e4034..9a9a708 100644
--- a/test/components/rpc_base/rpc_base_json_test.cc
+++ b/test/components/rpc_base/rpc_base_json_test.cc
@@ -83,6 +83,13 @@ TEST(ValidatedTypesJson, BooleanFromJsonTest) {
   ASSERT_EQ(readback.asBool(), true);
 }
 
+TEST(ValidatedTypesJson, BooleanNullTest) {
+  Boolean boolean(Value::null);
+  ASSERT_TRUE(boolean.is_initialized());
+  ASSERT_TRUE(boolean.is_null());
+  ASSERT_FALSE(boolean.is_valid());
+}
+
 TEST(ValidatedTypesJson, BooleanFromInvalidJsonTest) {
   Value inv(7);
   Boolean boolean(inv);
@@ -100,6 +107,13 @@ TEST(ValidatedTypesJson, IntegerFromJsonTest) {
   ASSERT_EQ(readback.asInt(), 42);
 }
 
+TEST(ValidatedTypesJson, IntegerNullTest) {
+  Integer<int32_t, -5, 192> integer(Value::null);
+  ASSERT_TRUE(integer.is_initialized());
+  ASSERT_TRUE(integer.is_null());
+  ASSERT_FALSE(integer.is_valid());
+}
+
 TEST(ValidatedTypesJson, IntegerFromOverflowingJsonTest) {
   Value int_val(0xFFFFFFFFFFll);
   Integer<int32_t, -5, 192> integer(int_val);
@@ -131,6 +145,13 @@ TEST(ValidatedTypesJson, FloatFromJsonTest) {
   ASSERT_EQ(readback.asDouble(), 4.2);
 }
 
+TEST(ValidatedTypesJson, FloatNullTest) {
+  Float<1, 7> flt(Value::null);
+  ASSERT_TRUE(flt.is_initialized());
+  ASSERT_TRUE(flt.is_null());
+  ASSERT_FALSE(flt.is_valid());
+}
+
 TEST(ValidatedTypesJson, FloatFromInvalidJsonTest) {
   Value str_val("Hello");
   Float<-5, 3> flt(str_val);
@@ -148,6 +169,13 @@ TEST(ValidatedTypesJson, StringFromJsonTest) {
   ASSERT_STREQ(readback.asCString(), "Hello");
 }
 
+TEST(ValidatedTypesJson, StringNullTest) {
+  String<1, 42> str(Value::null);
+  ASSERT_TRUE(str.is_initialized());
+  ASSERT_TRUE(str.is_null());
+  ASSERT_FALSE(str.is_valid());
+}
+
 TEST(ValidatedTypesJson, StringFromInvalidJsonTest) {
   Value int_val(42);
   String<1, 500> str(int_val);
@@ -172,6 +200,13 @@ TEST(ValidatedTypesJson, EnumFromJsonTest) {
   ASSERT_STREQ(readback.asCString(), "kValue1");
 }
 
+TEST(ValidatedTypesJson, EnumNullTest) {
+  Enum<TestEnum> enm(Value::null);
+  ASSERT_TRUE(enm.is_initialized());
+  ASSERT_TRUE(enm.is_null());
+  ASSERT_FALSE(enm.is_valid());
+}
+
 TEST(ValidatedTypesJson, EnumFromInvalidJsonTest) {
   Value str_value("Random string");
   Enum<TestEnum> enm(str_value);
@@ -191,6 +226,20 @@ TEST(ValidatedTypesJson, ArrayFromJsonTest) {
   ASSERT_EQ(readback.size(), array_value.size());
 }
 
+TEST(ValidatedTypesJson, ArrayNullTest) {
+  Array<String<1, 32>, 2, 5> arr(Value::null);
+  ASSERT_TRUE(arr.is_initialized());
+  ASSERT_TRUE(arr.is_null());
+  ASSERT_FALSE(arr.is_valid());
+}
+
+TEST(ValidatedTypesJson, MapNullTest) {
+  Map<String<1, 32>, 2, 5> map(Value::null);
+  ASSERT_TRUE(map.is_initialized());
+  ASSERT_TRUE(map.is_null());
+  ASSERT_FALSE(map.is_valid());
+}
+
 TEST(ValidatedTypesJson, ArrayFromInvalidJsonTest) {
   Value array_value;
   array_value.append(Value("Hello"));
-- 
2.7.4