aboutsummaryrefslogtreecommitdiff
path: root/butl/diagnostics
diff options
context:
space:
mode:
authorBoris Kolpackov <boris@codesynthesis.com>2016-11-22 12:08:21 +0200
committerBoris Kolpackov <boris@codesynthesis.com>2016-11-22 12:08:21 +0200
commit0324ad68eed762ebf00ed4fb5a7ea2f2e3bd77b6 (patch)
tree36a327dbe3f33c6c25eb48ba54491261411dadfe /butl/diagnostics
parenta345a24df9e40e0ba2bf1b35a5a98420b4cc255d (diff)
Add diagnostics facility
Diffstat (limited to 'butl/diagnostics')
-rw-r--r--butl/diagnostics198
1 files changed, 198 insertions, 0 deletions
diff --git a/butl/diagnostics b/butl/diagnostics
new file mode 100644
index 0000000..77f3f9c
--- /dev/null
+++ b/butl/diagnostics
@@ -0,0 +1,198 @@
+// file : butl/diagnostics -*- C++ -*-
+// copyright : Copyright (c) 2014-2016 Code Synthesis Ltd
+// license : MIT; see accompanying LICENSE file
+
+#ifndef BUTL_DIAGNOSTICS
+#define BUTL_DIAGNOSTICS
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <utility> // move(), forward()
+#include <exception> // uncaught_exception()
+
+#include <butl/utility>
+
+namespace butl
+{
+ // Diagnostic facility base infrastructure.
+ //
+ extern std::ostream* diag_stream; // std::cerr by default.
+
+ struct diag_record;
+ template <typename> struct diag_prologue;
+ template <typename> struct diag_mark;
+
+ using diag_epilogue = void (const diag_record&);
+
+ struct diag_record
+ {
+ template <typename T>
+ friend const diag_record&
+ operator<< (const diag_record& r, const T& x)
+ {
+ r.os << x;
+ return r;
+ }
+
+ diag_record (): empty_ (true), epilogue_ (nullptr) {}
+
+ template <typename B>
+ explicit
+ diag_record (const diag_prologue<B>& p)
+ : empty_ (true), epilogue_ (nullptr) { *this << p;}
+
+ template <typename B>
+ explicit
+ diag_record (const diag_mark<B>& m)
+ : empty_ (true), epilogue_ (nullptr) { *this << m;}
+
+ ~diag_record () noexcept (false);
+
+ bool
+ empty () const {return empty_;}
+
+ bool
+ full () const {return !empty_;}
+
+ void
+ flush () const;
+
+ void
+ append (diag_epilogue* e) const
+ {
+ if (e != nullptr)
+ {
+ assert (epilogue_ == nullptr); // No multiple epilogues support.
+ epilogue_ = e;
+ }
+
+ if (empty_)
+ empty_ = false;
+ else
+ os << "\n ";
+ }
+
+ // Move constructible-only type.
+ //
+ // Older versions of libstdc++ don't have the ostringstream move support
+ // and accuratly detecting its version is non-trivial. So we always use
+ // the pessimized implementation with libstdc++. Luckily, GCC doesn't seem
+ // to be needing move due to copy/move elision.
+ //
+#ifdef __GLIBCXX__
+ diag_record (diag_record&&);
+#else
+ diag_record (diag_record&& r)
+#ifndef __GLIBCXX__
+ : os (std::move (r.os))
+#endif
+ {
+ empty_ = r.empty_;
+ epilogue_ = r.epilogue_;
+
+ if (!empty_)
+ {
+#ifdef __GLIBCXX__
+ // os << r.os.str ();
+ assert (false); // No way to copy extra stream data?
+#endif
+ r.empty_ = true;
+ r.epilogue_ = nullptr;
+ }
+ }
+#endif
+
+ diag_record& operator= (diag_record&&) = delete;
+
+ diag_record (const diag_record&) = delete;
+ diag_record& operator= (const diag_record&) = delete;
+
+ public:
+ mutable std::ostringstream os;
+
+ protected:
+ mutable bool empty_;
+ mutable diag_epilogue* epilogue_;
+ };
+
+ template <typename B>
+ struct diag_prologue: B
+ {
+ diag_prologue (diag_epilogue* e = nullptr): B (), epilogue_ (e) {}
+
+ template <typename... A>
+ diag_prologue (A&&... a)
+ : B (std::forward<A> (a)...), epilogue_ (nullptr) {}
+
+ template <typename... A>
+ diag_prologue (diag_epilogue* e, A&&... a)
+ : B (std::forward<A> (a)...), epilogue_ (e) {}
+
+ template <typename T>
+ diag_record
+ operator<< (const T& x) const
+ {
+ diag_record r;
+ r.append (epilogue_);
+ B::operator() (r);
+ r << x;
+ return r;
+ }
+
+ friend const diag_record&
+ operator<< (const diag_record& r, const diag_prologue& p)
+ {
+ r.append (p.epilogue_);
+ p (r);
+ return r;
+ }
+
+ private:
+ diag_epilogue* epilogue_;
+ };
+
+ template <typename B>
+ struct diag_mark: B
+ {
+ diag_mark (): B () {}
+
+ template <typename... A>
+ diag_mark (A&&... a): B (std::forward<A> (a)...) {}
+
+ template <typename T>
+ diag_record
+ operator<< (const T& x) const
+ {
+ return B::operator() () << x;
+ }
+
+ friend const diag_record&
+ operator<< (const diag_record& r, const diag_mark& m)
+ {
+ return r << m ();
+ }
+ };
+
+ template <typename B>
+ struct diag_noreturn_end: B
+ {
+ diag_noreturn_end (): B () {}
+
+ template <typename... A>
+ diag_noreturn_end (A&&... a): B (std::forward<A> (a)...) {}
+
+ [[noreturn]] friend void
+ operator<< (const diag_record& r, const diag_noreturn_end& e)
+ {
+ // We said that we never return which means this end mark cannot be used
+ // to "maybe not return". And not returning without any diagnostics is
+ // probably a mistake.
+ //
+ assert (r.full ());
+ e.B::operator() (r);
+ }
+ };
+}
+
+#endif // BUTL_DIAGNOSTICS