dandri/pyxis
1
0
Fork 0
mirror of https://github.com/torlando-tech/pyxis.git synced 2026-08-25 12:09:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
main
pyxis/lib/tdeck_ui/UI/LXMF/NomadNetCompactPage.cpp
T

866 lines
40 KiB
C++
Raw Permalink Blame History

#include "NomadNetCompactPage.h"
#include "NomadNetGlyphs.h"
#include <algorithm>
#include <cstring>
#include <limits>
namespace UI::LXMF::NomadNet {
bool CompactPage::append(const std::string& value, uint32_t& offset, uint16_t& length) {
if (value.size() > std::numeric_limits<uint16_t>::max()) return false;
if (value.size() + 1 > MAX_ARENA_BYTES - std::min(_arena.size(), MAX_ARENA_BYTES)) return false;
if (_arena.size() > std::numeric_limits<uint32_t>::max() - value.size() - 1) return false;
offset = static_cast<uint32_t>(_arena.size());
length = static_cast<uint16_t>(value.size());
_arena.insert(_arena.end(), value.begin(), value.end());
_arena.push_back('\0');
return true;
}
bool CompactPage::append_display(const std::string& value, uint32_t& offset, uint16_t& length) {
if (value.size() > std::numeric_limits<uint16_t>::max()) return false;
if (value.size() + 1 > MAX_ARENA_BYTES - std::min(_arena.size(), MAX_ARENA_BYTES)) return false;
offset = static_cast<uint32_t>(_arena.size());
struct Context { ExternalVector<char>* arena; std::size_t bytes; } context{&_arena, 0};
visit_display_text(value, [](const char* bytes, std::size_t count, void* opaque) {
auto* state = static_cast<Context*>(opaque);
state->arena->insert(state->arena->end(), bytes, bytes + count);
state->bytes += count;
}, &context);
if (context.bytes > std::numeric_limits<uint16_t>::max()) return false;
length = static_cast<uint16_t>(context.bytes);
_arena.push_back('\0');
return true;
}
bool CompactPage::assign(const Document& document) {
clear();
try {
const bool reserve_notice = document.truncated || document.unsupported;
const std::size_t block_limit = MAX_BLOCKS - (reserve_notice ? 1 : 0);
const std::size_t run_limit = MAX_RUNS - (reserve_notice ? 1 : 0);
const std::size_t block_count = std::min(document.blocks.size(), block_limit);
const std::size_t link_count = std::min(document.links.size(), MAX_LINKS);
const std::size_t field_count = std::min(document.fields.size(), MAX_FIELDS);
const std::size_t partial_count = std::min(document.partials.size(), MAX_PARTIALS);
std::size_t partial_field_count = 0;
for (std::size_t i = 0; i < partial_count; ++i) {
partial_field_count += std::min(document.partials[i].fields.size(),
MAX_PARTIAL_FIELDS - std::min(partial_field_count, MAX_PARTIAL_FIELDS));
}
const std::size_t table_count = std::min(document.tables.size(), MAX_TABLES);
std::size_t table_cell_count = 0;
for (std::size_t i = 0; i < table_count; ++i) {
const std::size_t cells = static_cast<std::size_t>(document.tables[i].row_count) *
document.tables[i].column_count;
table_cell_count += std::min(cells,
MAX_TABLE_CELLS - std::min(table_cell_count, MAX_TABLE_CELLS));
}
std::size_t anchor_count = 0;
for (const auto& anchor : document.anchors) {
if (anchor_count >= MAX_ANCHORS) break;
if (anchor.block_index < block_count &&
anchor.name.size() <= DocumentParser::MAX_ANCHOR_NAME_BYTES)
++anchor_count;
}
std::size_t run_count = 0;
std::size_t arena_size = 0;
for (std::size_t i = 0; i < block_count; ++i) {
const std::size_t retained = std::min(document.blocks[i].runs.size(),
run_limit - std::min(run_count, run_limit));
run_count += retained;
for (std::size_t r = 0; r < retained; ++r) {
const std::size_t bytes = document.blocks[i].runs[r].text.size() + 1;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
}
}
const std::size_t table_run_count = std::min(document.table_runs.size(),
run_limit - std::min(run_count, run_limit));
for (std::size_t r = 0; r < table_run_count; ++r) {
const std::size_t bytes = document.table_runs[r].text.size() + 1;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
}
run_count += table_run_count;
for (std::size_t i = 0; i < link_count; ++i) {
const std::size_t bytes = document.links[i].target.size() +
(document.links[i].has_fields ? document.links[i].fields.size() + 1 : 0) + 1;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
}
for (std::size_t i = 0; i < field_count; ++i) {
const auto& field = document.fields[i];
const std::size_t bytes = field.name.size() + field.value.size() + field.label.size() + 3;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
}
for (std::size_t i = 0; i < partial_count; ++i) {
const auto& partial = document.partials[i];
std::size_t bytes = partial.descriptor.size() + partial.url.size() +
partial.selectors.size() + partial.id.size() + 4;
for (const auto& field : partial.fields) bytes += field.size() + 1;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
}
std::size_t anchors_accounted = 0;
for (const auto& anchor : document.anchors) {
if (anchors_accounted >= anchor_count) break;
if (anchor.block_index >= block_count ||
anchor.name.size() > DocumentParser::MAX_ANCHOR_NAME_BYTES) continue;
const std::size_t bytes = anchor.name.size() + 1;
if (bytes > MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES)) return false;
arena_size += bytes;
++anchors_accounted;
}
const std::size_t notice_slack = std::min(
MAX_NOTICE_BYTES + 1,
MAX_ARENA_BYTES - std::min(arena_size, MAX_ARENA_BYTES));
_arena.reserve(arena_size + notice_slack);
_blocks.reserve(block_count);
_runs.reserve(std::min(run_count, run_limit));
_links.reserve(link_count);
_fields.reserve(field_count);
_anchors.reserve(anchor_count);
_tables.reserve(table_count);
_table_cells.reserve(table_cell_count);
_partials.reserve(partial_count);
_partial_fields.reserve(partial_field_count);
for (std::size_t i = 0; i < link_count; ++i) {
LinkRecord link;
std::string navigation_target = document.links[i].target;
if (document.links[i].has_fields) {
navigation_target += '`';
navigation_target += document.links[i].fields;
}
if (!append(navigation_target, link.target_offset, link.target_length)) {
clear();
return false;
}
_links.push_back(link);
}
for (std::size_t i = 0; i < field_count; ++i) {
const auto& source = document.fields[i];
FieldRecord field;
if (!append(source.name, field.name_offset, field.name_length) ||
!append(source.value, field.value_offset, field.value_length) ||
!append(source.label, field.label_offset, field.label_length)) {
clear();
return false;
}
field.width = source.width;
field.type = source.type;
field.checked = source.checked;
field.masked = source.masked;
_fields.push_back(field);
}
for (std::size_t i = 0; i < partial_count; ++i) {
const auto& source = document.partials[i];
PartialRecord partial;
partial.first_field = static_cast<uint32_t>(_partial_fields.size());
if (!append(source.descriptor, partial.descriptor_offset, partial.descriptor_length) ||
!append(source.url, partial.url_offset, partial.url_length) ||
!append(source.selectors, partial.selectors_offset, partial.selectors_length) ||
!append(source.id, partial.id_offset, partial.id_length)) {
clear();
return false;
}
partial.refresh_interval_ms = source.refresh_interval_ms;
partial.descriptor_hash = source.descriptor_hash;
for (const auto& source_field : source.fields) {
if (_partial_fields.size() >= MAX_PARTIAL_FIELDS ||
partial.field_count == std::numeric_limits<uint16_t>::max()) break;
PartialFieldRecord field;
if (!append(source_field, field.value_offset, field.value_length)) {
clear();
return false;
}
_partial_fields.push_back(field);
++partial.field_count;
}
_partials.push_back(partial);
}
for (const auto& source_anchor : document.anchors) {
if (_anchors.size() >= anchor_count) break;
if (source_anchor.block_index >= block_count ||
source_anchor.name.size() > DocumentParser::MAX_ANCHOR_NAME_BYTES) continue;
AnchorRecord anchor;
if (!append(source_anchor.name, anchor.name_offset, anchor.name_length)) {
clear();
return false;
}
anchor.block_index = source_anchor.block_index;
_anchors.push_back(anchor);
}
for (std::size_t i = 0; i < block_count; ++i) {
const auto& source_block = document.blocks[i];
if (!source_block.runs.empty() && _runs.size() >= run_limit) {
_truncated = true;
continue;
}
BlockRecord block;
block.first_run = static_cast<uint32_t>(_runs.size());
block.type = source_block.type;
block.depth = source_block.depth;
block.alignment = source_block.alignment;
block.divider_codepoint = source_block.divider_codepoint;
block.table_index = source_block.table_index >= 0 &&
static_cast<std::size_t>(source_block.table_index) < table_count
? source_block.table_index : -1;
block.partial_index = source_block.partial_index >= 0 &&
static_cast<std::size_t>(source_block.partial_index) < partial_count
? source_block.partial_index : -1;
block.partial_region_index = source_block.partial_region_index >= 0 &&
static_cast<std::size_t>(source_block.partial_region_index) < partial_count
? source_block.partial_region_index : -1;
for (const auto& source_run : source_block.runs) {
if (_runs.size() >= run_limit || block.run_count == std::numeric_limits<uint16_t>::max()) {
_truncated = true;
break;
}
RunRecord run;
if (!append_display(source_run.text, run.text_offset, run.text_length)) {
clear();
return false;
}
run.link_index = source_run.link_index >= 0 &&
static_cast<std::size_t>(source_run.link_index) < _links.size()
? static_cast<int16_t>(source_run.link_index) : -1;
run.field_index = source_run.field_index >= 0 &&
static_cast<std::size_t>(source_run.field_index) < _fields.size()
? static_cast<int16_t>(source_run.field_index) : -1;
if (run.link_index >= 0)
_links[run.link_index].partial_region_index =
block.partial_region_index;
if (run.field_index >= 0)
_fields[run.field_index].partial_region_index =
block.partial_region_index;
if (source_run.bold) run.style |= BOLD;
if (source_run.italic) run.style |= ITALIC;
if (source_run.underline) run.style |= UNDERLINE;
if (source_run.has_foreground) run.style |= HAS_FOREGROUND;
if (source_run.has_background) run.style |= HAS_BACKGROUND;
run.foreground = source_run.foreground;
run.background = source_run.background;
_runs.push_back(run);
++block.run_count;
}
_blocks.push_back(block);
}
for (std::size_t i = 0; i < table_count; ++i) {
const auto& source_table = document.tables[i];
const std::size_t source_cells = static_cast<std::size_t>(source_table.row_count) *
source_table.column_count;
if (source_table.first_cell > document.table_cells.size() ||
source_cells > document.table_cells.size() - source_table.first_cell) {
clear();
return false;
}
TableRecord table;
table.first_cell = static_cast<uint32_t>(_table_cells.size());
table.column_count = source_table.column_count;
table.alignment = source_table.alignment;
table.max_width = source_table.max_width;
const std::size_t cells_left = MAX_TABLE_CELLS - std::min(_table_cells.size(), MAX_TABLE_CELLS);
const std::size_t retained_cells = std::min(source_cells, cells_left);
for (std::size_t c = 0; c < retained_cells; ++c) {
const auto& source_cell = document.table_cells[source_table.first_cell + c];
if (source_cell.first_run > document.table_runs.size() ||
source_cell.run_count > document.table_runs.size() - source_cell.first_run) {
clear();
return false;
}
TableCellRecord cell;
cell.first_run = static_cast<uint32_t>(_runs.size());
cell.alignment = source_cell.alignment;
for (std::size_t r = 0; r < source_cell.run_count; ++r) {
if (_runs.size() >= run_limit) {
_truncated = true;
break;
}
const auto& source_run = document.table_runs[source_cell.first_run + r];
RunRecord run;
if (!append_display(source_run.text, run.text_offset, run.text_length)) {
clear();
return false;
}
run.link_index = source_run.link_index >= 0 &&
static_cast<std::size_t>(source_run.link_index) < _links.size()
? static_cast<int16_t>(source_run.link_index) : -1;
run.field_index = source_run.field_index >= 0 &&
static_cast<std::size_t>(source_run.field_index) < _fields.size()
? static_cast<int16_t>(source_run.field_index) : -1;
if (source_run.bold) run.style |= BOLD;
if (source_run.italic) run.style |= ITALIC;
if (source_run.underline) run.style |= UNDERLINE;
if (source_run.has_foreground) run.style |= HAS_FOREGROUND;
if (source_run.has_background) run.style |= HAS_BACKGROUND;
run.foreground = source_run.foreground;
run.background = source_run.background;
_runs.push_back(run);
++cell.run_count;
}
_table_cells.push_back(cell);
}
table.row_count = table.column_count == 0 ? 0 :
static_cast<uint16_t>(retained_cells / table.column_count);
if (retained_cells != source_cells) _truncated = true;
_tables.push_back(table);
}
_has_background = document.has_background;
_background = document.background;
_has_foreground = document.has_foreground;
_foreground = document.foreground;
_truncated = _truncated || document.truncated || document.blocks.size() > block_count ||
document.links.size() > link_count || document.anchors.size() > anchor_count ||
document.fields.size() > field_count || document.tables.size() > table_count ||
document.partials.size() > partial_count ||
document.table_cells.size() > table_cell_count ||
document.table_runs.size() > table_run_count;
_unsupported = document.unsupported;
return true;
} catch (const std::bad_alloc&) {
clear();
return false;
}
}
PartialReplaceResult CompactPage::assign_replacing_partial(
const CompactPage& base, std::size_t partial_index,
const Document& fragment, std::size_t max_arena_bytes) {
clear();
if (partial_index >= base._partials.size())
return PartialReplaceResult::INVALID_PARTIAL;
if (fragment.allocation_failed)
return PartialReplaceResult::ALLOCATION_FAILED;
if (fragment.malformed || fragment.truncated ||
max_arena_bytes > MAX_ARENA_BYTES)
return PartialReplaceResult::LIMIT_EXCEEDED;
bool region_found = false;
for (const auto& block : base._blocks)
if (block.partial_region_index == static_cast<int16_t>(partial_index)) {
region_found = true;
break;
}
if (!region_found) return PartialReplaceResult::INVALID_PARTIAL;
CompactPage fragment_page;
if (!fragment_page.assign(fragment))
return PartialReplaceResult::ALLOCATION_FAILED;
if (fragment_page.truncated())
return PartialReplaceResult::LIMIT_EXCEEDED;
bool limit_failed = false;
try {
const std::size_t source_arena = std::min(
max_arena_bytes, base._arena.size() + fragment_page._arena.size());
const std::size_t reserve_arena = source_arena + std::min(
MAX_NOTICE_BYTES + 1, max_arena_bytes - source_arena);
_arena.reserve(reserve_arena);
_blocks.reserve(std::min(MAX_BLOCKS,
base._blocks.size() + fragment_page._blocks.size()));
_runs.reserve(std::min(MAX_RUNS,
base._runs.size() + fragment_page._runs.size()));
_links.reserve(std::min(MAX_LINKS,
base._links.size() + fragment_page._links.size()));
_fields.reserve(std::min(MAX_FIELDS,
base._fields.size() + fragment_page._fields.size()));
_anchors.reserve(std::min(MAX_ANCHORS,
base._anchors.size() + fragment_page._anchors.size()));
_tables.reserve(std::min(MAX_TABLES,
base._tables.size() + fragment_page._tables.size()));
_table_cells.reserve(std::min(MAX_TABLE_CELLS,
base._table_cells.size() + fragment_page._table_cells.size()));
_partials.reserve(base._partials.size());
_partial_fields.reserve(base._partial_fields.size());
auto append_view = [&](TextView value, uint32_t& offset,
uint16_t& length) -> bool {
if ((!value.data() && !value.empty()) ||
value.size() > std::numeric_limits<uint16_t>::max() ||
value.size() + 1 > max_arena_bytes -
std::min(_arena.size(), max_arena_bytes)) {
limit_failed = true;
return false;
}
offset = static_cast<uint32_t>(_arena.size());
length = static_cast<uint16_t>(value.size());
if (!value.empty())
_arena.insert(_arena.end(), value.data(), value.data() + value.size());
_arena.push_back('\0');
return true;
};
for (const auto& source : base._partials) {
PartialRecord partial;
partial.first_field = static_cast<uint32_t>(_partial_fields.size());
if (!append_view(base.partial_descriptor(source), partial.descriptor_offset,
partial.descriptor_length) ||
!append_view(base.partial_url(source), partial.url_offset,
partial.url_length) ||
!append_view(base.partial_selectors(source), partial.selectors_offset,
partial.selectors_length) ||
!append_view(base.partial_id(source), partial.id_offset,
partial.id_length)) {
clear();
return PartialReplaceResult::LIMIT_EXCEEDED;
}
partial.refresh_interval_ms = source.refresh_interval_ms;
partial.descriptor_hash = source.descriptor_hash;
for (std::size_t field_index = 0;
field_index < source.field_count; ++field_index) {
if (_partial_fields.size() >= MAX_PARTIAL_FIELDS) {
clear();
return PartialReplaceResult::LIMIT_EXCEEDED;
}
PartialFieldRecord field;
if (!append_view(base.partial_field(source, field_index),
field.value_offset, field.value_length)) {
clear();
return PartialReplaceResult::LIMIT_EXCEEDED;
}
_partial_fields.push_back(field);
++partial.field_count;
}
_partials.push_back(partial);
}
struct CopyMaps {
ExternalVector<int16_t> links;
ExternalVector<int16_t> fields;
ExternalVector<int16_t> tables;
ExternalVector<int32_t> blocks;
};
auto make_maps = [](const CompactPage& source) {
CopyMaps maps;
maps.links.assign(source._links.size(), -1);
maps.fields.assign(source._fields.size(), -1);
maps.tables.assign(source._tables.size(), -1);
maps.blocks.assign(source._blocks.size(), -1);
return maps;
};
CopyMaps base_maps = make_maps(base);
CopyMaps fragment_maps = make_maps(fragment_page);
auto copy_link = [&](const CompactPage& source, CopyMaps& maps,
int16_t source_index) -> int16_t {
if (source_index < 0 ||
static_cast<std::size_t>(source_index) >= source._links.size())
return -1;
int16_t& mapped = maps.links[source_index];
if (mapped >= 0) return mapped;
if (_links.size() >= MAX_LINKS) {
limit_failed = true;
return -1;
}
LinkRecord link;
if (!append_view(source.target(source_index), link.target_offset,
link.target_length))
return -1;
link.partial_region_index =
source._links[source_index].partial_region_index;
mapped = static_cast<int16_t>(_links.size());
_links.push_back(link);
return mapped;
};
auto copy_field = [&](const CompactPage& source, CopyMaps& maps,
int16_t source_index) -> int16_t {
if (source_index < 0 ||
static_cast<std::size_t>(source_index) >= source._fields.size())
return -1;
int16_t& mapped = maps.fields[source_index];
if (mapped >= 0) return mapped;
if (_fields.size() >= MAX_FIELDS) {
limit_failed = true;
return -1;
}
const auto& old = source._fields[source_index];
FieldRecord field;
if (!append_view(source.field_name(source_index), field.name_offset,
field.name_length) ||
!append_view(source.field_value(source_index), field.value_offset,
field.value_length) ||
!append_view(source.field_label(source_index), field.label_offset,
field.label_length))
return -1;
field.width = old.width;
field.type = old.type;
field.checked = old.checked;
field.masked = old.masked;
field.partial_region_index = old.partial_region_index;
mapped = static_cast<int16_t>(_fields.size());
_fields.push_back(field);
return mapped;
};
auto copy_run = [&](const CompactPage& source, CopyMaps& maps,
const RunRecord& old, RunRecord& run) -> bool {
if (_runs.size() >= MAX_RUNS) {
limit_failed = true;
return false;
}
if (!append_view(source.text(old), run.text_offset, run.text_length))
return false;
run.link_index = copy_link(source, maps, old.link_index);
run.field_index = copy_field(source, maps, old.field_index);
if (&source == &fragment_page) {
if (run.link_index >= 0)
_links[run.link_index].partial_region_index =
static_cast<int16_t>(partial_index);
if (run.field_index >= 0)
_fields[run.field_index].partial_region_index =
static_cast<int16_t>(partial_index);
}
run.style = old.style;
run.foreground = old.foreground;
run.background = old.background;
if ((old.link_index >= 0 && run.link_index < 0) ||
(old.field_index >= 0 && run.field_index < 0))
return false;
return true;
};
auto copy_table = [&](const CompactPage& source, CopyMaps& maps,
int16_t source_index) -> int16_t {
if (source_index < 0 ||
static_cast<std::size_t>(source_index) >= source._tables.size())
return -1;
int16_t& mapped = maps.tables[source_index];
if (mapped >= 0) return mapped;
if (_tables.size() >= MAX_TABLES) {
limit_failed = true;
return -1;
}
const auto& old_table = source._tables[source_index];
const std::size_t cell_count = static_cast<std::size_t>(old_table.row_count) *
old_table.column_count;
if (old_table.first_cell > source._table_cells.size() ||
cell_count > source._table_cells.size() - old_table.first_cell ||
cell_count > MAX_TABLE_CELLS -
std::min(_table_cells.size(), MAX_TABLE_CELLS)) {
limit_failed = true;
return -1;
}
TableRecord table;
table.first_cell = static_cast<uint32_t>(_table_cells.size());
table.row_count = old_table.row_count;
table.column_count = old_table.column_count;
table.alignment = old_table.alignment;
table.max_width = old_table.max_width;
for (std::size_t cell_index = 0; cell_index < cell_count; ++cell_index) {
const auto& old_cell = source._table_cells[old_table.first_cell + cell_index];
if (old_cell.first_run > source._runs.size() ||
old_cell.run_count > source._runs.size() - old_cell.first_run) {
limit_failed = true;
return -1;
}
TableCellRecord cell;
cell.first_run = static_cast<uint32_t>(_runs.size());
cell.alignment = old_cell.alignment;
for (std::size_t run_index = 0; run_index < old_cell.run_count; ++run_index) {
RunRecord run;
if (!copy_run(source, maps,
source._runs[old_cell.first_run + run_index], run))
return -1;
_runs.push_back(run);
++cell.run_count;
}
_table_cells.push_back(cell);
}
mapped = static_cast<int16_t>(_tables.size());
_tables.push_back(table);
return mapped;
};
auto copy_block = [&](const CompactPage& source, CopyMaps& maps,
std::size_t source_index, int16_t region_override,
bool retain_partial_index) -> bool {
if (source_index >= source._blocks.size() || _blocks.size() >= MAX_BLOCKS) {
limit_failed = true;
return false;
}
const auto& old = source._blocks[source_index];
if (old.first_run > source._runs.size() ||
old.run_count > source._runs.size() - old.first_run) {
limit_failed = true;
return false;
}
BlockRecord block;
block.first_run = static_cast<uint32_t>(_runs.size());
block.type = old.type;
block.depth = old.depth;
block.alignment = old.alignment;
block.divider_codepoint = old.divider_codepoint;
block.partial_index = retain_partial_index ? old.partial_index : -1;
block.partial_region_index = region_override >= 0
? region_override : old.partial_region_index;
if (old.table_index >= 0) {
block.table_index = copy_table(source, maps, old.table_index);
if (block.table_index < 0) return false;
}
for (std::size_t run_index = 0; run_index < old.run_count; ++run_index) {
RunRecord run;
if (!copy_run(source, maps,
source._runs[old.first_run + run_index], run))
return false;
_runs.push_back(run);
++block.run_count;
}
maps.blocks[source_index] = static_cast<int32_t>(_blocks.size());
_blocks.push_back(block);
return true;
};
bool inserted = false;
for (std::size_t block_index = 0; block_index < base._blocks.size(); ++block_index) {
const auto& block = base._blocks[block_index];
if (block.partial_region_index == static_cast<int16_t>(partial_index)) {
if (inserted) continue;
inserted = true;
if (fragment_page._blocks.empty()) {
if (_blocks.size() >= MAX_BLOCKS) {
limit_failed = true;
break;
}
BlockRecord marker;
marker.first_run = static_cast<uint32_t>(_runs.size());
marker.partial_region_index = static_cast<int16_t>(partial_index);
_blocks.push_back(marker);
} else {
for (std::size_t fragment_index = 0;
fragment_index < fragment_page._blocks.size(); ++fragment_index)
if (!copy_block(fragment_page, fragment_maps, fragment_index,
static_cast<int16_t>(partial_index), false)) {
limit_failed = true;
break;
}
}
if (limit_failed) break;
continue;
}
if (!copy_block(base, base_maps, block_index, -1, true)) {
limit_failed = true;
break;
}
}
if (!inserted || limit_failed) {
clear();
return PartialReplaceResult::LIMIT_EXCEEDED;
}
auto copy_anchors = [&](const CompactPage& source, const CopyMaps& maps) -> bool {
for (const auto& old : source._anchors) {
if (old.block_index >= maps.blocks.size()) continue;
const int32_t mapped_block = maps.blocks[old.block_index];
if (mapped_block < 0) continue;
if (_anchors.size() >= MAX_ANCHORS) {
limit_failed = true;
return false;
}
AnchorRecord anchor;
const TextView name(source._arena.data() + old.name_offset,
old.name_length);
if (!append_view(name, anchor.name_offset, anchor.name_length))
return false;
anchor.block_index = static_cast<uint16_t>(mapped_block);
_anchors.push_back(anchor);
}
return true;
};
if (!copy_anchors(base, base_maps) ||
!copy_anchors(fragment_page, fragment_maps) || limit_failed) {
clear();
return PartialReplaceResult::LIMIT_EXCEEDED;
}
std::stable_sort(_anchors.begin(), _anchors.end(),
[](const AnchorRecord& left, const AnchorRecord& right) {
return left.block_index < right.block_index;
});
_has_background = base._has_background;
_background = base._background;
_has_foreground = base._has_foreground;
_foreground = base._foreground;
_truncated = base._truncated;
_unsupported = base._unsupported || fragment_page._unsupported;
return PartialReplaceResult::APPLIED;
} catch (const std::bad_alloc&) {
clear();
return PartialReplaceResult::ALLOCATION_FAILED;
}
}
void CompactPage::clear() {
if (!_arena.empty()) {
volatile char* bytes = _arena.data();
for (std::size_t index = 0; index < _arena.size(); ++index)
bytes[index] = 0;
}
ExternalVector<char>().swap(_arena);
ExternalVector<BlockRecord>().swap(_blocks);
ExternalVector<RunRecord>().swap(_runs);
ExternalVector<LinkRecord>().swap(_links);
ExternalVector<AnchorRecord>().swap(_anchors);
ExternalVector<TableRecord>().swap(_tables);
ExternalVector<TableCellRecord>().swap(_table_cells);
ExternalVector<FieldRecord>().swap(_fields);
ExternalVector<PartialRecord>().swap(_partials);
ExternalVector<PartialFieldRecord>().swap(_partial_fields);
_has_background = false;
_background = 0;
_has_foreground = false;
_foreground = 0;
_truncated = false;
_unsupported = false;
}
CompactPage& CompactPage::operator=(CompactPage&& other) noexcept {
if (this == &other) return *this;
clear();
_arena.swap(other._arena);
_blocks.swap(other._blocks);
_runs.swap(other._runs);
_links.swap(other._links);
_anchors.swap(other._anchors);
_tables.swap(other._tables);
_table_cells.swap(other._table_cells);
_fields.swap(other._fields);
_partials.swap(other._partials);
_partial_fields.swap(other._partial_fields);
std::swap(_has_background, other._has_background);
std::swap(_background, other._background);
std::swap(_has_foreground, other._has_foreground);
std::swap(_foreground, other._foreground);
std::swap(_truncated, other._truncated);
std::swap(_unsupported, other._unsupported);
return *this;
}
bool CompactPage::append_notice(const std::string& value) {
if (value.size() > MAX_NOTICE_BYTES ||
value.size() + 1 > MAX_ARENA_BYTES - std::min(_arena.size(), MAX_ARENA_BYTES))
return false;
if (_blocks.size() >= MAX_BLOCKS) {
const BlockRecord removed = _blocks.back();
const std::size_t first = std::min<std::size_t>(removed.first_run, _runs.size());
_runs.resize(first);
_blocks.pop_back();
}
if (_runs.size() >= MAX_RUNS) {
std::size_t owner = _blocks.size();
while (owner > 0 && _blocks[owner - 1].run_count == 0) --owner;
if (owner == 0) return false;
_runs.pop_back();
--_blocks[owner - 1].run_count;
for (std::size_t i = owner; i < _blocks.size(); ++i)
_blocks[i].first_run = static_cast<uint32_t>(_runs.size());
}
_anchors.erase(std::remove_if(_anchors.begin(),_anchors.end(),
[this](const AnchorRecord& anchor){return anchor.block_index>=_blocks.size();}),
_anchors.end());
try {
RunRecord run;
if (!append(value, run.text_offset, run.text_length)) return false;
BlockRecord block;
block.first_run = static_cast<uint32_t>(_runs.size());
block.run_count = 1;
block.type = BlockType::UNSUPPORTED;
_runs.push_back(run);
_blocks.push_back(block);
return true;
} catch (const std::bad_alloc&) {
clear();
return false;
}
}
CompactPage::TextView CompactPage::text(const RunRecord& run) const {
if (run.text_offset > _arena.size() || run.text_length > _arena.size() - run.text_offset) return {};
return {_arena.data() + run.text_offset, run.text_length};
}
CompactPage::TextView CompactPage::target(std::size_t index) const {
if (index >= _links.size()) return {};
const auto& link = _links[index];
if (link.target_offset > _arena.size() || link.target_length > _arena.size() - link.target_offset) return {};
return {_arena.data() + link.target_offset, link.target_length};
}
CompactPage::TextView CompactPage::field_name(std::size_t index) const {
if (index >= _fields.size()) return {};
const auto& field = _fields[index];
if (field.name_offset > _arena.size() || field.name_length > _arena.size() - field.name_offset) return {};
return {_arena.data() + field.name_offset, field.name_length};
}
CompactPage::TextView CompactPage::field_value(std::size_t index) const {
if (index >= _fields.size()) return {};
const auto& field = _fields[index];
if (field.value_offset > _arena.size() || field.value_length > _arena.size() - field.value_offset) return {};
return {_arena.data() + field.value_offset, field.value_length};
}
CompactPage::TextView CompactPage::field_label(std::size_t index) const {
if (index >= _fields.size()) return {};
const auto& field = _fields[index];
if (field.label_offset > _arena.size() || field.label_length > _arena.size() - field.label_offset) return {};
return {_arena.data() + field.label_offset, field.label_length};
}
CompactPage::TextView CompactPage::partial_descriptor(const PartialRecord& partial) const {
if (partial.descriptor_offset > _arena.size() ||
partial.descriptor_length > _arena.size() - partial.descriptor_offset) return {};
return {_arena.data() + partial.descriptor_offset, partial.descriptor_length};
}
CompactPage::TextView CompactPage::partial_url(const PartialRecord& partial) const {
if (partial.url_offset > _arena.size() ||
partial.url_length > _arena.size() - partial.url_offset) return {};
return {_arena.data() + partial.url_offset, partial.url_length};
}
CompactPage::TextView CompactPage::partial_selectors(const PartialRecord& partial) const {
if (partial.selectors_offset > _arena.size() ||
partial.selectors_length > _arena.size() - partial.selectors_offset) return {};
return {_arena.data() + partial.selectors_offset, partial.selectors_length};
}
CompactPage::TextView CompactPage::partial_id(const PartialRecord& partial) const {
if (partial.id_offset > _arena.size() ||
partial.id_length > _arena.size() - partial.id_offset) return {};
return {_arena.data() + partial.id_offset, partial.id_length};
}
CompactPage::TextView CompactPage::partial_field(const PartialRecord& partial,
std::size_t index) const {
if (index >= partial.field_count || partial.first_field > _partial_fields.size() ||
index >= _partial_fields.size() - partial.first_field) return {};
const auto& field = _partial_fields[partial.first_field + index];
if (field.value_offset > _arena.size() ||
field.value_length > _arena.size() - field.value_offset) return {};
return {_arena.data() + field.value_offset, field.value_length};
}
bool CompactPage::find_anchor(const std::string& name, uint16_t& block_index) const {
if (name.size() > DocumentParser::MAX_ANCHOR_NAME_BYTES) return false;
for (const auto& anchor : _anchors) {
if (anchor.name_offset > _arena.size() ||
anchor.name_length > _arena.size() - anchor.name_offset) continue;
if (anchor.name_length == name.size() &&
std::memcmp(_arena.data() + anchor.name_offset, name.data(), name.size()) == 0) {
block_index = anchor.block_index;
return true;
}
}
return false;
}
} // namespace UI::LXMF::NomadNet
Reference in New Issue View Git Blame Copy Permalink