Add rtc::Optional::reset

webrtc/base/optional.h

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 114 matching lines @@
   // copy constructor if only the right-hand side has a value.
   Optional& operator=(const Optional& m) {
     if (m.has_value_) {
       if (has_value_) {
         value_ = m.value_;  // T's copy assignment.
       } else {
         UnpoisonValue();
         new (&value_) T(m.value_);  // T's copy constructor.
         has_value_ = true;
       }
-    } else if (has_value_) {
-      value_.~T();
-      has_value_ = false;
-      PoisonValue();
+    } else {
+      reset();
     }
     return *this;
   }
 
   // Move assignment. Uses T's move assignment if both sides have a value, T's
   // move constructor if only the right-hand side has a value. The state of m
   // after it's been moved from is as for the move constructor.
   Optional& operator=(Optional&& m) {
     if (m.has_value_) {
       if (has_value_) {
         value_ = std::move(m.value_);  // T's move assignment.
       } else {
         UnpoisonValue();
         new (&value_) T(std::move(m.value_));  // T's move constructor.
         has_value_ = true;
       }
-    } else if (has_value_) {
-      value_.~T();
-      has_value_ = false;
-      PoisonValue();
+    } else {
+      reset();
     }
     return *this;
   }
 
   // Swap the values if both m1 and m2 have values; move the value if only one
   // of them has one.
   friend void swap(Optional& m1, Optional& m2) {
     if (m1.has_value_) {
       if (m2.has_value_) {
         // Both have values: swap.
@@ skipping 12 matching lines @@
       // Only m2 has a value: move it to m1.
       m1.UnpoisonValue();
       new (&m1.value_) T(std::move(m2.value_));
       m2.value_.~T();  // Destroy the moved-from value.
       m1.has_value_ = true;
       m2.has_value_ = false;
       m2.PoisonValue();
     }
   }
 
+  // Destroy any contained value. Has no effect if we have no value.
+  void reset() {
+    if (!has_value_)
+      return;
+    value_.~T();
+    has_value_ = false;
+    PoisonValue();
+  }
+
   // Conversion to bool to test if we have a value.
   explicit operator bool() const { return has_value_; }
 
   // Dereferencing. Only allowed if we have a value.
   const T* operator->() const {
     RTC_DCHECK(has_value_);
     return &value_;
   }
   T* operator->() {
     RTC_DCHECK(has_value_);
@@ skipping 52 matching lines @@
     // construct it, and the Optional destructor won't automatically destroy
     // it. Basically, this just allocates a properly sized and aligned block of
     // memory in which we can manually put a T with placement new.
     T value_;
   };
 };
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_OPTIONAL_H_