Made rtc::Optional a bit more like std::optional.

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 44 matching lines @@
 //
 // TODO(kwiberg): Get rid of this class when the standard library has
 // std::optional (and we're allowed to use it).
 template <typename T>
 class Optional final {
  public:
   // Construct an empty Optional.
   Optional() : has_value_(false) {}
 
   // Construct an Optional that contains a value.
-  explicit Optional(const T& value) : has_value_(true) {
+  Optional(const T& value) : has_value_(true) {

[tommi, 2016/06/16 16:08:22]

this goes against the style guide though.  Is requiring explicit causing
problems?

[kwiberg-webrtc, 2016/06/16 17:26:42]

It's very convenient to have T convert implicitly to Optional<T>, and it's what
std::optional does. The standard library violates our style guide quite a lot...

     new (&value_) T(value);
   }
-  explicit Optional(T&& value) : has_value_(true) {
+  Optional(T&& value) : has_value_(true) {
     new (&value_) T(std::move(value));
   }
 
   // Copy constructor: copies the value from m if it has one.
   Optional(const Optional& m) : has_value_(m.has_value_) {
     if (has_value_)
       new (&value_) T(m.value_);
   }
 
   // Move constructor: if m has a value, moves the value from m, leaving m
@@ skipping 100 matching lines @@
   // if they're both empty.
   friend bool operator==(const Optional& m1, const Optional& m2) {
     return m1.has_value_ && m2.has_value_ ? m1.value_ == m2.value_
                                           : m1.has_value_ == m2.has_value_;
   }
   friend bool operator!=(const Optional& m1, const Optional& m2) {
     return m1.has_value_ && m2.has_value_ ? m1.value_ != m2.value_
                                           : m1.has_value_ != m2.has_value_;
   }
 
+  friend bool operator==(const Optional& opt, const T& val) {
+    return opt.has_value_ && opt.value_ == val;
+  }
+
+  friend bool operator==(const T& val, const Optional& opt) {
+    return opt == val;
+  }
+
+  friend bool operator!=(const Optional& opt, const T& val) {
+    return !(opt == val);
+  }
+
+  friend bool operator!=(const T& val, const Optional& opt) {
+    return !(opt == val);
+  }
+
  private:
   bool has_value_;  // True iff value_ contains a live value.
   union {
     // By placing value_ in a union, we get to manage its construction and
     // destruction manually: the Optional constructors won't automatically
     // 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_