diff --git a/webrtc/base/BUILD.gn b/webrtc/base/BUILD.gn index 79e204ed98..916a801700 100644 --- a/webrtc/base/BUILD.gn +++ b/webrtc/base/BUILD.gn @@ -114,6 +114,7 @@ static_library("rtc_base_approved") { "event_tracer.h", "exp_filter.cc", "exp_filter.h", + "maybe.h", "md5.cc", "md5.h", "md5digest.cc", diff --git a/webrtc/base/base.gyp b/webrtc/base/base.gyp index d57fe11aed..0db04389ca 100644 --- a/webrtc/base/base.gyp +++ b/webrtc/base/base.gyp @@ -53,6 +53,7 @@ 'exp_filter.h', 'logging.cc', 'logging.h', + 'maybe.h', 'md5.cc', 'md5.h', 'md5digest.cc', diff --git a/webrtc/base/base_tests.gyp b/webrtc/base/base_tests.gyp index f25f3e7b80..2c84036235 100644 --- a/webrtc/base/base_tests.gyp +++ b/webrtc/base/base_tests.gyp @@ -70,6 +70,7 @@ 'httpserver_unittest.cc', 'ipaddress_unittest.cc', 'logging_unittest.cc', + 'maybe_unittest.cc', 'md5digest_unittest.cc', 'messagedigest_unittest.cc', 'messagequeue_unittest.cc', diff --git a/webrtc/base/maybe.h b/webrtc/base/maybe.h new file mode 100644 index 0000000000..df204366d5 --- /dev/null +++ b/webrtc/base/maybe.h @@ -0,0 +1,121 @@ +/* + * 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. + */ + +#ifndef WEBRTC_BASE_MAYBE_H_ +#define WEBRTC_BASE_MAYBE_H_ + +#include +#include + +#include "webrtc/base/checks.h" + +namespace rtc { + +// Simple std::experimental::optional-wannabe. It either contains a T or not. +// In order to keep the implementation simple and portable, this implementation +// actually contains a (default-constructed) T even when it supposedly doesn't +// contain a value; use e.g. rtc::scoped_ptr instead if that's too +// expensive. +// +// A moved-from Maybe may only be destroyed, and assigned to if T allows +// being assigned to after having been moved from. Specifically, you may not +// assume that it just doesn't contain a value anymore. +// +// TODO(kwiberg): Get rid of this class when the standard library has +// std::optional (and we're allowed to use it). +template +class Maybe final { + public: + // Construct an empty Maybe. + Maybe() : has_value_(false) {} + + // Construct a Maybe that contains a value. Note: These are non-explicit, so + // that a T will implicitly convert to Maybe. + Maybe(const T& val) : value_(val), has_value_(true) {} + Maybe(T&& val) : value_(static_cast(val)), has_value_(true) {} + + // Copy and move constructors. + // TODO(kwiberg): =default the move constructor when MSVC supports it. + Maybe(const Maybe&) = default; + Maybe(Maybe&& m) + : value_(static_cast(m.value_)), has_value_(m.has_value_) {} + + // Assignment. Note that we allow assignment from either Maybe or plain T. + // TODO(kwiberg): =default the move assignment op when MSVC supports it. + Maybe& operator=(const Maybe&) = default; + Maybe& operator=(Maybe&& m) { + value_ = static_cast(m.value_); + has_value_ = m.has_value_; + return *this; + } + Maybe& operator=(const T& val) { + value_ = val; + has_value_ = true; + return *this; + } + Maybe& operator=(T&& val) { + value_ = static_cast(val); + has_value_ = true; + return *this; + } + + friend void swap(Maybe& m1, Maybe& m2) { + using std::swap; + swap(m1.value_, m2.value_); + swap(m1.has_value_, m2.has_value_); + } + + // 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_); + return &value_; + } + const T& operator*() const { + RTC_DCHECK(has_value_); + return value_; + } + T& operator*() { + RTC_DCHECK(has_value_); + return value_; + } + + // Dereference with a default value in case we don't have a value. + const T& value_or(const T& default_val) const { + return has_value_ ? value_ : default_val; + } + + // Equality tests. Two Maybes are equal if they contain equivalent values, or + // if they're both empty. + friend bool operator==(const Maybe& m1, const Maybe& m2) { + return m1.has_value_ && m2.has_value_ ? m1.value_ == m2.value_ + : m1.has_value_ == m2.has_value_; + } + friend bool operator!=(const Maybe& m1, const Maybe& m2) { + return m1.has_value_ && m2.has_value_ ? m1.value_ != m2.value_ + : m1.has_value_ != m2.has_value_; + } + + private: + // Invariant: Unless *this has been moved from, value_ is default-initialized + // (or copied or moved from a default-initialized T) if !has_value_. + T value_; + bool has_value_; +}; + +} // namespace rtc + +#endif // WEBRTC_BASE_MAYBE_H_ diff --git a/webrtc/base/maybe_unittest.cc b/webrtc/base/maybe_unittest.cc new file mode 100644 index 0000000000..73fdc90873 --- /dev/null +++ b/webrtc/base/maybe_unittest.cc @@ -0,0 +1,485 @@ +/* + * 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. + */ + +#include +#include +#include +#include + +#include "webrtc/base/gunit.h" +#include "webrtc/base/maybe.h" + +namespace rtc { + +namespace { + +// Class whose instances logs various method calls (constructor, destructor, +// etc.). Each instance has a unique ID (a simple global sequence number) and +// an origin ID. When a copy is made, the new object gets a fresh ID but copies +// the origin ID from the original. When a new Logger is created from scratch, +// it gets a fresh ID, and the origin ID is the same as the ID (default +// constructor) or given as an argument (explicit constructor). +class Logger { + public: + Logger() : id_(next_id_++), origin_(id_) { Log("default constructor"); } + explicit Logger(int origin) : id_(next_id_++), origin_(origin) { + Log("explicit constructor"); + } + Logger(const Logger& other) : id_(next_id_++), origin_(other.origin_) { + LogFrom("copy constructor", other); + } + Logger(Logger&& other) : id_(next_id_++), origin_(other.origin_) { + LogFrom("move constructor", other); + } + ~Logger() { Log("destructor"); } + Logger& operator=(const Logger& other) { + origin_ = other.origin_; + LogFrom("operator= copy", other); + return *this; + } + Logger& operator=(Logger&& other) { + origin_ = other.origin_; + LogFrom("operator= move", other); + return *this; + } + friend void swap(Logger& a, Logger& b) { + using std::swap; + swap(a.origin_, b.origin_); + Log2("swap", a, b); + } + friend bool operator==(const Logger& a, const Logger& b) { + Log2("operator==", a, b); + return a.origin_ == b.origin_; + } + friend bool operator!=(const Logger& a, const Logger& b) { + Log2("operator!=", a, b); + return a.origin_ != b.origin_; + } + void Foo() { Log("Foo()"); } + void Foo() const { Log("Foo() const"); } + static rtc::scoped_ptr> Setup() { + auto s = rtc_make_scoped_ptr(new std::vector); + Logger::log_ = s.get(); + Logger::next_id_ = 0; + return s; + } + + private: + int id_; + int origin_; + static std::vector* log_; + static int next_id_; + void Log(const char* msg) const { + std::ostringstream oss; + oss << id_ << ':' << origin_ << ". " << msg; + log_->push_back(oss.str()); + } + void LogFrom(const char* msg, const Logger& other) const { + std::ostringstream oss; + oss << id_ << ':' << origin_ << ". " << msg << " (from " << other.id_ << ':' + << other.origin_ << ")"; + log_->push_back(oss.str()); + } + static void Log2(const char* msg, const Logger& a, const Logger& b) { + std::ostringstream oss; + oss << msg << ' ' << a.id_ << ':' << a.origin_ << ", " << b.id_ << ':' + << b.origin_; + log_->push_back(oss.str()); + } +}; + +std::vector* Logger::log_ = nullptr; +int Logger::next_id_ = 0; + +// Append all the other args to the vector pointed to by the first arg. +template +void VectorAppend(std::vector* v) {} +template +void VectorAppend(std::vector* v, const T& e, Ts... es) { + v->push_back(e); + VectorAppend(v, es...); +} + +// Create a vector of strings. Because we're not allowed to use +// std::initializer_list. +template +std::vector V(Ts... es) { + std::vector strings; + VectorAppend(&strings, static_cast(es)...); + return strings; +} + +} // namespace + +TEST(MaybeTest, TestConstructDefault) { + auto log = Logger::Setup(); + { + Maybe x; + EXPECT_FALSE(x); + } + EXPECT_EQ(V("0:0. default constructor", "0:0. destructor"), *log); +} + +TEST(MaybeTest, TestConstructCopyEmpty) { + auto log = Logger::Setup(); + { + Maybe x; + EXPECT_FALSE(x); + auto y = x; + EXPECT_FALSE(y); + } + EXPECT_EQ(V("0:0. default constructor", "1:0. copy constructor (from 0:0)", + "1:0. destructor", "0:0. destructor"), + *log); +} + +TEST(MaybeTest, TestConstructCopyFull) { + auto log = Logger::Setup(); + { + Logger a; + Maybe x = a; + EXPECT_TRUE(x); + log->push_back("---"); + auto y = x; + EXPECT_TRUE(y); + log->push_back("---"); + } + EXPECT_EQ(V("0:0. default constructor", "1:0. copy constructor (from 0:0)", + "---", "2:0. copy constructor (from 1:0)", "---", + "2:0. destructor", "1:0. destructor", "0:0. destructor"), + *log); +} + +TEST(MaybeTest, TestConstructMoveEmpty) { + auto log = Logger::Setup(); + { + Maybe x; + EXPECT_FALSE(x); + auto y = static_cast&&>(x); + EXPECT_FALSE(y); + } + EXPECT_EQ(V("0:0. default constructor", "1:0. move constructor (from 0:0)", + "1:0. destructor", "0:0. destructor"), + *log); +} + +TEST(MaybeTest, TestConstructMoveFull) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + EXPECT_TRUE(x); + log->push_back("---"); + auto y = static_cast&&>(x); + EXPECT_TRUE(x); + EXPECT_TRUE(y); + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "---", "2:17. move constructor (from 1:17)", "---", + "2:17. destructor", "1:17. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToEmptyFromEmpty) { + auto log = Logger::Setup(); + { + Maybe x, y; + x = y; + } + EXPECT_EQ( + V("0:0. default constructor", "1:1. default constructor", + "0:1. operator= copy (from 1:1)", "1:1. destructor", "0:1. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToFullFromEmpty) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Maybe y; + log->push_back("---"); + x = y; + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:2. default constructor", "---", + "1:2. operator= copy (from 2:2)", "---", "2:2. destructor", + "1:2. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToEmptyFromFull) { + auto log = Logger::Setup(); + { + Maybe x; + Maybe y = Logger(17); + log->push_back("---"); + x = y; + log->push_back("---"); + } + EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", + "2:17. move constructor (from 1:17)", "1:17. destructor", "---", + "0:17. operator= copy (from 2:17)", "---", "2:17. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToFullFromFull) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Maybe y = Logger(42); + log->push_back("---"); + x = y; + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:42. explicit constructor", + "3:42. move constructor (from 2:42)", "2:42. destructor", "---", + "1:42. operator= copy (from 3:42)", "---", "3:42. destructor", + "1:42. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToEmptyFromT) { + auto log = Logger::Setup(); + { + Maybe x; + Logger y(17); + log->push_back("---"); + x = y; + log->push_back("---"); + } + EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", "---", + "0:17. operator= copy (from 1:17)", "---", "1:17. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestCopyAssignToFullFromT) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Logger y(42); + log->push_back("---"); + x = y; + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:42. explicit constructor", "---", + "1:42. operator= copy (from 2:42)", "---", "2:42. destructor", + "1:42. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToEmptyFromEmpty) { + auto log = Logger::Setup(); + { + Maybe x, y; + x = static_cast&&>(y); + } + EXPECT_EQ( + V("0:0. default constructor", "1:1. default constructor", + "0:1. operator= move (from 1:1)", "1:1. destructor", "0:1. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToFullFromEmpty) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Maybe y; + log->push_back("---"); + x = static_cast&&>(y); + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:2. default constructor", "---", + "1:2. operator= move (from 2:2)", "---", "2:2. destructor", + "1:2. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToEmptyFromFull) { + auto log = Logger::Setup(); + { + Maybe x; + Maybe y = Logger(17); + log->push_back("---"); + x = static_cast&&>(y); + log->push_back("---"); + } + EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", + "2:17. move constructor (from 1:17)", "1:17. destructor", "---", + "0:17. operator= move (from 2:17)", "---", "2:17. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToFullFromFull) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Maybe y = Logger(42); + log->push_back("---"); + x = static_cast&&>(y); + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:42. explicit constructor", + "3:42. move constructor (from 2:42)", "2:42. destructor", "---", + "1:42. operator= move (from 3:42)", "---", "3:42. destructor", + "1:42. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToEmptyFromT) { + auto log = Logger::Setup(); + { + Maybe x; + Logger y(17); + log->push_back("---"); + x = static_cast(y); + log->push_back("---"); + } + EXPECT_EQ(V("0:0. default constructor", "1:17. explicit constructor", "---", + "0:17. operator= move (from 1:17)", "---", "1:17. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestMoveAssignToFullFromT) { + auto log = Logger::Setup(); + { + Maybe x = Logger(17); + Logger y(42); + log->push_back("---"); + x = static_cast(y); + log->push_back("---"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:17. move constructor (from 0:17)", + "0:17. destructor", "2:42. explicit constructor", "---", + "1:42. operator= move (from 2:42)", "---", "2:42. destructor", + "1:42. destructor"), + *log); +} + +TEST(MaybeTest, TestDereference) { + auto log = Logger::Setup(); + { + Maybe x = Logger(42); + const auto& y = x; + log->push_back("---"); + x->Foo(); + y->Foo(); + static_cast&&>(x)->Foo(); + static_cast&&>(y)->Foo(); + log->push_back("---"); + (*x).Foo(); + (*y).Foo(); + (*static_cast&&>(x)).Foo(); + (*static_cast&&>(y)).Foo(); + log->push_back("---"); + } + EXPECT_EQ(V("0:42. explicit constructor", + "1:42. move constructor (from 0:42)", "0:42. destructor", "---", + "1:42. Foo()", "1:42. Foo() const", "1:42. Foo()", + "1:42. Foo() const", "---", "1:42. Foo()", "1:42. Foo() const", + "1:42. Foo()", "1:42. Foo() const", "---", "1:42. destructor"), + *log); +} + +TEST(MaybeTest, TestDereferenceWithDefault) { + auto log = Logger::Setup(); + { + const Logger a(17), b(42); + Maybe x(a); + Maybe y; + log->push_back("-1-"); + EXPECT_EQ(a, x.value_or(Logger(42))); + log->push_back("-2-"); + EXPECT_EQ(b, y.value_or(Logger(42))); + log->push_back("-3-"); + EXPECT_EQ(a, Maybe(Logger(17)).value_or(b)); + log->push_back("-4-"); + EXPECT_EQ(b, Maybe().value_or(b)); + log->push_back("-5-"); + } + EXPECT_EQ( + V("0:17. explicit constructor", "1:42. explicit constructor", + "2:17. copy constructor (from 0:17)", "3:3. default constructor", "-1-", + "4:42. explicit constructor", "operator== 0:17, 2:17", + "4:42. destructor", "-2-", "5:42. explicit constructor", + "operator== 1:42, 5:42", "5:42. destructor", "-3-", + "6:17. explicit constructor", "7:17. move constructor (from 6:17)", + "operator== 0:17, 7:17", "7:17. destructor", "6:17. destructor", "-4-", + "8:8. default constructor", "operator== 1:42, 1:42", "8:8. destructor", + "-5-", "3:3. destructor", "2:17. destructor", "1:42. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestEquality) { + auto log = Logger::Setup(); + { + Logger a(17), b(42); + Maybe ma1(a), ma2(a), mb(b), me1, me2; + log->push_back("---"); + EXPECT_EQ(ma1, ma1); + EXPECT_EQ(ma1, ma2); + EXPECT_NE(ma1, mb); + EXPECT_NE(ma1, me1); + EXPECT_EQ(me1, me1); + EXPECT_EQ(me1, me2); + log->push_back("---"); + } + EXPECT_EQ(V("0:17. explicit constructor", "1:42. explicit constructor", + "2:17. copy constructor (from 0:17)", + "3:17. copy constructor (from 0:17)", + "4:42. copy constructor (from 1:42)", "5:5. default constructor", + "6:6. default constructor", "---", "operator== 2:17, 2:17", + "operator== 2:17, 3:17", "operator!= 2:17, 4:42", "---", + "6:6. destructor", "5:5. destructor", "4:42. destructor", + "3:17. destructor", "2:17. destructor", "1:42. destructor", + "0:17. destructor"), + *log); +} + +TEST(MaybeTest, TestSwap) { + auto log = Logger::Setup(); + { + Logger a(17), b(42); + Maybe x1(a), x2(b), y1(a), y2, z1, z2; + log->push_back("---"); + swap(x1, x2); // Swap full <-> full. + swap(y1, y2); // Swap full <-> empty. + swap(z1, z2); // Swap empty <-> empty. + log->push_back("---"); + } + EXPECT_EQ(V("0:17. explicit constructor", "1:42. explicit constructor", + "2:17. copy constructor (from 0:17)", + "3:42. copy constructor (from 1:42)", + "4:17. copy constructor (from 0:17)", "5:5. default constructor", + "6:6. default constructor", "7:7. default constructor", "---", + "swap 2:42, 3:17", "swap 4:5, 5:17", "swap 6:7, 7:6", "---", + "7:6. destructor", "6:7. destructor", "5:17. destructor", + "4:5. destructor", "3:17. destructor", "2:42. destructor", + "1:42. destructor", "0:17. destructor"), + *log); +} + +} // namespace rtc