Rename AtomicString to AtomString
[WebKit-https.git] / Source / WTF / wtf / PrintStream.h
index ef86d46..04b0561 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012-2018 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef PrintStream_h
-#define PrintStream_h
+#pragma once
 
+#include <memory>
 #include <stdarg.h>
+#include <tuple>
+#include <wtf/Forward.h>
 #include <wtf/FastMalloc.h>
 #include <wtf/Noncopyable.h>
+#include <wtf/Optional.h>
 #include <wtf/RawPointer.h>
+#include <wtf/RefPtr.h>
 #include <wtf/StdLibExtras.h>
 
 namespace WTF {
 
-class CString;
-class String;
-class StringImpl;
+inline const char* boolForPrinting(bool value)
+{
+    return value ? "true" : "false";
+}
 
 class PrintStream {
     WTF_MAKE_FAST_ALLOCATED; WTF_MAKE_NONCOPYABLE(PrintStream);
@@ -45,34 +50,64 @@ public:
     virtual ~PrintStream();
 
     WTF_EXPORT_PRIVATE void printf(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
+    WTF_EXPORT_PRIVATE void printfVariableFormat(const char* format, ...);
     virtual void vprintf(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(2, 0) = 0;
 
     // Typically a no-op for many subclasses of PrintStream, this is a hint that
     // the implementation should flush its buffers if it had not done so already.
     virtual void flush();
-
-    template<typename T>
-    void print(const T& value)
+    
+    template<typename Func>
+    void atomically(const Func& func)
     {
-        printInternal(*this, value);
+        func(begin());
+        end();
     }
+    
+    template<typename... Types>
+    void print(const Types&... values)
+    {
+        atomically(
+            [&] (PrintStream& out) {
+                out.printImpl(values...);
+            });
+    }
+    
+    template<typename... Types>
+    void println(const Types&... values)
+    {
+        print(values..., "\n");
+    }
+
+protected:
+    void printImpl() { }
 
     template<typename T, typename... Types>
-    void print(const T& value, const Types&... remainingValues)
+    void printImpl(const T& value, const Types&... remainingValues)
     {
         printInternal(*this, value);
-        print(remainingValues...);
+        printImpl(remainingValues...);
     }
+    
+    virtual PrintStream& begin();
+    virtual void end();
 };
 
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const char*);
+WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const StringView&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const CString&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const String&);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const StringImpl*);
+inline void printInternal(PrintStream& out, const AtomStringImpl* value) { printInternal(out, bitwise_cast<const StringImpl*>(value)); }
+inline void printInternal(PrintStream& out, const UniquedStringImpl* value) { printInternal(out, bitwise_cast<const StringImpl*>(value)); }
+inline void printInternal(PrintStream& out, const UniquedStringImpl& value) { printInternal(out, &value); }
 inline void printInternal(PrintStream& out, char* value) { printInternal(out, static_cast<const char*>(value)); }
 inline void printInternal(PrintStream& out, CString& value) { printInternal(out, static_cast<const CString&>(value)); }
 inline void printInternal(PrintStream& out, String& value) { printInternal(out, static_cast<const String&>(value)); }
 inline void printInternal(PrintStream& out, StringImpl* value) { printInternal(out, static_cast<const StringImpl*>(value)); }
+inline void printInternal(PrintStream& out, AtomStringImpl* value) { printInternal(out, static_cast<const AtomStringImpl*>(value)); }
+inline void printInternal(PrintStream& out, UniquedStringImpl* value) { printInternal(out, static_cast<const UniquedStringImpl*>(value)); }
+inline void printInternal(PrintStream& out, UniquedStringImpl& value) { printInternal(out, &value); }
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, bool);
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, signed char); // NOTE: this prints as a number, not as a character; use CharacterDump if you want the character
 WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned char); // NOTE: see above.
@@ -97,7 +132,7 @@ void printInternal(PrintStream& out, const T& value)
 #define MAKE_PRINT_ADAPTOR(Name, Type, function) \
     class Name {                                 \
     public:                                      \
-        Name(const Type& value)                  \
+        Name(Type value)                         \
             : m_value(value)                     \
         {                                        \
         }                                        \
@@ -156,6 +191,18 @@ private:
 template<typename T>
 PointerDump<T> pointerDump(const T* ptr) { return PointerDump<T>(ptr); }
 
+template<typename T>
+void printInternal(PrintStream& out, const std::unique_ptr<T>& value)
+{
+    out.print(pointerDump(value.get()));
+}
+
+template<typename T>
+void printInternal(PrintStream& out, const RefPtr<T>& value)
+{
+    out.print(pointerDump(value.get()));
+}
+
 template<typename T, typename U>
 class ValueInContext {
 public:
@@ -233,15 +280,68 @@ ValueIgnoringContext<T, U> ignoringContext(const U& value)
     return ValueIgnoringContext<T, U>(value);
 }
 
+template<unsigned index, typename... Types>
+struct FormatImplUnpacker {
+    template<typename... Args>
+    static void unpack(PrintStream& out, const std::tuple<Types...>& tuple, const Args&... values);
+};
+    
+template<typename... Types>
+struct FormatImplUnpacker<0, Types...> {
+    template<typename... Args>
+    static void unpack(PrintStream& out, const std::tuple<Types...>& tuple, const Args&... values)
+    {
+        out.printfVariableFormat(std::get<0>(tuple), values...);
+    }
+};
+    
+template<unsigned index, typename... Types>
+template<typename... Args>
+void FormatImplUnpacker<index, Types...>::unpack(PrintStream& out, const std::tuple<Types...>& tuple, const Args&... values)
+{
+    FormatImplUnpacker<index - 1, Types...>::unpack(out, tuple, std::get<index>(tuple), values...);
+}
+
+template<typename... Types>
+class FormatImpl {
+public:
+    FormatImpl(Types... values)
+        : m_values(values...)
+    {
+    }
+    
+    void dump(PrintStream& out) const
+    {
+        FormatImplUnpacker<sizeof...(Types) - 1, Types...>::unpack(out, m_values);
+    }
+
+private:
+    std::tuple<Types...> m_values;
+};
+
+template<typename... Types>
+FormatImpl<Types...> format(Types... values)
+{
+    return FormatImpl<Types...>(values...);
+}
+
+template<typename T>
+void printInternal(PrintStream& out, const Optional<T>& value)
+{
+    if (value)
+        out.print(*value);
+    else
+        out.print("<nullopt>");
+}
+
 } // namespace WTF
 
+using WTF::boolForPrinting;
 using WTF::CharacterDump;
 using WTF::PointerDump;
 using WTF::PrintStream;
+using WTF::format;
 using WTF::ignoringContext;
 using WTF::inContext;
 using WTF::pointerDump;
 using WTF::pointerDumpInContext;
-
-#endif // PrintStream_h
-