buffered_istream.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_ISTREAM_HPP
#define PLYWOOT_BUFFERED_ISTREAM_HPP
 
 
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <istream>
#include <memory>
 
namespace {
 
constexpr std::size_t IStreamBufferSize{1024 * 1024};
 
}
 
namespace plywoot::detail {
 
class BufferedIStream
{
public:
  explicit BufferedIStream(std::istream &is) : is_{is} { buffer(); }
 
  BufferedIStream(const BufferedIStream &) = delete;
  BufferedIStream &operator=(const BufferedIStream &) = delete;
 
  bool eof() const { return *c_ == EOF; }
 
  const char *data() const { return c_; }
  const char *&data() { return c_; }
 
  template<typename T>
  inline T read()
  {
    // Note; buffer a bit more than strictly necessary, so that we can move the
    // read head unconditionally after reading the object of type T.
    if (c_ + sizeof(T) > eob_) buffer(sizeof(T));
    const char *t = c_;
    c_ += sizeof(T);
    return *reinterpret_cast<const T *>(t);
  }
 
  template<typename From, typename To, std::size_t N>
  std::uint8_t *read(std::uint8_t *dest)
  {
    if constexpr (std::is_same_v<From, To>)
    {
      return this->memcpy(dest, N * sizeof(From));
    }
    else
    {
      static_assert(
          N * sizeof(From) <= IStreamBufferSize,
          "input stream buffer size is too small; increase IStreamBufferSize");
 
      constexpr std::size_t bytesToRead = N * sizeof(From);
      if (c_ + bytesToRead > eob_) buffer(bytesToRead);
 
      const From *from = reinterpret_cast<const From *>(c_);
      To *to = reinterpret_cast<To *>(dest);
      for (std::size_t i = 0; i < N; ++i) { *to++ = *from++; }
 
      c_ += bytesToRead;
 
      return reinterpret_cast<std::uint8_t *>(to);
    }
  }
 
  inline std::uint8_t *memcpy(std::uint8_t *dest, std::size_t n)
  {
    if (n > IStreamBufferSize)
    {
      const std::size_t remaining = eob_ - c_;
      std::memcpy(dest, c_, remaining);
      is_.read(reinterpret_cast<char *>(dest) + remaining, n - remaining);
      c_ = eob_;
    }
    else
    {
      if (c_ + n > eob_) buffer(n);
 
      std::memcpy(dest, c_, n);
      c_ += n;
    }
 
    return dest + n;
  }
 
  void skip(std::size_t n)
  {
    const std::size_t remaining = eob_ - c_;
    if (remaining > n) { c_ += n; }
    else
    {
      is_.seekg(n - remaining, std::ios_base::cur);
      buffer();
    }
  }
 
  void skipLines(std::size_t n)
  {
    while (*c_ != EOF && n > 0)
    {
      c_ = static_cast<const char *>(std::memchr(c_, '\n', eob_ - c_));
      if (c_)
      {
        readCharacter();
        --n;
      }
      else { buffer(); }
    }
  }
 
  inline void skipWhitespace()
  {
    while (0 <= *c_ && *c_ <= 0x20) { readCharacter(); }
  }
 
  inline void skipNonWhitespace()
  {
    while (*c_ > 0x20) readCharacter();
  }
 
  void buffer(std::size_t minimum)
  {
    std::size_t remaining = eob_ - c_;
    if (remaining < minimum)
    {
      std::memcpy(buffer_.get(), c_, remaining);
      if (!is_.read(buffer_.get() + remaining, IStreamBufferSize - remaining))
      {
        // In case the buffer is only partially filled, fill the remainder with
        // EOF characters.
        remaining += is_.gcount();
        std::fill_n(buffer_.get() + remaining, IStreamBufferSize - remaining, EOF);
      }
 
      c_ = buffer_.get();
    }
  }
 
private:
  void buffer()
  {
    if (!is_.read(buffer_.get(), IStreamBufferSize))
    {
      // In case the buffer is only partially filled, fill the remainder with
      // EOF characters.
      auto remaining = is_.gcount();
      std::fill_n(buffer_.get() + remaining, IStreamBufferSize - remaining, EOF);
    }
 
    c_ = buffer_.get();
  }
 
  inline void readCharacter()
  {
    if (c_++ == eob_) { buffer(); }
  }
 
  std::unique_ptr<char[]> buffer_{new char[IStreamBufferSize]};
 
  const char *c_{buffer_.get() + IStreamBufferSize};
  const char *eob_{buffer_.get() + IStreamBufferSize};
 
  std::istream &is_;
};
 
}
 
#endif