#include "logging.h"
#include <babeltrace/babeltrace.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
#include "ctfcopytrace.h"
-#include "clock-fields.h"
+#include "clock-field.h"
BT_HIDDEN
-struct bt_clock_class *ctf_copy_clock_class(FILE *err,
- struct bt_clock_class *clock_class)
+const bt_clock_class *ctf_copy_clock_class(FILE *err,
+ const bt_clock_class *clock_class)
{
int64_t offset, offset_s;
int int_ret;
uint64_t u64_ret;
const char *name, *description;
- struct bt_clock_class *writer_clock_class = NULL;
+ const bt_clock_class *writer_clock_class = NULL;
- assert(err && clock_class);
+ BT_ASSERT(err && clock_class);
name = bt_clock_class_get_name(clock_class);
- assert(name);
+ BT_ASSERT(name);
writer_clock_class = bt_clock_class_create(name,
bt_clock_class_get_frequency(clock_class));
if (description) {
int_ret = bt_clock_class_set_description(writer_clock_class,
description);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
}
u64_ret = bt_clock_class_get_precision(clock_class);
- assert(u64_ret != -1ULL);
+ BT_ASSERT(u64_ret != -1ULL);
int_ret = bt_clock_class_set_precision(writer_clock_class,
u64_ret);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_get_offset_s(clock_class, &offset_s);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_set_offset_s(writer_clock_class, offset_s);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_get_offset_cycles(clock_class, &offset);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
int_ret = bt_clock_class_set_offset_cycles(writer_clock_class, offset);
- assert(!int_ret);
+ BT_ASSERT(!int_ret);
- int_ret = bt_clock_class_is_absolute(clock_class);
- assert(int_ret >= 0);
+ int_ret = bt_clock_class_origin_is_unix_epoch(clock_class);
+ BT_ASSERT(int_ret >= 0);
- int_ret = bt_clock_class_set_is_absolute(writer_clock_class, int_ret);
- assert(!int_ret);
+ int_ret = bt_clock_class_set_origin_is_unix_epoch(writer_clock_class, int_ret);
+ BT_ASSERT(!int_ret);
end:
return writer_clock_class;
}
BT_HIDDEN
-enum bt_component_status ctf_copy_clock_classes(FILE *err,
- struct bt_trace *writer_trace,
- struct bt_stream_class *writer_stream_class,
- struct bt_trace *trace)
+bt_component_status ctf_copy_clock_classes(FILE *err,
+ const bt_trace *writer_trace,
+ const bt_stream_class *writer_stream_class,
+ const bt_trace *trace)
{
- enum bt_component_status ret;
+ bt_component_status ret;
int int_ret, clock_class_count, i;
clock_class_count = bt_trace_get_clock_class_count(trace);
for (i = 0; i < clock_class_count; i++) {
- struct bt_clock_class *writer_clock_class;
- struct bt_clock_class *clock_class =
+ const bt_clock_class *writer_clock_class;
+ const bt_clock_class *clock_class =
bt_trace_get_clock_class_by_index(trace, i);
- assert(clock_class);
+ BT_ASSERT(clock_class);
writer_clock_class = ctf_copy_clock_class(err, clock_class);
- bt_put(clock_class);
+ bt_clock_class_put_ref(clock_class);
if (!writer_clock_class) {
BT_LOGE_STR("Failed to copy clock class.");
ret = BT_COMPONENT_STATUS_ERROR;
int_ret = bt_trace_add_clock_class(writer_trace, writer_clock_class);
if (int_ret != 0) {
- BT_PUT(writer_clock_class);
+ BT_CLOCK_CLASS_PUT_REF_AND_RESET(writer_clock_class);
BT_LOGE_STR("Failed to add clock class.");
ret = BT_COMPONENT_STATUS_ERROR;
goto end;
/*
* Ownership transferred to the trace.
*/
- bt_put(writer_clock_class);
+ bt_clock_class_put_ref(writer_clock_class);
}
ret = BT_COMPONENT_STATUS_OK;
}
static
-void replace_clock_classes(struct bt_trace *trace_copy,
- struct bt_field_type *field_type)
+void replace_clock_classes(const bt_trace *trace_copy,
+ bt_field_type *field_type)
{
int ret;
- assert(trace_copy);
- assert(field_type);
+ BT_ASSERT(trace_copy);
+ BT_ASSERT(field_type);
switch (bt_field_type_get_type_id(field_type)) {
case BT_FIELD_TYPE_ID_INTEGER:
{
- struct bt_clock_class *mapped_clock_class =
+ const bt_clock_class *mapped_clock_class =
bt_field_type_integer_get_mapped_clock_class(field_type);
- struct bt_clock_class *clock_class_copy = NULL;
+ const bt_clock_class *clock_class_copy = NULL;
const char *name;
if (!mapped_clock_class) {
}
name = bt_clock_class_get_name(mapped_clock_class);
- assert(name);
+ BT_ASSERT(name);
clock_class_copy = bt_trace_get_clock_class_by_name(
trace_copy, name);
- assert(clock_class_copy);
+ BT_ASSERT(clock_class_copy);
ret = bt_field_type_integer_set_mapped_clock_class(
field_type, clock_class_copy);
- assert(ret == 0);
- bt_put(mapped_clock_class);
- bt_put(clock_class_copy);
+ BT_ASSERT(ret == 0);
+ bt_clock_class_put_ref(mapped_clock_class);
+ bt_clock_class_put_ref(clock_class_copy);
break;
}
case BT_FIELD_TYPE_ID_ENUM:
case BT_FIELD_TYPE_ID_ARRAY:
case BT_FIELD_TYPE_ID_SEQUENCE:
{
- struct bt_field_type *subtype = NULL;
+ bt_field_type *subtype = NULL;
switch (bt_field_type_get_type_id(field_type)) {
case BT_FIELD_TYPE_ID_ENUM:
abort();
}
- assert(subtype);
+ BT_ASSERT(subtype);
replace_clock_classes(trace_copy, subtype);
- bt_put(subtype);
+ bt_object_put_ref(subtype);
break;
}
case BT_FIELD_TYPE_ID_STRUCT:
for (i = 0; i < count; i++) {
const char *name;
- struct bt_field_type *member_type;
+ bt_field_type *member_type;
ret = bt_field_type_structure_get_field_by_index(
field_type, &name, &member_type, i);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
replace_clock_classes(trace_copy, member_type);
- bt_put(member_type);
+ bt_object_put_ref(member_type);
}
break;
for (i = 0; i < count; i++) {
const char *name;
- struct bt_field_type *member_type;
+ bt_field_type *member_type;
ret = bt_field_type_variant_get_field_by_index(
field_type, &name, &member_type, i);
- assert(ret == 0);
+ BT_ASSERT(ret == 0);
replace_clock_classes(trace_copy, member_type);
- bt_put(member_type);
+ bt_object_put_ref(member_type);
}
break;
}
BT_HIDDEN
-struct bt_event_class *ctf_copy_event_class(FILE *err,
- struct bt_trace *trace_copy,
- struct bt_event_class *event_class)
+const bt_event_class *ctf_copy_event_class(FILE *err,
+ const bt_trace *trace_copy,
+ const bt_event_class *event_class)
{
- struct bt_event_class *writer_event_class = NULL;
- struct bt_field_type *context = NULL, *payload_type = NULL;
+ const bt_event_class *writer_event_class = NULL;
+ bt_field_type *context = NULL, *payload_type = NULL;
const char *name;
int ret;
int64_t id;
- enum bt_event_class_log_level log_level;
+ bt_event_class_log_level log_level;
const char *emf_uri;
name = bt_event_class_get_name(event_class);
writer_event_class = bt_event_class_create(name);
- assert(writer_event_class);
+ BT_ASSERT(writer_event_class);
id = bt_event_class_get_id(event_class);
- assert(id >= 0);
+ BT_ASSERT(id >= 0);
ret = bt_event_class_set_id(writer_event_class, id);
if (ret) {
payload_type = bt_event_class_get_payload_type(event_class);
if (payload_type) {
- struct bt_field_type *ft_copy =
+ bt_field_type *ft_copy =
bt_field_type_copy(payload_type);
if (!ft_copy) {
replace_clock_classes(trace_copy, ft_copy);
ret = bt_event_class_set_payload_type(writer_event_class,
ft_copy);
- bt_put(ft_copy);
+ bt_object_put_ref(ft_copy);
if (ret < 0) {
BT_LOGE_STR("Failed to set payload type.");
goto error;
context = bt_event_class_get_context_type(event_class);
if (context) {
- struct bt_field_type *ft_copy =
+ bt_field_type *ft_copy =
bt_field_type_copy(context);
if (!ft_copy) {
ret = bt_event_class_set_context_type(
writer_event_class, ft_copy);
- bt_put(ft_copy);
+ bt_object_put_ref(ft_copy);
if (ret < 0) {
BT_LOGE_STR("Failed to set context type.");
goto error;
goto end;
error:
- BT_PUT(writer_event_class);
+ BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
end:
- BT_PUT(context);
- BT_PUT(payload_type);
+ BT_OBJECT_PUT_REF_AND_RESET(context);
+ BT_OBJECT_PUT_REF_AND_RESET(payload_type);
return writer_event_class;
}
BT_HIDDEN
-enum bt_component_status ctf_copy_event_classes(FILE *err,
- struct bt_stream_class *stream_class,
- struct bt_stream_class *writer_stream_class)
+bt_component_status ctf_copy_event_classes(FILE *err,
+ const bt_stream_class *stream_class,
+ const bt_stream_class *writer_stream_class)
{
- enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
- struct bt_event_class *event_class = NULL, *writer_event_class = NULL;
+ bt_component_status ret = BT_COMPONENT_STATUS_OK;
+ const bt_event_class *event_class = NULL, *writer_event_class = NULL;
int count, i;
- struct bt_trace *writer_trace =
+ const bt_trace *writer_trace =
bt_stream_class_get_trace(writer_stream_class);
- assert(writer_trace);
+ BT_ASSERT(writer_trace);
count = bt_stream_class_get_event_class_count(stream_class);
- assert(count >= 0);
+ BT_ASSERT(count >= 0);
for (i = 0; i < count; i++) {
int int_ret;
event_class = bt_stream_class_get_event_class_by_index(
stream_class, i);
- assert(event_class);
+ BT_ASSERT(event_class);
if (i < bt_stream_class_get_event_class_count(writer_stream_class)) {
writer_event_class = bt_stream_class_get_event_class_by_index(
* event_classes after a trace has become
* static.
*/
- BT_PUT(writer_event_class);
- BT_PUT(event_class);
+ BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
+ BT_EVENT_CLASS_PUT_REF_AND_RESET(event_class);
continue;
}
}
ret = BT_COMPONENT_STATUS_ERROR;
goto error;
}
- BT_PUT(writer_event_class);
- BT_PUT(event_class);
+ BT_EVENT_CLASS_PUT_REF_AND_RESET(writer_event_class);
+ BT_EVENT_CLASS_PUT_REF_AND_RESET(event_class);
}
goto end;
error:
- bt_put(event_class);
- bt_put(writer_event_class);
+ bt_event_class_put_ref(event_class);
+ bt_event_class_put_ref(writer_event_class);
end:
- bt_put(writer_trace);
+ bt_trace_put_ref(writer_trace);
return ret;
}
BT_HIDDEN
-struct bt_stream_class *ctf_copy_stream_class(FILE *err,
- struct bt_stream_class *stream_class,
- struct bt_trace *writer_trace,
+const bt_stream_class *ctf_copy_stream_class(FILE *err,
+ const bt_stream_class *stream_class,
+ const bt_trace *writer_trace,
bool override_ts64)
{
- struct bt_field_type *type = NULL;
- struct bt_field_type *type_copy = NULL;
- struct bt_stream_class *writer_stream_class = NULL;
+ bt_field_type *type = NULL;
+ bt_field_type *type_copy = NULL;
+ const bt_stream_class *writer_stream_class = NULL;
int ret_int;
const char *name = bt_stream_class_get_name(stream_class);
writer_stream_class = bt_stream_class_create_empty(name);
- assert(writer_stream_class);
+ BT_ASSERT(writer_stream_class);
type = bt_stream_class_get_packet_context_type(stream_class);
if (type) {
replace_clock_classes(writer_trace, type_copy);
ret_int = bt_stream_class_set_packet_context_type(
writer_stream_class, type_copy);
- BT_PUT(type_copy);
+ BT_OBJECT_PUT_REF_AND_RESET(type_copy);
if (ret_int < 0) {
BT_LOGE_STR("Failed to set packet_context type.");
goto error;
}
- BT_PUT(type);
+ BT_OBJECT_PUT_REF_AND_RESET(type);
}
type = bt_stream_class_get_event_header_type(stream_class);
}
ret_int = bt_trace_get_clock_class_count(writer_trace);
- assert(ret_int >= 0);
+ BT_ASSERT(ret_int >= 0);
if (override_ts64 && ret_int > 0) {
- struct bt_field_type *new_event_header_type;
+ bt_field_type *new_event_header_type;
new_event_header_type = override_header_type(err, type_copy,
writer_trace);
replace_clock_classes(writer_trace, type_copy);
ret_int = bt_stream_class_set_event_header_type(
writer_stream_class, new_event_header_type);
- BT_PUT(type_copy);
- BT_PUT(new_event_header_type);
+ BT_OBJECT_PUT_REF_AND_RESET(type_copy);
+ BT_OBJECT_PUT_REF_AND_RESET(new_event_header_type);
if (ret_int < 0) {
BT_LOGE_STR("Failed to set event_header type.");
goto error;
replace_clock_classes(writer_trace, type_copy);
ret_int = bt_stream_class_set_event_header_type(
writer_stream_class, type_copy);
- BT_PUT(type_copy);
+ BT_OBJECT_PUT_REF_AND_RESET(type_copy);
if (ret_int < 0) {
BT_LOGE_STR("Failed to set event_header type.");
goto error;
}
}
- BT_PUT(type);
+ BT_OBJECT_PUT_REF_AND_RESET(type);
}
type = bt_stream_class_get_event_context_type(stream_class);
replace_clock_classes(writer_trace, type_copy);
ret_int = bt_stream_class_set_event_context_type(
writer_stream_class, type_copy);
- BT_PUT(type_copy);
+ BT_OBJECT_PUT_REF_AND_RESET(type_copy);
if (ret_int < 0) {
BT_LOGE_STR("Failed to set event_contexttype.");
goto error;
}
}
- BT_PUT(type);
+ BT_OBJECT_PUT_REF_AND_RESET(type);
goto end;
error:
- BT_PUT(writer_stream_class);
+ BT_STREAM_CLASS_PUT_REF_AND_RESET(writer_stream_class);
end:
- bt_put(type);
- bt_put(type_copy);
+ bt_object_put_ref(type);
+ bt_object_put_ref(type_copy);
return writer_stream_class;
}
BT_HIDDEN
-int ctf_stream_copy_packet_header(FILE *err, struct bt_packet *packet,
- struct bt_stream *writer_stream)
+int ctf_stream_copy_packet_header(FILE *err, const bt_packet *packet,
+ const bt_stream *writer_stream)
{
- struct bt_field *packet_header = NULL, *writer_packet_header = NULL;
+ const bt_field *packet_header = NULL, *writer_packet_header = NULL;
int ret = 0;
packet_header = bt_packet_get_header(packet);
error:
ret = -1;
end:
- bt_put(writer_packet_header);
- bt_put(packet_header);
+ bt_object_put_ref(writer_packet_header);
+ bt_object_put_ref(packet_header);
return ret;
}
BT_HIDDEN
-int ctf_packet_copy_header(FILE *err, struct bt_packet *packet,
- struct bt_packet *writer_packet)
+int ctf_packet_copy_header(FILE *err, const bt_packet *packet,
+ const bt_packet *writer_packet)
{
- struct bt_field *packet_header = NULL, *writer_packet_header = NULL;
+ const bt_field *packet_header = NULL, *writer_packet_header = NULL;
int ret = 0;
packet_header = bt_packet_get_header(packet);
error:
ret = -1;
end:
- bt_put(packet_header);
- bt_put(writer_packet_header);
+ bt_object_put_ref(packet_header);
+ bt_object_put_ref(writer_packet_header);
return ret;
}
BT_HIDDEN
-int ctf_stream_copy_packet_context(FILE *err, struct bt_packet *packet,
- struct bt_stream *writer_stream)
+int ctf_stream_copy_packet_context(FILE *err, const bt_packet *packet,
+ const bt_stream *writer_stream)
{
- struct bt_field *packet_context = NULL, *writer_packet_context = NULL;
+ const bt_field *packet_context = NULL, *writer_packet_context = NULL;
int ret = 0;
packet_context = bt_packet_get_context(packet);
error:
ret = -1;
end:
- bt_put(packet_context);
- bt_put(writer_packet_context);
+ bt_object_put_ref(packet_context);
+ bt_object_put_ref(writer_packet_context);
return ret;
}
BT_HIDDEN
-int ctf_packet_copy_context(FILE *err, struct bt_packet *packet,
- struct bt_stream *writer_stream,
- struct bt_packet *writer_packet)
+int ctf_packet_copy_context(FILE *err, const bt_packet *packet,
+ const bt_stream *writer_stream,
+ const bt_packet *writer_packet)
{
- struct bt_field *packet_context = NULL, *writer_packet_context = NULL;
+ const bt_field *packet_context = NULL, *writer_packet_context = NULL;
int ret = 0;
packet_context = bt_packet_get_context(packet);
error:
ret = -1;
end:
- bt_put(writer_packet_context);
- bt_put(packet_context);
+ bt_object_put_ref(writer_packet_context);
+ bt_object_put_ref(packet_context);
return ret;
}
BT_HIDDEN
-int ctf_copy_event_header(FILE *err, struct bt_event *event,
- struct bt_event_class *writer_event_class,
- struct bt_event *writer_event,
- struct bt_field *event_header)
+int ctf_copy_event_header(FILE *err, const bt_event *event,
+ const bt_event_class *writer_event_class,
+ const bt_event *writer_event,
+ const bt_field *event_header)
{
- struct bt_clock_class *clock_class = NULL, *writer_clock_class = NULL;
- struct bt_clock_value *clock_value = NULL, *writer_clock_value = NULL;
+ const bt_clock_class *clock_class = NULL, *writer_clock_class = NULL;
+ bt_clock_snapshot *clock_snapshot = NULL, *writer_clock_snapshot = NULL;
int ret;
- struct bt_field *writer_event_header = NULL;
+ const bt_field *writer_event_header = NULL;
uint64_t value;
clock_class = event_get_clock_class(err, event);
goto error;
}
- clock_value = bt_event_get_clock_value(event, clock_class);
- BT_PUT(clock_class);
- assert(clock_value);
+ clock_snapshot = bt_event_get_clock_snapshot(event, clock_class);
+ BT_CLOCK_CLASS_PUT_REF_AND_RESET(clock_class);
+ BT_ASSERT(clock_snapshot);
- ret = bt_clock_value_get_value(clock_value, &value);
- BT_PUT(clock_value);
+ ret = bt_clock_snapshot_get_value(clock_snapshot, &value);
+ BT_OBJECT_PUT_REF_AND_RESET(clock_snapshot);
if (ret) {
BT_LOGE_STR("Failed to get clock value.");
goto error;
goto error;
}
- writer_clock_value = bt_clock_value_create(writer_clock_class, value);
- BT_PUT(writer_clock_class);
- if (!writer_clock_value) {
+ writer_clock_snapshot = bt_clock_snapshot_create(writer_clock_class, value);
+ BT_CLOCK_CLASS_PUT_REF_AND_RESET(writer_clock_class);
+ if (!writer_clock_snapshot) {
BT_LOGE_STR("Failed to create clock value.");
goto error;
}
- ret = bt_event_set_clock_value(writer_event, writer_clock_value);
- BT_PUT(writer_clock_value);
+ ret = bt_event_set_clock_snapshot(writer_event, writer_clock_snapshot);
+ BT_OBJECT_PUT_REF_AND_RESET(writer_clock_snapshot);
if (ret) {
BT_LOGE_STR("Failed to set clock value.");
goto error;
}
ret = bt_event_set_header(writer_event, writer_event_header);
- BT_PUT(writer_event_header);
+ BT_OBJECT_PUT_REF_AND_RESET(writer_event_header);
if (ret < 0) {
BT_LOGE_STR("Failed to set event_header.");
goto error;
}
static
-struct bt_trace *event_class_get_trace(FILE *err,
- struct bt_event_class *event_class)
+const bt_trace *event_class_get_trace(FILE *err,
+ const bt_event_class *event_class)
{
- struct bt_trace *trace = NULL;
- struct bt_stream_class *stream_class = NULL;
+ const bt_trace *trace = NULL;
+ const bt_stream_class *stream_class = NULL;
stream_class = bt_event_class_get_stream_class(event_class);
- assert(stream_class);
+ BT_ASSERT(stream_class);
trace = bt_stream_class_get_trace(stream_class);
- assert(trace);
+ BT_ASSERT(trace);
- bt_put(stream_class);
+ bt_stream_class_put_ref(stream_class);
return trace;
}
BT_HIDDEN
-struct bt_event *ctf_copy_event(FILE *err, struct bt_event *event,
- struct bt_event_class *writer_event_class,
+const bt_event *ctf_copy_event(FILE *err, const bt_event *event,
+ const bt_event_class *writer_event_class,
bool override_ts64)
{
- struct bt_event *writer_event = NULL;
- struct bt_field *field = NULL, *copy_field = NULL;
- struct bt_trace *writer_trace = NULL;
+ const bt_event *writer_event = NULL;
+ const bt_field *field = NULL, *copy_field = NULL;
+ const bt_trace *writer_trace = NULL;
int ret;
writer_event = bt_event_create(writer_event_class);
* is.
*/
ret = bt_trace_get_clock_class_count(writer_trace);
- assert(ret >= 0);
+ BT_ASSERT(ret >= 0);
if (override_ts64 && ret > 0) {
copy_field = bt_event_get_header(writer_event);
- assert(copy_field);
+ BT_ASSERT(copy_field);
ret = copy_override_field(err, event, writer_event, field,
copy_field);
BT_LOGE_STR("Failed to copy and override field.");
goto error;
}
- BT_PUT(copy_field);
+ BT_OBJECT_PUT_REF_AND_RESET(copy_field);
} else {
ret = ctf_copy_event_header(err, event, writer_event_class,
writer_event, field);
goto error;
}
}
- BT_PUT(field);
+ BT_OBJECT_PUT_REF_AND_RESET(field);
}
/* Optional field, so it can fail silently. */
BT_LOGE_STR("Failed to set stream_event_context.");
goto error;
}
- BT_PUT(field);
- BT_PUT(copy_field);
+ BT_OBJECT_PUT_REF_AND_RESET(field);
+ BT_OBJECT_PUT_REF_AND_RESET(copy_field);
}
/* Optional field, so it can fail silently. */
BT_LOGE_STR("Failed to set event_context.");
goto error;
}
- BT_PUT(field);
- BT_PUT(copy_field);
+ BT_OBJECT_PUT_REF_AND_RESET(field);
+ BT_OBJECT_PUT_REF_AND_RESET(copy_field);
}
field = bt_event_get_event_payload(event);
BT_LOGE_STR("Failed to set event_payload.");
goto error;
}
- BT_PUT(field);
- BT_PUT(copy_field);
+ BT_OBJECT_PUT_REF_AND_RESET(field);
+ BT_OBJECT_PUT_REF_AND_RESET(copy_field);
}
goto end;
error:
- BT_PUT(writer_event);
+ BT_OBJECT_PUT_REF_AND_RESET(writer_event);
end:
- bt_put(field);
- bt_put(copy_field);
- bt_put(writer_trace);
+ bt_object_put_ref(field);
+ bt_object_put_ref(copy_field);
+ bt_trace_put_ref(writer_trace);
return writer_event;
}
BT_HIDDEN
-enum bt_component_status ctf_copy_trace(FILE *err, struct bt_trace *trace,
- struct bt_trace *writer_trace)
+bt_component_status ctf_copy_trace(FILE *err, const bt_trace *trace,
+ const bt_trace *writer_trace)
{
- enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
+ bt_component_status ret = BT_COMPONENT_STATUS_OK;
int field_count, i, int_ret;
- struct bt_field_type *header_type = NULL;
- enum bt_byte_order order;
+ bt_field_type *header_type = NULL;
+ bt_byte_order order;
const char *trace_name;
const unsigned char *trace_uuid;
for (i = 0; i < field_count; i++) {
int ret_int;
const char *name;
- struct bt_value *value = NULL;
+ bt_value *value = NULL;
name = bt_trace_get_environment_field_name_by_index(
trace, i);
- assert(name);
+ BT_ASSERT(name);
value = bt_trace_get_environment_field_value_by_index(
trace, i);
- assert(value);
+ BT_ASSERT(value);
ret_int = bt_trace_set_environment_field(writer_trace,
name, value);
- BT_PUT(value);
+ BT_VALUE_PUT_REF_AND_RESET(value);
if (ret_int < 0) {
BT_LOGE("Failed to set environment: field-name=\"%s\"",
name);
}
order = bt_trace_get_native_byte_order(trace);
- assert(order != BT_BYTE_ORDER_UNKNOWN);
+ BT_ASSERT(order != BT_BYTE_ORDER_UNKNOWN);
/*
* Only explicitly set the writer trace's native byte order if
header_type = bt_trace_get_packet_header_type(trace);
if (header_type) {
int_ret = bt_trace_set_packet_header_type(writer_trace, header_type);
- BT_PUT(header_type);
+ BT_OBJECT_PUT_REF_AND_RESET(header_type);
if (int_ret < 0) {
BT_LOGE_STR("Failed to set packet header type.");
ret = BT_COMPONENT_STATUS_ERROR;
projects / babeltrace.git / blobdiff