fn generate_unsafe_provider_probe_impl_trait() -> String {
    let mut decl= r#"
        /// This trait is implemented by tracing providers that operate on probe arguments in their Rust represention, not
        /// their C native representation.  Most implementations will not implement this trait directly but rather its subtrait
        /// `UnsafeProviderProbeNativeImpl`, which provides an implementation of this trait which wraps all parameters in their
        /// wrapper types and calls its own trait methods with native C representations of each argument.
        ///
        /// This trait and its subtrait `UnsafeProviderProbeNativeImpl` are both unsafe because the provider cannot necessarily
        /// verify that the types and argument counts for the probe match those when the probe was first created.  This is partially for
        /// performance reasons and also a practical limitation of the `var-arg` based implementations most commonly used in C tracing
        /// libraries.
        ///
        /// The implementor of this API for a specific tracing library need only implement all 13
        /// possible `fire` methods, one for each number of args from 0 to 12.
        #[allow(clippy::too_many_arguments)]
        pub trait UnsafeProviderProbeImpl
        {
            /// Tests if this probe is enabled or not.  This should be a very fast test, ideally just a memory
            /// access.  The Rust compiler should be able to inline this implementation for maxmimum performance.
            fn is_enabled(&self) -> bool;

            unsafe fn fire0(&self);
    "#.to_string();

    for arity in 1..=MAX_ARITY {
        //For every possible arity level, declare a `probeN` method that takes a tuple of N
        //`ProbeArgType<T>` types.  That is, types that are not wrapped yet but are passed as-is as Rust types.
        let type_params = get_type_param_names(arity);

        decl += &format!(
            r##"
            unsafe fn fire{arg_count}<{type_list}>(&self, {args})
                where {where_clause};
            "##,
            arg_count = type_params.len(),
            type_list = type_params.join(","),
            args = xform_types_i(&type_params, |i, x| format!("arg{}: {}", i, x)).join(","),
            where_clause =
                xform_types(&type_params, |x| format!("{t}: ProbeArgType<{t}>", t = x)).join(",")
        );
    }

    decl.push_str("}");

    decl
}
/// This generates the declaration of the `UnsafeProviderProbeImpl` trait.  This trait implements tracing
/// for implementations that will operate on Rust types, not native C types.  The intention of this library
/// is to support C native tracing libraries, so the only direct implementation of this trait is likely to be
/// an implementation which simply logs the probe arguments to Rust's `logging` crate, for debugging purposes
/// or use on platforms without a supported tracing library.
This generates the declaration of the `UnsafeProviderProbeImpl` trait.  This trait implements tracing
for implementations that will operate on Rust types, not native C types.  The intention of this library
is to support C native tracing libraries, so the only direct implementation of this trait is likely to be
an implementation which simply logs the probe arguments to Rust's `logging` crate, for debugging purposes
or use on platforms without a supported tracing library.
This generates the declaration of the ` UnsafeProviderProbeImpl ` trait . This trait implements tracing for implementations that will operate on Rust types not native C types . The intention of this library is to support C native tracing libraries so the only direct implementation of this trait is likely to be an implementation which simply logs the probe arguments to Rust ' s ` logging ` crate for debugging purposes or use on platforms without a supported tracing library .
fn generate_unsafe_provider_probe_impl_trait() -> String {
    let mut decl= r#"
        /// This trait is implemented by tracing providers that operate on probe arguments in their Rust represention, not
        /// their C native representation.  Most implementations will not implement this trait directly but rather its subtrait
        /// `UnsafeProviderProbeNativeImpl`, which provides an implementation of this trait which wraps all parameters in their
        /// wrapper types and calls its own trait methods with native C representations of each argument.
        ///
        /// This trait and its subtrait `UnsafeProviderProbeNativeImpl` are both unsafe because the provider cannot necessarily
        /// verify that the types and argument counts for the probe match those when the probe was first created.  This is partially for
        /// performance reasons and also a practical limitation of the `var-arg` based implementations most commonly used in C tracing
        /// libraries.
        ///
        /// The implementor of this API for a specific tracing library need only implement all 13
        /// possible `fire` methods, one for each number of args from 0 to 12.
        #[allow(clippy::too_many_arguments)]
        pub trait UnsafeProviderProbeImpl
        {
            /// Tests if this probe is enabled or not.  This should be a very fast test, ideally just a memory
            /// access.  The Rust compiler should be able to inline this implementation for maxmimum performance.
            fn is_enabled(&self) -> bool;
            unsafe fn fire0(&self);
    "#.to_string();
    for arity in 1..=MAX_ARITY {
        //For every possible arity level, declare a `probeN` method that takes a tuple of N
        //`ProbeArgType<T>` types.  That is, types that are not wrapped yet but are passed as-is as Rust types.
        let type_params = get_type_param_names(arity);
        decl += &format!(
            r##"
            unsafe fn fire{arg_count}<{type_list}>(&self, {args})
                where {where_clause};
            "##,
            arg_count = type_params.len(),
            type_list = type_params.join(","),
            args = xform_types_i(&type_params, |i, x| format!("arg{}: {}", i, x)).join(","),
            where_clause =
                xform_types(&type_params, |x| format!("{t}: ProbeArgType<{t}>", t = x)).join(",")
        );
    }
    decl.push_str("}");
    decl
}
fn generate_unsafe_provider_probe_impl_trait ( ) -> String { let mut decl = r#"
        /// This trait is implemented by tracing providers that operate on probe arguments in their Rust represention, not
        /// their C native representation.  Most implementations will not implement this trait directly but rather its subtrait
        /// `UnsafeProviderProbeNativeImpl`, which provides an implementation of this trait which wraps all parameters in their
        /// wrapper types and calls its own trait methods with native C representations of each argument.
        ///
        /// This trait and its subtrait `UnsafeProviderProbeNativeImpl` are both unsafe because the provider cannot necessarily
        /// verify that the types and argument counts for the probe match those when the probe was first created.  This is partially for
        /// performance reasons and also a practical limitation of the `var-arg` based implementations most commonly used in C tracing
        /// libraries.
        ///
        /// The implementor of this API for a specific tracing library need only implement all 13
        /// possible `fire` methods, one for each number of args from 0 to 12.
        #[allow(clippy::too_many_arguments)]
        pub trait UnsafeProviderProbeImpl
        {
            /// Tests if this probe is enabled or not.  This should be a very fast test, ideally just a memory
            /// access.  The Rust compiler should be able to inline this implementation for maxmimum performance.
            fn is_enabled(&self) -> bool;

            unsafe fn fire0(&self);
    "# . to_string ( ) ; for arity in 1 ..= MAX_ARITY { //For every possible arity level, declare a `probeN` method that takes a tuple of N //`ProbeArgType<T>` types.  That is, types that are not wrapped yet but are passed as-is as Rust types. let type_params = get_type_param_names ( arity ) ; decl += & format ! ( r##"
            unsafe fn fire{arg_count}<{type_list}>(&self, {args})
                where {where_clause};
            "## arg_count type_params len ( ) type_list type_params join ( " " ) args xform_types_i ( type_params i x format ( " " i x ) ) join ( " " ) where_clause xform_types ( type_params x format ( " " t x ) ) join ( " " ) ) ; } decl . push_str ( " " ) ; decl }
This generates the declaration of the `UnsafeProviderProbeImpl` trait.
This generates the declaration of the ` UnsafeProviderProbeImpl ` trait .