8 files changed, 0 insertions, 638 deletions
diff --git a/src/common/io/AutoReadStream.cpp b/src/common/io/AutoReadStream.cpp
deleted file mode 100644
index 18bc18da..00000000
--- a/src/common/io/AutoReadStream.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#include "cru/common/io/AutoReadStream.h"
-#include "cru/common/io/Stream.h"
-
-#include <thread>
-
-namespace cru::io {
-
-AutoReadStream::AutoReadStream(Stream* stream, bool auto_delete,
-                               const AutoReadStreamOptions& options)
-    : Stream(false, true, stream->CanSeek()) {
-  auto buffer_stream_options = options.GetBufferStreamOptions();
-  stream_ = stream;
-  size_per_read_ = buffer_stream_options.GetBlockSizeOrDefault();
-  buffer_stream_ = std::make_unique<BufferStream>(buffer_stream_options);
-  background_thread_ = std::thread(&AutoReadStream::BackgroundThreadRun, this);
-}
-
-AutoReadStream::~AutoReadStream() {
-  if (auto_delete_) {
-    delete stream_;
-  }
-}
-
-Index AutoReadStream::DoRead(std::byte* buffer, Index offset, Index size) {
-  std::unique_lock lock(buffer_stream_mutex_);
-  return buffer_stream_->Read(buffer, offset, size);
-}
-
-Index AutoReadStream::DoWrite(const std::byte* buffer, Index offset,
-                              Index size) {
-  return stream_->Write(buffer, offset, size);
-}
-
-void AutoReadStream::DoFlush() { stream_->Flush(); }
-
-void AutoReadStream::DoClose() {}
-
-void AutoReadStream::BackgroundThreadRun() {
-  std::vector<std::byte> buffer(size_per_read_);
-  while (true) {
-    try {
-      auto read = stream_->Read(buffer.data(), buffer.size());
-      if (read == 0) {
-        buffer_stream_->SetEof();
-        break;
-      } else {
-        buffer_stream_->Write(buffer.data(), read);
-      }
-    } catch (const StreamAlreadyClosedException& exception) {
-      buffer_stream_->SetEof();
-      break;
-    }
-  }
-}
-
-}  // namespace cru::io
diff --git a/src/common/io/BufferStream.cpp b/src/common/io/BufferStream.cpp
deleted file mode 100644
index 73e5719b..00000000
--- a/src/common/io/BufferStream.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-#include "cru/common/io/BufferStream.h"
-#include "cru/common/io/Stream.h"
-
-namespace cru::io {
-BufferStream::BufferStream(const BufferStreamOptions& options)
-    : Stream(false, true, true) {
-  block_size_ = options.GetBlockSizeOrDefault();
-  max_block_count_ = options.GetMaxBlockCount();
-
-  eof_ = false;
-}
-
-BufferStream::~BufferStream() { DoClose(); }
-
-Index BufferStream::DoRead(std::byte* buffer, Index offset, Index size) {
-  std::unique_lock lock(mutex_);
-
-  condition_variable_.wait(lock,
-                           [this] { return !buffer_list_.empty() || eof_; });
-
-  if (buffer_list_.empty() && eof_) {
-    return 0;
-  }
-
-  auto full = max_block_count_ > 0 && buffer_list_.size() == max_block_count_;
-
-  Index read = 0;
-
-  while (!buffer_list_.empty()) {
-    auto& stream_buffer = buffer_list_.front();
-    auto this_read =
-        stream_buffer.PopFront(buffer + offset + read, size - read);
-    if (stream_buffer.GetUsedSize() == 0) {
-      buffer_list_.pop_front();
-    }
-    read += this_read;
-    if (read == size) {
-      break;
-    }
-  }
-
-  if (full && buffer_list_.size() < max_block_count_) {
-    // By convention, there should be at most one producer waiting. So
-    // notify_one and notify_all should be the same.
-    condition_variable_.notify_one();
-  }
-
-  return read;
-}
-
-Index BufferStream::DoWrite(const std::byte* buffer, Index offset, Index size) {
-  std::unique_lock lock(mutex_);
-
-  if (eof_) {
-    throw WriteAfterEofException(
-        u"Stream has been set eof. Can't write to it any more.");
-  }
-
-  condition_variable_.wait(lock, [this] {
-    return max_block_count_ <= 0 || buffer_list_.size() < max_block_count_ ||
-           buffer_list_.back().GetBackFree() > 0;
-  });
-
-  auto empty = buffer_list_.empty();
-
-  Index written = 0;
-
-  if (empty) {
-    buffer_list_.push_back(Buffer(block_size_));
-  }
-
-  while (true) {
-    if (buffer_list_.back().GetBackFree() == 0) {
-      if (max_block_count_ > 0 && buffer_list_.size() == max_block_count_) {
-        break;
-      }
-      buffer_list_.push_back(Buffer(block_size_));
-    }
-    auto& stream_buffer = buffer_list_.back();
-    auto this_written =
-        stream_buffer.PushBack(buffer + offset + written, size - written);
-    written += this_written;
-    if (written == size) {
-      break;
-    }
-  }
-
-  if (empty) {
-    // By convention, there should be at most one consumer waiting. So
-    // notify_one and notify_all should be the same.
-    condition_variable_.notify_one();
-  }
-
-  return written;
-}
-
-void BufferStream::SetEof() {
-  std::unique_lock lock(mutex_);
-
-  eof_ = true;
-  if (buffer_list_.empty()) {
-    // By convention, there should be at most one consumer waiting. So
-    // notify_one and notify_all should be the same.
-    condition_variable_.notify_one();
-  }
-}
-
-void BufferStream::DoClose() { CRU_STREAM_BEGIN_CLOSE }
-}  // namespace cru::io
diff --git a/src/common/io/CFileStream.cpp b/src/common/io/CFileStream.cpp
deleted file mode 100644
index 01456437..00000000
--- a/src/common/io/CFileStream.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "cru/common/io/CFileStream.h"
-#include "cru/common/Exception.h"
-#include "cru/common/io/Stream.h"
-
-#include <cstdio>
-
-namespace cru::io {
-static bool ModeCanRead(const char* mode) {
-  for (const char* p = mode; *p != '\0'; p++) {
-    if (*p == 'r' || *p == '+') {
-      return true;
-    }
-  }
-  return false;
-}
-
-static bool ModeCanWrite(const char* mode) {
-  for (const char* p = mode; *p != '\0'; p++) {
-    if (*p == 'w' || *p == 'a' || *p == '+') {
-      return true;
-    }
-  }
-  return false;
-}
-
-CFileStream::CFileStream(const char* path, const char* mode)
-    : Stream(true, ModeCanRead(mode), ModeCanWrite(mode)),
-      file_(std::fopen(path, mode)),
-      auto_close_(true) {
-  if (file_ == nullptr) {
-    throw ErrnoException(u"Cannot open file.");
-  }
-}
-
-CFileStream::CFileStream(std::FILE* file, bool readable, bool writable,
-                         bool auto_close)
-    : Stream(true, readable, writable), file_(file), auto_close_(auto_close) {
-  if (file_ == nullptr) {
-    throw Exception(u"File is NULL.");
-  }
-}
-
-CFileStream::~CFileStream() {
-  if (auto_close_ && file_ != nullptr) {
-    std::fclose(file_);
-  }
-}
-
-static int ConvertOriginFlag(Stream::SeekOrigin origin) {
-  switch (origin) {
-    case Stream::SeekOrigin::Begin:
-      return SEEK_SET;
-    case Stream::SeekOrigin::Current:
-      return SEEK_CUR;
-    case Stream::SeekOrigin::End:
-      return SEEK_END;
-    default:
-      throw Exception(u"Unknown seek origin.");
-  }
-}
-
-Index CFileStream::DoSeek(Index offset, SeekOrigin origin) {
-  if (std::fseek(file_, offset, ConvertOriginFlag(origin))) {
-    throw ErrnoException(u"Seek failed.");
-  }
-  return DoTell();
-}
-
-Index CFileStream::DoTell() {
-  long position = std::ftell(file_);
-  if (position == -1) {
-    throw ErrnoException(u"Tell failed.");
-  }
-  return position;
-}
-
-void CFileStream::DoRewind() { std::rewind(file_); }
-
-Index CFileStream::DoRead(std::byte* buffer, Index offset, Index size) {
-  auto count = std::fread(buffer + offset, 1, size, file_);
-  return count;
-}
-
-Index CFileStream::DoWrite(const std::byte* buffer, Index offset, Index size) {
-  auto count = std::fwrite(buffer + offset, 1, size, file_);
-  return count;
-}
-
-void CFileStream::DoFlush() { std::fflush(file_); }
-
-void CFileStream::DoClose() {
-  CRU_STREAM_BEGIN_CLOSE
-  std::fclose(file_);
-  file_ = nullptr;
-}
-}  // namespace cru::io
diff --git a/src/common/io/MemoryStream.cpp b/src/common/io/MemoryStream.cpp
deleted file mode 100644
index 4b33d780..00000000
--- a/src/common/io/MemoryStream.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "cru/common/io/MemoryStream.h"
-
-#include <cstring>
-#include "cru/common/Exception.h"
-#include "cru/common/io/Stream.h"
-
-namespace cru::io {
-MemoryStream::MemoryStream(
-    std::byte* buffer, Index size, bool read_only,
-    std::function<void(std::byte* buffer, Index size)> release_func)
-    : Stream(true, true, !read_only),
-      buffer_(buffer),
-      size_(size),
-      position_(0),
-      release_func_(std::move(release_func)) {
-  if (!buffer) {
-    throw Exception(u"Buffer is nullptr");
-  }
-  if (size <= 0) {
-    throw Exception(u"Size is 0 or negative.");
-  }
-}
-
-MemoryStream::~MemoryStream() {}
-
-void MemoryStream::Close() { DoClose(); }
-
-Index MemoryStream::DoSeek(Index offset, SeekOrigin origin) {
-  switch (origin) {
-    case SeekOrigin::Current:
-      position_ += offset;
-      break;
-    case SeekOrigin::Begin:
-      position_ = offset;
-      break;
-    case SeekOrigin::End:
-      position_ = size_ + offset;
-      break;
-  }
-  return position_;
-}
-
-Index MemoryStream::DoRead(std::byte* buffer, Index offset, Index size) {
-  if (position_ + size > size_) {
-    size = size_ - position_;
-  }
-  if (size <= 0) {
-    return 0;
-  }
-  std::memmove(buffer + offset, buffer_ + position_, size);
-  position_ += size;
-  return size;
-}
-
-Index MemoryStream::DoWrite(const std::byte* buffer, Index offset, Index size) {
-  if (position_ + size > size_) {
-    size = size_ - position_;
-  }
-  if (size <= 0) {
-    return 0;
-  }
-  std::memmove(buffer_ + position_, buffer + offset, size);
-  position_ += size;
-  return size;
-}
-
-void MemoryStream::DoClose() {
-  CRU_STREAM_BEGIN_CLOSE
-  release_func_(buffer_, size_);
-  buffer_ = nullptr;
-  release_func_ = {};
-}
-
-}  // namespace cru::io
diff --git a/src/common/io/OpenFileFlag.cpp b/src/common/io/OpenFileFlag.cpp
deleted file mode 100644
index 6b9957fe..00000000
--- a/src/common/io/OpenFileFlag.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "cru/common/io/OpenFileFlag.h"
-
-namespace cru::io {
-bool CheckOpenFileFlag(OpenFileFlag flags) {
-  auto has = [flags](OpenFileFlag flag) { return flags & flag; };
-
-  if ((has(OpenFileFlags::Append) || has(OpenFileFlags::Truncate) ||
-       has(OpenFileFlags::Create)) &&
-      !has(OpenFileFlags::Write)) {
-    return false;
-  }
-
-  if (has(OpenFileFlags::Truncate) && has(OpenFileFlags::Append)) {
-    return false;
-  }
-
-  return true;
-}
-}  // namespace cru::io
diff --git a/src/common/io/ProxyStream.cpp b/src/common/io/ProxyStream.cpp
deleted file mode 100644
index c2e64056..00000000
--- a/src/common/io/ProxyStream.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "cru/common/io/ProxyStream.h"
-#include "cru/common/io/Stream.h"
-
-namespace cru::io {
-ProxyStream::ProxyStream(ProxyStreamHandlers handlers)
-    : Stream(static_cast<bool>(handlers.seek), static_cast<bool>(handlers.read),
-             static_cast<bool>(handlers.write)),
-      handlers_(std::move(handlers)) {}
-
-ProxyStream::~ProxyStream() { DoClose(); }
-
-Index ProxyStream::DoSeek(Index offset, SeekOrigin origin) {
-  return handlers_.seek(offset, origin);
-}
-
-Index ProxyStream::DoRead(std::byte* buffer, Index offset, Index size) {
-  return handlers_.read(buffer, offset, size);
-}
-
-Index ProxyStream::DoWrite(const std::byte* buffer, Index offset, Index size) {
-  return handlers_.write(buffer, offset, size);
-}
-
-void ProxyStream::DoFlush() {
-  if (handlers_.flush) {
-    handlers_.flush();
-  }
-}
-
-void ProxyStream::DoClose() {
-  CRU_STREAM_BEGIN_CLOSE
-  if (handlers_.close) {
-    handlers_.close();
-  }
-  handlers_ = {};
-}
-}  // namespace cru::io
diff --git a/src/common/io/Resource.cpp b/src/common/io/Resource.cpp
deleted file mode 100644
index b847e1cf..00000000
--- a/src/common/io/Resource.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "cru/common/io/Resource.h"
-#include "cru/common/Exception.h"
-#include "cru/common/log/Logger.h"
-
-#if defined(CRU_PLATFORM_OSX)
-#include <CoreFoundation/CoreFoundation.h>
-#elif defined(CRU_PLATFORM_WINDOWS)
-#include <Windows.h>
-#endif
-
-#include <filesystem>
-
-namespace cru::io {
-std::filesystem::path GetResourceDir() {
-  constexpr auto kLogTag = u"GetResourceDir";
-
-#if defined(CRU_PLATFORM_OSX)
-  CFBundleRef main_bundle = CFBundleGetMainBundle();
-  CFURLRef bundle_url = CFBundleCopyBundleURL(main_bundle);
-  CFStringRef cf_string_ref =
-      CFURLCopyFileSystemPath(bundle_url, kCFURLPOSIXPathStyle);
-  std::filesystem::path bundle_path(
-      CFStringGetCStringPtr(cf_string_ref, kCFStringEncodingUTF8));
-
-  CFRelease(bundle_url);
-  CFRelease(cf_string_ref);
-
-  return bundle_path / "Contents/Resources";
-#elif defined(CRU_PLATFORM_WINDOWS)
-  wchar_t buffer[MAX_PATH];
-  DWORD size = ::GetModuleFileNameW(nullptr, buffer, MAX_PATH);
-  std::filesystem::path module_path(buffer, buffer + size);
-  auto p = module_path;
-  while (p.has_parent_path()) {
-    p = p.parent_path();
-    auto resource_dir_path = p / "assets";
-    if (std::filesystem::exists(resource_dir_path) &&
-        std::filesystem::is_directory(resource_dir_path)) {
-      return resource_dir_path;
-    }
-  }
-
-  throw Exception(u"Failed to find resource directory.");
-#else
-  throw Exception(u"Not implemented.");
-#endif
-}
-}  // namespace cru::io
diff --git a/src/common/io/Stream.cpp b/src/common/io/Stream.cpp
deleted file mode 100644
index 6b0a513c..00000000
--- a/src/common/io/Stream.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-#include "cru/common/io/Stream.h"
-#include "cru/common/Exception.h"
-#include "cru/common/Format.h"
-
-#include <utility>
-
-namespace cru::io {
-StreamOperationNotSupportedException::StreamOperationNotSupportedException(
-    String operation)
-    : operation_(std::move(operation)) {
-  SetMessage(Format(u"Stream operation {} not supported.", operation_));
-}
-
-void StreamOperationNotSupportedException::CheckSeek(bool seekable) {
-  if (!seekable) throw StreamOperationNotSupportedException(u"seek");
-}
-
-void StreamOperationNotSupportedException::CheckRead(bool readable) {
-  if (!readable) throw StreamOperationNotSupportedException(u"read");
-}
-
-void StreamOperationNotSupportedException::CheckWrite(bool writable) {
-  if (!writable) throw StreamOperationNotSupportedException(u"write");
-}
-
-StreamAlreadyClosedException::StreamAlreadyClosedException()
-    : Exception(u"Stream is already closed.") {}
-
-void StreamAlreadyClosedException::Check(bool closed) {
-  if (closed) throw StreamAlreadyClosedException();
-}
-
-Stream::Stream(SupportedOperations supported_operations)
-    : supported_operations_(std::move(supported_operations)), closed_(false) {}
-
-Stream::Stream(std::optional<bool> can_seek, std::optional<bool> can_read,
-               std::optional<bool> can_write)
-    : Stream(SupportedOperations{can_seek, can_read, can_write}) {}
-
-bool Stream::CanSeek() {
-  CheckClosed();
-  return DoCanSeek();
-}
-
-Index Stream::Seek(Index offset, SeekOrigin origin) {
-  CheckClosed();
-  StreamOperationNotSupportedException::CheckSeek(DoCanSeek());
-  return DoSeek(offset, origin);
-}
-
-Index Stream::Tell() {
-  CheckClosed();
-  return DoTell();
-}
-
-void Stream::Rewind() {
-  CheckClosed();
-  return DoRewind();
-}
-
-Index Stream::GetSize() {
-  CheckClosed();
-  return DoGetSize();
-}
-
-bool Stream::CanRead() {
-  CheckClosed();
-  return DoCanRead();
-}
-
-Index Stream::Read(std::byte* buffer, Index offset, Index size) {
-  CheckClosed();
-  StreamOperationNotSupportedException::CheckRead(DoCanRead());
-  return DoRead(buffer, offset, size);
-}
-
-Index Stream::Read(std::byte* buffer, Index size) {
-  return Read(buffer, 0, size);
-}
-
-Index Stream::Read(char* buffer, Index offset, Index size) {
-  return Read(reinterpret_cast<std::byte*>(buffer), offset, size);
-}
-
-Index Stream::Read(char* buffer, Index size) {
-  return Read(reinterpret_cast<std::byte*>(buffer), 0, size);
-}
-
-bool Stream::CanWrite() {
-  CheckClosed();
-  return DoCanWrite();
-}
-
-Index Stream::Write(const std::byte* buffer, Index offset, Index size) {
-  CheckClosed();
-  StreamOperationNotSupportedException::CheckWrite(DoCanWrite());
-  return DoWrite(buffer, offset, size);
-}
-
-Index Stream::Write(const std::byte* buffer, Index size) {
-  return Write(buffer, 0, size);
-}
-
-Index Stream::Write(const char* buffer, Index offset, Index size) {
-  return Write(reinterpret_cast<const std::byte*>(buffer), offset, size);
-}
-
-Index Stream::Write(const char* buffer, Index size) {
-  return Write(reinterpret_cast<const std::byte*>(buffer), size);
-}
-
-void Stream::Flush() {
-  CheckClosed();
-  DoFlush();
-}
-
-bool Stream::DoCanSeek() {
-  if (supported_operations_->can_seek) {
-    return *supported_operations_->can_seek;
-  } else {
-    throw Exception(
-        u"Can seek is neither set in supported_operations nor implemeted in "
-        u"virtual function.");
-  }
-}
-
-bool Stream::DoCanRead() {
-  if (supported_operations_->can_read) {
-    return *supported_operations_->can_read;
-  } else {
-    throw Exception(
-        u"Can read is neither set in supported_operations nor implemeted in "
-        u"virtual function.");
-  }
-}
-
-bool Stream::DoCanWrite() {
-  if (supported_operations_->can_write) {
-    return *supported_operations_->can_write;
-  } else {
-    throw Exception(
-        u"Can write is neither set in supported_operations nor implemeted in "
-        u"virtual function.");
-  }
-}
-
-Index Stream::DoSeek(Index offset, SeekOrigin origin) {
-  throw Exception(u"Stream is seekable but DoSeek is not implemented.");
-}
-
-Index Stream::DoTell() {
-  StreamOperationNotSupportedException::CheckSeek(DoCanSeek());
-  return DoSeek(0, SeekOrigin::Current);
-}
-
-void Stream::DoRewind() {
-  StreamOperationNotSupportedException::CheckSeek(DoCanSeek());
-  DoSeek(0, SeekOrigin::Begin);
-}
-
-Index Stream::DoGetSize() {
-  StreamOperationNotSupportedException::CheckSeek(DoCanSeek());
-  Index current_position = DoTell();
-  Seek(0, SeekOrigin::End);
-  Index size = DoTell();
-  Seek(current_position, SeekOrigin::Begin);
-  return size;
-}
-
-Index Stream::DoRead(std::byte* buffer, Index offset, Index size) {
-  throw Exception(u"Stream is readable but DoSeek is not implemented.");
-}
-
-Index Stream::DoWrite(const std::byte* buffer, Index offset, Index size) {
-  throw Exception(u"Stream is writable but DoSeek is not implemented.");
-}
-
-void Stream::DoFlush() {}
-
-Buffer Stream::ReadToEnd(Index grow_size) {
-  Buffer buffer(grow_size);
-  while (true) {
-    auto read = Read(buffer.GetUsedEndPtr(), buffer.GetBackFree());
-    buffer.PushBackCount(read);
-    if (read == 0) {
-      break;
-    }
-    if (buffer.IsUsedReachEnd()) {
-      buffer.ResizeBuffer(buffer.GetBufferSize() + grow_size, true);
-    }
-  }
-  return buffer;
-}
-
-String Stream::ReadToEndAsUtf8String() {
-  auto buffer = ReadToEnd();
-  return String::FromUtf8(buffer);
-}
-}  // namespace cru::io