Base: add Optional<T>.

base/optional.h

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_OPTIONAL_H_
+#define BASE_OPTIONAL_H_
+
+#include <cstddef>
+
+#include "base/logging.h"
+
+namespace base {
+
+// base::Optional is a Chromium version of the C++ library experimental optional
+// class: http://en.cppreference.com/w/cpp/experimental/optional/optional
+// It is not meant to be a full implementation of the experimental class but a

[danakj, 2015/10/15 20:45:26]

Why? Can you expand?

[mlamouri (slow - plz ping), 2015/10/24 09:46:59]

Done.

+// subset of it. It uses nullptr_t instead of exeperimental::nullopt_t.

[mlamouri (slow - plz ping), 2015/08/23 14:35:03]

If preferred, I can create an Optional::nullopt_t?

[danakj, 2015/10/15 20:45:26]

nullptr i guess is misleading cuz this isn't holding a pointer. also it could be
holding a pointer, and nullopt would be different from nullptr. ie missing vs
present-but-null. base::nullopt_t is probably what we would want?

[mlamouri (slow - plz ping), 2015/10/24 09:46:59]

Done.

+template <typename T>
+class Optional {
+ public:
+  Optional() : value_(), is_null_(true) { }
+  Optional(std::nullptr_t) : value_(), is_null_(true) { }

[danakj, 2015/10/15 20:45:26]

std::nullptr_t is a c++11 library feature. no go.

you could use decltype(nullptr)

[mlamouri (slow - plz ping), 2015/10/24 09:46:59]

I switched to base::nullopt_t;

+  Optional(const T& value) : value_(value), is_null_(false) { }
+  Optional(const Optional& other)
+      : value_(other.value_), is_null_(other.is_null_) {
+  }
+
+  Optional& operator=(std::nullptr_t) {

[danakj, 2015/10/15 20:45:26]

styleguide says to name all arguments even if not used

[mlamouri (slow - plz ping), 2015/10/24 09:46:59]

Done.

+    value_ = T();
+    is_null_ = true;
+    return *this;
+  }
+
+  Optional& operator=(const Optional& other) {
+    value_ = other.value_;
+    is_null_ = other.is_null_;
+    return *this;
+  }
+
+  Optional& operator=(const T& value) {
+    value_ = value;
+    is_null_ = false;
+    return *this;
+  }
+
+  const T* operator->() const { DCHECK(!is_null_); return &value_; }
+  T* operator->() { DCHECK(!is_null_); return &value_; }
+  const T& operator*() const { DCHECK(!is_null_); return value_; }
+  T& operator*() { DCHECK(!is_null_); return value_; }
+
+  explicit operator bool() const { return !is_null_; }
+
+  const T& value() const { DCHECK(!is_null_); return value_; }
+  T& value() { DCHECK(!is_null_); return value_; }
+
+  const T& value_or(const T& default_value) const {
+    return is_null_ ? default_value : value_;
+  }
+
+  bool operator==(const Optional& other) const {
+    return (is_null_ && other.is_null_) ||
+           (!is_null_ && !other.is_null_ && value_ == other.value_);
+  }
+
+  bool operator!=(const Optional& other) const {
+    return !this->operator==(other);
+  }
+
+ private:
+  T value_;

[danakj, 2015/10/15 20:45:26]

This is going to default-construct a T even if you don't have one in the
optional. But not all Ts are default-constructable.

You should take a look at the WTF implementation which does not have this
unintended (and different from libc++) behaviour:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

libc++ uses a union, but that depends on union of class types which is a new
c++11 feature: http://en.cppreference.com/w/cpp/language/union and not allowed
by our c++11 style guide yet (no one has proposed it afaik). jbroman says he
tried it and found an issue with msvc maybe.

[mlamouri (slow - plz ping), 2015/10/24 09:46:59]

Done.

+  bool is_null_;
+};
+
+}  // namespace base
+
+#endif // BASE_OPTIONAL_H_