1 files changed, 91 insertions, 97 deletions

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 b5fd9a567a..b9fcac4b6a 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
@@ -40,8 +40,7 @@ namespace rpc {
 
 // static
 inline PrimitiveType::ValueState PrimitiveType::InitHelper(
-  const Json::Value* value,
-  bool (Json::Value::*type_check)() const) {
+    const Json::Value* value, bool (Json::Value::*type_check)() const) {
   if (!value) {
     return kUninitialized;
   } else if ((value->*type_check)()) {
@@ -51,18 +50,19 @@ inline PrimitiveType::ValueState PrimitiveType::InitHelper(
   }
 }
 
-inline policy_table_interface_base::PolicyTableType PrimitiveType::GetPolicyTableType() const  {
+inline policy_table_interface_base::PolicyTableType
+PrimitiveType::GetPolicyTableType() const {
   return policy_table_type_;
 }
 
-inline void PrimitiveType::SetPolicyTableType(policy_table_interface_base::PolicyTableType pt_type) {
+inline void PrimitiveType::SetPolicyTableType(
+    policy_table_interface_base::PolicyTableType pt_type) {
   policy_table_type_ = pt_type;
 }
 
 // static
 inline CompositeType::InitializationState CompositeType::InitHelper(
-  const Json::Value* value,
-  bool (Json::Value::*type_check)() const) {
+    const Json::Value* value, bool (Json::Value::*type_check)() const) {
   if (!value) {
     return kUninitialized;
   } else if ((value->*type_check)()) {
@@ -77,11 +77,13 @@ inline CompositeType::InitializationState CompositeType::InitHelper(
   }
 }
 
-inline policy_table_interface_base::PolicyTableType CompositeType::GetPolicyTableType() const {
+inline policy_table_interface_base::PolicyTableType
+CompositeType::GetPolicyTableType() const {
   return policy_table_type_;
 }
 
-inline void CompositeType::SetPolicyTableType(policy_table_interface_base::PolicyTableType pt_type) {
+inline void CompositeType::SetPolicyTableType(
+    policy_table_interface_base::PolicyTableType pt_type) {
   policy_table_type_ = pt_type;
 }
 
@@ -95,7 +97,7 @@ inline const Json::Value* ValueMember(const Json::Value* value,
   return NULL;
 }
 
-template<class T>
+template <class T>
 inline void WriteJsonField(const char* field_name,
                            const T& field,
                            Json::Value* json_value) {
@@ -107,13 +109,12 @@ inline void WriteJsonField(const char* field_name,
 }  // namespace impl
 
 inline Boolean::Boolean(const Json::Value* value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isBool)),
-    value_(is_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(InitHelper(value, &Json::Value::isBool)),
-    value_(is_valid() ? 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;
@@ -124,10 +125,9 @@ inline Json::Value Boolean::ToJsonValue() const {
   return Json::Value(value_);
 }
 
-template<typename T, T minval, T maxval>
+template <typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(const Json::Value* value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isInt)),
-    value_() {
+    : PrimitiveType(InitHelper(value, &Json::Value::isInt)), value_() {
   if (is_valid()) {
     Json::Value::Int64 intval = value->asInt64();
     if (range_.Includes(intval)) {
@@ -138,16 +138,14 @@ Integer<T, minval, maxval>::Integer(const Json::Value* value)
   }
 }
 
-template<typename T, T minval, T maxval>
+template <typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(const Integer& val)
-  : PrimitiveType(range_.Includes(val.value_) ? kValid : kInvalid),
-    value_(val.value_) {
-}
+    : PrimitiveType(range_.Includes(val.value_) ? kValid : kInvalid)
+    , value_(val.value_) {}
 
-template<typename T, T minval, T maxval>
+template <typename T, T minval, T maxval>
 Integer<T, minval, maxval>::Integer(const Json::Value* value, IntType def_value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isInt)),
-    value_(def_value) {
+    : PrimitiveType(InitHelper(value, &Json::Value::isInt)), value_(def_value) {
   if (!is_initialized()) {
     value_state_ = kValid;
   } else if (is_valid()) {
@@ -160,26 +158,25 @@ Integer<T, minval, maxval>::Integer(const Json::Value* value, IntType def_value)
   }
 }
 
-template<typename T, T minval, T maxval>
+template <typename T, T minval, T maxval>
 Json::Value Integer<T, minval, maxval>::ToJsonValue() const {
   return Json::Value(Json::Int64(value_));
 }
 
-template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
+template <int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>::Float(const Json::Value* value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isDouble)),
-    value_() {
+    : 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>
+template <int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Float<minnum, maxnum, minden, maxden>::Float(const Json::Value* value,
-    double def_value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isDouble)),
-    value_(def_value) {
+                                             double def_value)
+    : PrimitiveType(InitHelper(value, &Json::Value::isDouble))
+    , value_(def_value) {
   if (!is_initialized()) {
     value_state_ = kValid;
   } else if (is_valid()) {
@@ -188,24 +185,25 @@ Float<minnum, maxnum, minden, maxden>::Float(const Json::Value* value,
   }
 }
 
-template<int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
+template <int64_t minnum, int64_t maxnum, int64_t minden, int64_t maxden>
 Json::Value Float<minnum, maxnum, minden, maxden>::ToJsonValue() const {
   return Json::Value(value_);
 }
 
-template<size_t minlen, size_t maxlen>
+template <size_t minlen, size_t maxlen>
 String<minlen, maxlen>::String(const Json::Value* value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isString)),
-    value_(is_valid() ? value->asString() : std::string()) {
+    : PrimitiveType(InitHelper(value, &Json::Value::isString))
+    , value_(is_valid() ? value->asString() : std::string()) {
   if (is_valid()) {
     value_state_ = length_range_.Includes(value_.length()) ? kValid : kInvalid;
   }
 }
 
-template<size_t minlen, size_t maxlen>
-String<minlen, maxlen>::String(const Json::Value* value, const std::string& def_value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isString)),
-    value_(def_value) {
+template <size_t minlen, size_t maxlen>
+String<minlen, maxlen>::String(const Json::Value* value,
+                               const std::string& def_value)
+    : PrimitiveType(InitHelper(value, &Json::Value::isString))
+    , value_(def_value) {
   if (!is_initialized()) {
     value_state_ = kValid;
   } else if (is_valid()) {
@@ -213,42 +211,42 @@ String<minlen, maxlen>::String(const Json::Value* value, const std::string& def_
   }
 }
 
-template<size_t minlen, size_t maxlen>
+template <size_t minlen, size_t maxlen>
 Json::Value String<minlen, maxlen>::ToJsonValue() const {
   return Json::Value(value_);
 }
 
-template<typename T>
+template <typename T>
 Enum<T>::Enum(const Json::Value* value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isString)),
-    value_(EnumType()) {
+    : PrimitiveType(InitHelper(value, &Json::Value::isString))
+    , value_(EnumType()) {
   if (is_valid()) {
     value_state_ =
-      EnumFromJsonString(value->asString(), &value_) ? kValid : kInvalid;
+        EnumFromJsonString(value->asString(), &value_) ? kValid : kInvalid;
   }
 }
 
-template<typename T>
+template <typename T>
 Enum<T>::Enum(const Json::Value* value, EnumType def_value)
-  : PrimitiveType(InitHelper(value, &Json::Value::isString)),
-    value_(def_value) {
+    : PrimitiveType(InitHelper(value, &Json::Value::isString))
+    , value_(def_value) {
   if (!is_initialized()) {
     value_state_ = kValid;
   } else if (is_valid()) {
     value_state_ =
-      EnumFromJsonString(value->asString(), &value_) ? kValid : kInvalid;
+        EnumFromJsonString(value->asString(), &value_) ? kValid : kInvalid;
   }
 }
 
-template<typename T>
+template <typename T>
 Json::Value Enum<T>::ToJsonValue() const {
   return Json::Value(Json::StaticString(EnumToJsonString(value_)));
 }
 
 // Non-const version
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Array<T, minsize, maxsize>::Array(Json::Value* value)
-  : CompositeType(InitHelper(value, &Json::Value::isArray)) {
+    : CompositeType(InitHelper(value, &Json::Value::isArray)) {
   if (value) {
     if (value->isArray()) {
       this->reserve(value->size());
@@ -263,13 +261,14 @@ Array<T, minsize, maxsize>::Array(Json::Value* value)
 }
 
 // Const version, must be identical to the non-const version
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Array<T, minsize, maxsize>::Array(const Json::Value* value)
-  : CompositeType(InitHelper(value, &Json::Value::isArray)) {
+    : CompositeType(InitHelper(value, &Json::Value::isArray)) {
   if (value) {
     if (value->isArray()) {
       this->reserve(value->size());
-      for (Json::Value::const_iterator i = value->begin(); i != value->end(); ++i) {
+      for (Json::Value::const_iterator i = value->begin(); i != value->end();
+           ++i) {
         push_back(&*i);
       }
     } else {
@@ -279,20 +278,20 @@ Array<T, minsize, maxsize>::Array(const Json::Value* value)
   }
 }
 
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Json::Value Array<T, minsize, maxsize>::ToJsonValue() const {
   Json::Value array(Json::arrayValue);
   array.resize(this->size());
   for (size_t i = 0; i != this->size(); ++i) {
-    array[Json::ArrayIndex(i)] = (this->operator [](i)).ToJsonValue();
+    array[Json::ArrayIndex(i)] = (this->operator[](i)).ToJsonValue();
   }
   return array;
 }
 
 // Non-const version
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Map<T, minsize, maxsize>::Map(Json::Value* value)
-  : CompositeType(InitHelper(value, &Json::Value::isObject)) {
+    : CompositeType(InitHelper(value, &Json::Value::isObject)) {
   if (value) {
     if (value->isObject()) {
       for (Json::Value::iterator i = value->begin(); i != value->end(); ++i) {
@@ -305,12 +304,13 @@ Map<T, minsize, maxsize>::Map(Json::Value* value)
   }
 }
 
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Map<T, minsize, maxsize>::Map(const Json::Value* value)
-  : CompositeType(InitHelper(value, &Json::Value::isObject)) {
+    : CompositeType(InitHelper(value, &Json::Value::isObject)) {
   if (value) {
     if (value->isObject()) {
-      for (Json::Value::const_iterator i = value->begin(); i != value->end(); ++i) {
+      for (Json::Value::const_iterator i = value->begin(); i != value->end();
+           ++i) {
         this->insert(typename MapType::value_type(i.key().asString(), T(&*i)));
       }
     } else {
@@ -320,70 +320,64 @@ Map<T, minsize, maxsize>::Map(const Json::Value* value)
   }
 }
 
-template<typename T, size_t minsize, size_t maxsize>
+template <typename T, size_t minsize, size_t maxsize>
 Json::Value Map<T, minsize, maxsize>::ToJsonValue() const {
   Json::Value map(Json::objectValue);
-  for (typename MapType::const_iterator i = this->begin(); i != this->end(); ++i) {
+  for (typename MapType::const_iterator i = this->begin(); i != this->end();
+       ++i) {
     map[i->first] = i->second.ToJsonValue();
   }
   return map;
 }
 
-template<typename T>
+template <typename T>
 Nullable<T>::Nullable(const Json::Value* value)
-  : T(value),
-    marked_null_(value != NULL&&  value->isNull()) {
-}
+    : T(value), marked_null_(value != NULL && value->isNull()) {}
 
-template<typename T>
+template <typename T>
 Nullable<T>::Nullable(Json::Value* value)
-  : T(value),
-    marked_null_(value != NULL&&  value->isNull()) {
-}
+    : T(value), marked_null_(value != NULL && value->isNull()) {}
 
-template<typename T>
-template<typename U>
+template <typename T>
+template <typename U>
 Nullable<T>::Nullable(const Json::Value* value, const U& def_value)
-  : T(value, def_value),
-    marked_null_(value != NULL&&  value->isNull()) {
-}
+    : T(value, def_value), marked_null_(value != NULL && value->isNull()) {}
 
-template<typename T>
+template <typename T>
 inline Json::Value Nullable<T>::ToJsonValue() const {
   return marked_null_ ? Json::Value::null : T::ToJsonValue();
 }
 
-template<typename T>
-template<typename U>
+template <typename T>
+template <typename U>
 Optional<T>::Optional(const Json::Value* value, const U& def_value)
-  : value_(value, def_value) {
-}
+    : value_(value, def_value) {}
 
-template<typename T>
+template <typename T>
 inline Json::Value Optional<T>::ToJsonValue() const {
   return value_.ToJsonValue();
 }
 
-template<typename T>
+template <typename T>
 Stringifyable<T>::Stringifyable(const Json::Value* value)
-  : T(NULL != value&&  !value->isString() ? value : NULL),
-    predefined_string_(NULL != value&&   value->isString() ? value->asString() : "") {
-}
+    : T(NULL != value && !value->isString() ? value : NULL)
+    , predefined_string_(NULL != value && value->isString() ? value->asString()
+                                                            : "") {}
 
-template<typename T>
+template <typename T>
 Stringifyable<T>::Stringifyable(Json::Value* value)
-  : T(NULL != value&&  !value->isString() ? value : NULL),
-    predefined_string_(NULL != value&&   value->isString() ? value->asString() : "") {
-}
+    : T(NULL != value && !value->isString() ? value : NULL)
+    , predefined_string_(NULL != value && value->isString() ? value->asString()
+                                                            : "") {}
 
-template<typename T>
-template<typename U>
+template <typename T>
+template <typename U>
 Stringifyable<T>::Stringifyable(const Json::Value* value, const U& def_value)
-  : T(NULL != value&&  !value->isString() ? (value, def_value) : NULL),
-    predefined_string_(NULL != value&&   value->isString() ? value->asString() : "")  {
-}
+    : T(NULL != value && !value->isString() ? (value, def_value) : NULL)
+    , predefined_string_(NULL != value && value->isString() ? value->asString()
+                                                            : "") {}
 
-template<typename T>
+template <typename T>
 inline Json::Value Stringifyable<T>::ToJsonValue() const {
   return predefined_string_.empty() ? T::ToJsonValue() : predefined_string_;
 }