LLVM  8.0.1
circular_raw_ostream.h
Go to the documentation of this file.
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 
19 
20 namespace llvm {
21  /// circular_raw_ostream - A raw_ostream which *can* save its data
22  /// to a circular buffer, or can pass it through directly to an
23  /// underlying stream if specified with a buffer of zero.
24  ///
26  public:
27  /// TAKE_OWNERSHIP - Tell this stream that it owns the underlying
28  /// stream and is responsible for cleanup, memory management
29  /// issues, etc.
30  ///
31  static const bool TAKE_OWNERSHIP = true;
32 
33  /// REFERENCE_ONLY - Tell this stream it should not manage the
34  /// held stream.
35  ///
36  static const bool REFERENCE_ONLY = false;
37 
38  private:
39  /// TheStream - The real stream we output to. We set it to be
40  /// unbuffered, since we're already doing our own buffering.
41  ///
42  raw_ostream *TheStream;
43 
44  /// OwnsStream - Are we responsible for managing the underlying
45  /// stream?
46  ///
47  bool OwnsStream;
48 
49  /// BufferSize - The size of the buffer in bytes.
50  ///
51  size_t BufferSize;
52 
53  /// BufferArray - The actual buffer storage.
54  ///
55  char *BufferArray;
56 
57  /// Cur - Pointer to the current output point in BufferArray.
58  ///
59  char *Cur;
60 
61  /// Filled - Indicate whether the buffer has been completely
62  /// filled. This helps avoid garbage output.
63  ///
64  bool Filled;
65 
66  /// Banner - A pointer to a banner to print before dumping the
67  /// log.
68  ///
69  const char *Banner;
70 
71  /// flushBuffer - Dump the contents of the buffer to Stream.
72  ///
73  void flushBuffer() {
74  if (Filled)
75  // Write the older portion of the buffer.
76  TheStream->write(Cur, BufferArray + BufferSize - Cur);
77  // Write the newer portion of the buffer.
78  TheStream->write(BufferArray, Cur - BufferArray);
79  Cur = BufferArray;
80  Filled = false;
81  }
82 
83  void write_impl(const char *Ptr, size_t Size) override;
84 
85  /// current_pos - Return the current position within the stream,
86  /// not counting the bytes currently in the buffer.
87  ///
88  uint64_t current_pos() const override {
89  // This has the same effect as calling TheStream.current_pos(),
90  // but that interface is private.
91  return TheStream->tell() - TheStream->GetNumBytesInBuffer();
92  }
93 
94  public:
95  /// circular_raw_ostream - Construct an optionally
96  /// circular-buffered stream, handing it an underlying stream to
97  /// do the "real" output.
98  ///
99  /// As a side effect, if BuffSize is nonzero, the given Stream is
100  /// set to be Unbuffered. This is because circular_raw_ostream
101  /// does its own buffering, so it doesn't want another layer of
102  /// buffering to be happening underneath it.
103  ///
104  /// "Owns" tells the circular_raw_ostream whether it is
105  /// responsible for managing the held stream, doing memory
106  /// management of it, etc.
107  ///
108  circular_raw_ostream(raw_ostream &Stream, const char *Header,
109  size_t BuffSize = 0, bool Owns = REFERENCE_ONLY)
110  : raw_ostream(/*unbuffered*/ true), TheStream(nullptr),
111  OwnsStream(Owns), BufferSize(BuffSize), BufferArray(nullptr),
112  Filled(false), Banner(Header) {
113  if (BufferSize != 0)
114  BufferArray = new char[BufferSize];
115  Cur = BufferArray;
116  setStream(Stream, Owns);
117  }
118 
120  flush();
122  releaseStream();
123  delete[] BufferArray;
124  }
125 
126  /// setStream - Tell the circular_raw_ostream to output a
127  /// different stream. "Owns" tells circular_raw_ostream whether
128  /// it should take responsibility for managing the underlying
129  /// stream.
130  ///
131  void setStream(raw_ostream &Stream, bool Owns = REFERENCE_ONLY) {
132  releaseStream();
133  TheStream = &Stream;
134  OwnsStream = Owns;
135  }
136 
137  /// flushBufferWithBanner - Force output of the buffer along with
138  /// a small header.
139  ///
140  void flushBufferWithBanner();
141 
142  private:
143  /// releaseStream - Delete the held stream if needed. Otherwise,
144  /// transfer the buffer settings from this circular_raw_ostream
145  /// back to the underlying stream.
146  ///
147  void releaseStream() {
148  if (!TheStream)
149  return;
150  if (OwnsStream)
151  delete TheStream;
152  }
153  };
154 } // end llvm namespace
155 
156 #endif
This class represents lattice values for constants.
Definition: AllocatorList.h:24
block Block Frequency true
circular_raw_ostream(raw_ostream &Stream, const char *Header, size_t BuffSize=0, bool Owns=REFERENCE_ONLY)
circular_raw_ostream - Construct an optionally circular-buffered stream, handing it an underlying str...
circular_raw_ostream - A raw_ostream which can save its data to a circular buffer, or can pass it through directly to an underlying stream if specified with a buffer of zero.
void setStream(raw_ostream &Stream, bool Owns=REFERENCE_ONLY)
setStream - Tell the circular_raw_ostream to output a different stream.
raw_ostream & write(unsigned char C)
void flushBufferWithBanner()
flushBufferWithBanner - Force output of the buffer along with a small header.
static const bool REFERENCE_ONLY
REFERENCE_ONLY - Tell this stream it should not manage the held stream.
size_t GetNumBytesInBuffer() const
Definition: raw_ostream.h:134
uint32_t Size
Definition: Profile.cpp:47
static const bool TAKE_OWNERSHIP
TAKE_OWNERSHIP - Tell this stream that it owns the underlying stream and is responsible for cleanup...
uint64_t tell() const
tell - Return the current offset with the file.
Definition: raw_ostream.h:100
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46