extensions/common/value_builder.cc

   1 // Copyright 2013 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 #include "extensions/common/value_builder.h"
   6
   7 #include "base/json/json_writer.h"
   8
   9 namespace extensions {
  10
  11 // DictionaryBuilder
  12
  13 DictionaryBuilder::DictionaryBuilder() : dict_(new base::DictionaryValue) {}
  14
  15 DictionaryBuilder::DictionaryBuilder(const base::DictionaryValue& init)
  16     : dict_(init.DeepCopy()) {}
  17
  18 DictionaryBuilder::~DictionaryBuilder() {}
  19
  20 std::string DictionaryBuilder::ToJSON() const {
  21   std::string json;
  22   base::JSONWriter::WriteWithOptions(
  23       *dict_, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
  24   return json;
  25 }
  26
  27 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  28                                           int in_value) {
  29   dict_->SetWithoutPathExpansion(path, new base::FundamentalValue(in_value));
  30   return *this;
  31 }
  32
  33 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  34                                           double in_value) {
  35   dict_->SetWithoutPathExpansion(path, new base::FundamentalValue(in_value));
  36   return *this;
  37 }
  38
  39 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  40                                           const std::string& in_value) {
  41   dict_->SetWithoutPathExpansion(path, new base::StringValue(in_value));
  42   return *this;
  43 }
  44
  45 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  46                                           const base::string16& in_value) {
  47   dict_->SetWithoutPathExpansion(path, new base::StringValue(in_value));
  48   return *this;
  49 }
  50
  51 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  52                                           DictionaryBuilder& in_value) {
  53   dict_->SetWithoutPathExpansion(path, in_value.Build().Pass());
  54   return *this;
  55 }
  56
  57 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  58                                           ListBuilder& in_value) {
  59   dict_->SetWithoutPathExpansion(path, in_value.Build().Pass());
  60   return *this;
  61 }
  62
  63 DictionaryBuilder& DictionaryBuilder::Set(const std::string& path,
  64                                           scoped_ptr<base::Value> in_value) {
  65   dict_->SetWithoutPathExpansion(path, in_value.Pass());
  66   return *this;
  67 }
  68
  69 DictionaryBuilder& DictionaryBuilder::SetBoolean(
  70     const std::string& path, bool in_value) {
  71   dict_->SetWithoutPathExpansion(path, new base::FundamentalValue(in_value));
  72   return *this;
  73 }
  74
  75 // ListBuilder
  76
  77 ListBuilder::ListBuilder() : list_(new base::ListValue) {}
  78 ListBuilder::ListBuilder(const base::ListValue& init) : list_(init.DeepCopy()) {
  79 }
  80 ListBuilder::~ListBuilder() {}
  81
  82 ListBuilder& ListBuilder::Append(int in_value) {
  83   list_->Append(new base::FundamentalValue(in_value));
  84   return *this;
  85 }
  86
  87 ListBuilder& ListBuilder::Append(double in_value) {
  88   list_->Append(new base::FundamentalValue(in_value));
  89   return *this;
  90 }
  91
  92 ListBuilder& ListBuilder::Append(const std::string& in_value) {
  93   list_->Append(new base::StringValue(in_value));
  94   return *this;
  95 }
  96
  97 ListBuilder& ListBuilder::Append(const base::string16& in_value) {
  98   list_->Append(new base::StringValue(in_value));
  99   return *this;
 100 }
 101
 102 ListBuilder& ListBuilder::Append(DictionaryBuilder& in_value) {
 103   list_->Append(in_value.Build().Pass());
 104   return *this;
 105 }
 106
 107 ListBuilder& ListBuilder::Append(ListBuilder& in_value) {
 108   list_->Append(in_value.Build().Pass());
 109   return *this;
 110 }
 111
 112 ListBuilder& ListBuilder::AppendBoolean(bool in_value) {
 113   list_->Append(new base::FundamentalValue(in_value));
 114   return *this;
 115 }
 116
 117 }  // namespace extensions