src/llvm/include/llvm/Support/circular_raw_ostream.h

   1 //===-- llvm/Support/circular_raw_ostream.h - Buffered streams --*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains raw_ostream implementations for streams to do circular
  11 // buffering of their output.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H
  16 #define LLVM_SUPPORT_CIRCULAR_RAW_OSTREAM_H
  17
  18 #include "llvm/Support/raw_ostream.h"
  19
  20 namespace llvm
  21 {
  22   /// circular_raw_ostream - A raw_ostream which *can* save its data
  23   /// to a circular buffer, or can pass it through directly to an
  24   /// underlying stream if specified with a buffer of zero.
  25   ///
  26   class circular_raw_ostream : public raw_ostream {
  27   public:
  28     /// TAKE_OWNERSHIP - Tell this stream that it owns the underlying
  29     /// stream and is responsible for cleanup, memory management
  30     /// issues, etc.
  31     ///
  32     static const bool TAKE_OWNERSHIP = true;
  33
  34     /// REFERENCE_ONLY - Tell this stream it should not manage the
  35     /// held stream.
  36     ///
  37     static const bool REFERENCE_ONLY = false;
  38
  39   private:
  40     /// TheStream - The real stream we output to. We set it to be
  41     /// unbuffered, since we're already doing our own buffering.
  42     ///
  43     raw_ostream *TheStream;
  44
  45     /// OwnsStream - Are we responsible for managing the underlying
  46     /// stream?
  47     ///
  48     bool OwnsStream;
  49
  50     /// BufferSize - The size of the buffer in bytes.
  51     ///
  52     size_t BufferSize;
  53
  54     /// BufferArray - The actual buffer storage.
  55     ///
  56     char *BufferArray;
  57
  58     /// Cur - Pointer to the current output point in BufferArray.
  59     ///
  60     char *Cur;
  61
  62     /// Filled - Indicate whether the buffer has been completely
  63     /// filled.  This helps avoid garbage output.
  64     ///
  65     bool Filled;
  66
  67     /// Banner - A pointer to a banner to print before dumping the
  68     /// log.
  69     ///
  70     const char *Banner;
  71
  72     /// flushBuffer - Dump the contents of the buffer to Stream.
  73     ///
  74     void flushBuffer(void) {
  75       if (Filled)
  76         // Write the older portion of the buffer.
  77         TheStream->write(Cur, BufferArray + BufferSize - Cur);
  78       // Write the newer portion of the buffer.
  79       TheStream->write(BufferArray, Cur - BufferArray);
  80       Cur = BufferArray;
  81       Filled = false;
  82     }
  83
  84     virtual void write_impl(const char *Ptr, size_t Size) LLVM_OVERRIDE;
  85
  86     /// current_pos - Return the current position within the stream,
  87     /// not counting the bytes currently in the buffer.
  88     ///
  89     virtual uint64_t current_pos() const LLVM_OVERRIDE {
  90       // This has the same effect as calling TheStream.current_pos(),
  91       // but that interface is private.
  92       return TheStream->tell() - TheStream->GetNumBytesInBuffer();
  93     }
  94
  95   public:
  96     /// circular_raw_ostream - Construct an optionally
  97     /// circular-buffered stream, handing it an underlying stream to
  98     /// do the "real" output.
  99     ///
 100     /// As a side effect, if BuffSize is nonzero, the given Stream is
 101     /// set to be Unbuffered.  This is because circular_raw_ostream
 102     /// does its own buffering, so it doesn't want another layer of
 103     /// buffering to be happening underneath it.
 104     ///
 105     /// "Owns" tells the circular_raw_ostream whether it is
 106     /// responsible for managing the held stream, doing memory
 107     /// management of it, etc.
 108     ///
 109     circular_raw_ostream(raw_ostream &Stream, const char *Header,
 110                          size_t BuffSize = 0, bool Owns = REFERENCE_ONLY)
 111         : raw_ostream(/*unbuffered*/true),
 112             TheStream(0),
 113             OwnsStream(Owns),
 114             BufferSize(BuffSize),
 115             BufferArray(0),
 116             Filled(false),
 117             Banner(Header) {
 118       if (BufferSize != 0)
 119         BufferArray = new char[BufferSize];
 120       Cur = BufferArray;
 121       setStream(Stream, Owns);
 122     }
 123     explicit circular_raw_ostream()
 124         : raw_ostream(/*unbuffered*/true),
 125             TheStream(0),
 126             OwnsStream(REFERENCE_ONLY),
 127             BufferArray(0),
 128             Filled(false),
 129             Banner("") {
 130       Cur = BufferArray;
 131     }
 132
 133     ~circular_raw_ostream() {
 134       flush();
 135       flushBufferWithBanner();
 136       releaseStream();
 137       delete[] BufferArray;
 138     }
 139
 140     /// setStream - Tell the circular_raw_ostream to output a
 141     /// different stream.  "Owns" tells circular_raw_ostream whether
 142     /// it should take responsibility for managing the underlying
 143     /// stream.
 144     ///
 145     void setStream(raw_ostream &Stream, bool Owns = REFERENCE_ONLY) {
 146       releaseStream();
 147       TheStream = &Stream;
 148       OwnsStream = Owns;
 149     }
 150
 151     /// flushBufferWithBanner - Force output of the buffer along with
 152     /// a small header.
 153     ///
 154     void flushBufferWithBanner(void);
 155
 156   private:
 157     /// releaseStream - Delete the held stream if needed. Otherwise,
 158     /// transfer the buffer settings from this circular_raw_ostream
 159     /// back to the underlying stream.
 160     ///
 161     void releaseStream() {
 162       if (!TheStream)
 163         return;
 164       if (OwnsStream)
 165         delete TheStream;
 166     }
 167   };
 168 } // end llvm namespace
 169
 170
 171 #endif