buffered_ostream.hpp

Go to the documentation of this file.

/*
   This file is part of PLYwoot, a header-only PLY parser.
 
   Copyright (C) 2023-2025, Ton van den Heuvel
 
   PLYwoot is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef PLYWOOT_BUFFERED_OSTREAM_HPP
#define PLYWOOT_BUFFERED_OSTREAM_HPP
 
 
#include "type_traits.hpp"
 
#include <charconv>
#include <cstring>
#include <memory>
#include <ostream>
#include <type_traits>
 
namespace {
 
constexpr std::size_t OStreamBufferSize{1024 * 1024};
 
}
 
namespace plywoot::detail {
 
class BufferedOStream
{
public:
  explicit BufferedOStream(std::ostream &os) : os_{os} {}
 
  ~BufferedOStream() { flush(); }
 
  BufferedOStream(const BufferedOStream &) = delete;
  BufferedOStream &operator=(const BufferedOStream &) = delete;
 
  void put(char c)
  {
    *c_++ = c;
    if (c_ == eob_) flush();
  }
 
  void write(const char *src, std::size_t n)
  {
    if (n >= OStreamBufferSize)
    {
      flush();
      os_.write(src, n);
    }
    else
    {
      if (c_ + n >= eob_) { flush(); }
      std::memcpy(c_, src, n);
      c_ += n;
    }
  }
 
  template<typename T>
  void writeAscii(T t)
  {
    constexpr int MIN_BUFFER_SIZE = 100;
    if (c_ + MIN_BUFFER_SIZE >= eob_) { flush(); }
    c_ = std::to_chars(c_, c_ + MIN_BUFFER_SIZE, t).ptr;
  }
 
  template<typename T>
  void write(T t)
  {
    if (c_ + sizeof(T) >= eob_) { flush(); }
    std::memcpy(c_, reinterpret_cast<const char *>(&t), sizeof(T));
    c_ += sizeof(T);
  }
 
private:
  void flush()
  {
    os_.write(buffer_.get(), c_ - buffer_.get());
    c_ = buffer_.get();
  }
 
  std::unique_ptr<char[]> buffer_{new char[OStreamBufferSize]};
 
  char *c_{buffer_.get()};
  const char *eob_{buffer_.get() + OStreamBufferSize};
 
  std::ostream &os_;
};
 
}
 
#endif