File size: 2,439 Bytes
8652957 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 |
/* Like std::ofstream but without being incredibly slow. Backed by a raw fd.
* Supports most of the built-in types except for long double.
*/
#ifndef UTIL_FILE_STREAM_H
#define UTIL_FILE_STREAM_H
#include "util/fake_ostream.hh"
#include "util/file.hh"
#include "util/scoped.hh"
#include <cassert>
#include <cstring>
#include <stdint.h>
namespace util {
class FileStream : public FakeOStream<FileStream> {
public:
explicit FileStream(int out = -1, std::size_t buffer_size = 8192)
: buf_(util::MallocOrThrow(std::max<std::size_t>(buffer_size, kToStringMaxBytes))),
current_(static_cast<char*>(buf_.get())),
end_(current_ + std::max<std::size_t>(buffer_size, kToStringMaxBytes)),
fd_(out) {}
#if __cplusplus >= 201103L
FileStream(FileStream &&from) noexcept : buf_(from.buf_.release()), current_(from.current_), end_(from.end_), fd_(from.fd_) {
from.end_ = reinterpret_cast<char*>(from.buf_.get());
from.current_ = from.end_;
}
#endif
~FileStream() {
flush();
}
void SetFD(int to) {
flush();
fd_ = to;
}
FileStream &flush() {
if (current_ != buf_.get()) {
util::WriteOrThrow(fd_, buf_.get(), current_ - (char*)buf_.get());
current_ = static_cast<char*>(buf_.get());
}
return *this;
}
// For writes of arbitrary size.
FileStream &write(const void *data, std::size_t length) {
if (UTIL_LIKELY(current_ + length <= end_)) {
std::memcpy(current_, data, length);
current_ += length;
return *this;
}
flush();
if (current_ + length <= end_) {
std::memcpy(current_, data, length);
current_ += length;
} else {
util::WriteOrThrow(fd_, data, length);
}
return *this;
}
FileStream &seekp(uint64_t to) {
flush();
util::SeekOrThrow(fd_, to);
return *this;
}
protected:
friend class FakeOStream<FileStream>;
// For writes directly to buffer guaranteed to have amount < buffer size.
char *Ensure(std::size_t amount) {
if (UTIL_UNLIKELY(current_ + amount > end_)) {
flush();
assert(current_ + amount <= end_);
}
return current_;
}
void AdvanceTo(char *to) {
current_ = to;
assert(current_ <= end_);
}
private:
util::scoped_malloc buf_;
char *current_, *end_;
int fd_;
};
} // namespace
#endif
|