90 lines
2.7 KiB
C++
90 lines
2.7 KiB
C++
/*
|
|
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <ostream>
|
|
#include <streambuf>
|
|
#include <string>
|
|
|
|
namespace facebook {
|
|
namespace hermes {
|
|
namespace inspector {
|
|
namespace detail {
|
|
|
|
/// Subclass of \c std::ostream where flushing is implemented through a
|
|
/// callback. Writes are collected in a buffer. When filled, the buffer's
|
|
/// contents are emptied out and sent to a callback.
|
|
struct CallbackOStream : public std::ostream {
|
|
/// Signature of callback called to flush buffer contents. Accepts the buffer
|
|
/// as a string. Returns a boolean indicating whether flushing succeeded.
|
|
/// Callback failure will be translated to stream failure. If the callback
|
|
/// throws an exception it will be swallowed and translated into stream
|
|
/// failure.
|
|
using Fn = std::function<bool(std::string)>;
|
|
|
|
/// Construct a new stream.
|
|
///
|
|
/// \p sz The size of the buffer -- how large it can get before it must be
|
|
/// flushed. Must be non-zero.
|
|
/// \p cb The callback function.
|
|
CallbackOStream(size_t sz, Fn cb);
|
|
|
|
/// This class is neither movable nor copyable.
|
|
CallbackOStream(CallbackOStream &&that) = delete;
|
|
CallbackOStream &operator=(CallbackOStream &&that) = delete;
|
|
CallbackOStream(const CallbackOStream &that) = delete;
|
|
CallbackOStream &operator=(const CallbackOStream &that) = delete;
|
|
|
|
private:
|
|
/// \c std::streambuf sub-class backed by a std::string buffer and
|
|
/// implementing overflow by calling a callback.
|
|
struct StreamBuf : public std::streambuf {
|
|
/// Construct a new streambuf. Parameters are the same as those of
|
|
/// \c CallbackOStream .
|
|
StreamBuf(size_t sz, Fn cb);
|
|
|
|
/// Destruction will flush any remaining buffer contents.
|
|
~StreamBuf();
|
|
|
|
/// StreamBufs are not copyable, to avoid the flush callback receiving
|
|
/// the contents of multiple streams.
|
|
StreamBuf(const StreamBuf &) = delete;
|
|
StreamBuf &operator=(const StreamBuf &) = delete;
|
|
|
|
protected:
|
|
/// std::streambuf overrides
|
|
int_type overflow(int_type ch) override;
|
|
int sync() override;
|
|
|
|
private:
|
|
/// The size of the backing buffer. Fixed for an instance of the streambuf.
|
|
size_t sz_;
|
|
|
|
/// The backing buffer that writes will go to until full.
|
|
std::unique_ptr<char[]> buf_;
|
|
|
|
/// The function called when buf_ has been filled.
|
|
Fn cb_;
|
|
|
|
/// Clears the backing buffer.
|
|
void reset();
|
|
|
|
/// Clears the backing buffer and returns it contents in a string.
|
|
std::string take();
|
|
};
|
|
|
|
StreamBuf sbuf_;
|
|
};
|
|
|
|
} // namespace detail
|
|
} // namespace inspector
|
|
} // namespace hermes
|
|
} // namespace facebook
|