Add nonstd::unique_ptr move assigment operator.

third_party/base/nonstd_unique_ptr.h

 // Copyright 2013 Google Inc. All Rights Reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
@@ skipping 158 matching lines @@
   // this->reset(this->get()) works.
   void reset(C* p = NULL) {
     if (p != ptr_) {
       enum { type_must_be_complete = sizeof(C) };
       C* old_ptr = ptr_;
       ptr_ = p;
       delete old_ptr;
     }
   }
 
+  // Move assignment.
+  unique_ptr<C>& operator=(unique_ptr<C>&& that) {
+    if (that.ptr_ != ptr_) {

[Jeffrey Yasskin, 2015/09/22 20:12:55]

Implement this as "reset(that.release());"

[Tom Sepez, 2015/09/22 22:05:13]

Done. clever.

+      enum { type_must_be_complete = sizeof(C) };
+      C* old_ptr = ptr_;
+      ptr_ = that.ptr_;
+      that.ptr_ = nullptr;
+      delete old_ptr;
+    }
+    return *this;
+  }
+
 private:
   // Forbid comparison of unique_ptr types.  If C2 != C, it totally doesn't
   // make sense, and if C2 == C, it still doesn't make sense because you should
   // never have the same object owned by two different unique_ptrs.
   template <class C2> bool operator==(unique_ptr<C2> const& p2) const;
   template <class C2> bool operator!=(unique_ptr<C2> const& p2) const;
 
   // Disallow evil constructors. It doesn't make sense to make a copy of
   // something that's allegedly unique.
   unique_ptr(const unique_ptr&) = delete;
   void operator=(const unique_ptr&) = delete;
 };
 
 // Specialization for arrays using delete[].
 template <class C>
 class unique_ptr<C[]> : public unique_ptr_base<C> {

[Jeffrey Yasskin, 2015/09/22 20:12:55]

Probably keep unique_ptr<C[]> consistent with unique_ptr<C> by adding the move
assignment here too.

[Tom Sepez, 2015/09/22 22:05:13]

Done.

  public:
   using unique_ptr_base<C>::ptr_;
 
   // Constructor. Defaults to initializing with NULL. There is no way
   // to create an uninitialized unique_ptr. The input parameter must be
   // allocated with new[] (not new - see above).
   explicit unique_ptr(C* p = NULL) : unique_ptr_base<C>(p) { }
 
   // Move constructor.
   unique_ptr(unique_ptr<C>&& that) : unique_ptr_base<C>(nonstd::move(that)) {}
@@ skipping 45 matching lines @@
 }
 
 template <class C>
 bool operator!=(C* p1, const unique_ptr<C>& p2) {
   return p1 != p2.get();
 }
 
 }  // namespace nonstd
 
 #endif  // NONSTD_UNIQUE_PTR_H_