Added std::string to Value via Set/GetString overloading.

base/values.h

 // Copyright (c) 2006-2008 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.
 
 // This file specifies a recursive data storage class called Value
 // intended for storing setting and other persistable data.
 // It includes the ability to specify (recursive) lists and dictionaries, so
 // it's fairly expressive.  However, the API is optimized for the common case,
 // namely storing a hierarchical tree of simple values.  Given a
 // DictionaryValue root, you can easily do things like:
@@ skipping 34 matching lines @@
  public:
   virtual ~Value();
 
   // Convenience methods for creating Value objects for various
   // kinds of values without thinking about which class implements them.
   // These can always be expected to return a valid Value*.
   static Value* CreateNullValue();
   static Value* CreateBooleanValue(bool in_value);
   static Value* CreateIntegerValue(int in_value);
   static Value* CreateRealValue(double in_value);
+  static Value* CreateStringValue(const std::string& in_value);
   static Value* CreateStringValue(const std::wstring& in_value);
 
   // This one can return NULL if the input isn't valid.  If the return value
   // is non-null, the new object has taken ownership of the buffer pointer.
   static BinaryValue* CreateBinaryValue(char* buffer, size_t size);
 
   typedef enum {
     TYPE_NULL = 0,
     TYPE_BOOLEAN,
     TYPE_INTEGER,
@@ skipping 14 matching lines @@
   // Returns true if the current object represents a given type.
   bool IsType(ValueType type) const { return type == type_; }
 
   // These methods allow the convenient retrieval of settings.
   // If the current setting object can be converted into the given type,
   // the value is returned through the "value" parameter and true is returned;
   // otherwise, false is returned and "value" is unchanged.
   virtual bool GetAsBoolean(bool* out_value) const;
   virtual bool GetAsInteger(int* out_value) const;
   virtual bool GetAsReal(double* out_value) const;
+  virtual bool GetAsString(std::string* out_value) const;
   virtual bool GetAsString(std::wstring* out_value) const;
 
   // This creates a deep copy of the entire Value tree, and returns a pointer
   // to the copy.  The caller gets ownership of the copy, of course.
   virtual Value* DeepCopy() const;
 
   // Compares if two Value objects have equal contents.
   virtual bool Equals(const Value* other) const;
 
  protected:
@@ skipping 31 matching lines @@
 
   union {
     bool boolean_value_;
     int integer_value_;
     double real_value_;
   };
 };
 
 class StringValue : public Value {
  public:
-  StringValue(const std::wstring& in_value)
-    : Value(TYPE_STRING), value_(in_value) {}
+  // Initializes a StringValue with a UTF-8 narrow character string.
+  StringValue(const std::string& in_value);
+
+  // Initializes a StringValue with a wide character string.
+  StringValue(const std::wstring& in_value);
+
   ~StringValue();
 
   // Subclassed methods
+  bool GetAsString(std::string* out_value) const;
   bool GetAsString(std::wstring* out_value) const;
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
   DISALLOW_EVIL_CONSTRUCTORS(StringValue);
 
-  std::wstring value_;
+  std::string value_;
 };
 
 class BinaryValue: public Value {
 public:
   // Creates a Value to represent a binary buffer.  The new object takes
   // ownership of the pointer passed in, if successful.
   // Returns NULL if buffer is NULL.
   static BinaryValue* Create(char* buffer, size_t size);
 
   // For situations where you want to keep ownership of your buffer, this
@@ skipping 46 matching lines @@
   // to the path in that location.
   // Note that the dictionary takes ownership of the value
   // referenced by in_value.
   bool Set(const std::wstring& path, Value* in_value);
 
   // Convenience forms of Set().  These methods will replace any existing
   // value at that path, even if it has a different type.
   bool SetBoolean(const std::wstring& path, bool in_value);
   bool SetInteger(const std::wstring& path, int in_value);
   bool SetReal(const std::wstring& path, double in_value);
+  bool SetString(const std::wstring& path, const std::string& in_value);
   bool SetString(const std::wstring& path, const std::wstring& in_value);
 
   // Gets the Value associated with the given path starting from this object.
   // A path has the form "<key>" or "<key>.<key>.[...]", where "." indexes
   // into the next DictionaryValue down.  If the path can be resolved
   // successfully, the value for the last key in the path will be returned
   // through the "value" parameter, and the function will return true.
   // Otherwise, it will return false and "value" will be untouched.
   // Note that the dictionary always owns the value that's returned.
   bool Get(const std::wstring& path, Value** out_value) const;
 
   // These are convenience forms of Get().  The value will be retrieved
   // and the return value will be true if the path is valid and the value at
   // the end of the path can be returned in the form specified.
   bool GetBoolean(const std::wstring& path, bool* out_value) const;
   bool GetInteger(const std::wstring& path, int* out_value) const;
   bool GetReal(const std::wstring& path, double* out_value) const;
+  bool GetString(const std::wstring& path, std::string* out_value) const;
   bool GetString(const std::wstring& path, std::wstring* out_value) const;
   bool GetBinary(const std::wstring& path, BinaryValue** out_value) const;
   bool GetDictionary(const std::wstring& path,
                      DictionaryValue** out_value) const;
   bool GetList(const std::wstring& path, ListValue** out_value) const;
 
   // Removes the Value with the specified path from this dictionary (or one
   // of its child dictionaries, if the path is more than just a local key).
   // If |out_value| is non-NULL, the removed Value AND ITS OWNERSHIP will be
   // passed out via out_value.  If |out_value| is NULL, the removed value will
@@ skipping 106 matching lines @@
   // The method should return true if and only if the root parameter is set
   // to a complete Value representation of the serialized form.  If the
   // return value is true, the caller takes ownership of the objects pointed
   // to by root.  If the return value is false, root should be unchanged and if
   // error_message is non-null, it should be filled with a message describing
   // the error.
   virtual bool Deserialize(Value** root, std::string* error_message) = 0;
 };
 
 #endif  // BASE_VALUES_H_