base/json/json_value_converter.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_JSON_JSON_VALUE_CONVERTER_H_
   6 #define BASE_JSON_JSON_VALUE_CONVERTER_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/base_export.h"
  12 #include "base/basictypes.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/scoped_vector.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string16.h"
  18 #include "base/strings/string_piece.h"
  19 #include "base/values.h"
  20
  21 // JSONValueConverter converts a JSON value into a C++ struct in a
  22 // lightweight way.
  23 //
  24 // Usage:
  25 // For real examples, you may want to refer to _unittest.cc file.
  26 //
  27 // Assume that you have a struct like this:
  28 //   struct Message {
  29 //     int foo;
  30 //     std::string bar;
  31 //     static void RegisterJSONConverter(
  32 //         JSONValueConverter<Message>* converter);
  33 //   };
  34 //
  35 // And you want to parse a json data into this struct.  First, you
  36 // need to declare RegisterJSONConverter() method in your struct.
  37 //   // static
  38 //   void Message::RegisterJSONConverter(
  39 //       JSONValueConverter<Message>* converter) {
  40 //     converter->RegisterIntField("foo", &Message::foo);
  41 //     converter->RegisterStringField("bar", &Message::bar);
  42 //   }
  43 //
  44 // Then, you just instantiate your JSONValueConverter of your type and call
  45 // Convert() method.
  46 //   Message message;
  47 //   JSONValueConverter<Message> converter;
  48 //   converter.Convert(json, &message);
  49 //
  50 // Convert() returns false when it fails.  Here "fail" means that the value is
  51 // structurally different from expected, such like a string value appears
  52 // for an int field.  Do not report failures for missing fields.
  53 // Also note that Convert() will modify the passed |message| even when it
  54 // fails for performance reason.
  55 //
  56 // For nested field, the internal message also has to implement the registration
  57 // method.  Then, just use RegisterNestedField() from the containing struct's
  58 // RegisterJSONConverter method.
  59 //   struct Nested {
  60 //     Message foo;
  61 //     static void RegisterJSONConverter(...) {
  62 //       ...
  63 //       converter->RegisterNestedField("foo", &Nested::foo);
  64 //     }
  65 //   };
  66 //
  67 // For repeated field, we just assume ScopedVector for its container
  68 // and you can put RegisterRepeatedInt or some other types.  Use
  69 // RegisterRepeatedMessage for nested repeated fields.
  70 //
  71 // Sometimes JSON format uses string representations for other types such
  72 // like enum, timestamp, or URL.  You can use RegisterCustomField method
  73 // and specify a function to convert a StringPiece to your type.
  74 //   bool ConvertFunc(const StringPiece& s, YourEnum* result) {
  75 //     // do something and return true if succeed...
  76 //   }
  77 //   struct Message {
  78 //     YourEnum ye;
  79 //     ...
  80 //     static void RegisterJSONConverter(...) {
  81 //       ...
  82 //       converter->RegsiterCustomField<YourEnum>(
  83 //           "your_enum", &Message::ye, &ConvertFunc);
  84 //     }
  85 //   };
  86
  87 namespace base {
  88
  89 template <typename StructType>
  90 class JSONValueConverter;
  91
  92 namespace internal {
  93
  94 template<typename StructType>
  95 class FieldConverterBase {
  96  public:
  97   explicit FieldConverterBase(const std::string& path) : field_path_(path) {}
  98   virtual ~FieldConverterBase() {}
  99   virtual bool ConvertField(const base::Value& value, StructType* obj)
 100       const = 0;
 101   const std::string& field_path() const { return field_path_; }
 102
 103  private:
 104   std::string field_path_;
 105   DISALLOW_COPY_AND_ASSIGN(FieldConverterBase);
 106 };
 107
 108 template <typename FieldType>
 109 class ValueConverter {
 110  public:
 111   virtual ~ValueConverter() {}
 112   virtual bool Convert(const base::Value& value, FieldType* field) const = 0;
 113 };
 114
 115 template <typename StructType, typename FieldType>
 116 class FieldConverter : public FieldConverterBase<StructType> {
 117  public:
 118   explicit FieldConverter(const std::string& path,
 119                           FieldType StructType::* field,
 120                           ValueConverter<FieldType>* converter)
 121       : FieldConverterBase<StructType>(path),
 122         field_pointer_(field),
 123         value_converter_(converter) {
 124   }
 125
 126   bool ConvertField(const base::Value& value, StructType* dst) const override {
 127     return value_converter_->Convert(value, &(dst->*field_pointer_));
 128   }
 129
 130  private:
 131   FieldType StructType::* field_pointer_;
 132   scoped_ptr<ValueConverter<FieldType> > value_converter_;
 133   DISALLOW_COPY_AND_ASSIGN(FieldConverter);
 134 };
 135
 136 template <typename FieldType>
 137 class BasicValueConverter;
 138
 139 template <>
 140 class BASE_EXPORT BasicValueConverter<int> : public ValueConverter<int> {
 141  public:
 142   BasicValueConverter() {}
 143
 144   bool Convert(const base::Value& value, int* field) const override;
 145
 146  private:
 147   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 148 };
 149
 150 template <>
 151 class BASE_EXPORT BasicValueConverter<std::string>
 152     : public ValueConverter<std::string> {
 153  public:
 154   BasicValueConverter() {}
 155
 156   bool Convert(const base::Value& value, std::string* field) const override;
 157
 158  private:
 159   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 160 };
 161
 162 template <>
 163 class BASE_EXPORT BasicValueConverter<string16>
 164     : public ValueConverter<string16> {
 165  public:
 166   BasicValueConverter() {}
 167
 168   bool Convert(const base::Value& value, string16* field) const override;
 169
 170  private:
 171   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 172 };
 173
 174 template <>
 175 class BASE_EXPORT BasicValueConverter<double> : public ValueConverter<double> {
 176  public:
 177   BasicValueConverter() {}
 178
 179   bool Convert(const base::Value& value, double* field) const override;
 180
 181  private:
 182   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 183 };
 184
 185 template <>
 186 class BASE_EXPORT BasicValueConverter<bool> : public ValueConverter<bool> {
 187  public:
 188   BasicValueConverter() {}
 189
 190   bool Convert(const base::Value& value, bool* field) const override;
 191
 192  private:
 193   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 194 };
 195
 196 template <typename FieldType>
 197 class ValueFieldConverter : public ValueConverter<FieldType> {
 198  public:
 199   typedef bool(*ConvertFunc)(const base::Value* value, FieldType* field);
 200
 201   ValueFieldConverter(ConvertFunc convert_func)
 202       : convert_func_(convert_func) {}
 203
 204   bool Convert(const base::Value& value, FieldType* field) const override {
 205     return convert_func_(&value, field);
 206   }
 207
 208  private:
 209   ConvertFunc convert_func_;
 210
 211   DISALLOW_COPY_AND_ASSIGN(ValueFieldConverter);
 212 };
 213
 214 template <typename FieldType>
 215 class CustomFieldConverter : public ValueConverter<FieldType> {
 216  public:
 217   typedef bool(*ConvertFunc)(const StringPiece& value, FieldType* field);
 218
 219   CustomFieldConverter(ConvertFunc convert_func)
 220       : convert_func_(convert_func) {}
 221
 222   bool Convert(const base::Value& value, FieldType* field) const override {
 223     std::string string_value;
 224     return value.GetAsString(&string_value) &&
 225         convert_func_(string_value, field);
 226   }
 227
 228  private:
 229   ConvertFunc convert_func_;
 230
 231   DISALLOW_COPY_AND_ASSIGN(CustomFieldConverter);
 232 };
 233
 234 template <typename NestedType>
 235 class NestedValueConverter : public ValueConverter<NestedType> {
 236  public:
 237   NestedValueConverter() {}
 238
 239   bool Convert(const base::Value& value, NestedType* field) const override {
 240     return converter_.Convert(value, field);
 241   }
 242
 243  private:
 244   JSONValueConverter<NestedType> converter_;
 245   DISALLOW_COPY_AND_ASSIGN(NestedValueConverter);
 246 };
 247
 248 template <typename Element>
 249 class RepeatedValueConverter : public ValueConverter<ScopedVector<Element> > {
 250  public:
 251   RepeatedValueConverter() {}
 252
 253   bool Convert(const base::Value& value,
 254                ScopedVector<Element>* field) const override {
 255     const base::ListValue* list = NULL;
 256     if (!value.GetAsList(&list)) {
 257       // The field is not a list.
 258       return false;
 259     }
 260
 261     field->reserve(list->GetSize());
 262     for (size_t i = 0; i < list->GetSize(); ++i) {
 263       const base::Value* element = NULL;
 264       if (!list->Get(i, &element))
 265         continue;
 266
 267       scoped_ptr<Element> e(new Element);
 268       if (basic_converter_.Convert(*element, e.get())) {
 269         field->push_back(e.release());
 270       } else {
 271         DVLOG(1) << "failure at " << i << "-th element";
 272         return false;
 273       }
 274     }
 275     return true;
 276   }
 277
 278  private:
 279   BasicValueConverter<Element> basic_converter_;
 280   DISALLOW_COPY_AND_ASSIGN(RepeatedValueConverter);
 281 };
 282
 283 template <typename NestedType>
 284 class RepeatedMessageConverter
 285     : public ValueConverter<ScopedVector<NestedType> > {
 286  public:
 287   RepeatedMessageConverter() {}
 288
 289   bool Convert(const base::Value& value,
 290                ScopedVector<NestedType>* field) const override {
 291     const base::ListValue* list = NULL;
 292     if (!value.GetAsList(&list))
 293       return false;
 294
 295     field->reserve(list->GetSize());
 296     for (size_t i = 0; i < list->GetSize(); ++i) {
 297       const base::Value* element = NULL;
 298       if (!list->Get(i, &element))
 299         continue;
 300
 301       scoped_ptr<NestedType> nested(new NestedType);
 302       if (converter_.Convert(*element, nested.get())) {
 303         field->push_back(nested.release());
 304       } else {
 305         DVLOG(1) << "failure at " << i << "-th element";
 306         return false;
 307       }
 308     }
 309     return true;
 310   }
 311
 312  private:
 313   JSONValueConverter<NestedType> converter_;
 314   DISALLOW_COPY_AND_ASSIGN(RepeatedMessageConverter);
 315 };
 316
 317 template <typename NestedType>
 318 class RepeatedCustomValueConverter
 319     : public ValueConverter<ScopedVector<NestedType> > {
 320  public:
 321   typedef bool(*ConvertFunc)(const base::Value* value, NestedType* field);
 322
 323   RepeatedCustomValueConverter(ConvertFunc convert_func)
 324       : convert_func_(convert_func) {}
 325
 326   bool Convert(const base::Value& value,
 327                ScopedVector<NestedType>* field) const override {
 328     const base::ListValue* list = NULL;
 329     if (!value.GetAsList(&list))
 330       return false;
 331
 332     field->reserve(list->GetSize());
 333     for (size_t i = 0; i < list->GetSize(); ++i) {
 334       const base::Value* element = NULL;
 335       if (!list->Get(i, &element))
 336         continue;
 337
 338       scoped_ptr<NestedType> nested(new NestedType);
 339       if ((*convert_func_)(element, nested.get())) {
 340         field->push_back(nested.release());
 341       } else {
 342         DVLOG(1) << "failure at " << i << "-th element";
 343         return false;
 344       }
 345     }
 346     return true;
 347   }
 348
 349  private:
 350   ConvertFunc convert_func_;
 351   DISALLOW_COPY_AND_ASSIGN(RepeatedCustomValueConverter);
 352 };
 353
 354
 355 }  // namespace internal
 356
 357 template <class StructType>
 358 class JSONValueConverter {
 359  public:
 360   JSONValueConverter() {
 361     StructType::RegisterJSONConverter(this);
 362   }
 363
 364   void RegisterIntField(const std::string& field_name,
 365                         int StructType::* field) {
 366     fields_.push_back(new internal::FieldConverter<StructType, int>(
 367         field_name, field, new internal::BasicValueConverter<int>));
 368   }
 369
 370   void RegisterStringField(const std::string& field_name,
 371                            std::string StructType::* field) {
 372     fields_.push_back(new internal::FieldConverter<StructType, std::string>(
 373         field_name, field, new internal::BasicValueConverter<std::string>));
 374   }
 375
 376   void RegisterStringField(const std::string& field_name,
 377                            string16 StructType::* field) {
 378     fields_.push_back(new internal::FieldConverter<StructType, string16>(
 379         field_name, field, new internal::BasicValueConverter<string16>));
 380   }
 381
 382   void RegisterBoolField(const std::string& field_name,
 383                          bool StructType::* field) {
 384     fields_.push_back(new internal::FieldConverter<StructType, bool>(
 385         field_name, field, new internal::BasicValueConverter<bool>));
 386   }
 387
 388   void RegisterDoubleField(const std::string& field_name,
 389                            double StructType::* field) {
 390     fields_.push_back(new internal::FieldConverter<StructType, double>(
 391         field_name, field, new internal::BasicValueConverter<double>));
 392   }
 393
 394   template <class NestedType>
 395   void RegisterNestedField(
 396       const std::string& field_name, NestedType StructType::* field) {
 397     fields_.push_back(new internal::FieldConverter<StructType, NestedType>(
 398             field_name,
 399             field,
 400             new internal::NestedValueConverter<NestedType>));
 401   }
 402
 403   template <typename FieldType>
 404   void RegisterCustomField(
 405       const std::string& field_name,
 406       FieldType StructType::* field,
 407       bool (*convert_func)(const StringPiece&, FieldType*)) {
 408     fields_.push_back(new internal::FieldConverter<StructType, FieldType>(
 409         field_name,
 410         field,
 411         new internal::CustomFieldConverter<FieldType>(convert_func)));
 412   }
 413
 414   template <typename FieldType>
 415   void RegisterCustomValueField(
 416       const std::string& field_name,
 417       FieldType StructType::* field,
 418       bool (*convert_func)(const base::Value*, FieldType*)) {
 419     fields_.push_back(new internal::FieldConverter<StructType, FieldType>(
 420         field_name,
 421         field,
 422         new internal::ValueFieldConverter<FieldType>(convert_func)));
 423   }
 424
 425   void RegisterRepeatedInt(const std::string& field_name,
 426                            ScopedVector<int> StructType::* field) {
 427     fields_.push_back(
 428         new internal::FieldConverter<StructType, ScopedVector<int> >(
 429             field_name, field, new internal::RepeatedValueConverter<int>));
 430   }
 431
 432   void RegisterRepeatedString(const std::string& field_name,
 433                               ScopedVector<std::string> StructType::* field) {
 434     fields_.push_back(
 435         new internal::FieldConverter<StructType, ScopedVector<std::string> >(
 436             field_name,
 437             field,
 438             new internal::RepeatedValueConverter<std::string>));
 439   }
 440
 441   void RegisterRepeatedString(const std::string& field_name,
 442                               ScopedVector<string16> StructType::* field) {
 443     fields_.push_back(
 444         new internal::FieldConverter<StructType, ScopedVector<string16> >(
 445             field_name,
 446             field,
 447             new internal::RepeatedValueConverter<string16>));
 448   }
 449
 450   void RegisterRepeatedDouble(const std::string& field_name,
 451                               ScopedVector<double> StructType::* field) {
 452     fields_.push_back(
 453         new internal::FieldConverter<StructType, ScopedVector<double> >(
 454             field_name, field, new internal::RepeatedValueConverter<double>));
 455   }
 456
 457   void RegisterRepeatedBool(const std::string& field_name,
 458                             ScopedVector<bool> StructType::* field) {
 459     fields_.push_back(
 460         new internal::FieldConverter<StructType, ScopedVector<bool> >(
 461             field_name, field, new internal::RepeatedValueConverter<bool>));
 462   }
 463
 464   template <class NestedType>
 465   void RegisterRepeatedCustomValue(
 466       const std::string& field_name,
 467       ScopedVector<NestedType> StructType::* field,
 468       bool (*convert_func)(const base::Value*, NestedType*)) {
 469     fields_.push_back(
 470         new internal::FieldConverter<StructType, ScopedVector<NestedType> >(
 471             field_name,
 472             field,
 473             new internal::RepeatedCustomValueConverter<NestedType>(
 474                 convert_func)));
 475   }
 476
 477   template <class NestedType>
 478   void RegisterRepeatedMessage(const std::string& field_name,
 479                                ScopedVector<NestedType> StructType::* field) {
 480     fields_.push_back(
 481         new internal::FieldConverter<StructType, ScopedVector<NestedType> >(
 482             field_name,
 483             field,
 484             new internal::RepeatedMessageConverter<NestedType>));
 485   }
 486
 487   bool Convert(const base::Value& value, StructType* output) const {
 488     const DictionaryValue* dictionary_value = NULL;
 489     if (!value.GetAsDictionary(&dictionary_value))
 490       return false;
 491
 492     for(size_t i = 0; i < fields_.size(); ++i) {
 493       const internal::FieldConverterBase<StructType>* field_converter =
 494           fields_[i];
 495       const base::Value* field = NULL;
 496       if (dictionary_value->Get(field_converter->field_path(), &field)) {
 497         if (!field_converter->ConvertField(*field, output)) {
 498           DVLOG(1) << "failure at field " << field_converter->field_path();
 499           return false;
 500         }
 501       }
 502     }
 503     return true;
 504   }
 505
 506  private:
 507   ScopedVector<internal::FieldConverterBase<StructType> > fields_;
 508
 509   DISALLOW_COPY_AND_ASSIGN(JSONValueConverter);
 510 };
 511
 512 }  // namespace base
 513
 514 #endif  // BASE_JSON_JSON_VALUE_CONVERTER_H_