X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=include%2Fbabeltrace%2Fctf-ir%2Ftrace.h;h=c7fa1f31b5eb7d0d0798c47f94625f061ecdfc5e;hb=2f4b93cd29ab927436c42544ef6fccfb33429c0f;hp=6cae6d6fd3f676f2b4c95bf6c358beb77b36293b;hpb=2c1c33a46b0842b5fcce20fe8a58de184ca865a4;p=babeltrace.git diff --git a/include/babeltrace/ctf-ir/trace.h b/include/babeltrace/ctf-ir/trace.h index 6cae6d6f..c7fa1f31 100644 --- a/include/babeltrace/ctf-ir/trace.h +++ b/include/babeltrace/ctf-ir/trace.h @@ -33,7 +33,8 @@ #include #include #include -#include +#include +#include #include #ifdef __cplusplus @@ -45,6 +46,10 @@ extern "C" { @ingroup ctfir @brief CTF IR trace class. +@code +#include +@endcode + A CTF IR trace class is a descriptor of traces. @@ -52,16 +57,17 @@ You can obtain a trace class in two different modes: - Normal mode: use bt_ctf_trace_create() to create a default, empty trace class. -- CTF IR writer mode: use bt_ctf_writer_get_trace() to - get the trace class created by a given CTF IR writer object. +- CTF writer mode: use bt_ctf_writer_get_trace() to + get the trace class created by a given CTF writer object. A trace class has the following properties: - A \b name. -- A default byte order: all the - \link ctfirfieldtype field types\endlink eventually part of the trace +- A native byte order: all the + \link ctfirfieldtypes field types\endlink eventually part of the trace class with a byte order set to #BT_CTF_BYTE_ORDER_NATIVE have this "real" byte order. +- A \b UUID. - An \b environment, which is a custom key-value mapping. Keys are strings and values can be strings or integers. @@ -72,6 +78,10 @@ can add an event class to a stream class with bt_ctf_stream_class_add_event_class(). You can add a stream class to a trace class with bt_ctf_trace_add_stream_class(). +You can access the streams of a trace, that is, the streams which were +created from the trace's stream classes with bt_ctf_stream_create(), +with bt_ctf_trace_get_stream_by_index(). + A trace class owns the trace packet header \link ctfirfieldtypes field type\endlink, which represents the \c trace.packet.header CTF scope. This field type describes the @@ -90,7 +100,7 @@ As a reminder, here's the structure of a CTF packet: @imgpacketstructure A trace class also contains zero or more -\link ctfirclockclass clock classes\endlink. +\link ctfirclockclass CTF IR clock classes\endlink. @todo Elaborate about clock classes irt clock values. @@ -105,21 +115,16 @@ success: - bt_ctf_trace_add_stream_class() - bt_ctf_writer_create_stream() - (\link ctfirwriter CTF IR writer\endlink mode only) + (\link ctfwriter CTF writer\endlink mode only) You cannot modify a frozen trace class: it is considered immutable, except for: - Adding a stream class to it with bt_ctf_trace_add_stream_class(). -- Adding a clock class to it with bt_ctf_trace_add_clock(). +- Adding a CTF IR clock class to it with bt_ctf_trace_add_clock_class(). - \link refs Reference counting\endlink. -You can add a custom listener with bt_ctf_trace_add_listener() to get -notified if anything changes in a trace class, that is, if an event -class is added to one of its stream class, if a stream class is added, -or if a clock class is added. - @sa ctfirstreamclass @sa ctfireventclass @sa ctfirclockclass @@ -140,7 +145,21 @@ or if a clock class is added. struct bt_ctf_trace; struct bt_ctf_stream; struct bt_ctf_stream_class; -struct bt_ctf_clock; +struct bt_ctf_clock_class; + +/** +@brief User function type to use with + bt_ctf_trace_add_is_static_listener(). + +@param[in] trace_class Trace class which is now static. +@param[in] data User data as passed to + bt_ctf_trace_add_is_static_listener() when + you added the listener. + +@prenotnull{trace_class} +*/ +typedef void (* bt_ctf_trace_is_static_listener)( + struct bt_ctf_trace *trace_class, void *data); /** @name Creation function @@ -151,26 +170,20 @@ struct bt_ctf_clock; @brief Creates a default CTF IR trace class. On success, the trace packet header field type of the created trace -class has the following fields: - -- magic: a 32-bit unsigned integer field type. -- uuid: an array field type of 16 8-bit unsigned integer - field types. -- stream_id: a 32-bit unsigned integer field type. - -You can modify this default trace packet header field type after the -trace class is created with bt_ctf_trace_set_packet_header_type(). +class is an empty structure field type. You can modify this default +trace packet header field type after the trace class is created with +bt_ctf_trace_get_packet_header_type() and +bt_ctf_trace_set_packet_header_type(). The created trace class has the following initial properties: - Name: none. You can set a name with bt_ctf_trace_set_name(). -- Default byte order: #BT_CTF_BYTE_ORDER_NATIVE. You - can set a default byte order with bt_ctf_trace_set_byte_order(). - - Note that you \em must set the default byte order if any field type - contained in the created trace class, in its stream classes, or in - its event classes, has a byte order set to #BT_CTF_BYTE_ORDER_NATIVE. +- UUID: none. You can set a UUID with + bt_ctf_trace_set_uuid(). +- Native byte order: #BT_CTF_BYTE_ORDER_UNSPECIFIED. + You can set a native byte order with + bt_ctf_trace_set_native_byte_order(). - Environment: empty. You can add environment entries with bt_ctf_trace_set_environment_field(), bt_ctf_trace_set_environment_field_integer(), and @@ -227,50 +240,92 @@ extern int bt_ctf_trace_set_name(struct bt_ctf_trace *trace_class, const char *name); /** -@brief Returns the default byte order of the CTF IR trace class +@brief Returns the native byte order of the CTF IR trace class \p trace_class. @param[in] trace_class Trace class of which to get the default byte order. -@returns Default byte order of trace class - \p trace_class, or #BT_CTF_BYTE_ORDER_UNKNOWN - on error. +@returns Native byte order of \p trace_class, + or #BT_CTF_BYTE_ORDER_UNKNOWN on error. @prenotnull{trace_class} @postrefcountsame{trace_class} -@sa bt_ctf_trace_set_name(): Sets the name of a given trace class. +@sa bt_ctf_trace_set_native_byte_order(): Sets the native byte order of + a given trace class. */ -extern enum bt_ctf_byte_order bt_ctf_trace_get_byte_order( +extern enum bt_ctf_byte_order bt_ctf_trace_get_native_byte_order( struct bt_ctf_trace *trace_class); /** -@brief Sets the default byte order of the CTF IR trace class - \p trace_class to \p name. +@brief Sets the native byte order of the CTF IR trace class + \p trace_class to \p native_byte_order. -\p byte_order \em must be one of: +\p native_byte_order \em must be one of: - #BT_CTF_BYTE_ORDER_LITTLE_ENDIAN - #BT_CTF_BYTE_ORDER_BIG_ENDIAN - #BT_CTF_BYTE_ORDER_NETWORK +- If the trace is not in CTF writer mode, + #BT_CTF_BYTE_ORDER_UNSPECIFIED. -@param[in] trace_class Trace class of which to set the default byte - order. -@param[in] byte_order Default byte order of the trace class. -@returns 0 on success, or a negative value on error. +@param[in] trace_class Trace class of which to set the native byte + order. +@param[in] native_byte_order Native byte order of the trace class. +@returns 0 on success, or a negative value on error. @prenotnull{trace_class} -@prenotnull{name} @prehot{trace_class} -@pre \p byte_order is either #BT_CTF_BYTE_ORDER_LITTLE_ENDIAN, - #BT_CTF_BYTE_ORDER_BIG_ENDIAN, or +@pre \p native_byte_order is either #BT_CTF_BYTE_ORDER_UNSPECIFIED (if the + trace is not in CTF writer mode), + #BT_CTF_BYTE_ORDER_LITTLE_ENDIAN, #BT_CTF_BYTE_ORDER_BIG_ENDIAN, or #BT_CTF_BYTE_ORDER_NETWORK. @postrefcountsame{trace_class} -@sa bt_ctf_trace_get_name(): Returns the name of a given trace class. +@sa bt_ctf_trace_get_native_byte_order(): Returns the native byte order of a + given trace class. */ -extern int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace_class, - enum bt_ctf_byte_order byte_order); +extern int bt_ctf_trace_set_native_byte_order(struct bt_ctf_trace *trace_class, + enum bt_ctf_byte_order native_byte_order); + +/** +@brief Returns the UUID of the CTF IR trace class \p trace_class. + +On success, the return value is an array of 16 bytes. + +@param[in] trace_class Trace class of which to get the UUID. +@returns UUID of trace class \p trace_class, or + \c NULL if \p trace_class has no UUID or on error. + +@prenotnull{trace_class} +@postrefcountsame{trace_class} + +@sa bt_ctf_trace_set_uuid(): Sets the UUID of a given trace class. +*/ +extern const unsigned char *bt_ctf_trace_get_uuid( + struct bt_ctf_trace *trace_class); + +/** +@brief Sets the UUID of the CTF IR trace class \p trace_class to + \p uuid. + +\p uuid \em must be an array of 16 bytes. + +@param[in] trace_class Trace class of which to set the UUID. +@param[in] uuid UUID of the \p trace_class (copied on + success). +@returns 0 on success, or a negative value on error. + +@prenotnull{trace_class} +@prenotnull{uuid} +@prehot{trace_class} +@pre \p uuid is an array of 16 bytes. +@postrefcountsame{trace_class} + +@sa bt_ctf_trace_get_uuid(): Returns the UUID of a given trace class. +*/ +extern int bt_ctf_trace_set_uuid(struct bt_ctf_trace *trace_class, + const unsigned char *uuid); /** @brief Returns the number of entries contained in the environment of @@ -285,7 +340,7 @@ extern int bt_ctf_trace_set_byte_order(struct bt_ctf_trace *trace_class, @prenotnull{trace_class} @postrefcountsame{trace_class} */ -extern int bt_ctf_trace_get_environment_field_count( +extern int64_t bt_ctf_trace_get_environment_field_count( struct bt_ctf_trace *trace_class); /** @@ -307,7 +362,7 @@ the returned string. \p trace_class (see bt_ctf_trace_get_environment_field_count()). @postrefcountsame{trace_class} -@sa bt_ctf_trace_get_environment_field_value(): Finds a trace class's +@sa bt_ctf_trace_get_environment_field_value_by_index(): Finds a trace class's environment entry by index. @sa bt_ctf_trace_get_environment_field_value_by_name(): Finds a trace class's environment entry by name. @@ -315,8 +370,8 @@ the returned string. class's environment entry. */ extern const char * -bt_ctf_trace_get_environment_field_name(struct bt_ctf_trace *trace_class, - int index); +bt_ctf_trace_get_environment_field_name_by_index( + struct bt_ctf_trace *trace_class, uint64_t index); /** @brief Returns the value of the environment entry at index @@ -340,8 +395,8 @@ bt_ctf_trace_get_environment_field_name(struct bt_ctf_trace *trace_class, class's environment entry. */ extern struct bt_value * -bt_ctf_trace_get_environment_field_value(struct bt_ctf_trace *trace_class, - int index); +bt_ctf_trace_get_environment_field_value_by_index(struct bt_ctf_trace *trace_class, + uint64_t index); /** @brief Returns the value of the environment entry named \p name @@ -359,7 +414,7 @@ bt_ctf_trace_get_environment_field_value(struct bt_ctf_trace *trace_class, @postrefcountsame{trace_class} @postsuccessrefcountretinc -@sa bt_ctf_trace_get_environment_field_value(): Finds a trace class's +@sa bt_ctf_trace_get_environment_field_value_by_index(): Finds a trace class's environment entry by index. @sa bt_ctf_trace_set_environment_field(): Sets the value of a trace class's environment entry. @@ -393,7 +448,7 @@ value is first put, and then replaced by \p value. @postrefcountsame{trace_class} @postsuccessrefcountinc{value} -@sa bt_ctf_trace_get_environment_field_value(): Finds a trace class's +@sa bt_ctf_trace_get_environment_field_value_by_index(): Finds a trace class's environment entry by index. @sa bt_ctf_trace_get_environment_field_value_by_name(): Finds a trace class's environment entry by name. @@ -474,10 +529,13 @@ extern int bt_ctf_trace_set_environment_field_string( @param[in] trace_class Trace class of which to get the packet header field type. @returns Packet header field type of \p trace_class, - or \c NULL on error. + or \c NULL if \p trace_class has no packet header field + type or on error. @prenotnull{trace_class} -@postsuccessrefcountretinc +@postrefcountsame{trace_class} +@post On success, if the return value is a field type, its + reference count is incremented. @sa bt_ctf_trace_set_packet_header_type(): Sets the packet header field type of a given trace class. @@ -487,22 +545,29 @@ extern struct bt_ctf_field_type *bt_ctf_trace_get_packet_header_type( /** @brief Sets the packet header field type of the CTF IR trace class - \p trace_class to \p packet_context_type. + \p trace_class to \p packet_header_type, or unsets the current packet + header field type from \p trace_class. + +If \p packet_header_type is \c NULL, then this function unsets the current +packet header field type from \p trace_class, effectively making \p trace_class +a trace without a packet header field type. -As of Babeltrace \btversion, \p packet_context_type \em must be a -CTF IR structure field type object. +As of Babeltrace \btversion, if \p packet_header_type is not \c NULL, +\p packet_header_type \em must be a CTF IR structure field type object. @param[in] trace_class Trace class of which to set the packet header field type. -@param[in] packet_header_type Packet header field type. +@param[in] packet_header_type Packet header field type, or \c NULL to unset + the current packet header field type. @returns 0 on success, or a negative value on error. @prenotnull{trace_class} -@prenotnull{packet_header_type} @prehot{trace_class} -@preisstructft{packet_header_type} +@pre \p packet_header_type, if not \c NULL, is a CTF IR + structure field type. @postrefcountsame{trace_class} -@postsuccessrefcountinc{packet_header_type} +@post On success, if \p packet_header_type is not \c NULL, + the reference count of \p packet_header_type is incremented. @sa bt_ctf_trace_get_packet_header_type(): Returns the packet header field type of a given trace class. @@ -513,75 +578,81 @@ extern int bt_ctf_trace_set_packet_header_type(struct bt_ctf_trace *trace_class, /** @} */ /** -@name Clock class children functions +@name Contained clock classes functions @{ */ /** -@brief Returns the number of clock classes contained in the +@brief Returns the number of CTF IR clock classes contained in the CTF IR trace class \p trace_class. @param[in] trace_class Trace class of which to get the number - of children clock classes. -@returns Number of children clock classes + of contained clock classes. +@returns Number of contained clock classes contained in \p trace_class, or a negative value on error. @prenotnull{trace_class} @postrefcountsame{trace_class} */ -extern int bt_ctf_trace_get_clock_count(struct bt_ctf_trace *trace_class); +extern int64_t bt_ctf_trace_get_clock_class_count( + struct bt_ctf_trace *trace_class); /** -@brief Returns the clock class at index \p index in the CTF IR trace - class \p trace_class. +@brief Returns the CTF IR clock class at index \p index in the CTF + IR trace class \p trace_class. -@param[in] trace_class Trace class of which to get the clock class. -@param[in] index Index of the clock class to find. -@returns Clock class at index \p index, or \c NULL - on error. +@param[in] trace_class Trace class of which to get the clock class + contained at index \p index. +@param[in] index Index of the clock class to find in + \p trace_class. +@returns Clock class at index \p index in \p trace_class, + or \c NULL on error. @prenotnull{trace_class} @pre \p index is lesser than the number of clock classes contained in the trace class \p trace_class (see - bt_ctf_trace_get_clock_count()). + bt_ctf_trace_get_clock_class_count()). @postrefcountsame{trace_class} @postsuccessrefcountretinc -@sa bt_ctf_trace_get_clock_by_name(): Finds a clock class by name. -@sa bt_ctf_trace_add_clock(): Adds a clock class to a trace class. +@sa bt_ctf_trace_get_clock_class_by_name(): Finds a clock class by name + in a given trace class. +@sa bt_ctf_trace_add_clock_class(): Adds a clock class to a trace class. */ -extern struct bt_ctf_clock *bt_ctf_trace_get_clock( - struct bt_ctf_trace *trace_class, int index); +extern struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_index( + struct bt_ctf_trace *trace_class, uint64_t index); /** -@brief Returns the clock class named \c name found in the CTF IR trace - class \p trace_class. +@brief Returns the CTF IR clock class named \c name found in the CTF + IR trace class \p trace_class. -@param[in] trace_class Trace class of which to get the clock class. -@param[in] name Name of the clock class to find. -@returns Clock class named \p name, or \c NULL - on error. +@param[in] trace_class Trace class of which to get the clock class + named \p name. +@param[in] name Name of the clock class to find in \p trace_class. +@returns Clock class named \p name in \p trace_class, + or \c NULL on error. @prenotnull{trace_class} @prenotnull{name} @postrefcountsame{trace_class} @postsuccessrefcountretinc -@sa bt_ctf_trace_get_clock(): Returns the clock class contained in a - given trace class at a given index. -@sa bt_ctf_trace_add_clock(): Adds a clock class to a trace class. +@sa bt_ctf_trace_get_clock_class_by_index(): Returns the clock class contained + in a given trace class at a given index. +@sa bt_ctf_trace_add_clock_class(): Adds a clock class to a trace class. */ -extern struct bt_ctf_clock *bt_ctf_trace_get_clock_by_name( +extern struct bt_ctf_clock_class *bt_ctf_trace_get_clock_class_by_name( struct bt_ctf_trace *trace_class, const char *name); /** @brief Adds the CTF IR clock class \p clock_class to the CTF IR trace class \p trace_class. -On success, \p clock_class becomes the child of \p trace_class. +On success, \p trace_class contains \p clock_class. -You can call this function even if \p trace_class is frozen. +You can call this function even if \p trace_class or \p clock_class +are frozen. @param[in] trace_class Trace class to which to add \p clock_class. @param[in] clock_class Clock class to add to \p trace_class. @@ -591,15 +662,16 @@ You can call this function even if \p trace_class is frozen. @prenotnull{clock_class} @postrefcountsame{trace_class} @postsuccessrefcountinc{clock_class} -@post On success, if \p trace_class is frozen, +@post On success, if \p trace_class is frozen, \p clock_class is frozen. -@sa bt_ctf_trace_get_clock(): Returns the clock class contained in a - given trace class at a given index. -@sa bt_ctf_trace_get_clock_by_name(): Finds a clock class by name. +@sa bt_ctf_trace_get_clock_class_by_index(): Returns the clock class contained + in a given trace class at a given index. +@sa bt_ctf_trace_get_clock_class_by_name(): Finds a clock class by name + in a given trace class. */ -extern int bt_ctf_trace_add_clock(struct bt_ctf_trace *trace_class, - struct bt_ctf_clock *clock_class); +extern int bt_ctf_trace_add_clock_class(struct bt_ctf_trace *trace_class, + struct bt_ctf_clock_class *clock_class); /** @} */ @@ -621,7 +693,8 @@ extern int bt_ctf_trace_add_clock(struct bt_ctf_trace *trace_class, @prenotnull{trace_class} @postrefcountsame{trace_class} */ -extern int bt_ctf_trace_get_stream_class_count(struct bt_ctf_trace *trace_class); +extern int64_t bt_ctf_trace_get_stream_class_count( + struct bt_ctf_trace *trace_class); /** @brief Returns the stream class at index \p index in the CTF IR trace @@ -637,13 +710,12 @@ extern int bt_ctf_trace_get_stream_class_count(struct bt_ctf_trace *trace_class) the trace class \p trace_class (see bt_ctf_trace_get_stream_class_count()). @postrefcountsame{trace_class} -@postsuccessrefcountretinc @sa bt_ctf_trace_get_stream_class_by_id(): Finds a stream class by ID. @sa bt_ctf_trace_add_stream_class(): Adds a stream class to a trace class. */ -extern struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class( - struct bt_ctf_trace *trace_class, int index); +extern struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_index( + struct bt_ctf_trace *trace_class, uint64_t index); /** @brief Returns the stream class with ID \c id found in the CTF IR @@ -658,12 +730,12 @@ extern struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class( @postrefcountsame{trace_class} @postsuccessrefcountretinc -@sa bt_ctf_trace_get_clock(): Returns the stream class contained in a - given trace class at a given index. +@sa bt_ctf_trace_get_stream_class_by_index(): Returns the stream class contained + in a given trace class at a given index. @sa bt_ctf_trace_add_stream_class(): Adds a stream class to a trace class. */ extern struct bt_ctf_stream_class *bt_ctf_trace_get_stream_class_by_id( - struct bt_ctf_trace *trace_class, uint32_t id); + struct bt_ctf_trace *trace_class, uint64_t id); /** @brief Adds the CTF IR stream class \p stream_class to the @@ -675,6 +747,13 @@ You can only add a given stream class to one trace class. You can call this function even if \p trace_class is frozen. +This function tries to resolve the needed +\link ctfirfieldtypes CTF IR field type\endlink of the dynamic field +types that are found anywhere in the root field types of +\p stream_class and of all its currently contained +\link ctfireventclass CTF IR event classes\endlink. If any automatic +resolving fails, then this function fails. + @param[in] trace_class Trace class to which to add \p stream_class. @param[in] stream_class Stream class to add to \p trace_class. @returns 0 on success, or a negative value on error. @@ -685,8 +764,8 @@ You can call this function even if \p trace_class is frozen. @postsuccessrefcountinc{stream_class} @postsuccessfrozen{stream_class} -@sa bt_ctf_trace_get_clock(): Returns the stream class contained in a - given trace class at a given index. +@sa bt_ctf_trace_get_stream_class_by_index(): Returns the stream class contained + in a given trace class at a given index. @sa bt_ctf_trace_get_stream_class_by_id(): Finds a stream class by ID. */ extern int bt_ctf_trace_add_stream_class(struct bt_ctf_trace *trace_class, @@ -694,40 +773,159 @@ extern int bt_ctf_trace_add_stream_class(struct bt_ctf_trace *trace_class, /** @} */ +/** +@name Stream children functions +@{ +*/ + +/** +@brief Returns the number of streams contained in the CTF IR trace + class \p trace_class. + +@param[in] trace_class Trace class of which to get the number + of children streams. +@returns Number of children streams + contained in \p trace_class, or a negative + value on error. + +@prenotnull{trace_class} +@postrefcountsame{trace_class} +*/ +extern int64_t bt_ctf_trace_get_stream_count(struct bt_ctf_trace *trace_class); + +/** +@brief Returns the stream at index \p index in the CTF IR trace + class \p trace_class. + +@param[in] trace_class Trace class of which to get the stream. +@param[in] index Index of the stream to find. +@returns Stream at index \p index, or \c NULL + on error. + +@prenotnull{trace_class} +@pre \p index is lesser than the number of streams contained in + the trace class \p trace_class (see + bt_ctf_trace_get_stream_count()). +@postrefcountsame{trace_class} +*/ +extern struct bt_ctf_stream *bt_ctf_trace_get_stream_by_index( + struct bt_ctf_trace *trace_class, uint64_t index); + +/** @} */ + /** @name Misc. functions @{ */ /** -@brief User function type to use with bt_ctf_trace_add_listener(). +@brief Returns whether or not the CTF IR trace class \p trace_class + is static. -@param[in] obj New CTF IR object which is part of the trace - class hierarchy. -@param[in] data User data. +It is guaranteed that a static trace class will never contain new +streams, stream classes, or clock classes. A static class is always +frozen. -@prenotnull{obj} +This function returns #BT_TRUE if bt_ctf_trace_set_is_static() was +previously called on it. + +@param[in] trace_class Trace class to check. +@returns #BT_TRUE if \p trace_class is static, + +@sa bt_ctf_trace_set_is_static(): Makes a trace class static. */ -typedef void (*bt_ctf_listener_cb)(struct bt_ctf_object *obj, void *data); +extern bt_bool bt_ctf_trace_is_static(struct bt_ctf_trace *trace_class); /** -@brief Adds the trace class modification listener \p listener to - the CTF IR trace class \p trace_class. +@brief Makes the CTF IR trace class \p trace_class static. -Once you add \p listener to \p trace_class, whenever \p trace_class -is modified, \p listener is called with the new element and with -\p data (user data). +A static trace class is frozen and you cannot call any modifying +function on it: -@param[in] trace_class Trace class to which to add \p listener. -@param[in] listener Modification listener function. -@param[in] data User data. +- bt_ctf_trace_add_stream_class() +- bt_ctf_trace_add_clock_class() +- bt_ctf_trace_set_environment_field() +- bt_ctf_trace_set_environment_field_integer() +- bt_ctf_trace_set_environment_field_string() +- bt_ctf_trace_add_is_static_listener() + +You cannot create a stream with bt_ctf_stream_create() with any of the +stream classes of a static trace class. + +@param[in] trace_class Trace class to make static. @returns 0 on success, or a negative value on error. +@prenotnull{trace_class} +@postrefcountsame{trace_class} +@postsuccessfrozen{trace_class} + +@sa bt_ctf_trace_is_static(): Checks whether or not a given trace class + is static. +@sa bt_ctf_trace_add_is_static_listener(): Adds a listener to a trace + class which is called when the trace class is made static. +*/ +extern int bt_ctf_trace_set_is_static(struct bt_ctf_trace *trace_class); + +/** +@brief Adds the listener \p listener to the CTF IR trace class + \p trace_class which is called when the trace is made static. + +\p listener is called with \p data, the user data, the first time +bt_ctf_trace_set_is_static() is called on \p trace_class. + +This function fails if \p trace_class is already static: you need to +check the condition first with bt_ctf_trace_is_static(). + +On success, this function returns a unique numeric identifier for this +listener within \p trace. You can use this identifier to remove the +specific listener you added with +bt_ctf_trace_remove_is_static_listener(). + +@param[in] trace_class Trace class to which to add the listener. +@param[in] listener Listener to add to \p trace_class. +@param[in] data User data passed when \p listener is called. +@returns A unique numeric identifier for this listener + on success (0 or greater), or a negative value + on error. + @prenotnull{trace_class} @prenotnull{listener} +@pre \p trace_class is not static. +@postrefcountsame{trace_class} + +@sa bt_ctf_trace_remove_is_static_listener(): Removes a "trace is + static" listener from a trace class previously added with this + function. +@sa bt_ctf_trace_is_static(): Checks whether or not a given trace class + is static. +@sa bt_ctf_trace_set_is_static(): Makes a trace class static. */ -extern int bt_ctf_trace_add_listener(struct bt_ctf_trace *trace_class, - bt_ctf_listener_cb listener, void *data); +extern int bt_ctf_trace_add_is_static_listener( + struct bt_ctf_trace *trace_class, + bt_ctf_trace_is_static_listener listener, void *data); + +/** +@brief Removes the "trace is static" listener identified by + \p listener_id from the trace class \p trace_class. + +@param[in] trace_class Trace class from which to remove the listener + identified by \p listener_id. +@param[in] listener_id Identifier of the listener to remove from + \p trace_class. +@returns 0 if this function removed the listener, or + a negative value on error. + +@prenotnull{trace_class} +@pre \p listener_id is the identifier of a listener that you previously + added with bt_ctf_trace_add_is_static_listener() and did not + already remove with this function. +@postrefcountsame{trace_class} + +@sa bt_ctf_trace_add_is_static_listener(): Adds a listener to a trace + class which is called when the trace class is made static. +*/ +extern int bt_ctf_trace_remove_is_static_listener( + struct bt_ctf_trace *trace_class, int listener_id); /** @brief Accepts the visitor \p visitor to visit the hierarchy of the @@ -752,17 +950,7 @@ extern int bt_ctf_trace_visit(struct bt_ctf_trace *trace_class, /** @} */ -/* - * bt_ctf_trace_get_metadata_string: get metadata string. - * - * Get the trace's TSDL metadata. The caller assumes the ownership of the - * returned string. - * - * @param trace Trace instance. - * - * Returns the metadata string on success, NULL on error. - */ -extern char *bt_ctf_trace_get_metadata_string(struct bt_ctf_trace *trace); +/** @} */ #ifdef __cplusplus }