StringData FieldRef::dottedSubstring(size_t startPart, size_t endPart) const {
if (_size == 0 || startPart >= endPart || endPart > numParts())
return StringData();
if (!_replacements.empty() || _size != _cachedSize)
reserialize();
dassert(_replacements.empty() && _size == _cachedSize);
StringData result(_dotted);
// Fast-path if we want the whole thing
if (startPart == 0 && endPart == numParts())
return result;
size_t startChar = 0;
for (size_t i = 0; i < startPart; ++i) {
startChar += getPart(i).size() + 1; // correct for '.'
}
size_t endChar = startChar;
for (size_t i = startPart; i < endPart; ++i) {
endChar += getPart(i).size() + 1;
}
// correct for last '.'
if (endPart != numParts())
--endChar;
return result.substr(startChar, endChar - startChar);
}
String apc_reserialize(const String& str) {
if (str.empty() ||
!apcExtension::EnableApcSerialize) return str;
VariableUnserializer uns(str.data(), str.size(),
VariableUnserializer::Type::APCSerialize);
StringBuffer buf;
reserialize(&uns, buf);
return buf.detach();
}
bool builder::
construct()
{
memory_limit_ = calculate_memory_limit();
uint16_t start_stage = 0;
uint16_t final_stage = desc_.final_stage;
auto input_file = fs::canonical(fs::path(desc_.input_file));
const std::string input_file_type = input_file.extension().string();
if (input_file_type == ".xyz" ||
input_file_type == ".ply" ||
input_file_type == ".bin")
desc_.compute_normals_and_radii = true;
if (input_file_type == ".xyz" ||
input_file_type == ".xyz_all" ||
input_file_type == ".ply")
start_stage = 0;
else if (input_file_type == ".bin" || input_file_type == ".bin_all")
start_stage = 1;
else if (input_file_type == ".bin_wo_outlier")
start_stage = 3;
else if (input_file_type == ".bvhd")
start_stage = 4;
else if (input_file_type == ".bvhu")
start_stage = 5;
else {
LOGGER_ERROR("Unknown input file format");
return false;
}
// init algorithms
std::unique_ptr<reduction_strategy> reduction_strategy{get_reduction_strategy(desc_.reduction_algo)};
std::unique_ptr<normal_computation_strategy> normal_comp_strategy{get_normal_strategy(desc_.normal_computation_algo)};
std::unique_ptr<radius_computation_strategy> radius_comp_strategy{get_radius_strategy(desc_.radius_computation_algo)};
// convert to binary file
if ((0 >= start_stage) && (0 <= final_stage)) {
input_file = convert_to_binary(input_file_type);
if(input_file.empty()) return false;
}
// downsweep (create bvh)
if ((3 >= start_stage) && (3 <= final_stage)) {
input_file = downsweep(input_file, start_stage);
if(input_file.empty()) return false;
}
// upsweep (create LOD)
if ((4 >= start_stage) && (4 <= final_stage)) {
input_file = upsweep(input_file, start_stage, reduction_strategy.get(), normal_comp_strategy.get(), radius_comp_strategy.get());
if(input_file.empty()) return false;
}
// serialize to file
if ((5 >= start_stage) && (5 <= final_stage)) {
bool reserialize_success = reserialize(input_file, start_stage);
if(!reserialize_success) return false;
}
return true;
}
void reserialize(VariableUnserializer *uns, StringBuffer &buf) {
char type = uns->readChar();
char sep = uns->readChar();
if (type == 'N') {
buf.append(type);
buf.append(sep);
return;
}
switch (type) {
case 'r':
case 'R':
case 'b':
case 'i':
case 'd':
{
buf.append(type);
buf.append(sep);
while (uns->peek() != ';') {
char ch;
ch = uns->readChar();
buf.append(ch);
}
}
break;
case 'S':
case 'A':
{
// shouldn't happen, but keep the code here anyway.
buf.append(type);
buf.append(sep);
char pointer[8];
uns->read(pointer, 8);
buf.append(pointer, 8);
}
break;
case 's':
{
String v;
v.unserialize(uns);
assert(!v.isNull());
if (v->isStatic()) {
union {
char pointer[8];
StringData *sd;
} u;
u.sd = v.get();
buf.append("S:");
buf.append(u.pointer, 8);
buf.append(';');
} else {
buf.append("s:");
buf.append(v.size());
buf.append(":\"");
buf.append(v.data(), v.size());
buf.append("\";");
}
sep = uns->readChar();
return;
}
break;
case 'a':
{
buf.append("a:");
int64_t size = uns->readInt();
char sep2 = uns->readChar();
buf.append(size);
buf.append(sep2);
sep2 = uns->readChar();
buf.append(sep2);
for (int64_t i = 0; i < size; i++) {
reserialize(uns, buf); // key
reserialize(uns, buf); // value
}
sep2 = uns->readChar(); // '}'
buf.append(sep2);
return;
}
break;
case 'o':
case 'O':
{
buf.append(type);
buf.append(sep);
String clsName;
clsName.unserialize(uns);
buf.append(clsName.size());
buf.append(":\"");
buf.append(clsName.data(), clsName.size());
buf.append("\":");
uns->readChar();
int64_t size = uns->readInt();
char sep2 = uns->readChar();
buf.append(size);
buf.append(sep2);
sep2 = uns->readChar(); // '{'
buf.append(sep2);
for (int64_t i = 0; i < size; i++) {
reserialize(uns, buf); // property name
reserialize(uns, buf); // property value
}
sep2 = uns->readChar(); // '}'
buf.append(sep2);
return;
}
break;
case 'C':
{
buf.append(type);
buf.append(sep);
String clsName;
clsName.unserialize(uns);
buf.append(clsName.size());
buf.append(":\"");
buf.append(clsName.data(), clsName.size());
buf.append("\":");
sep = uns->readChar(); // ':'
String serialized;
serialized.unserialize(uns, '{', '}');
buf.append(serialized.size());
buf.append(":{");
buf.append(serialized.data(), serialized.size());
buf.append('}');
return;
}
break;
default:
throw Exception("Unknown type '%c'", type);
}
sep = uns->readChar(); // the last ';'
buf.append(sep);
}
