bool CommandCat::run() {
if (m_input_files.size() == 1) { // single input file
m_vout << "Copying input file '" << m_input_files[0].filename() << "'\n";
osmium::io::Reader reader(m_input_files[0], osm_entity_bits());
osmium::io::Header header = reader.header();
setup_header(header);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
while (osmium::memory::Buffer buffer = reader.read()) {
writer(std::move(buffer));
}
writer.close();
reader.close();
} else { // multiple input files
osmium::io::Header header;
setup_header(header);
osmium::io::Writer writer(m_output_file, header, m_output_overwrite, m_fsync);
for (const auto& input_file : m_input_files) {
m_vout << "Copying input file '" << input_file.filename() << "'\n";
osmium::io::Reader reader(input_file, osm_entity_bits());
while (osmium::memory::Buffer buffer = reader.read()) {
writer(std::move(buffer));
}
reader.close();
}
writer.close();
}
show_memory_used();
m_vout << "Done.\n";
return true;
}
/* main output routine... */
int dooutput(lpTrajectory trajectory, int error)
{
if (error) posterr_error(error, (error > 0) ? errors_traj[error] : NULL);
else
{
html_cgitext();
setup_openhead();
setup_body();
setup_info(TRAJ_VERSION);
setup_header(2);
html_horzrule(NULL, 0, 0, 0, 0);
writedata(trajectory);
html_horzrule(NULL, 0, 0, 0, 0);
writetable(trajectory);
html_closebody();
html_closehead();
}
return 0;
}
void setup_message_layer() {
int header_height = get_header_height();
int text_height = get_text_height();
setup_header(header_height);
layer_set_frame(text_layer_get_layer(messagetext_layer), GRect(0, header_height, 144, text_height));
scroll_layer_set_content_offset(message_layer, GPoint(0, 0), false);
scroll_layer_set_content_size(message_layer, GSize(144, header_height + text_height));
layer_set_hidden(scroll_layer_get_layer(message_layer), false);
}
bool CommandGetParents::run() {
m_vout << "Opening input file...\n";
osmium::io::Reader reader{m_input_file, get_needed_types()};
m_vout << "Opening output file...\n";
osmium::io::Header header = reader.header();
setup_header(header);
osmium::io::Writer writer{m_output_file, header, m_output_overwrite, m_fsync};
m_vout << "Copying matching objects to output file...\n";
osmium::ProgressBar progress_bar{reader.file_size(), display_progress()};
while (osmium::memory::Buffer buffer = reader.read()) {
progress_bar.update(reader.offset());
for (const auto& object : buffer.select<osmium::OSMObject>()) {
if (m_add_self && m_ids(object.type()).get(object.positive_id())) {
writer(object);
continue;
}
if (object.type() == osmium::item_type::way) {
const auto& way = static_cast<const osmium::Way&>(object);
for (const auto& nr : way.nodes()) {
if (m_ids(osmium::item_type::node).get(nr.positive_ref())) {
writer(object);
break;
}
}
} else if (object.type() == osmium::item_type::relation) {
const auto& relation = static_cast<const osmium::Relation&>(object);
for (const auto& member : relation.members()) {
if (m_ids(member.type()).get(member.positive_ref())) {
writer(object);
break;
}
}
}
}
}
progress_bar.done();
m_vout << "Closing output file...\n";
writer.close();
m_vout << "Closing input file...\n";
reader.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
/* Prepare DHCPv4 Message request and send it to peer */
static void send_request(struct net_if *iface, bool renewal)
{
struct net_buf *buf;
buf = prepare_message(iface, DHCPV4_MSG_TYPE_REQUEST);
if (!buf) {
goto fail;
}
if (!add_server_id(buf) ||
!add_req_ipaddr(buf) ||
!add_end(buf)) {
goto fail;
}
setup_header(buf);
if (net_send_data(buf) < 0) {
goto fail;
}
if (renewal) {
iface->dhcpv4.state = NET_DHCPV4_RENEWAL;
} else {
iface->dhcpv4.state = NET_DHCPV4_REQUEST;
}
iface->dhcpv4.attempts++;
k_delayed_work_init(&iface->dhcpv4_timeout, dhcpv4_timeout);
k_delayed_work_submit(&iface->dhcpv4_timeout, get_dhcpv4_timeout());
return;
fail:
NET_DBG("Message preparation failed");
if (!buf) {
net_nbuf_unref(buf);
}
}
/* main output routine... */
int dooutput(lpMcDrag mcdrag, int error)
{
if (error) posterr_error(error, (error > 0) ? errors_drag[error] : NULL);
else
{
html_cgitext();
setup_openhead();
setup_body();
setup_info(DRAG_VERSION);
setup_header(2);
html_horzrule(NULL, 0, 0, 0, 0);
writedata(mcdrag);
html_horzrule(NULL, 0, 0, 0, 0);
writetable(mcdrag);
html_closebody();
html_closehead();
}
return 0;
}
/* Prepare DHCPv4 Discover message and broadcast it */
static void send_discover(struct net_if *iface)
{
struct net_buf *buf;
iface->dhcpv4.xid++;
buf = prepare_message(iface, DHCPV4_MSG_TYPE_DISCOVER);
if (!buf) {
goto fail;
}
if (!add_req_options(buf) ||
!add_end(buf)) {
goto fail;
}
setup_header(buf);
if (net_send_data(buf) < 0) {
goto fail;
}
iface->dhcpv4.state = NET_DHCPV4_DISCOVER;
k_delayed_work_init(&iface->dhcpv4_timeout, dhcpv4_timeout);
k_delayed_work_submit(&iface->dhcpv4_timeout, get_dhcpv4_timeout());
return;
fail:
NET_DBG("Message preparation failed");
if (!buf) {
net_nbuf_unref(buf);
}
}
/* main output routine... */
int dooutput(lpPointBlankRange pointblankrange, int error)
{
if (error) posterr_error(error, (error > 0) ? errors_pbr[error] : NULL);
else
{
html_cgitext();
setup_openhead();
setup_body();
setup_info(PBR_VERSION);
setup_header(2);
html_horzrule(NULL, 0, 0, 0, 0);
writedata(pointblankrange);
html_horzrule(NULL, 0, 0, 0, 0);
writetable(pointblankrange);
html_closebody();
html_closehead();
}
return 0;
}
bool CommandSort::run_single_pass() {
std::vector<osmium::memory::Buffer> data;
osmium::ObjectPointerCollection objects;
osmium::Box bounding_box;
uint64_t buffers_count = 0;
uint64_t buffers_size = 0;
uint64_t buffers_capacity = 0;
m_vout << "Reading contents of input files...\n";
osmium::ProgressBar progress_bar{file_size_sum(m_input_files), display_progress()};
for (const std::string& file_name : m_filenames) {
osmium::io::Reader reader{file_name, osmium::osm_entity_bits::object};
osmium::io::Header header{reader.header()};
bounding_box.extend(header.joined_boxes());
while (osmium::memory::Buffer buffer = reader.read()) {
++buffers_count;
buffers_size += buffer.committed();
buffers_capacity += buffer.capacity();
progress_bar.update(reader.offset());
osmium::apply(buffer, objects);
data.push_back(std::move(buffer));
}
progress_bar.file_done(reader.file_size());
reader.close();
}
progress_bar.done();
m_vout << "Number of buffers: " << buffers_count << "\n";
const auto buffers_size_rounded = static_cast<double>(buffers_size / (1000 * 1000)) / 1000; // NOLINT(bugprone-integer-division)
m_vout << "Sum of buffer sizes: " << buffers_size << " (" << buffers_size_rounded << " GB)\n";
const auto buffers_capacity_rounded = static_cast<double>(buffers_capacity / (1000 * 1000)) / 1000; // NOLINT(bugprone-integer-division)
if (buffers_capacity != 0) {
const auto fill_factor = std::round(100 * static_cast<double>(buffers_size) / static_cast<double>(buffers_capacity));
m_vout << "Sum of buffer capacities: " << buffers_capacity << " (" << buffers_capacity_rounded << " GB, " << fill_factor << "% full)\n";
} else {
m_vout << "Sum of buffer capacities: 0 (0 GB)\n";
}
m_vout << "Opening output file...\n";
osmium::io::Header header;
setup_header(header);
if (bounding_box) {
header.add_box(bounding_box);
}
osmium::io::Writer writer{m_output_file, header, m_output_overwrite, m_fsync};
m_vout << "Sorting data...\n";
objects.sort(osmium::object_order_type_id_version());
m_vout << "Writing out sorted data...\n";
auto out = osmium::io::make_output_iterator(writer);
std::copy(objects.begin(), objects.end(), out);
m_vout << "Closing output file...\n";
writer.close();
show_memory_used();
m_vout << "Done.\n";
return true;
}
