struct bt_clock_value *clock_value;
uint64_t cycles;
- clock_value = bt_event_get_clock_value(event, clock_class);
+ clock_value = bt_event_borrow_clock_value(event, clock_class);
if (!clock_value) {
g_string_append(pretty->string, "????????????????????");
return;
}
ret = bt_clock_value_get_value(clock_value, &cycles);
- bt_put(clock_value);
if (ret) {
// TODO: log, this is unexpected
g_string_append(pretty->string, "Error");
struct bt_trace *trace = NULL;
struct bt_clock_class *clock_class = NULL;
- stream = bt_event_get_stream(event);
+ stream = bt_event_borrow_stream(event);
if (!stream) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- stream_class = bt_stream_get_class(stream);
+ stream_class = bt_stream_borrow_class(stream);
if (!stream_class) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- trace = bt_stream_class_get_trace(stream_class);
+ trace = bt_stream_class_borrow_trace(stream_class);
if (!trace) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
clock_class =
- bt_clock_class_priority_map_get_highest_priority_clock_class(
+ bt_clock_class_priority_map_borrow_highest_priority_clock_class(
cc_prio_map);
if (!clock_class) {
ret = BT_COMPONENT_STATUS_ERROR;
print_timestamp_cycles(pretty, clock_class, event);
} else {
struct bt_clock_value *clock_value =
- bt_event_get_clock_value(event, clock_class);
+ bt_event_borrow_clock_value(event, clock_class);
print_timestamp_wall(pretty, clock_value);
- bt_put(clock_value);
}
if (pretty->use_colors) {
g_string_append(pretty->string, COLOR_RST);
*start_line = !print_names;
end:
- bt_put(stream);
- bt_put(clock_class);
- bt_put(stream_class);
- bt_put(trace);
return ret;
}
struct bt_trace *trace_class = NULL;
int dom_print = 0;
- event_class = bt_event_get_class(event);
+ event_class = bt_event_borrow_class(event);
if (!event_class) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- stream_class = bt_event_class_get_stream_class(event_class);
+ stream_class = bt_event_class_borrow_stream_class(event_class);
if (!stream_class) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- trace_class = bt_stream_class_get_trace(stream_class);
+ trace_class = bt_stream_class_borrow_trace(stream_class);
if (!trace_class) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
if (pretty->options.print_trace_hostname_field) {
struct bt_value *hostname_str;
- hostname_str = bt_trace_get_environment_field_value_by_name(trace_class,
- "hostname");
+ hostname_str = bt_trace_borrow_environment_field_value_by_name(
+ trace_class, "hostname");
if (hostname_str) {
const char *str;
== BT_VALUE_STATUS_OK) {
g_string_append(pretty->string, str);
}
- bt_put(hostname_str);
dom_print = 1;
}
}
if (pretty->options.print_trace_domain_field) {
struct bt_value *domain_str;
- domain_str = bt_trace_get_environment_field_value_by_name(trace_class,
- "domain");
+ domain_str = bt_trace_borrow_environment_field_value_by_name(
+ trace_class, "domain");
if (domain_str) {
const char *str;
== BT_VALUE_STATUS_OK) {
g_string_append(pretty->string, str);
}
- bt_put(domain_str);
dom_print = 1;
}
}
if (pretty->options.print_trace_procname_field) {
struct bt_value *procname_str;
- procname_str = bt_trace_get_environment_field_value_by_name(trace_class,
- "procname");
+ procname_str = bt_trace_borrow_environment_field_value_by_name(
+ trace_class, "procname");
if (procname_str) {
const char *str;
== BT_VALUE_STATUS_OK) {
g_string_append(pretty->string, str);
}
- bt_put(procname_str);
+
dom_print = 1;
}
}
if (pretty->options.print_trace_vpid_field) {
struct bt_value *vpid_value;
- vpid_value = bt_trace_get_environment_field_value_by_name(trace_class,
- "vpid");
+ vpid_value = bt_trace_borrow_environment_field_value_by_name(
+ trace_class, "vpid");
if (vpid_value) {
int64_t value;
== BT_VALUE_STATUS_OK) {
g_string_append_printf(pretty->string, "(%" PRId64 ")", value);
}
- bt_put(vpid_value);
+
dom_print = 1;
}
}
} else {
g_string_append(pretty->string, ", ");
}
+
end:
- bt_put(trace_class);
- bt_put(stream_class);
- bt_put(event_class);
return ret;
}
} v;
bool rst_color = false;
- field_type = bt_field_get_type(field);
+ field_type = bt_field_borrow_type(field);
if (!field_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
if (rst_color) {
g_string_append(pretty->string, COLOR_RST);
}
- bt_put(field_type);
return ret;
}
int nr_mappings = 0;
int is_signed;
- enumeration_field_type = bt_field_get_type(field);
+ enumeration_field_type = bt_field_borrow_type(field);
if (!enumeration_field_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- container_field = bt_field_enumeration_get_container(field);
+ container_field = bt_field_enumeration_borrow_container(field);
if (!container_field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- container_field_type = bt_field_get_type(container_field);
+ container_field_type = bt_field_borrow_type(container_field);
if (!container_field_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
g_string_append(pretty->string, " )");
end:
bt_put(iter);
- bt_put(container_field_type);
- bt_put(container_field);
- bt_put(enumeration_field_type);
return ret;
}
struct bt_field *field = NULL;
struct bt_field_type *field_type = NULL;;
- field = bt_field_structure_get_field_by_index(_struct, i);
+ field = bt_field_structure_borrow_field_by_index(_struct, i);
if (!field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- if (bt_field_type_structure_get_field_by_index(struct_type,
+ if (bt_field_type_structure_borrow_field_by_index(struct_type,
&field_name, &field_type, i) < 0) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
ret = print_field(pretty, field, print_names, NULL, 0);
*nr_printed_fields += 1;
+
end:
- bt_put(field_type);
- bt_put(field);
return ret;
}
struct bt_field_type *struct_type = NULL;
int nr_fields, i, nr_printed_fields;
- struct_type = bt_field_get_type(_struct);
+ struct_type = bt_field_borrow_type(_struct);
if (!struct_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
pretty->depth--;
g_string_append(pretty->string, " }");
+
end:
- bt_put(struct_type);
return ret;
}
g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
}
}
- field = bt_field_array_get_field(array, i);
+ field = bt_field_array_borrow_field(array, i);
if (!field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
ret = print_field(pretty, field, print_names, NULL, 0);
+
end:
- bt_put(field);
return ret;
}
uint64_t i;
bool is_string = false;
- array_type = bt_field_get_type(array);
+ array_type = bt_field_borrow_type(array);
if (!array_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- field_type = bt_field_type_array_get_element_field_type(array_type);
+ field_type = bt_field_type_array_borrow_element_field_type(array_type);
if (!field_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
} else {
g_string_append(pretty->string, " ]");
}
+
end:
- bt_put(field_type);
- bt_put(array_type);
return ret;
}
g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i);
}
}
- field = bt_field_sequence_get_field(seq, i);
+ field = bt_field_sequence_borrow_field(seq, i);
if (!field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
ret = print_field(pretty, field, print_names, NULL, 0);
+
end:
- bt_put(field);
return ret;
}
uint64_t i;
bool is_string = false;
- seq_type = bt_field_get_type(seq);
+ seq_type = bt_field_borrow_type(seq);
if (!seq_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- length_field = bt_field_sequence_get_length(seq);
+ length_field = bt_field_sequence_borrow_length(seq);
if (!length_field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- field_type = bt_field_type_sequence_get_element_field_type(seq_type);
+ field_type = bt_field_type_sequence_borrow_element_field_type(seq_type);
if (!field_type) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
} else {
g_string_append(pretty->string, " ]");
}
+
end:
- bt_put(length_field);
- bt_put(field_type);
- bt_put(seq_type);
return ret;
}
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_field *field = NULL;
- field = bt_field_variant_get_current_field(variant);
+ field = bt_field_variant_borrow_current_field(variant);
if (!field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
const char *tag_choice;
struct bt_field_type_enumeration_mapping_iterator *iter;
- tag_field = bt_field_variant_get_tag(variant);
+ tag_field = bt_field_variant_borrow_tag(variant);
if (!tag_field) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
iter_ret = bt_field_type_enumeration_mapping_iterator_next(
iter);
if (!iter || ret) {
- bt_put(tag_field);
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
iter, &tag_choice, NULL, NULL);
if (iter_ret) {
bt_put(iter);
- bt_put(tag_field);
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
print_field_name_equal(pretty, tag_choice);
- bt_put(tag_field);
bt_put(iter);
}
ret = print_field(pretty, field, print_names, NULL, 0);
}
pretty->depth--;
g_string_append(pretty->string, " }");
+
end:
- bt_put(field);
return ret;
}
struct bt_packet *packet = NULL;
struct bt_field *main_field = NULL;
- packet = bt_event_get_packet(event);
+ packet = bt_event_borrow_packet(event);
if (!packet) {
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
}
- main_field = bt_packet_get_context(packet);
+ main_field = bt_packet_borrow_context(packet);
if (!main_field) {
goto end;
}
pretty->options.print_context_field_names,
stream_packet_context_quarks,
STREAM_PACKET_CONTEXT_QUARKS_LEN);
+
end:
- bt_put(main_field);
- bt_put(packet);
return ret;
}
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_field *main_field = NULL;
- main_field = bt_event_get_header(event);
+ main_field = bt_event_borrow_header(event);
if (!main_field) {
goto end;
}
}
ret = print_field(pretty, main_field,
pretty->options.print_header_field_names, NULL, 0);
+
end:
- bt_put(main_field);
return ret;
}
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_field *main_field = NULL;
- main_field = bt_event_get_stream_event_context(event);
+ main_field = bt_event_borrow_stream_event_context(event);
if (!main_field) {
goto end;
}
}
ret = print_field(pretty, main_field,
pretty->options.print_context_field_names, NULL, 0);
+
end:
- bt_put(main_field);
return ret;
}
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_field *main_field = NULL;
- main_field = bt_event_get_context(event);
+ main_field = bt_event_borrow_context(event);
if (!main_field) {
goto end;
}
}
ret = print_field(pretty, main_field,
pretty->options.print_context_field_names, NULL, 0);
+
end:
- bt_put(main_field);
return ret;
}
enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
struct bt_field *main_field = NULL;
- main_field = bt_event_get_payload(event);
+ main_field = bt_event_borrow_payload(event);
if (!main_field) {
goto end;
}
}
ret = print_field(pretty, main_field,
pretty->options.print_payload_field_names, NULL, 0);
+
end:
- bt_put(main_field);
return ret;
}
{
enum bt_component_status ret;
struct bt_event *event =
- bt_notification_event_get_event(event_notif);
+ bt_notification_event_borrow_event(event_notif);
struct bt_clock_class_priority_map *cc_prio_map =
- bt_notification_event_get_clock_class_priority_map(event_notif);
+ bt_notification_event_borrow_clock_class_priority_map(
+ event_notif);
BT_ASSERT(event);
BT_ASSERT(cc_prio_map);
}
end:
- bt_put(event);
- bt_put(cc_prio_map);
return ret;
}
/* Stream name */
switch (bt_notification_get_type(notif)) {
case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
- stream = bt_notification_discarded_events_get_stream(notif);
+ stream = bt_notification_discarded_events_borrow_stream(notif);
count = bt_notification_discarded_events_get_count(notif);
is_discarded_events = true;
break;
case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
- stream = bt_notification_discarded_packets_get_stream(notif);
+ stream = bt_notification_discarded_packets_borrow_stream(notif);
count = bt_notification_discarded_packets_get_count(notif);
is_discarded_events = false;
break;
stream_name = bt_stream_get_name(stream);
/* Stream class ID */
- stream_class = bt_stream_get_class(stream);
+ stream_class = bt_stream_borrow_class(stream);
BT_ASSERT(stream_class);
stream_class_id = bt_stream_class_get_id(stream_class);
stream_id = bt_stream_get_id(stream);
/* Trace path */
- trace = bt_stream_class_get_trace(stream_class);
+ trace = bt_stream_class_borrow_trace(stream_class);
BT_ASSERT(trace);
trace_name = bt_trace_get_name(trace);
if (!trace_name) {
count == 1 ? "" : "s");
g_string_assign(pretty->string, "");
clock_value = is_discarded_events ?
- bt_notification_discarded_events_get_begin_clock_value(notif) :
- bt_notification_discarded_packets_get_begin_clock_value(notif);
+ bt_notification_discarded_events_borrow_begin_clock_value(notif) :
+ bt_notification_discarded_packets_borrow_begin_clock_value(notif);
print_timestamp_wall(pretty, clock_value);
- BT_PUT(clock_value);
fprintf(stderr, "%s] and [", pretty->string->str);
g_string_assign(pretty->string, "");
clock_value = is_discarded_events ?
- bt_notification_discarded_events_get_end_clock_value(notif) :
- bt_notification_discarded_packets_get_end_clock_value(notif);
+ bt_notification_discarded_events_borrow_end_clock_value(notif) :
+ bt_notification_discarded_packets_borrow_end_clock_value(notif);
print_timestamp_wall(pretty, clock_value);
- BT_PUT(clock_value);
fprintf(stderr, "%s] in trace \"%s\" ",
pretty->string->str, trace_name);
}
fprintf(stderr, ").%s\n", bt_common_color_reset());
- bt_put(stream);
- bt_put(stream_class);
- bt_put(trace);
- bt_put(clock_value);
return ret;
}