Add custom field converter to JSONValueConverter.

base/json/json_value_converter.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef BASE_JSON_JSON_VALUE_CONVERTER_H_
 #define BASE_JSON_JSON_VALUE_CONVERTER_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
+#include "base/string_piece.h"
 #include "base/values.h"
 
 // JSONValueConverter converts a JSON value into a C++ struct in a
 // lightweight way.
 //
 // Usage:
 // For real examples, you may want to refer to _unittest.cc file.
 //
 // Assume that you have a struct like this:
 //   struct Message {
@@ skipping 32 matching lines @@
 //     static void RegisterJSONConverter(...) {
 //       ...
 //       converter->RegisterNestedField("foo", &Nested::foo);
 //     }
 //   };
 //
 // For repeated field, we just assume std::vector for its container
 // and you can put RegisterRepeatedInt or some other types.  Use
 // RegisterRepeatedMessage for nested repeated fields.
 //
+// Sometimes JSON format uses string representations for other types such
+// like enum, timestamp, or URL.  You can use RegisterCustomField method
+// and specify a function to convert a StringPiece to your type.
+//   bool ConvertFunc(const StringPiece& s, YourEnum* result) {
+//     // do something and return true if succeed...
+//   }
+//   struct Message {
+//     YourEnum ye;
+//     ...
+//     static void RegisterJSONConverter(...) {
+//       ...
+//       converter->RegsiterCustomField<YourEnum>(
+//           "your_enum", &Message::ye, &ConvertFunc);
+//     }
+//   };
 
 namespace base {
 
 template <typename StructType>
 class JSONValueConverter;
 
 namespace internal {
 
 class FieldConverterBase {
  public:
@@ skipping 100 matching lines @@
   BasicValueConverter() {}
 
   virtual bool Convert(const base::Value& value, bool* field) const OVERRIDE {
     return value.GetAsBoolean(field);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BasicValueConverter);
 };
 
+template <typename FieldType>
+class CustomFieldConverter : public ValueConverter<FieldType> {
+ public:
+  typedef bool(*ConvertFunc)(const StringPiece& value, FieldType* field);
+
+  CustomFieldConverter(ConvertFunc convert_func)
+      : convert_func_(convert_func) {}
+
+  virtual bool Convert(const base::Value& value,
+                       FieldType* field) const OVERRIDE {
+    std::string string_value;
+    return value.GetAsString(&string_value) &&
+        convert_func_(string_value, field);
+  }
+
+ private:
+  ConvertFunc convert_func_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomFieldConverter);
+};
+
 template <typename NestedType>
 class NestedValueConverter : public ValueConverter<NestedType> {
  public:
   NestedValueConverter() {}
 
   virtual bool Convert(
       const base::Value& value, NestedType* field) const OVERRIDE {
     return converter_.Convert(value, field);
   }
 
@@ skipping 113 matching lines @@
 
   template <class NestedType>
   void RegisterNestedField(
       const std::string& field_name, NestedType StructType::* field) {
     fields_.push_back(new internal::FieldConverter<StructType, NestedType>(
             field_name,
             field,
             new internal::NestedValueConverter<NestedType>));
   }
 
+  template <typename FieldType>
+  void RegisterCustomField(
+      const std::string& field_name,
+      FieldType StructType::* field,
+      bool (*convert_func)(const StringPiece&, FieldType*)) {
+    fields_.push_back(new internal::FieldConverter<StructType, FieldType>(
+        field_name,
+        field,
+        new internal::CustomFieldConverter<FieldType>(convert_func)));
+  }
+
   void RegisterRepeatedInt(const std::string& field_name,
                            std::vector<int> StructType::* field) {
     fields_.push_back(
         new internal::FieldConverter<StructType, std::vector<int> >(
             field_name, field, new internal::RepeatedValueConverter<int>));
   }
 
   void RegisterRepeatedString(const std::string& field_name,
                               std::vector<std::string> StructType::* field) {
     fields_.push_back(
@@ skipping 56 matching lines @@
 
  private:
   std::vector<internal::FieldConverterBase*> fields_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONValueConverter);
 };
 
 }  // namespace base
 
 #endif  // BASE_JSON_JSON_VALUE_CONVERTER_H_