#ifndef PrintStream_h
#define PrintStream_h
#include <stdarg.h>
#include <wtf/FastMalloc.h>
#include <wtf/Noncopyable.h>
#include <wtf/RawPointer.h>
#include <wtf/StdLibExtras.h>
namespace WTF {
class AtomicStringImpl;
class CString;
class String;
class StringImpl;
class UniquedStringImpl;
class PrintStream {
WTF_MAKE_FAST_ALLOCATED; WTF_MAKE_NONCOPYABLE(PrintStream);
public:
PrintStream();
virtual ~PrintStream();
WTF_EXPORT_PRIVATE void printf(const char* format, ...) WTF_ATTRIBUTE_PRINTF(2, 3);
virtual void vprintf(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(2, 0) = 0;
virtual void flush();
template<typename T>
void print(const T& value)
{
printInternal(*this, value);
}
template<typename T, typename... Types>
void print(const T& value, const Types&... remainingValues)
{
printInternal(*this, value);
print(remainingValues...);
}
};
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, const char*);
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 AtomicStringImpl* 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, 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, AtomicStringImpl* value) { printInternal(out, static_cast<const AtomicStringImpl*>(value)); }
inline void printInternal(PrintStream& out, UniquedStringImpl* value) { printInternal(out, static_cast<const UniquedStringImpl*>(value)); }
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, bool);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, signed char); WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned char); WTF_EXPORT_PRIVATE void printInternal(PrintStream&, short);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned short);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, int);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, long);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned long);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, long long);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, unsigned long long);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, float);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, double);
WTF_EXPORT_PRIVATE void printInternal(PrintStream&, RawPointer);
template<typename T>
void printInternal(PrintStream& out, const T& value)
{
value.dump(out);
}
#define MAKE_PRINT_ADAPTOR(Name, Type, function) \
class Name { \
public: \
Name(const Type& value) \
: m_value(value) \
{ \
} \
void dump(PrintStream& out) const \
{ \
function(out, m_value); \
} \
private: \
Type m_value; \
}
#define MAKE_PRINT_METHOD_ADAPTOR(Name, Type, method) \
class Name { \
public: \
Name(const Type& value) \
: m_value(value) \
{ \
} \
void dump(PrintStream& out) const \
{ \
m_value.method(out); \
} \
private: \
const Type& m_value; \
}
#define MAKE_PRINT_METHOD(Type, dumpMethod, method) \
MAKE_PRINT_METHOD_ADAPTOR(DumperFor_##method, Type, dumpMethod); \
DumperFor_##method method() const { return DumperFor_##method(*this); }
WTF_EXPORT_PRIVATE void dumpCharacter(PrintStream&, char);
MAKE_PRINT_ADAPTOR(CharacterDump, char, dumpCharacter);
template<typename T>
class PointerDump {
public:
PointerDump(const T* ptr)
: m_ptr(ptr)
{
}
void dump(PrintStream& out) const
{
if (m_ptr)
printInternal(out, *m_ptr);
else
out.print("(null)");
}
private:
const T* m_ptr;
};
template<typename T>
PointerDump<T> pointerDump(const T* ptr) { return PointerDump<T>(ptr); }
template<typename T, typename U>
class ValueInContext {
public:
ValueInContext(const T& value, U* context)
: m_value(&value)
, m_context(context)
{
}
void dump(PrintStream& out) const
{
m_value->dumpInContext(out, m_context);
}
private:
const T* m_value;
U* m_context;
};
template<typename T, typename U>
ValueInContext<T, U> inContext(const T& value, U* context)
{
return ValueInContext<T, U>(value, context);
}
template<typename T, typename U>
class PointerDumpInContext {
public:
PointerDumpInContext(const T* ptr, U* context)
: m_ptr(ptr)
, m_context(context)
{
}
void dump(PrintStream& out) const
{
if (m_ptr)
m_ptr->dumpInContext(out, m_context);
else
out.print("(null)");
}
private:
const T* m_ptr;
U* m_context;
};
template<typename T, typename U>
PointerDumpInContext<T, U> pointerDumpInContext(const T* ptr, U* context)
{
return PointerDumpInContext<T, U>(ptr, context);
}
template<typename T, typename U>
class ValueIgnoringContext {
public:
ValueIgnoringContext(const U& value)
: m_value(&value)
{
}
void dump(PrintStream& out) const
{
T context;
m_value->dumpInContext(out, &context);
}
private:
const U* m_value;
};
template<typename T, typename U>
ValueIgnoringContext<T, U> ignoringContext(const U& value)
{
return ValueIgnoringContext<T, U>(value);
}
}
using WTF::CharacterDump;
using WTF::PointerDump;
using WTF::PrintStream;
using WTF::ignoringContext;
using WTF::inContext;
using WTF::pointerDump;
using WTF::pointerDumpInContext;
#endif // PrintStream_h