Use std::unique_ptr for ValueBase object hierarchy

1 files changed, 97 insertions, 80 deletions

diff --git a/src/ValueBase.cc b/src/ValueBase.cc
index b8c4e6db..d8a3afdf 100644
--- a/src/ValueBase.cc
+++ b/src/ValueBase.cc
@@ -36,39 +36,49 @@
 
 namespace aria2 {
 
-const std::shared_ptr<ValueBase> ValueBase::none;
+String::String(const ValueType& string):str_{string} {}
+String::String(ValueType&& string):str_{std::move(string)} {}
 
-String::String(const ValueType& string):str_(string) {}
+String::String(const char* cstring):str_{cstring} {}
 
-String::String(const char* cstring):str_(cstring) {}
+String::String(const char* data, size_t length)
+  : str_{&data[0], &data[length]}
+ {}
 
-String::String(const char* data, size_t length):str_(&data[0], &data[length]) {}
-
-String::String(const unsigned char* data, size_t length):
-  str_(&data[0], &data[length]) {}
+String::String(const unsigned char* data, size_t length)
+  : str_{&data[0], &data[length]}
+ {}
 
 String::String() {}
 
-String::~String() {}
-
 const String::ValueType& String::s() const
 {
   return str_;
 }
 
+String::ValueType String::popValue() const
+{
+  return std::move(str_);
+}
+
 const unsigned char* String::uc() const
 {
   return reinterpret_cast<const unsigned char*>(str_.data());
 }
 
-std::shared_ptr<String> String::g(const ValueType& string)
+std::unique_ptr<String> String::g(const ValueType& string)
 {
-  return std::shared_ptr<String>(new String(string));
+  return make_unique<String>(string);
 }
 
-std::shared_ptr<String> String::g(const unsigned char* data, size_t length)
+std::unique_ptr<String> String::g(ValueType&& string)
 {
-  return std::shared_ptr<String>(new String(data, length));
+  return make_unique<String>(std::move(string));
+}
+
+std::unique_ptr<String> String::g(const unsigned char* data, size_t length)
+{
+  return make_unique<String>(data, length);
 }
 
 void String::accept(ValueBaseVisitor& v) const
@@ -76,20 +86,18 @@ void String::accept(ValueBaseVisitor& v) const
   v.visit(*this);
 }
 
-Integer::Integer(ValueType integer):integer_(integer) {}
-
-Integer::Integer():integer_(0) {}
+Integer::Integer(ValueType integer) : integer_{integer} {}
 
-Integer::~Integer() {}
+Integer::Integer() : integer_{0} {}
 
 Integer::ValueType Integer::i() const
 {
   return integer_;
 }
 
-std::shared_ptr<Integer> Integer::g(ValueType integer)
+std::unique_ptr<Integer> Integer::g(ValueType integer)
 {
-  return std::shared_ptr<Integer>(new Integer(integer));
+  return make_unique<Integer>(integer);
 }
 
 void Integer::accept(ValueBaseVisitor& v) const
@@ -97,17 +105,16 @@ void Integer::accept(ValueBaseVisitor& v) const
   v.visit(*this);
 }
 
-const std::shared_ptr<Bool> Bool::trueValue_(new Bool(true));
-const std::shared_ptr<Bool> Bool::falseValue_(new Bool(false));
+Bool::Bool(bool val):val_{val} {}
 
-std::shared_ptr<Bool> Bool::gTrue()
+std::unique_ptr<Bool> Bool::gTrue()
 {
-  return trueValue_;
+  return make_unique<Bool>(true);
 }
 
-std::shared_ptr<Bool> Bool::gFalse()
+std::unique_ptr<Bool> Bool::gFalse()
 {
-  return falseValue_;
+  return make_unique<Bool>(false);
 }
 
 bool Bool::val() const
@@ -120,13 +127,11 @@ void Bool::accept(ValueBaseVisitor& v) const
   v.visit(*this);
 }
 
-Bool::Bool(bool val):val_(val) {}
-
-const std::shared_ptr<Null> Null::nullValue_(new Null());
+Null::Null() {}
 
-std::shared_ptr<Null> Null::g()
+std::unique_ptr<Null> Null::g()
 {
-  return nullValue_;
+  return make_unique<Null>();
 }
 
 void Null::accept(ValueBaseVisitor& v) const
@@ -134,41 +139,37 @@ void Null::accept(ValueBaseVisitor& v) const
   v.visit(*this);
 }
 
-Null::Null() {}
-
 List::List() {}
 
-List::~List() {}
-
-const std::shared_ptr<ValueBase>& List::get(size_t index) const
+ValueBase* List::get(size_t index) const
 {
-  return list_[index];
+  return list_[index].get();
 }
 
-void List::set(size_t index, const std::shared_ptr<ValueBase>& v)
+void List::set(size_t index, std::unique_ptr<ValueBase> v)
 {
-  list_[index] = v;
+  list_[index] = std::move(v);
 }
 
-void List::append(const std::shared_ptr<ValueBase>& v)
+void List::append(std::unique_ptr<ValueBase> v)
 {
-  list_.push_back(v);
+  list_.push_back(std::move(v));
 }
 
-void List::append(const String::ValueType& string)
+void List::append(String::ValueType string)
 {
-  list_.push_back(String::g(string));
+  list_.push_back(String::g(std::move(string)));
 }
 
-List& List::operator<<(const std::shared_ptr<ValueBase>& v)
+List& List::operator<<(std::unique_ptr<ValueBase> v)
 {
-  list_.push_back(v);
+  list_.push_back(std::move(v));
   return *this;
 }
 
-const std::shared_ptr<ValueBase>& List::operator[](size_t index) const
+ValueBase* List::operator[](size_t index) const
 {
-  return list_[index];
+  return list_[index].get();
 }
 
 List::ValueType::iterator List::begin()
@@ -191,6 +192,16 @@ List::ValueType::const_iterator List::end() const
   return list_.end();
 }
 
+List::ValueType::const_iterator List::cbegin() const
+{
+  return list_.cbegin();
+}
+
+List::ValueType::const_iterator List::cend() const
+{
+  return list_.cend();
+}
+
 size_t List::size() const
 {
   return list_.size();
@@ -201,9 +212,9 @@ bool List::empty() const
   return list_.empty();
 }
 
-std::shared_ptr<List> List::g()
+std::unique_ptr<List> List::g()
 {
-  return std::shared_ptr<List>(new List());
+  return make_unique<List>();
 }
 
 void List::accept(ValueBaseVisitor& v) const
@@ -213,55 +224,38 @@ void List::accept(ValueBaseVisitor& v) const
 
 Dict::Dict() {}
 
-Dict::~Dict() {}
-
-void Dict::put(const std::string& key, const std::shared_ptr<ValueBase>& vlb)
+void Dict::put(std::string key, std::unique_ptr<ValueBase> vlb)
 {
-  ValueType::value_type p = std::make_pair(key, vlb);
-  std::pair<ValueType::iterator, bool> r = dict_.insert(p);
+  auto p = std::make_pair(std::move(key), std::move(vlb));
+  auto r = dict_.insert(std::move(p));
   if(!r.second) {
-    (*r.first).second = vlb;
+    (*r.first).second = std::move(vlb);
   }
 }
 
-void Dict::put(const std::string& key, const String::ValueType& string)
+void Dict::put(std::string key, String::ValueType string)
 {
-  put(key, String::g(string));
+  put(std::move(key), String::g(std::move(string)));
 }
 
-const std::shared_ptr<ValueBase>& Dict::get(const std::string& key) const
+ValueBase* Dict::get(const std::string& key) const
 {
-  ValueType::const_iterator itr = dict_.find(key);
-  if(itr == dict_.end()) {
-    return ValueBase::none;
+  auto itr = dict_.find(key);
+  if(itr == std::end(dict_)) {
+    return nullptr;
   } else {
-    return (*itr).second;
+    return (*itr).second.get();
   }
 }
 
-std::shared_ptr<ValueBase>& Dict::get(const std::string& key)
-{
-  ValueType::iterator itr = dict_.find(key);
-  if(itr == dict_.end()) {
-    return dict_[key];
-  } else {
-    return (*itr).second;
-  }
-}
-
-std::shared_ptr<ValueBase>& Dict::operator[](const std::string& key)
-{
-  return get(key);
-}
-
-const std::shared_ptr<ValueBase>& Dict::operator[](const std::string& key) const
+ValueBase* Dict::operator[](const std::string& key) const
 {
   return get(key);
 }
 
 bool Dict::containsKey(const std::string& key) const
 {
-  return dict_.count(key) == 1;
+  return dict_.count(key);
 }
 
 void Dict::removeKey(const std::string& key)
@@ -269,6 +263,18 @@ void Dict::removeKey(const std::string& key)
   dict_.erase(key);
 }
 
+std::unique_ptr<ValueBase> Dict::popValue(const std::string& key)
+{
+  auto i = dict_.find(key);
+  if(i == std::end(dict_)) {
+    return nullptr;
+  } else {
+    auto res = std::move((*i).second);
+    dict_.erase(i);
+    return res;
+  }
+}
+
 Dict::ValueType::iterator Dict::begin()
 {
   return dict_.begin();
@@ -289,6 +295,16 @@ Dict::ValueType::const_iterator Dict::end() const
   return dict_.end();
 }
 
+Dict::ValueType::const_iterator Dict::cbegin() const
+{
+  return dict_.cbegin();
+}
+
+Dict::ValueType::const_iterator Dict::cend() const
+{
+  return dict_.cend();
+}
+
 size_t Dict::size() const
 {
   return dict_.size();
@@ -299,10 +315,11 @@ bool Dict::empty() const
   return dict_.empty();
 }
 
-std::shared_ptr<Dict> Dict::g()
+std::unique_ptr<Dict> Dict::g()
 {
-  return std::shared_ptr<Dict>(new Dict());
+  return make_unique<Dict>();
 }
+
 void Dict::accept(ValueBaseVisitor& v) const
 {
   v.visit(*this);