diff --git a/include/gtest/gtest-printers.h b/include/gtest/gtest-printers.h index a86a4a34..c8daa294 100644 --- a/include/gtest/gtest-printers.h +++ b/include/gtest/gtest-printers.h @@ -404,22 +404,22 @@ GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); // Overloads for C strings. GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); inline void PrintTo(char* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } // signed/unsigned char is often used for representing binary data, so // we print pointers to it as void* to be safe. inline void PrintTo(const signed char* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } inline void PrintTo(signed char* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } inline void PrintTo(const unsigned char* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } inline void PrintTo(unsigned char* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } // MSVC can be configured to define wchar_t as a typedef of unsigned @@ -431,7 +431,7 @@ inline void PrintTo(unsigned char* s, ::std::ostream* os) { // Overloads for wide C strings GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); inline void PrintTo(wchar_t* s, ::std::ostream* os) { - PrintTo(implicit_cast(s), os); + PrintTo(ImplicitCast_(s), os); } #endif diff --git a/include/gtest/internal/gtest-port.h b/include/gtest/internal/gtest-port.h index 900a41dc..be2297ed 100644 --- a/include/gtest/internal/gtest-port.h +++ b/include/gtest/internal/gtest-port.h @@ -919,25 +919,29 @@ inline void FlushInfoLog() { fflush(NULL); } // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // -// Use implicit_cast as a safe version of static_cast for upcasting in +// Use ImplicitCast_ as a safe version of static_cast for upcasting in // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a -// const Foo*). When you use implicit_cast, the compiler checks that -// the cast is safe. Such explicit implicit_casts are necessary in +// const Foo*). When you use ImplicitCast_, the compiler checks that +// the cast is safe. Such explicit ImplicitCast_s are necessary in // surprisingly many situations where C++ demands an exact type match // instead of an argument type convertable to a target type. // -// The syntax for using implicit_cast is the same as for static_cast: +// The syntax for using ImplicitCast_ is the same as for static_cast: // -// implicit_cast(expr) +// ImplicitCast_(expr) // -// implicit_cast would have been part of the C++ standard library, +// ImplicitCast_ would have been part of the C++ standard library, // but the proposal was submitted too late. It will probably make // its way into the language in the future. +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., implicit_cast). The internal +// namespace alone is not enough because the function can be found by ADL. template -inline To implicit_cast(To x) { return x; } +inline To ImplicitCast_(To x) { return x; } // When you upcast (that is, cast a pointer from type Foo to type -// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts +// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts // always succeed. When you downcast (that is, cast a pointer from // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because // how do you know the pointer is really of type SubclassOfFoo? It @@ -953,15 +957,19 @@ inline To implicit_cast(To x) { return x; } // if (dynamic_cast(foo)) HandleASubclass1Object(foo); // if (dynamic_cast(foo)) HandleASubclass2Object(foo); // You should design the code some other way not to need this. -template // use like this: down_cast(foo); -inline To down_cast(From* f) { // so we only accept pointers +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., down_cast). The internal +// namespace alone is not enough because the function can be found by ADL. +template // use like this: DownCast_(foo); +inline To DownCast_(From* f) { // so we only accept pointers // Ensures that To is a sub-type of From *. This test is here only // for compile-time type checking, and has no overhead in an // optimized build at run-time, as it will be optimized away // completely. if (false) { const To to = NULL; - ::testing::internal::implicit_cast(to); + ::testing::internal::ImplicitCast_(to); } #if GTEST_HAS_RTTI diff --git a/src/gtest-printers.cc b/src/gtest-printers.cc index c85d5822..bfbca9c8 100644 --- a/src/gtest-printers.cc +++ b/src/gtest-printers.cc @@ -308,7 +308,7 @@ void PrintTo(const char* s, ostream* os) { if (s == NULL) { *os << "NULL"; } else { - *os << implicit_cast(s) << " pointing to "; + *os << ImplicitCast_(s) << " pointing to "; PrintCharsAsStringTo(s, strlen(s), os); } } @@ -325,7 +325,7 @@ void PrintTo(const wchar_t* s, ostream* os) { if (s == NULL) { *os << "NULL"; } else { - *os << implicit_cast(s) << " pointing to "; + *os << ImplicitCast_(s) << " pointing to "; PrintWideCharsAsStringTo(s, wcslen(s), os); } } diff --git a/test/gtest-port_test.cc b/test/gtest-port_test.cc index db63ea98..5afba2d8 100644 --- a/test/gtest-port_test.cc +++ b/test/gtest-port_test.cc @@ -79,12 +79,12 @@ class Derived : public Base { TEST(ImplicitCastTest, ConvertsPointers) { Derived derived(0); - EXPECT_TRUE(&derived == ::testing::internal::implicit_cast(&derived)); + EXPECT_TRUE(&derived == ::testing::internal::ImplicitCast_(&derived)); } TEST(ImplicitCastTest, CanUseInheritance) { Derived derived(1); - Base base = ::testing::internal::implicit_cast(derived); + Base base = ::testing::internal::ImplicitCast_(derived); EXPECT_EQ(derived.member(), base.member()); } @@ -103,7 +103,7 @@ class Castable { TEST(ImplicitCastTest, CanUseNonConstCastOperator) { bool converted = false; Castable castable(&converted); - Base base = ::testing::internal::implicit_cast(castable); + Base base = ::testing::internal::ImplicitCast_(castable); EXPECT_TRUE(converted); } @@ -122,7 +122,7 @@ class ConstCastable { TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) { bool converted = false; const ConstCastable const_castable(&converted); - Base base = ::testing::internal::implicit_cast(const_castable); + Base base = ::testing::internal::ImplicitCast_(const_castable); EXPECT_TRUE(converted); } @@ -148,14 +148,14 @@ TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) { bool converted = false; bool const_converted = false; ConstAndNonConstCastable castable(&converted, &const_converted); - Base base = ::testing::internal::implicit_cast(castable); + Base base = ::testing::internal::ImplicitCast_(castable); EXPECT_TRUE(converted); EXPECT_FALSE(const_converted); converted = false; const_converted = false; const ConstAndNonConstCastable const_castable(&converted, &const_converted); - base = ::testing::internal::implicit_cast(const_castable); + base = ::testing::internal::ImplicitCast_(const_castable); EXPECT_FALSE(converted); EXPECT_TRUE(const_converted); } @@ -167,7 +167,7 @@ class To { TEST(ImplicitCastTest, CanUseImplicitConstructor) { bool converted = false; - To to = ::testing::internal::implicit_cast(&converted); + To to = ::testing::internal::ImplicitCast_(&converted); (void)to; EXPECT_TRUE(converted); }