--- /dev/null
+// Copyright 2014 the V8 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.
+
+#ifndef V8_BASE_FLAGS_H_
+#define V8_BASE_FLAGS_H_
+
+#include "include/v8config.h"
+
+namespace v8 {
+namespace base {
+
+// The Flags class provides a type-safe way of storing OR-combinations of enum
+// values. The Flags<T> class is a template class, where T is an enum type.
+//
+// The traditional C++ approach for storing OR-combinations of enum values is to
+// use an int or unsigned int variable. The inconvenience with this approach is
+// that there's no type checking at all; any enum value can be OR'd with any
+// other enum value and passed on to a function that takes an int or unsigned
+// int.
+template <typename T>
+class Flags V8_FINAL {
+ public:
+ typedef T flag_type;
+ typedef int mask_type;
+
+ Flags() : mask_(0) {}
+ Flags(flag_type flag) : mask_(flag) {} // NOLINT(runtime/explicit)
+ explicit Flags(mask_type mask) : mask_(mask) {}
+
+ Flags& operator&=(const Flags& flags) {
+ mask_ &= flags.mask_;
+ return *this;
+ }
+ Flags& operator|=(const Flags& flags) {
+ mask_ |= flags.mask_;
+ return *this;
+ }
+ Flags& operator^=(const Flags& flags) {
+ mask_ ^= flags.mask_;
+ return *this;
+ }
+
+ Flags operator&(const Flags& flags) const { return Flags(*this) &= flags; }
+ Flags operator|(const Flags& flags) const { return Flags(*this) |= flags; }
+ Flags operator^(const Flags& flags) const { return Flags(*this) ^= flags; }
+
+ Flags& operator&=(flag_type flag) { return operator&=(Flags(flag)); }
+ Flags& operator|=(flag_type flag) { return operator|=(Flags(flag)); }
+ Flags& operator^=(flag_type flag) { return operator^=(Flags(flag)); }
+
+ Flags operator&(flag_type flag) const { return operator&(Flags(flag)); }
+ Flags operator|(flag_type flag) const { return operator|(Flags(flag)); }
+ Flags operator^(flag_type flag) const { return operator^(Flags(flag)); }
+
+ Flags operator~() const { return Flags(~mask_); }
+
+ operator mask_type() const { return mask_; }
+ bool operator!() const { return !mask_; }
+
+ private:
+ mask_type mask_;
+};
+
+
+#define DEFINE_FLAGS(Type, Enum) typedef ::v8::base::Flags<Enum> Type
+
+#define DEFINE_OPERATORS_FOR_FLAGS(Type) \
+ inline ::v8::base::Flags<Type::flag_type> operator&( \
+ Type::flag_type lhs, \
+ Type::flag_type rhs)V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator&(Type::flag_type lhs, \
+ Type::flag_type rhs) { \
+ return ::v8::base::Flags<Type::flag_type>(lhs) & rhs; \
+ } \
+ inline ::v8::base::Flags<Type::flag_type> operator&( \
+ Type::flag_type lhs, const ::v8::base::Flags<Type::flag_type>& rhs) \
+ V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator&( \
+ Type::flag_type lhs, const ::v8::base::Flags<Type::flag_type>& rhs) { \
+ return rhs & lhs; \
+ } \
+ inline void operator&(Type::flag_type lhs, Type::mask_type rhs)V8_UNUSED; \
+ inline void operator&(Type::flag_type lhs, Type::mask_type rhs) {} \
+ inline ::v8::base::Flags<Type::flag_type> operator|(Type::flag_type lhs, \
+ Type::flag_type rhs) \
+ V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator|(Type::flag_type lhs, \
+ Type::flag_type rhs) { \
+ return ::v8::base::Flags<Type::flag_type>(lhs) | rhs; \
+ } \
+ inline ::v8::base::Flags<Type::flag_type> operator|( \
+ Type::flag_type lhs, const ::v8::base::Flags<Type::flag_type>& rhs) \
+ V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator|( \
+ Type::flag_type lhs, const ::v8::base::Flags<Type::flag_type>& rhs) { \
+ return rhs | lhs; \
+ } \
+ inline void operator|(Type::flag_type lhs, Type::mask_type rhs) V8_UNUSED; \
+ inline void operator|(Type::flag_type lhs, Type::mask_type rhs) {} \
+ inline ::v8::base::Flags<Type::flag_type> operator^(Type::flag_type lhs, \
+ Type::flag_type rhs) \
+ V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator^(Type::flag_type lhs, \
+ Type::flag_type rhs) { \
+ return ::v8::base::Flags<Type::flag_type>(lhs) ^ rhs; \
+ } inline ::v8::base::Flags<Type::flag_type> \
+ operator^(Type::flag_type lhs, \
+ const ::v8::base::Flags<Type::flag_type>& rhs) \
+ V8_UNUSED V8_WARN_UNUSED_RESULT; \
+ inline ::v8::base::Flags<Type::flag_type> operator^( \
+ Type::flag_type lhs, const ::v8::base::Flags<Type::flag_type>& rhs) { \
+ return rhs ^ lhs; \
+ } inline void operator^(Type::flag_type lhs, Type::mask_type rhs) V8_UNUSED; \
+ inline void operator^(Type::flag_type lhs, Type::mask_type rhs) {}
+
+} // namespace base
+} // namespace v8
+
+#endif // V8_BASE_FLAGS_H_
--- /dev/null
+// Copyright 2014 the V8 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.
+
+#include "src/base/flags.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace base {
+
+namespace {
+
+enum Flag1 {
+ kFlag1None = 0,
+ kFlag1First = 1u << 1,
+ kFlag1Second = 1u << 2,
+ kFlag1All = kFlag1None | kFlag1First | kFlag1Second
+};
+DEFINE_FLAGS(Flags1, Flag1);
+
+
+DEFINE_OPERATORS_FOR_FLAGS(Flags1)
+
+
+Flags1 bar(Flags1 flags1) { return flags1; }
+
+} // namespace
+
+
+TEST(FlagsTest, BasicOperations) {
+ Flags1 a;
+ EXPECT_EQ(kFlag1None, static_cast<int>(a));
+ a |= kFlag1First;
+ EXPECT_EQ(kFlag1First, static_cast<int>(a));
+ a = a | kFlag1Second;
+ EXPECT_EQ(kFlag1All, static_cast<int>(a));
+ a &= kFlag1Second;
+ EXPECT_EQ(kFlag1Second, static_cast<int>(a));
+ a = kFlag1None & a;
+ EXPECT_EQ(kFlag1None, static_cast<int>(a));
+ a ^= (kFlag1All | kFlag1None);
+ EXPECT_EQ(kFlag1All, static_cast<int>(a));
+ Flags1 b = ~a;
+ EXPECT_EQ(kFlag1All, static_cast<int>(a));
+ EXPECT_EQ(~static_cast<int>(a), static_cast<int>(b));
+ Flags1 c = a;
+ EXPECT_EQ(a, c);
+ EXPECT_NE(a, b);
+ EXPECT_EQ(a, bar(a));
+ EXPECT_EQ(a, bar(kFlag1All));
+}
+
+
+namespace {
+namespace foo {
+
+enum Option {
+ kNoOptions = 0,
+ kOption1 = 1,
+ kOption2 = 2,
+ kAllOptions = kNoOptions | kOption1 | kOption2
+};
+DEFINE_FLAGS(Options, Option);
+
+} // namespace foo
+
+
+DEFINE_OPERATORS_FOR_FLAGS(foo::Options)
+
+} // namespace
+
+
+TEST(FlagsTest, NamespaceScope) {
+ foo::Options options;
+ options ^= foo::kNoOptions;
+ options |= foo::kOption1 | foo::kOption2;
+ EXPECT_EQ(foo::kAllOptions, static_cast<int>(options));
+}
+
+
+namespace {
+
+struct Foo {
+ enum Enum { kEnum1 = 1, kEnum2 = 2 };
+ DEFINE_FLAGS(Enums, Enum);
+};
+
+
+DEFINE_OPERATORS_FOR_FLAGS(Foo::Enums)
+
+} // namespace
+
+
+TEST(FlagsTest, ClassScope) {
+ Foo::Enums enums;
+ enums |= Foo::kEnum1;
+ enums |= Foo::kEnum2;
+ EXPECT_TRUE(enums & Foo::kEnum1);
+ EXPECT_TRUE(enums & Foo::kEnum2);
+}
+
+} // namespace base
+} // namespace v8