archive_r_ruby 0.1.0

data/ext/archive_r/vendor/archive_r/src/multi_volume_stream_base.cc

@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/multi_volume_stream_base.h"
+
+#include "archive_r/path_hierarchy_utils.h"
+
+#include <algorithm>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+
+namespace archive_r {
+
+struct MultiVolumeStreamBase::Impl {
+  explicit Impl(MultiVolumeStreamBase &owner)
+      : self(owner) {}
+
+  MultiVolumeStreamBase &self;
+  std::vector<int64_t> part_offsets;
+  std::size_t total_parts = 0;
+  std::size_t active_part_index = 0;
+  bool part_open = false;
+  int64_t logical_offset = 0;
+  int64_t total_size = -1;
+
+  void ensure_part_active(std::size_t part_index);
+  bool advance_to_next_part();
+  bool ensure_size_metadata();
+  int64_t compute_target_offset(int64_t offset, int whence) const;
+  std::size_t locate_part_for_offset(int64_t target, int64_t &offset_within_part) const;
+};
+
+MultiVolumeStreamBase::MultiVolumeStreamBase(PathHierarchy logical_path, bool supports_seek)
+  : _logical_path(std::move(logical_path))
+  , _supports_seek(supports_seek)
+  , _impl(std::make_unique<Impl>(*this)) {
+  _impl->total_parts = pathhierarchy_volume_size(_logical_path);
+  if (_impl->total_parts == 0) {
+    throw std::invalid_argument("MultiVolumeStreamBase requires at least one volume component");
+  }
+  _impl->part_offsets.assign(_impl->total_parts + 1, 0);
+}
+
+MultiVolumeStreamBase::~MultiVolumeStreamBase() = default;
+
+ssize_t MultiVolumeStreamBase::read(void *buffer, size_t size) {
+  if (size == 0) {
+    return 0;
+  }
+
+  std::size_t total_read = 0;
+  auto *out = static_cast<char *>(buffer);
+
+  while (total_read < size) {
+    if (_impl->active_part_index >= _impl->total_parts) {
+      break;
+    }
+
+    _impl->ensure_part_active(_impl->active_part_index);
+    const ssize_t bytes = read_from_single_part(out + total_read, size - total_read);
+    if (bytes > 0) {
+      total_read += static_cast<std::size_t>(bytes);
+      _impl->logical_offset += bytes;
+      continue;
+    }
+
+    if (bytes < 0) {
+      return bytes;
+    }
+
+    if (!_impl->advance_to_next_part()) {
+      break;
+    }
+  }
+
+  return static_cast<ssize_t>(total_read);
+}
+
+void MultiVolumeStreamBase::rewind() {
+  deactivate_active_part();
+  _impl->active_part_index = 0;
+  _impl->logical_offset = 0;
+}
+
+bool MultiVolumeStreamBase::at_end() const {
+  return (_impl->active_part_index >= _impl->total_parts) && !_impl->part_open;
+}
+
+int64_t MultiVolumeStreamBase::seek(int64_t offset, int whence) {
+  if (!_supports_seek) {
+    return -1;
+  }
+  if (!_impl->ensure_size_metadata()) {
+    return -1;
+  }
+
+  const int64_t target = _impl->compute_target_offset(offset, whence);
+  if (target < 0 || target > _impl->total_size) {
+    return -1;
+  }
+
+  if (target == _impl->total_size) {
+    deactivate_active_part();
+    _impl->active_part_index = _impl->total_parts;
+    _impl->logical_offset = target;
+    return _impl->logical_offset;
+  }
+
+  int64_t offset_within_part = 0;
+  const std::size_t part_index = _impl->locate_part_for_offset(target, offset_within_part);
+  _impl->ensure_part_active(part_index);
+  if (seek_within_single_part(offset_within_part, SEEK_SET) < 0) {
+    return -1;
+  }
+
+  _impl->logical_offset = target;
+  _impl->active_part_index = part_index;
+  return _impl->logical_offset;
+}
+
+int64_t MultiVolumeStreamBase::tell() const { return _impl->logical_offset; }
+
+void MultiVolumeStreamBase::Impl::ensure_part_active(std::size_t part_index) {
+  if (part_open && active_part_index == part_index) {
+    return;
+  }
+
+  self.deactivate_active_part();
+  PathHierarchy single_part = pathhierarchy_select_single_part(self._logical_path, part_index);
+  self.open_single_part(single_part);
+  active_part_index = part_index;
+  part_open = true;
+}
+
+void MultiVolumeStreamBase::deactivate_active_part() {
+  if (_impl->part_open) {
+    close_single_part();
+    _impl->part_open = false;
+  }
+}
+
+bool MultiVolumeStreamBase::Impl::advance_to_next_part() {
+  if (active_part_index >= total_parts) {
+    return false;
+  }
+  self.deactivate_active_part();
+  ++active_part_index;
+  return active_part_index < total_parts;
+}
+
+bool MultiVolumeStreamBase::Impl::ensure_size_metadata() {
+  if (total_size >= 0) {
+    return true;
+  }
+
+  int64_t prefix = 0;
+  part_offsets[0] = 0;
+  for (std::size_t index = 0; index < total_parts; ++index) {
+    PathHierarchy single_part = pathhierarchy_select_single_part(self._logical_path, index);
+    const int64_t size = self.size_of_single_part(single_part);
+    if (size < 0) {
+      total_size = -1;
+      return false;
+    }
+    prefix += size;
+    part_offsets[index + 1] = prefix;
+  }
+
+  total_size = prefix;
+  return true;
+}
+
+int64_t MultiVolumeStreamBase::Impl::compute_target_offset(int64_t offset, int whence) const {
+  switch (whence) {
+    case SEEK_SET:
+      return offset;
+    case SEEK_CUR:
+      return logical_offset + offset;
+    case SEEK_END:
+      return total_size + offset;
+    default:
+      return -1;
+  }
+}
+
+std::size_t MultiVolumeStreamBase::Impl::locate_part_for_offset(int64_t target, int64_t &offset_within_part) const {
+  auto it = std::upper_bound(part_offsets.begin(), part_offsets.end(), target);
+  if (it == part_offsets.begin()) {
+    offset_within_part = target;
+    return 0;
+  }
+
+  const std::size_t index = static_cast<std::size_t>(std::distance(part_offsets.begin(), it) - 1);
+  offset_within_part = target - part_offsets[index];
+  return index;
+}
+
+} // namespace archive_r

data/ext/archive_r/vendor/archive_r/src/path_hierarchy.cc

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/path_hierarchy.h"
+
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace archive_r {
+namespace {
+
+int entry_type_rank(const PathEntry &entry) {
+  if (entry.is_single()) {
+    return 0;
+  }
+  if (entry.is_multi_volume()) {
+    return 1;
+  }
+  return 2;
+}
+
+int compare_node_lists_impl(const PathEntry::NodeList &lhs, const PathEntry::NodeList &rhs);
+
+int compare_entries_impl(const PathEntry &lhs, const PathEntry &rhs) {
+  const int lhs_rank = entry_type_rank(lhs);
+  const int rhs_rank = entry_type_rank(rhs);
+  if (lhs_rank != rhs_rank) {
+    return lhs_rank < rhs_rank ? -1 : 1;
+  }
+
+  if (lhs.is_single()) {
+    const auto &lval = lhs.single_value();
+    const auto &rval = rhs.single_value();
+    if (lval < rval) {
+      return -1;
+    }
+    if (rval < lval) {
+      return 1;
+    }
+    return 0;
+  }
+
+  if (lhs.is_multi_volume()) {
+    const auto &lparts = lhs.multi_volume_parts();
+    const auto &rparts = rhs.multi_volume_parts();
+    if (lparts.ordering != rparts.ordering) {
+      return static_cast<int>(lparts.ordering) < static_cast<int>(rparts.ordering) ? -1 : 1;
+    }
+
+    const std::size_t lsize = lparts.values.size();
+    const std::size_t rsize = rparts.values.size();
+    const std::size_t compare_count = lsize < rsize ? lsize : rsize;
+    for (std::size_t i = 0; i < compare_count; ++i) {
+      const std::string &lvalue = lparts.values[i];
+      const std::string &rvalue = rparts.values[i];
+      if (lvalue < rvalue) {
+        return -1;
+      }
+      if (rvalue < lvalue) {
+        return 1;
+      }
+    }
+
+    if (lsize != rsize) {
+      return lsize < rsize ? -1 : 1;
+    }
+
+    return 0;
+  }
+
+  return compare_node_lists_impl(lhs.nested_nodes(), rhs.nested_nodes());
+}
+
+int compare_node_lists_impl(const PathEntry::NodeList &lhs, const PathEntry::NodeList &rhs) {
+  const std::size_t lsize = lhs.size();
+  const std::size_t rsize = rhs.size();
+  const std::size_t compare_count = lsize < rsize ? lsize : rsize;
+  for (std::size_t i = 0; i < compare_count; ++i) {
+    const int cmp = compare_entries_impl(lhs[i], rhs[i]);
+    if (cmp != 0) {
+      return cmp;
+    }
+  }
+  if (lsize != rsize) {
+    return lsize < rsize ? -1 : 1;
+  }
+  return 0;
+}
+
+int compare_hierarchies_impl(const PathHierarchy &lhs, const PathHierarchy &rhs) {
+  const std::size_t lhs_size = lhs.size();
+  const std::size_t rhs_size = rhs.size();
+  const std::size_t compare_count = lhs_size < rhs_size ? lhs_size : rhs_size;
+  for (std::size_t i = 0; i < compare_count; ++i) {
+    const int cmp = compare_entries_impl(lhs[i], rhs[i]);
+    if (cmp != 0) {
+      return cmp;
+    }
+  }
+  if (lhs_size != rhs_size) {
+    return lhs_size < rhs_size ? -1 : 1;
+  }
+  return 0;
+}
+
+bool entries_equal_impl(const PathEntry &lhs, const PathEntry &rhs) { return compare_entries_impl(lhs, rhs) == 0; }
+
+bool hierarchies_equal_impl(const PathHierarchy &lhs, const PathHierarchy &rhs) { return compare_hierarchies_impl(lhs, rhs) == 0; }
+
+} // namespace
+
+int compare_entries(const PathEntry &lhs, const PathEntry &rhs) { return compare_entries_impl(lhs, rhs); }
+
+int compare_hierarchies(const PathHierarchy &lhs, const PathHierarchy &rhs) { return compare_hierarchies_impl(lhs, rhs); }
+
+bool entries_equal(const PathEntry &lhs, const PathEntry &rhs) { return entries_equal_impl(lhs, rhs); }
+
+bool hierarchies_equal(const PathHierarchy &lhs, const PathHierarchy &rhs) { return hierarchies_equal_impl(lhs, rhs); }
+
+bool PathHierarchyLess::operator()(const PathHierarchy &lhs, const PathHierarchy &rhs) const { return compare_hierarchies(lhs, rhs) < 0; }
+
+PathHierarchy make_single_path(const std::string &root) {
+  PathHierarchy hierarchy;
+  hierarchy.emplace_back(PathEntry::single(root));
+  return hierarchy;
+}
+
+void append_single(PathHierarchy &hierarchy, std::string value) { hierarchy.emplace_back(PathEntry::single(std::move(value))); }
+
+void append_multi_volume(PathHierarchy &hierarchy, std::vector<std::string> parts, PathEntry::Parts::Ordering ordering) {
+  hierarchy.emplace_back(PathEntry::multi_volume(std::move(parts), ordering));
+}
+
+PathHierarchy pathhierarchy_prefix_until(const PathHierarchy &hierarchy, size_t inclusive_index) {
+  if (hierarchy.empty() || inclusive_index >= hierarchy.size()) {
+    return {};
+  }
+  const auto prefix_end = hierarchy.begin() + static_cast<PathHierarchy::difference_type>(inclusive_index + 1);
+  return PathHierarchy(hierarchy.begin(), prefix_end);
+}
+
+PathHierarchy parent_hierarchy(const PathHierarchy &hierarchy) {
+  if (hierarchy.size() <= 1) {
+    return {};
+  }
+  return pathhierarchy_prefix_until(hierarchy, hierarchy.size() - 2);
+}
+
+
+} // namespace archive_r

data/ext/archive_r/vendor/archive_r/src/path_hierarchy_utils.cc

@@ -0,0 +1,304 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2025 archive_r Team
+
+#include "archive_r/path_hierarchy_utils.h"
+
+#include <algorithm>
+#include <filesystem>
+
+namespace archive_r {
+
+namespace {
+
+struct CollapseSegments {
+  PathHierarchy prefix;
+  PathHierarchy suffix;
+  std::size_t multi_volume_depth = 0;
+};
+
+PathHierarchy hierarchy_suffix_from(const PathHierarchy &hierarchy, std::size_t start_index) {
+  if (hierarchy.empty() || start_index >= hierarchy.size()) {
+    return {};
+  }
+  const auto begin = hierarchy.begin() + static_cast<PathHierarchy::difference_type>(start_index);
+  return PathHierarchy(begin, hierarchy.end());
+}
+
+bool determine_multi_volume_segments(const std::vector<PathHierarchy> &sources, CollapseSegments &segments) {
+  if (sources.empty()) {
+    return false;
+  }
+
+  const PathHierarchy &reference = sources.front();
+  if (reference.empty()) {
+    return false;
+  }
+
+  std::size_t multi_volume_depth = reference.size() - 1;
+  bool difference_found = false;
+
+  for (std::size_t depth = 0; depth < reference.size(); ++depth) {
+    const PathEntry &reference_entry = reference[depth];
+    for (std::size_t i = 1; i < sources.size(); ++i) {
+      const PathHierarchy &candidate = sources[i];
+      if (candidate.size() <= depth) {
+        return false;
+      }
+      if (!archive_r::entries_equal(reference_entry, candidate[depth])) {
+        multi_volume_depth = depth;
+        difference_found = true;
+        break;
+      }
+    }
+    if (difference_found) {
+      break;
+    }
+  }
+
+  if (!difference_found) {
+    for (std::size_t i = 1; i < sources.size(); ++i) {
+      if (sources[i].size() != reference.size()) {
+        return false;
+      }
+    }
+  }
+
+  segments.multi_volume_depth = multi_volume_depth;
+  segments.prefix.clear();
+  if (multi_volume_depth > 0) {
+    segments.prefix = pathhierarchy_prefix_until(reference, multi_volume_depth - 1);
+  }
+  segments.suffix = hierarchy_suffix_from(reference, multi_volume_depth + 1);
+  return true;
+}
+
+bool collect_multi_volume_parts(const std::vector<PathHierarchy> &sources, const CollapseSegments &segments, std::vector<std::string> &parts) {
+  if (sources.empty()) {
+    return false;
+  }
+
+  const std::size_t suffix_size = segments.suffix.size();
+  const std::size_t required_size = segments.multi_volume_depth + 1 + suffix_size;
+
+  parts.clear();
+  parts.reserve(sources.size());
+
+  for (const auto &hierarchy : sources) {
+    if (hierarchy.empty() || hierarchy.size() <= segments.multi_volume_depth) {
+      return false;
+    }
+
+    if (hierarchy.size() != required_size) {
+      return false;
+    }
+
+    const PathEntry &component = hierarchy[segments.multi_volume_depth];
+    if (!component.is_single()) {
+      return false;
+    }
+
+    for (std::size_t offset = 0; offset < suffix_size; ++offset) {
+      const PathEntry &reference_entry = segments.suffix[offset];
+      const PathEntry &candidate_entry = hierarchy[segments.multi_volume_depth + 1 + offset];
+      if (!archive_r::entries_equal(reference_entry, candidate_entry)) {
+        return false;
+      }
+    }
+
+    parts.push_back(component.single_value());
+  }
+
+  return true;
+}
+
+bool flatten_single_entry(const PathEntry &entry, std::string &output) {
+  if (entry.is_single()) {
+    output = entry.single_value();
+    return true;
+  }
+  return flatten_entry_to_string(entry, output);
+}
+
+} // namespace
+
+const std::string *path_entry_component_at(const PathEntry &entry, std::size_t index) {
+  if (entry.is_single()) {
+    if (index == 0) {
+      return &entry.single_value();
+    }
+    return nullptr;
+  }
+
+  if (entry.is_multi_volume()) {
+    const auto &parts = entry.multi_volume_parts().values;
+    if (index < parts.size()) {
+      return &parts[index];
+    }
+    return nullptr;
+  }
+
+  return nullptr;
+}
+
+std::size_t pathhierarchy_volume_size(const PathHierarchy &logical) {
+  if (logical.empty()) {
+    return 0;
+  }
+  const PathEntry &tail = logical.back();
+  if (!tail.is_multi_volume()) {
+    return 1;
+  }
+  const auto &parts = tail.multi_volume_parts().values;
+  return parts.size();
+}
+
+std::string pathhierarchy_volume_entry_name(const PathHierarchy &logical, std::size_t index) {
+  if (logical.empty()) {
+    return {};
+  }
+  const PathEntry &tail = logical.back();
+  if (!tail.is_multi_volume()) {
+    if (index != 0) {
+      return {};
+    }
+
+    std::string entry_name;
+    if (!flatten_single_entry(tail, entry_name)) {
+      return {};
+    }
+    return entry_name;
+  }
+
+  const auto &parts = tail.multi_volume_parts().values;
+  if (index >= parts.size()) {
+    return {};
+  }
+  return parts[index];
+}
+
+bool pathhierarchy_is_multivolume(const PathHierarchy &hierarchy) {
+  if (hierarchy.empty()) {
+    return false;
+  }
+  return hierarchy.back().is_multi_volume();
+}
+
+PathHierarchy pathhierarchy_select_single_part(const PathHierarchy &logical, std::size_t index) {
+  if (logical.empty()) {
+    return {};
+  }
+
+  PathHierarchy result = parent_hierarchy(logical);
+  append_single(result, pathhierarchy_volume_entry_name(logical, index));
+  return result;
+}
+
+void sort_hierarchies(std::vector<PathHierarchy> &hierarchies) {
+  std::sort(hierarchies.begin(), hierarchies.end(), [](const PathHierarchy &lhs, const PathHierarchy &rhs) { return archive_r::compare_hierarchies(lhs, rhs) < 0; });
+}
+
+bool flatten_entry_to_string(const PathEntry &entry, std::string &output) {
+  if (entry.is_single()) {
+    output = entry.single_value();
+    return true;
+  }
+
+  if (entry.is_nested()) {
+    std::string result;
+    bool first = true;
+    for (const auto &child : entry.nested_nodes()) {
+      std::string component;
+      if (!flatten_entry_to_string(child, component)) {
+        return false;
+      }
+      if (component.empty()) {
+        return false;
+      }
+      if (!first) {
+        result.push_back('/');
+      }
+      result += component;
+      first = false;
+    }
+    output = result;
+    return !result.empty();
+  }
+
+  return false;
+}
+
+bool entry_name_from_component(const PathEntry &entry, std::string &output) {
+  if (entry.is_multi_volume()) {
+    const auto &parts = entry.multi_volume_parts().values;
+    if (parts.empty()) {
+      return false;
+    }
+    output = parts.front();
+    return true;
+  }
+
+  return flatten_entry_to_string(entry, output);
+}
+
+PathHierarchy merge_multi_volume_sources(const std::vector<PathHierarchy> &sources) {
+  CollapseSegments segments;
+  if (!determine_multi_volume_segments(sources, segments)) {
+    return {};
+  }
+
+  std::vector<std::string> parts;
+  if (!collect_multi_volume_parts(sources, segments, parts)) {
+    return {};
+  }
+
+  PathHierarchy result = segments.prefix;
+  result.reserve(result.size() + 1 + segments.suffix.size());
+  result.emplace_back(PathEntry::multi_volume(std::move(parts)));
+  result.insert(result.end(), segments.suffix.begin(), segments.suffix.end());
+  return result;
+}
+
+std::string path_entry_display(const PathEntry &entry) {
+  if (entry.is_single()) {
+    return entry.single_value();
+  }
+  if (entry.is_multi_volume()) {
+    std::string value = "[";
+    bool first = true;
+    for (const auto &part : entry.multi_volume_parts().values) {
+      if (!first) {
+        value.push_back('|');
+      }
+      value += part;
+      first = false;
+    }
+    value.push_back(']');
+    return value;
+  }
+  std::string value = "{";
+  bool first = true;
+  for (const auto &child : entry.nested_nodes()) {
+    if (!first) {
+      value.push_back('/');
+    }
+    value += path_entry_display(child);
+    first = false;
+  }
+  value.push_back('}');
+  return value;
+}
+
+std::string hierarchy_display(const PathHierarchy &hierarchy) {
+  std::string result;
+  bool first = true;
+  for (const auto &component : hierarchy) {
+    if (!first) {
+      result.push_back('/');
+    }
+    result += path_entry_display(component);
+    first = false;
+  }
+  return result;
+}
+
+} // namespace archive_r