struct bt_self_notification_iterator *notification_iterator,
struct bt_clock_class *default_clock_class);
-extern int bt_private_notification_inactivity_set_default_clock_value(
+extern void bt_private_notification_inactivity_set_default_clock_value(
struct bt_private_notification *notif, uint64_t raw_value);
#ifdef __cplusplus
bt_private_notification_stream_begin_borrow_stream(
struct bt_private_notification *notification);
-extern int bt_private_notification_stream_begin_set_default_clock_value(
+extern void bt_private_notification_stream_begin_set_default_clock_value(
struct bt_private_notification *notif, uint64_t value_cycles);
extern struct bt_private_stream *
bt_private_notification_stream_end_borrow_stream(
struct bt_private_notification *notification);
-extern int bt_private_notification_stream_end_set_default_clock_value(
+extern void bt_private_notification_stream_end_set_default_clock_value(
struct bt_private_notification *notif, uint64_t value_cycles);
#ifdef __cplusplus
enum bt_self_component_port_status {
BT_SELF_PORT_STATUS_OK = 0,
- BT_SELF_PORT_STATUS_ERROR = -1,
};
static inline
struct bt_private_clock_class *clock_class,
const char *description);
-extern int bt_private_clock_class_set_frequency(
+extern void bt_private_clock_class_set_frequency(
struct bt_private_clock_class *clock_class, uint64_t freq);
-extern int bt_private_clock_class_set_precision(
+extern void bt_private_clock_class_set_precision(
struct bt_private_clock_class *clock_class,
uint64_t precision);
-extern int bt_private_clock_class_set_offset(
+extern void bt_private_clock_class_set_offset(
struct bt_private_clock_class *clock_class,
int64_t seconds, uint64_t cycles);
-extern int bt_private_clock_class_set_is_absolute(
+extern void bt_private_clock_class_set_is_absolute(
struct bt_private_clock_class *clock_class,
bt_bool is_absolute);
-extern int bt_private_clock_class_set_uuid(
+extern void bt_private_clock_class_set_uuid(
struct bt_private_clock_class *clock_class, bt_uuid uuid);
#ifdef __cplusplus
extern int bt_private_event_class_set_name(
struct bt_private_event_class *event_class, const char *name);
-extern int bt_private_event_class_set_log_level(
+extern void bt_private_event_class_set_log_level(
struct bt_private_event_class *event_class,
enum bt_event_class_log_level log_level);
extern struct bt_private_field *bt_private_event_borrow_payload_field(
struct bt_private_event *event);
-extern int bt_private_event_set_default_clock_value(
+extern void bt_private_event_set_default_clock_value(
struct bt_private_event *event, uint64_t value_cycles);
#ifdef __cplusplus
extern struct bt_private_field_class *
bt_private_field_class_signed_integer_create(void);
-extern int bt_private_field_class_integer_set_field_value_range(
+extern void bt_private_field_class_integer_set_field_value_range(
struct bt_private_field_class *field_class, uint64_t size);
-extern int bt_private_field_class_integer_set_preferred_display_base(
+extern void bt_private_field_class_integer_set_preferred_display_base(
struct bt_private_field_class *field_class,
enum bt_field_class_integer_preferred_display_base base);
extern struct bt_private_field_class *bt_private_field_class_real_create(void);
-extern int bt_private_field_class_real_set_is_single_precision(
+extern void bt_private_field_class_real_set_is_single_precision(
struct bt_private_field_class *field_class,
bt_bool is_single_precision);
struct bt_private_packet_context_field *context);
extern
-int bt_private_packet_set_default_beginning_clock_value(
+void bt_private_packet_set_default_beginning_clock_value(
struct bt_private_packet *packet, uint64_t value_cycles);
extern
-int bt_private_packet_set_default_end_clock_value(
+void bt_private_packet_set_default_end_clock_value(
struct bt_private_packet *packet, uint64_t value_cycles);
extern
-int bt_private_packet_set_discarded_event_counter_snapshot(
+void bt_private_packet_set_discarded_event_counter_snapshot(
struct bt_private_packet *packet, uint64_t value);
extern
-int bt_private_packet_set_packet_counter_snapshot(
+void bt_private_packet_set_packet_counter_snapshot(
struct bt_private_packet *packet, uint64_t value);
#ifdef __cplusplus
struct bt_private_stream_class *stream_class,
const char *name);
-extern int bt_private_stream_class_set_assigns_automatic_event_class_id(
+extern void bt_private_stream_class_set_assigns_automatic_event_class_id(
struct bt_private_stream_class *stream_class, bt_bool value);
-extern int bt_private_stream_class_set_assigns_automatic_stream_id(
+extern void bt_private_stream_class_set_assigns_automatic_stream_id(
struct bt_private_stream_class *stream_class, bt_bool value);
extern struct bt_private_field_class *
extern bt_bool bt_private_stream_class_default_clock_is_always_known(
struct bt_private_stream_class *stream_class);
-extern int
+extern void
bt_private_stream_class_set_packets_have_discarded_event_counter_snapshot(
struct bt_private_stream_class *stream_class, bt_bool value);
-extern int
+extern void
bt_private_stream_class_set_packets_have_packet_counter_snapshot(
struct bt_private_stream_class *stream_class, bt_bool value);
-extern int
+extern void
bt_private_stream_class_set_packets_have_default_beginning_clock_value(
struct bt_private_stream_class *stream_class, bt_bool value);
-extern int
+extern void
bt_private_stream_class_set_packets_have_default_end_clock_value(
struct bt_private_stream_class *stream_class, bt_bool value);
extern struct bt_private_trace *bt_private_trace_create(void);
-extern int bt_private_trace_set_assigns_automatic_stream_class_id(
+extern void bt_private_trace_set_assigns_automatic_stream_class_id(
struct bt_private_trace *trace, bt_bool value);
extern int bt_private_trace_set_name(struct bt_private_trace *trace,
const char *name);
-extern int bt_private_trace_set_uuid(struct bt_private_trace *trace,
+extern void bt_private_trace_set_uuid(struct bt_private_trace *trace,
bt_uuid uuid);
extern void bt_private_trace_borrow_environment_entry_by_index(
return (void *) ret_notif;
}
-int bt_private_notification_inactivity_set_default_clock_value(
+void bt_private_notification_inactivity_set_default_clock_value(
struct bt_private_notification *priv_notif,
uint64_t value_cycles)
{
bt_clock_value_set_value_inline(inactivity->default_cv, value_cycles);
BT_LIB_LOGV("Set inactivity notification's default clock value: "
"%![notif-]+n, value=%" PRIu64, notif, value_cycles);
- return 0;
}
struct bt_clock_value *bt_notification_inactivity_borrow_default_clock_value(
(void *) notification);
}
-int bt_private_notification_stream_end_set_default_clock_value(
+void bt_private_notification_stream_end_set_default_clock_value(
struct bt_private_notification *priv_notif,
uint64_t value_cycles)
{
- int ret = 0;
struct bt_notification *notif = (void *) priv_notif;
struct bt_notification_stream_end *se_notif = (void *) notif;
"Notification's stream class has no default clock class: "
"%![notif-]+n, %![sc-]+S", notif, se_notif->stream->class);
- if (!se_notif->default_cv) {
- se_notif->default_cv = bt_clock_value_create(
- se_notif->stream->class->default_clock_class);
- if (!se_notif->default_cv) {
- ret = -1;
- goto end;
- }
- }
-
+ /* TODO: have the object already created */
+ se_notif->default_cv = bt_clock_value_create(
+ se_notif->stream->class->default_clock_class);
+ BT_ASSERT(se_notif->default_cv);
bt_clock_value_set_value_inline(se_notif->default_cv, value_cycles);
BT_LIB_LOGV("Set notification's default clock value: %![notif-]+n, "
"value=%" PRIu64, value_cycles);
-
-end:
- return ret;
}
struct bt_clock_value *bt_notification_stream_end_borrow_default_clock_value(
(void *) notification);
}
-int bt_private_notification_stream_begin_set_default_clock_value(
+void bt_private_notification_stream_begin_set_default_clock_value(
struct bt_private_notification *priv_notif,
uint64_t value_cycles)
{
- int ret = 0;
struct bt_notification *notif = (void *) priv_notif;
struct bt_notification_stream_begin *sb_notif = (void *) notif;
"Notification's stream class has no default clock class: "
"%![notif-]+n, %![sc-]+S", notif, sb_notif->stream->class);
- if (!sb_notif->default_cv) {
- sb_notif->default_cv = bt_clock_value_create(
- sb_notif->stream->class->default_clock_class);
- if (!sb_notif->default_cv) {
- ret = -1;
- goto end;
- }
- }
-
+ /* TODO: have the object already created */
+ sb_notif->default_cv = bt_clock_value_create(
+ sb_notif->stream->class->default_clock_class);
+ BT_ASSERT(sb_notif->default_cv);
bt_clock_value_set_value_inline(sb_notif->default_cv, value_cycles);
BT_LIB_LOGV("Set notification's default clock value: %![notif-]+n, "
"value=%" PRIu64, value_cycles);
-
-end:
- return ret;
}
struct bt_clock_value *bt_notification_stream_begin_borrow_default_clock_value(
return clock_class->frequency;
}
-int bt_private_clock_class_set_frequency(
+void bt_private_clock_class_set_frequency(
struct bt_private_clock_class *priv_clock_class,
uint64_t frequency)
{
clock_class->frequency = frequency;
set_base_offset(clock_class);
BT_LIB_LOGV("Set clock class's frequency: %!+K", clock_class);
- return 0;
}
uint64_t bt_clock_class_get_precision(struct bt_clock_class *clock_class)
return clock_class->precision;
}
-int bt_private_clock_class_set_precision(
+void bt_private_clock_class_set_precision(
struct bt_private_clock_class *priv_clock_class,
uint64_t precision)
{
clock_class, precision);
clock_class->precision = precision;
BT_LIB_LOGV("Set clock class's precision: %!+K", clock_class);
- return 0;
}
void bt_clock_class_get_offset(struct bt_clock_class *clock_class,
*cycles = clock_class->offset_cycles;
}
-int bt_private_clock_class_set_offset(
+void bt_private_clock_class_set_offset(
struct bt_private_clock_class *priv_clock_class,
int64_t seconds, uint64_t cycles)
{
clock_class->offset_cycles = cycles;
set_base_offset(clock_class);
BT_LIB_LOGV("Set clock class's offset: %!+K", clock_class);
- return 0;
}
bt_bool bt_clock_class_is_absolute(struct bt_clock_class *clock_class)
return (bool) clock_class->is_absolute;
}
-int bt_private_clock_class_set_is_absolute(
+void bt_private_clock_class_set_is_absolute(
struct bt_private_clock_class *priv_clock_class,
bt_bool is_absolute)
{
clock_class->is_absolute = (bool) is_absolute;
BT_LIB_LOGV("Set clock class's absolute property: %!+K",
clock_class);
- return 0;
}
bt_uuid bt_clock_class_get_uuid(struct bt_clock_class *clock_class)
return clock_class->uuid.value;
}
-int bt_private_clock_class_set_uuid(
+void bt_private_clock_class_set_uuid(
struct bt_private_clock_class *priv_clock_class,
bt_uuid uuid)
{
memcpy(clock_class->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
clock_class->uuid.value = clock_class->uuid.uuid;
BT_LIB_LOGV("Set clock class's UUID: %!+K", clock_class);
- return 0;
}
BT_HIDDEN
return event_class->log_level.base.avail;
}
-int bt_private_event_class_set_log_level(
+void bt_private_event_class_set_log_level(
struct bt_private_event_class *priv_event_class,
enum bt_event_class_log_level log_level)
{
bt_property_uint_set(&event_class->log_level,
(uint64_t) log_level);
BT_LIB_LOGV("Set event class's log level: %!+E", event_class);
- return 0;
}
const char *bt_event_class_get_emf_uri(struct bt_event_class *event_class)
g_free(event);
}
-int bt_private_event_set_default_clock_value(
+void bt_private_event_set_default_clock_value(
struct bt_private_event *priv_event, uint64_t value_cycles)
{
struct bt_event *event = (void *) priv_event;
bt_clock_value_set_value_inline(event->default_cv, value_cycles);
BT_LIB_LOGV("Set event's default clock value: %![event-]+e, "
"value=%" PRIu64, event, value_cycles);
- return 0;
}
enum bt_clock_value_status bt_event_borrow_default_clock_value(
return true;
}
-int bt_private_field_class_integer_set_field_value_range(
+void bt_private_field_class_integer_set_field_value_range(
struct bt_private_field_class *priv_fc, uint64_t size)
{
struct bt_field_class *fc = (void *) priv_fc;
"which are outside this range: %!+F, size=%" PRIu64, fc, size);
int_fc->range = size;
BT_LIB_LOGV("Set integer field class's field value range: %!+F", fc);
- return 0;
}
enum bt_field_class_integer_preferred_display_base
return int_fc->base;
}
-int bt_private_field_class_integer_set_preferred_display_base(
+void bt_private_field_class_integer_set_preferred_display_base(
struct bt_private_field_class *priv_fc,
enum bt_field_class_integer_preferred_display_base base)
{
BT_ASSERT_PRE_FC_HOT(fc, "Field class");
int_fc->base = base;
BT_LIB_LOGV("Set integer field class's preferred display base: %!+F", fc);
- return 0;
}
static
return real_fc->is_single_precision;
}
-int bt_private_field_class_real_set_is_single_precision(
+void bt_private_field_class_real_set_is_single_precision(
struct bt_private_field_class *priv_fc,
bt_bool is_single_precision)
{
real_fc->is_single_precision = (bool) is_single_precision;
BT_LIB_LOGV("Set real field class's \"is single precision\" property: "
"%!+F", fc);
- return 0;
}
static
return 0;
}
-int bt_private_packet_set_default_beginning_clock_value(
+void bt_private_packet_set_default_beginning_clock_value(
struct bt_private_packet *priv_packet,
uint64_t value_cycles)
{
"no default beginning clock value: %![packet-]+a, %![sc-]+S",
packet, sc);
BT_ASSERT(packet->default_beginning_cv);
- bt_clock_value_set_value_inline(packet->default_beginning_cv, value_cycles);
+ bt_clock_value_set_value_inline(packet->default_beginning_cv,
+ value_cycles);
BT_LIB_LOGV("Set packet's default beginning clock value: "
"%![packet-]+a, value=%" PRIu64, packet, value_cycles);
- return 0;
}
enum bt_clock_value_status bt_packet_borrow_default_beginning_clock_value(
return BT_CLOCK_VALUE_STATUS_KNOWN;
}
-int bt_private_packet_set_default_end_clock_value(
+void bt_private_packet_set_default_end_clock_value(
struct bt_private_packet *priv_packet,
uint64_t value_cycles)
{
bt_clock_value_set_value_inline(packet->default_end_cv, value_cycles);
BT_LIB_LOGV("Set packet's default end clock value: "
"%![packet-]+a, value=%" PRIu64, packet, value_cycles);
- return 0;
}
enum bt_clock_value_status bt_packet_borrow_default_end_clock_value(
return packet->discarded_event_counter_snapshot.base.avail;
}
-int bt_private_packet_set_discarded_event_counter_snapshot(
+void bt_private_packet_set_discarded_event_counter_snapshot(
struct bt_private_packet *priv_packet, uint64_t value)
{
struct bt_packet *packet = (void *) priv_packet;
"Packet's stream's discarded event counter is not enabled: "
"%![packet-]+a", packet);
bt_property_uint_set(&packet->discarded_event_counter_snapshot, value);
- return 0;
}
enum bt_property_availability bt_packet_get_packet_counter_snapshot(
return packet->packet_counter_snapshot.base.avail;
}
-int bt_private_packet_set_packet_counter_snapshot(
+void bt_private_packet_set_packet_counter_snapshot(
struct bt_private_packet *priv_packet, uint64_t value)
{
struct bt_packet *packet = (void *) priv_packet;
"Packet's stream's packet counter is not enabled: "
"%![packet-]+a", packet);
bt_property_uint_set(&packet->packet_counter_snapshot, value);
- return 0;
}
return (bt_bool) stream_class->assigns_automatic_event_class_id;
}
-int bt_private_stream_class_set_assigns_automatic_event_class_id(
+void bt_private_stream_class_set_assigns_automatic_event_class_id(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
stream_class->assigns_automatic_event_class_id = (bool) value;
BT_LIB_LOGV("Set stream class's automatic event class ID "
"assignment property: %!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_assigns_automatic_stream_id(
return (bt_bool) stream_class->assigns_automatic_stream_id;
}
-int bt_private_stream_class_set_assigns_automatic_stream_id(
+void bt_private_stream_class_set_assigns_automatic_stream_id(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
stream_class->assigns_automatic_stream_id = (bool) value;
BT_LIB_LOGV("Set stream class's automatic stream ID "
"assignment property: %!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_packets_have_discarded_event_counter_snapshot(
return (bt_bool) stream_class->packets_have_discarded_event_counter_snapshot;
}
-int bt_private_stream_class_set_packets_have_discarded_event_counter_snapshot(
+void bt_private_stream_class_set_packets_have_discarded_event_counter_snapshot(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
BT_LIB_LOGV("Set stream class's "
"\"packets have discarded event counter snapshot\" property: "
"%!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_packets_have_packet_counter_snapshot(
return (bt_bool) stream_class->packets_have_packet_counter_snapshot;
}
-int bt_private_stream_class_set_packets_have_packet_counter_snapshot(
+void bt_private_stream_class_set_packets_have_packet_counter_snapshot(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
BT_LIB_LOGV("Set stream class's "
"\"packets have packet counter snapshot\" property: "
"%!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_packets_have_default_beginning_clock_value(
return (bt_bool) stream_class->packets_have_default_beginning_cv;
}
-int bt_private_stream_class_set_packets_have_default_beginning_clock_value(
+void bt_private_stream_class_set_packets_have_default_beginning_clock_value(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
BT_LIB_LOGV("Set stream class's "
"\"packets have default beginning clock value\" property: "
"%!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_packets_have_default_end_clock_value(
return (bt_bool) stream_class->packets_have_default_end_cv;
}
-int bt_private_stream_class_set_packets_have_default_end_clock_value(
+void bt_private_stream_class_set_packets_have_default_end_clock_value(
struct bt_private_stream_class *priv_stream_class,
bt_bool value)
{
BT_LIB_LOGV("Set stream class's "
"\"packets have default end clock value\" property: "
"%!+S", stream_class);
- return 0;
}
bt_bool bt_stream_class_default_clock_is_always_known(
return trace->uuid.value;
}
-int bt_private_trace_set_uuid(struct bt_private_trace *priv_trace, bt_uuid uuid)
+void bt_private_trace_set_uuid(struct bt_private_trace *priv_trace,
+ bt_uuid uuid)
{
struct bt_trace *trace = (void *) priv_trace;
memcpy(trace->uuid.uuid, uuid, BABELTRACE_UUID_LEN);
trace->uuid.value = trace->uuid.uuid;
BT_LIB_LOGV("Set trace's UUID: %!+t", trace);
- return 0;
}
BT_ASSERT_FUNC
return (bt_bool) trace->assigns_automatic_stream_class_id;
}
-int bt_private_trace_set_assigns_automatic_stream_class_id(
+void bt_private_trace_set_assigns_automatic_stream_class_id(
struct bt_private_trace *priv_trace, bt_bool value)
{
struct bt_trace *trace = (void *) priv_trace;
trace->assigns_automatic_stream_class_id = (bool) value;
BT_LIB_LOGV("Set trace's automatic stream class ID "
"assignment property: %!+t", trace);
- return 0;
}
BT_HIDDEN
void ctf_field_class_int_set_props(struct ctf_field_class_int *fc,
struct bt_private_field_class *ir_fc)
{
- int ret;
-
- ret = bt_private_field_class_integer_set_field_value_range(ir_fc,
+ bt_private_field_class_integer_set_field_value_range(ir_fc,
fc->base.size);
- BT_ASSERT(ret == 0);
- ret = bt_private_field_class_integer_set_preferred_display_base(ir_fc,
+ bt_private_field_class_integer_set_preferred_display_base(ir_fc,
fc->disp_base);
- BT_ASSERT(ret == 0);
}
static inline
struct ctf_field_class_float *fc)
{
struct bt_private_field_class *ir_fc;
- int ret;
ir_fc = bt_private_field_class_real_create();
BT_ASSERT(ir_fc);
if (fc->base.size == 32) {
- ret = bt_private_field_class_real_set_is_single_precision(ir_fc,
+ bt_private_field_class_real_set_is_single_precision(ir_fc,
BT_TRUE);
- BT_ASSERT(ret == 0);
}
return ir_fc;
}
if (ec->log_level != -1) {
- ret = bt_private_event_class_set_log_level(ir_ec, ec->log_level);
- BT_ASSERT(ret == 0);
+ bt_private_event_class_set_log_level(ir_ec, ec->log_level);
}
ec->is_translated = true;
}
}
- ret = bt_private_stream_class_set_assigns_automatic_event_class_id(ir_sc,
+ bt_private_stream_class_set_assigns_automatic_event_class_id(ir_sc,
BT_FALSE);
- BT_ASSERT(ret == 0);
- ret = bt_private_stream_class_set_assigns_automatic_stream_id(ir_sc, BT_FALSE);
- BT_ASSERT(ret == 0);
+ bt_private_stream_class_set_assigns_automatic_stream_id(ir_sc, BT_FALSE);
if (sc->default_clock_class) {
ret = bt_private_stream_class_set_default_clock_class(ir_sc,
"events_discarded");
if (int_fc) {
if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_DISC_EV_REC_COUNTER_SNAPSHOT) {
- ret = bt_private_stream_class_set_packets_have_discarded_event_counter_snapshot(
+ bt_private_stream_class_set_packets_have_discarded_event_counter_snapshot(
ir_sc, BT_TRUE);
- BT_ASSERT(ret == 0);
}
}
"packet_seq_num");
if (int_fc) {
if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_PACKET_COUNTER_SNAPSHOT) {
- ret = bt_private_stream_class_set_packets_have_packet_counter_snapshot(
+ bt_private_stream_class_set_packets_have_packet_counter_snapshot(
ir_sc, BT_TRUE);
- BT_ASSERT(ret == 0);
}
}
"timestamp_begin");
if (int_fc) {
if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_PACKET_BEGINNING_TIME) {
- ret = bt_private_stream_class_set_packets_have_default_beginning_clock_value(
+ bt_private_stream_class_set_packets_have_default_beginning_clock_value(
ir_sc, BT_TRUE);
- BT_ASSERT(ret == 0);
}
}
"timestamp_end");
if (int_fc) {
if (int_fc->meaning == CTF_FIELD_CLASS_MEANING_PACKET_END_TIME) {
- ret = bt_private_stream_class_set_packets_have_default_end_clock_value(
+ bt_private_stream_class_set_packets_have_default_end_clock_value(
ir_sc, BT_TRUE);
- BT_ASSERT(ret == 0);
}
}
}
if (tc->is_uuid_set) {
- ret = bt_private_trace_set_uuid(ir_trace, tc->uuid);
- if (ret) {
- goto end;
- }
+ bt_private_trace_set_uuid(ir_trace, tc->uuid);
}
for (i = 0; i < tc->env_entries->len; i++) {
}
}
- ret = bt_private_trace_set_assigns_automatic_stream_class_id(ir_trace,
+ bt_private_trace_set_assigns_automatic_stream_class_id(ir_trace,
BT_FALSE);
- if (ret) {
- goto end;
- }
-
tc->is_translated = true;
tc->ir_tc = ir_trace;
*/
clock_class_to_map_to = bt_private_clock_class_create();
BT_ASSERT(clock_class_to_map_to);
- ret = bt_private_clock_class_set_frequency(clock_class_to_map_to,
+ bt_private_clock_class_set_frequency(clock_class_to_map_to,
UINT64_C(1000000000));
- BT_ASSERT(ret == 0);
ret = bt_private_clock_class_set_name(clock_class_to_map_to,
"default");
BT_ASSERT(ret == 0);
goto error;
}
- ret = bt_private_clock_class_set_uuid(clock, uuid);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "Cannot set clock class's UUID.");
- goto error;
- }
-
+ bt_private_clock_class_set_uuid(clock, uuid);
_SET(set, _CLOCK_UUID_SET);
} else if (!strcmp(left, "description")) {
char *right;
goto error;
}
- ret = bt_private_clock_class_set_frequency(clock, freq);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "Cannot set clock class's frequency.");
- goto error;
- }
-
+ bt_private_clock_class_set_frequency(clock, freq);
_SET(set, _CLOCK_FREQ_SET);
} else if (!strcmp(left, "precision")) {
uint64_t precision;
goto error;
}
- ret = bt_private_clock_class_set_precision(clock, precision);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "Cannot set clock class's precision.");
- goto error;
- }
-
+ bt_private_clock_class_set_precision(clock, precision);
_SET(set, _CLOCK_PRECISION_SET);
} else if (!strcmp(left, "offset_s")) {
if (_IS_SET(set, _CLOCK_OFFSET_S_SET)) {
goto error;
}
- ret = bt_private_clock_class_set_is_absolute(clock, ret);
- if (ret) {
- _BT_LOGE_NODE(entry_node,
- "Cannot set clock class's absolute flag.");
- goto error;
- }
-
+ bt_private_clock_class_set_is_absolute(clock, ret);
_SET(set, _CLOCK_ABSOLUTE_SET);
} else {
_BT_LOGW_NODE(entry_node,
void apply_clock_class_offset(struct ctx *ctx,
struct bt_private_clock_class *clock)
{
- int ret;
uint64_t freq;
int64_t offset_s_to_apply = ctx->decoder_config.clock_class_offset_s;
uint64_t offset_ns_to_apply;
calibrate_clock_class_offsets(&cur_offset_s, &cur_offset_cycles, freq);
/* Set final offsets */
- ret = bt_private_clock_class_set_offset(clock, cur_offset_s, cur_offset_cycles);
- BT_ASSERT(ret == 0);
+ bt_private_clock_class_set_offset(clock, cur_offset_s, cur_offset_cycles);
end:
return;
}
/* CTF: not absolute by default */
- ret = bt_private_clock_class_set_is_absolute(clock, BT_FALSE);
- if (ret) {
- _BT_LOGE_NODE(clock_node,
- "Cannot set clock class's absolute flag.");
- goto end;
- }
+ bt_private_clock_class_set_is_absolute(clock, BT_FALSE);
bt_list_for_each_entry(entry_node, decl_list, siblings) {
ret = visit_clock_decl_entry(ctx, entry_node, clock, &set,
* it's a condition to be able to sort notifications
* from different sources.
*/
- ret = bt_private_clock_class_set_is_absolute(clock, BT_TRUE);
- if (ret) {
- _BT_LOGE_NODE(clock_node,
- "Cannot set clock class's absolute flag.");
- goto end;
- }
+ bt_private_clock_class_set_is_absolute(clock, BT_TRUE);
}
/*
calibrate_clock_class_offsets(&offset_seconds, &offset_cycles, freq);
BT_ASSERT(offset_cycles < bt_clock_class_get_frequency(
bt_private_clock_class_borrow_clock_class(clock)));
- ret = bt_private_clock_class_set_offset(clock, offset_seconds, offset_cycles);
- BT_ASSERT(ret == 0);
+ bt_private_clock_class_set_offset(clock, offset_seconds, offset_cycles);
apply_clock_class_offset(ctx, clock);
g_ptr_array_add(ctx->ctf_tc->clock_classes, bt_object_get_ref(clock));
BT_ASSERT(event);
if (bt_stream_class_borrow_default_clock_class(sc)) {
- int ret = bt_private_event_set_default_clock_value(event,
+ bt_private_event_set_default_clock_value(event,
notit->default_clock_val);
-
- BT_ASSERT(ret == 0);
}
}
if (bt_stream_class_packets_have_discarded_event_counter_snapshot(sc)) {
BT_ASSERT(notit->snapshots.discarded_events != UINT64_C(-1));
- ret = bt_private_packet_set_discarded_event_counter_snapshot(
+ bt_private_packet_set_discarded_event_counter_snapshot(
notit->packet, notit->snapshots.discarded_events);
- BT_ASSERT(ret == 0);
}
if (bt_stream_class_packets_have_packet_counter_snapshot(sc)) {
BT_ASSERT(notit->snapshots.packets != UINT64_C(-1));
- ret = bt_private_packet_set_packet_counter_snapshot(
+ bt_private_packet_set_packet_counter_snapshot(
notit->packet, notit->snapshots.packets);
- BT_ASSERT(ret == 0);
}
if (bt_stream_class_packets_have_default_beginning_clock_value(sc)) {
BT_ASSERT(notit->snapshots.beginning_clock != UINT64_C(-1));
- ret = bt_private_packet_set_default_beginning_clock_value(
+ bt_private_packet_set_default_beginning_clock_value(
notit->packet, notit->snapshots.beginning_clock);
- BT_ASSERT(ret == 0);
}
if (bt_stream_class_packets_have_default_end_clock_value(sc)) {
BT_ASSERT(notit->snapshots.end_clock != UINT64_C(-1));
- ret = bt_private_packet_set_default_end_clock_value(
+ bt_private_packet_set_default_end_clock_value(
notit->packet, notit->snapshots.end_clock);
- BT_ASSERT(ret == 0);
}
if (notit->packet_header_field) {
BT_ASSERT(event);
if (dmesg_comp->clock_class) {
- ret = bt_private_event_set_default_clock_value(event, ts);
- BT_ASSERT(ret == 0);
+ bt_private_event_set_default_clock_value(event, ts);
}
goto end;
BT_ASSERT(structure);
ui8 = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(ui8);
- ret = bt_private_field_class_integer_set_field_value_range(ui8, 8);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(ui8, 8);
ret = bt_private_field_class_structure_append_member(structure,
"payload_8", ui8);
BT_ASSERT(ret == 0);
ui16 = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(ui16);
- ret = bt_private_field_class_integer_set_field_value_range(ui16, 16);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(ui16, 16);
ret = bt_private_field_class_structure_append_member(structure,
"payload_16", ui16);
BT_ASSERT(ret == 0);
ui32 = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(ui32);
- ret = bt_private_field_class_integer_set_field_value_range(ui32, 32);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(ui32, 32);
ret = bt_private_field_class_structure_append_member(structure,
"payload_32", ui32);
BT_ASSERT(ret == 0);
BT_ASSERT(packet_context_type);
fc = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(fc);
- ret = bt_private_field_class_integer_set_field_value_range(fc, 32);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(fc, 32);
ret = bt_private_field_class_structure_append_member(packet_context_type,
"packet_size", fc);
BT_ASSERT(ret == 0);
bt_object_put_ref(fc);
fc = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(fc);
- ret = bt_private_field_class_integer_set_field_value_range(fc, 32);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(fc, 32);
ret = bt_private_field_class_structure_append_member(packet_context_type,
"content_size", fc);
BT_ASSERT(ret == 0);
BT_ASSERT(event_header_type);
fc = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(fc);
- ret = bt_private_field_class_integer_set_field_value_range(fc, 32);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(fc, 32);
ret = bt_private_field_class_structure_append_member(event_header_type,
"id", fc);
BT_ASSERT(ret == 0);
BT_ASSERT(packet_header_type);
fc = bt_private_field_class_unsigned_integer_create();
BT_ASSERT(fc);
- ret = bt_private_field_class_integer_set_field_value_range(fc, 32);
- BT_ASSERT(ret == 0);
+ bt_private_field_class_integer_set_field_value_range(fc, 32);
ret = bt_private_field_class_structure_append_member(packet_header_type,
"stream_id", fc);
BT_ASSERT(ret == 0);
projects / babeltrace.git / commitdiff
