// LOG(INFO) << "data: " << x;
// vector<int> v1, v2;
// CHECK_EQ(v1, v2);
-//
-// Note that if you want to use these operators from the non-global namespace,
-// you may get an error since they are not in namespace std (and they are not
-// in namespace std since that would result in undefined behavior). You may
-// need to write
-//
-// using ::operator<<;
-//
-// to fix these errors.
-//
-//
-// Notice for clang users: you should include stl_logging.h BEFORE you
-// include logging.h. Otherwise, you will see some errors when you use
-// CHECK with STL containers.
-//
-// Clang's "using ::operator<<" incorporate symbols which are declared
-// before the using keyword. With GCC, symbols defined after the using
-// keyword are incorporated as well. The CHECK macro defined in
-// logging.h uses the using keyword so you need to include logging.h
-// after including stl_logging.h.
-//
#ifndef UTIL_GTL_STL_LOGGING_INL_H_
#define UTIL_GTL_STL_LOGGING_INL_H_
# include <ext/slist>
#endif
+// Forward declare these two, and define them after all the container streams
+// operators so that we can recurse from pair -> container -> container -> pair
+// properly.
template<class First, class Second>
-inline std::ostream& operator<<(std::ostream& out,
- const std::pair<First, Second>& p) {
- out << '(' << p.first << ", " << p.second << ')';
- return out;
-}
+std::ostream& operator<<(std::ostream& out, const std::pair<First, Second>& p);
@ac_google_start_namespace@
template<class Iter>
-inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
- using ::operator<<;
- // Output at most 100 elements -- appropriate if used for logging.
- for (int i = 0; begin != end && i < 100; ++i, ++begin) {
- if (i > 0) out << ' ';
- out << *begin;
- }
- if (begin != end) {
- out << " ...";
- }
-}
+void PrintSequence(std::ostream& out, Iter begin, Iter end);
@ac_google_end_namespace@
#undef OUTPUT_FIVE_ARG_CONTAINER
+template<class First, class Second>
+inline std::ostream& operator<<(std::ostream& out,
+ const std::pair<First, Second>& p) {
+ out << '(' << p.first << ", " << p.second << ')';
+ return out;
+}
+
+@ac_google_start_namespace@
+
+template<class Iter>
+inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
+ // Output at most 100 elements -- appropriate if used for logging.
+ for (int i = 0; begin != end && i < 100; ++i, ++begin) {
+ if (i > 0) out << ' ';
+ out << *begin;
+ }
+ if (begin != end) {
+ out << " ...";
+ }
+}
+
+@ac_google_end_namespace@
+
+// Note that this is technically undefined behavior! We are adding things into
+// the std namespace for a reason though -- we are providing new operations on
+// types which are themselves defined with this namespace. Without this, these
+// operator overloads cannot be found via ADL. If these definitions are not
+// found via ADL, they must be #included before they're used, which requires
+// this header to be included before apparently independent other headers.
+//
+// For example, base/logging.h defines various template functions to implement
+// CHECK_EQ(x, y) and stream x and y into the log in the event the check fails.
+// It does so via the function template MakeCheckOpValueString:
+// template<class T>
+// void MakeCheckOpValueString(strstream* ss, const T& v) {
+// (*ss) << v;
+// }
+// Because 'glog/logging.h' is included before 'glog/stl_logging.h',
+// subsequent CHECK_EQ(v1, v2) for vector<...> typed variable v1 and v2 can only
+// find these operator definitions via ADL.
+//
+// Even this solution has problems -- it may pull unintended operators into the
+// namespace as well, allowing them to also be found via ADL, and creating code
+// that only works with a particular order of includes. Long term, we need to
+// move all of the *definitions* into namespace std, bet we need to ensure no
+// one references them first. This lets us take that step. We cannot define them
+// in both because that would create ambiguous overloads when both are found.
+namespace std { using ::operator<<; }
+
#endif // UTIL_GTL_STL_LOGGING_INL_H_
// LOG(INFO) << "data: " << x;
// vector<int> v1, v2;
// CHECK_EQ(v1, v2);
-//
-// Note that if you want to use these operators from the non-global namespace,
-// you may get an error since they are not in namespace std (and they are not
-// in namespace std since that would result in undefined behavior). You may
-// need to write
-//
-// using ::operator<<;
-//
-// to fix these errors.
-//
-//
-// Notice for clang users: you should include stl_logging.h BEFORE you
-// include logging.h. Otherwise, you will see some errors when you use
-// CHECK with STL containers.
-//
-// Clang's "using ::operator<<" incorporate symbols which are declared
-// before the using keyword. With GCC, symbols defined after the using
-// keyword are incorporated as well. The CHECK macro defined in
-// logging.h uses the using keyword so you need to include logging.h
-// after including stl_logging.h.
-//
#ifndef UTIL_GTL_STL_LOGGING_INL_H_
#define UTIL_GTL_STL_LOGGING_INL_H_
# include <ext/slist>
#endif
+// Forward declare these two, and define them after all the container streams
+// operators so that we can recurse from pair -> container -> container -> pair
+// properly.
template<class First, class Second>
-inline std::ostream& operator<<(std::ostream& out,
- const std::pair<First, Second>& p) {
- out << '(' << p.first << ", " << p.second << ')';
- return out;
-}
+std::ostream& operator<<(std::ostream& out, const std::pair<First, Second>& p);
namespace google {
template<class Iter>
-inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
- using ::operator<<;
- // Output at most 100 elements -- appropriate if used for logging.
- for (int i = 0; begin != end && i < 100; ++i, ++begin) {
- if (i > 0) out << ' ';
- out << *begin;
- }
- if (begin != end) {
- out << " ...";
- }
-}
+void PrintSequence(std::ostream& out, Iter begin, Iter end);
}
#undef OUTPUT_FIVE_ARG_CONTAINER
+template<class First, class Second>
+inline std::ostream& operator<<(std::ostream& out,
+ const std::pair<First, Second>& p) {
+ out << '(' << p.first << ", " << p.second << ')';
+ return out;
+}
+
+namespace google {
+
+template<class Iter>
+inline void PrintSequence(std::ostream& out, Iter begin, Iter end) {
+ // Output at most 100 elements -- appropriate if used for logging.
+ for (int i = 0; begin != end && i < 100; ++i, ++begin) {
+ if (i > 0) out << ' ';
+ out << *begin;
+ }
+ if (begin != end) {
+ out << " ...";
+ }
+}
+
+}
+
+// Note that this is technically undefined behavior! We are adding things into
+// the std namespace for a reason though -- we are providing new operations on
+// types which are themselves defined with this namespace. Without this, these
+// operator overloads cannot be found via ADL. If these definitions are not
+// found via ADL, they must be #included before they're used, which requires
+// this header to be included before apparently independent other headers.
+//
+// For example, base/logging.h defines various template functions to implement
+// CHECK_EQ(x, y) and stream x and y into the log in the event the check fails.
+// It does so via the function template MakeCheckOpValueString:
+// template<class T>
+// void MakeCheckOpValueString(strstream* ss, const T& v) {
+// (*ss) << v;
+// }
+// Because 'glog/logging.h' is included before 'glog/stl_logging.h',
+// subsequent CHECK_EQ(v1, v2) for vector<...> typed variable v1 and v2 can only
+// find these operator definitions via ADL.
+//
+// Even this solution has problems -- it may pull unintended operators into the
+// namespace as well, allowing them to also be found via ADL, and creating code
+// that only works with a particular order of includes. Long term, we need to
+// move all of the *definitions* into namespace std, bet we need to ensure no
+// one references them first. This lets us take that step. We cannot define them
+// in both because that would create ambiguous overloads when both are found.
+namespace std { using ::operator<<; }
+
#endif // UTIL_GTL_STL_LOGGING_INL_H_