use alloc::vec::Vec;
use core::mem::size_of;
use core::ptr::copy_nonoverlapping;
use tracelogging::Channel;
use tracelogging::Guid;
use tracelogging::InType;
use tracelogging::Level;
use tracelogging::Opcode;
use tracelogging::OutType;
use tracelogging::_internal::EventDataDescriptor;
use tracelogging::_internal::EventDescriptor;
use crate::provider::Provider;
pub struct EventBuilder {
meta: Vec<u8>,
data: Vec<u8>,
descriptor: EventDescriptor,
}
impl EventBuilder {
pub fn new() -> EventBuilder {
return Self::new_with_capacity(256, 256);
}
pub fn new_with_capacity(meta_capacity: u16, data_capacity: u16) -> EventBuilder {
let mut b = EventBuilder {
meta: Vec::with_capacity(if meta_capacity < 4 {
4
} else {
meta_capacity as usize
}),
data: Vec::with_capacity(data_capacity as usize),
descriptor: EventDescriptor::zero(),
};
b.meta.resize(4, 0); return b;
}
pub fn reset(&mut self, name: &str, level: Level, keyword: u64, event_tag: u32) -> &mut Self {
debug_assert!(!name.contains('\0'), "event name must not contain '\\0'");
debug_assert_eq!(
event_tag & 0x0FFFFFFF,
event_tag,
"event_tag must fit into 28 bits"
);
self.meta.clear();
self.data.clear();
self.descriptor = EventDescriptor::new(level, keyword);
self.meta.push(0);
self.meta.push(0);
if (event_tag & 0x0FE00000) == event_tag {
self.meta.push((event_tag >> 21) as u8);
} else if (event_tag & 0x0FFFC000) == event_tag {
self.meta.push((event_tag >> 21) as u8 | 0x80);
self.meta.push((event_tag >> 14) as u8 & 0x7F);
} else {
self.meta.push((event_tag >> 21) as u8 | 0x80);
self.meta.push((event_tag >> 14) as u8 | 0x80);
self.meta.push((event_tag >> 7) as u8 | 0x80);
self.meta.push(event_tag as u8 & 0x7F);
}
self.meta.extend_from_slice(name.as_bytes());
self.meta.push(0);
return self;
}
pub fn write(
&mut self,
provider: &Provider,
activity_id: Option<&Guid>,
related_id: Option<&Guid>,
) -> u32 {
let result;
let meta_len = self.meta.len();
if meta_len > 65535 {
result = 534; } else {
self.meta[0] = meta_len as u8;
self.meta[1] = (meta_len >> 8) as u8;
let dd = [
EventDataDescriptor::from_raw_bytes(&provider.meta, 2), EventDataDescriptor::from_raw_bytes(&self.meta, 1), EventDataDescriptor::from_raw_bytes(&self.data, 0), ];
let ctx = &provider.context;
result = ctx.write_transfer(&self.descriptor, activity_id, related_id, &dd);
}
return result;
}
pub fn id_version(&mut self, id: u16, version: u8) -> &mut Self {
self.descriptor.id = id;
self.descriptor.version = version;
return self;
}
pub fn channel(&mut self, channel: Channel) -> &mut Self {
self.descriptor.channel = channel;
return self;
}
pub fn opcode(&mut self, opcode: Opcode) -> &mut Self {
self.descriptor.opcode = opcode;
return self;
}
pub fn task(&mut self, task: u16) -> &mut Self {
self.descriptor.task = task;
return self;
}
pub fn add_cstr16(
&mut self,
field_name: &str,
field_value: impl AsRef<[u16]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::CStr16, out_type, field_tag)
.raw_add_data_cstr(field_value.as_ref());
}
pub fn add_cstr16_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u16]>,
{
return self
.raw_add_meta_vcount(field_name, InType::CStr16, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_cstr(value.as_ref());
});
}
pub fn add_cstr8(
&mut self,
field_name: &str,
field_value: impl AsRef<[u8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::CStr8, out_type, field_tag)
.raw_add_data_cstr(field_value.as_ref());
}
pub fn add_cstr8_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u8]>,
{
return self
.raw_add_meta_vcount(field_name, InType::CStr8, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_cstr(value.as_ref());
});
}
pub fn add_i8(
&mut self,
field_name: &str,
field_value: i8,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::I8, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_i8_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i8>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::I8, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_u8(
&mut self,
field_name: &str,
field_value: u8,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::U8, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_u8_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u8>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::U8, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_i16(
&mut self,
field_name: &str,
field_value: i16,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::I16, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_i16_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i16>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::I16, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_u16(
&mut self,
field_name: &str,
field_value: u16,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::U16, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_u16_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u16>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::U16, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_i32(
&mut self,
field_name: &str,
field_value: i32,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::I32, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_i32_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i32>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::I32, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_u32(
&mut self,
field_name: &str,
field_value: u32,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::U32, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_u32_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u32>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::U32, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_i64(
&mut self,
field_name: &str,
field_value: i64,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::I64, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_i64_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i64>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::I64, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_u64(
&mut self,
field_name: &str,
field_value: u64,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::U64, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_u64_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u64>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::U64, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_isize(
&mut self,
field_name: &str,
field_value: isize,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::ISize, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_isize_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a isize>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::ISize, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_usize(
&mut self,
field_name: &str,
field_value: usize,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::USize, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_usize_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a usize>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::USize, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_f32(
&mut self,
field_name: &str,
field_value: f32,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::F32, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_f32_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a f32>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::F32, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_f64(
&mut self,
field_name: &str,
field_value: f64,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::F64, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_f64_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a f64>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::F64, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_bool32(
&mut self,
field_name: &str,
field_value: i32,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Bool32, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_bool32_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i32>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::Bool32, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_binary(
&mut self,
field_name: &str,
field_value: impl AsRef<[u8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Binary, out_type, field_tag)
.raw_add_data_counted(field_value.as_ref());
}
pub fn add_guid(
&mut self,
field_name: &str,
field_value: &Guid,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Guid, out_type, field_tag)
.raw_add_data_value(field_value);
}
pub fn add_guid_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a Guid>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::Guid, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_filetime(
&mut self,
field_name: &str,
field_value: i64,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::FileTime, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_filetime_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a i64>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::FileTime, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_systemtime(
&mut self,
field_name: &str,
field_value: &[u16; 8],
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::SystemTime, out_type, field_tag)
.raw_add_data_value(field_value);
}
pub fn add_systemtime_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a [u16; 8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::SystemTime, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_sid(
&mut self,
field_name: &str,
field_value: impl AsRef<[u8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Sid, out_type, field_tag)
.raw_add_data_sid(field_value.as_ref());
}
pub fn add_sid_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u8]>,
{
return self
.raw_add_meta_vcount(field_name, InType::Sid, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_sid(value.as_ref());
});
}
pub fn add_hex32(
&mut self,
field_name: &str,
field_value: u32,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Hex32, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_hex32_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u32>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::Hex32, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_hex64(
&mut self,
field_name: &str,
field_value: u64,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Hex64, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_hex64_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a u64>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::Hex64, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_hexsize(
&mut self,
field_name: &str,
field_value: usize,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::HexSize, out_type, field_tag)
.raw_add_data_value(&field_value);
}
pub fn add_hexsize_sequence<'a>(
&mut self,
field_name: &str,
field_values: impl IntoIterator<Item = &'a usize>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_vcount(field_name, InType::HexSize, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_value(value);
});
}
pub fn add_str16(
&mut self,
field_name: &str,
field_value: impl AsRef<[u16]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Str16, out_type, field_tag)
.raw_add_data_counted(field_value.as_ref());
}
pub fn add_str16_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u16]>,
{
return self
.raw_add_meta_vcount(field_name, InType::Str16, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_counted(value.as_ref());
});
}
pub fn add_str8(
&mut self,
field_name: &str,
field_value: impl AsRef<[u8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::Str8, out_type, field_tag)
.raw_add_data_counted(field_value.as_ref());
}
pub fn add_str8_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u8]>,
{
return self
.raw_add_meta_vcount(field_name, InType::Str8, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_counted(value.as_ref());
});
}
pub fn add_binaryc(
&mut self,
field_name: &str,
field_value: impl AsRef<[u8]>,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
return self
.raw_add_meta_scalar(field_name, InType::BinaryC, out_type, field_tag)
.raw_add_data_counted(field_value.as_ref());
}
pub fn add_binaryc_sequence<T: IntoIterator>(
&mut self,
field_name: &str,
field_values: T,
out_type: OutType,
field_tag: u32,
) -> &mut Self
where
T::Item: AsRef<[u8]>,
{
return self
.raw_add_meta_vcount(field_name, InType::BinaryC, out_type, field_tag)
.raw_add_data_range(field_values, |this, value| {
this.raw_add_data_counted(value.as_ref());
});
}
pub fn add_struct(
&mut self,
field_name: &str,
struct_field_count: u8,
field_tag: u32,
) -> &mut Self {
debug_assert_eq!(
struct_field_count & OutType::TypeMask,
struct_field_count,
"struct_field_count must be less than 128"
);
return self.raw_add_meta(
field_name,
InType::Struct.as_int(),
struct_field_count & OutType::TypeMask,
field_tag,
);
}
pub fn raw_add_meta_scalar(
&mut self,
field_name: &str,
in_type: InType,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
debug_assert_eq!(
in_type.as_int() & InType::FlagMask,
0,
"in_type must not include any flags"
);
return self.raw_add_meta(field_name, in_type.as_int(), out_type.as_int(), field_tag);
}
pub fn raw_add_meta_vcount(
&mut self,
field_name: &str,
in_type: InType,
out_type: OutType,
field_tag: u32,
) -> &mut Self {
debug_assert_eq!(
in_type.as_int() & InType::FlagMask,
0,
"in_type must not include any flags"
);
return self.raw_add_meta(
field_name,
in_type.as_int() | InType::VariableCountFlag,
out_type.as_int(),
field_tag,
);
}
pub fn raw_add_data_value<T: Copy>(&mut self, value: &T) -> &mut Self {
let value_size = size_of::<T>();
let old_data_size = self.data.len();
self.data.reserve(value_size);
unsafe {
copy_nonoverlapping(
value as *const T as *const u8,
self.data.as_mut_ptr().add(old_data_size),
value_size,
);
self.data.set_len(old_data_size + value_size);
}
return self;
}
pub fn raw_add_data_slice<T: Copy>(&mut self, value: &[T]) -> &mut Self {
let value_size = value.len() * size_of::<T>();
let old_data_size = self.data.len();
self.data.reserve(value_size);
unsafe {
copy_nonoverlapping(
value.as_ptr() as *const u8,
self.data.as_mut_ptr().add(old_data_size),
value_size,
);
self.data.set_len(old_data_size + value_size);
}
return self;
}
fn raw_add_meta(
&mut self,
field_name: &str,
in_type: u8,
out_type: u8,
field_tag: u32,
) -> &mut Self {
debug_assert!(
!field_name.contains('\0'),
"field_name must not contain '\\0'"
);
debug_assert_eq!(
field_tag & 0x0FFFFFFF,
field_tag,
"field_tag must fit into 28 bits"
);
self.meta.reserve(field_name.len() + 7);
self.meta.extend_from_slice(field_name.as_bytes());
self.meta.push(0);
if field_tag != 0 {
self.meta.push(0x80 | in_type);
self.meta.push(0x80 | out_type);
self.meta.push(0x80 | (field_tag >> 21) as u8);
self.meta.push(0x80 | (field_tag >> 14) as u8);
self.meta.push(0x80 | (field_tag >> 7) as u8);
self.meta.push((0x7F & field_tag) as u8);
} else if out_type != 0 {
self.meta.push(0x80 | in_type);
self.meta.push(out_type);
} else {
self.meta.push(in_type);
}
return self;
}
fn raw_add_data_sid(&mut self, value: &[u8]) -> &mut Self {
let sid_length = 8 + 4 * (value[1] as usize);
debug_assert!(
sid_length <= value.len(),
"add_sid(value) requires value.len() >= sid_length(value)"
);
return self.raw_add_data_slice(&value[0..sid_length]);
}
fn raw_add_data_cstr<T: Copy + Default + Eq>(&mut self, value: &[T]) -> &mut Self {
let zero = T::default();
let mut nul_pos = 0;
while nul_pos != value.len() {
if value[nul_pos] == zero {
return self.raw_add_data_slice(&value[0..nul_pos + 1]);
}
nul_pos += 1;
}
return self.raw_add_data_slice(value).raw_add_data_value(&zero);
}
fn raw_add_data_counted<T: Copy>(&mut self, value: &[T]) -> &mut Self {
let max_len = 65535 / size_of::<T>();
if value.len() > max_len {
return self
.raw_add_data_value(&((max_len as u16) * (size_of::<T>() as u16)))
.raw_add_data_slice(&value[0..max_len]);
} else {
return self
.raw_add_data_value(&((value.len() as u16) * (size_of::<T>() as u16)))
.raw_add_data_slice(value);
}
}
fn raw_add_data_range<T: IntoIterator>(
&mut self,
field_values: T,
add_data: impl Fn(&mut Self, T::Item),
) -> &mut Self {
let mut count = 0u16;
let old_data_size = self.data.len();
self.raw_add_data_value(&count);
for value in field_values {
if count == u16::MAX {
break;
}
count += 1;
add_data(self, value);
}
self.data[old_data_size] = count as u8;
self.data[old_data_size + 1] = (count >> 8) as u8;
return self;
}
}
impl Default for EventBuilder {
fn default() -> Self {
return Self::new();
}
}