Move implementation from header to source.

base/values.h

 // Copyright (c) 2010 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 86 matching lines @@
   // 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:
   // This isn't safe for end-users (they should use the Create*Value()
   // static methods above), but it's useful for subclasses.
-  explicit Value(ValueType type) : type_(type) {}
+  explicit Value(ValueType type);
 
  private:
   Value();
 
   ValueType type_;
 
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 // FundamentalValue represents the simple fundamental types of values.
 class FundamentalValue : public Value {
  public:
-  explicit FundamentalValue(bool in_value)
-    : Value(TYPE_BOOLEAN), boolean_value_(in_value) {}
-  explicit FundamentalValue(int in_value)
-    : Value(TYPE_INTEGER), integer_value_(in_value) {}
-  explicit FundamentalValue(double in_value)
-    : Value(TYPE_REAL), real_value_(in_value) {}
+  explicit FundamentalValue(bool in_value);
+  explicit FundamentalValue(int in_value);
+  explicit FundamentalValue(double in_value);
   ~FundamentalValue();
 
   // Subclassed methods
   virtual bool GetAsBoolean(bool* out_value) const;
   virtual bool GetAsInteger(int* out_value) const;
   virtual bool GetAsReal(double* out_value) const;
   virtual Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
@@ skipping 63 matching lines @@
   BinaryValue(char* buffer, size_t size);
 
   char* buffer_;
   size_t size_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryValue);
 };
 
 class DictionaryValue : public Value {
  public:
-  DictionaryValue() : Value(TYPE_DICTIONARY) {}
+  DictionaryValue();
   ~DictionaryValue();
 
   // Subclassed methods
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
   // Returns true if the current dictionary has a value for the given key.
   bool HasKeyASCII(const std::string& key) const;
   // Deprecated version of the above.  TODO: add a string16 version for Unicode.
   // http://code.google.com/p/chromium/issues/detail?id=23581
@@ skipping 125 matching lines @@
 
  private:
   ValueMap dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(DictionaryValue);
 };
 
 // This type of Value represents a list of other Value values.
 class ListValue : public Value {
  public:
-  ListValue() : Value(TYPE_LIST) {}
+  ListValue();
   ~ListValue();
 
   // Subclassed methods
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
   // Clears the contents of this ListValue
   void Clear();
 
   // Returns the number of Values in this list.
@@ skipping 62 matching lines @@
  private:
   ValueVector list_;
 
   DISALLOW_COPY_AND_ASSIGN(ListValue);
 };
 
 // This interface is implemented by classes that know how to serialize and
 // deserialize Value objects.
 class ValueSerializer {
  public:
-  virtual ~ValueSerializer() {}
+  virtual ~ValueSerializer();
 
   virtual bool Serialize(const Value& root) = 0;
 
   // This method deserializes the subclass-specific format into a Value object.
   // If the return value is non-NULL, the caller takes ownership of returned
   // Value. If the return value is NULL, and if error_code is non-NULL,
   // error_code will be set with the underlying error.
   // If |error_message| is non-null, it will be filled in with a formatted
   // error message including the location of the error if appropriate.
   virtual Value* Deserialize(int* error_code, std::string* error_str) = 0;
 };
 
 #endif  // BASE_VALUES_H_