extern crate alloc;
#[allow(unused_imports, dead_code)]
pub mod nmp {
#[allow(unused_imports, dead_code)]
pub mod threading {
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_THREAD_POINTER_KIND: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_THREAD_POINTER_KIND: u8 = 2;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_THREAD_POINTER_KIND: [ThreadPointerKind; 3] = [
ThreadPointerKind::Event,
ThreadPointerKind::Address,
ThreadPointerKind::External,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct ThreadPointerKind(pub u8);
#[allow(non_upper_case_globals)]
impl ThreadPointerKind {
pub const Event: Self = Self(0);
pub const Address: Self = Self(1);
pub const External: Self = Self(2);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 2;
pub const ENUM_VALUES: &'static [Self] = &[Self::Event, Self::Address, Self::External];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::Event => Some("Event"),
Self::Address => Some("Address"),
Self::External => Some("External"),
_ => None,
}
}
}
impl ::core::fmt::Debug for ThreadPointerKind {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
if let Some(name) = self.variant_name() {
f.write_str(name)
} else {
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
}
}
}
impl<'a> ::flatbuffers::Follow<'a> for ThreadPointerKind {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
Self(b)
}
}
impl ::flatbuffers::Push for ThreadPointerKind {
type Output = ThreadPointerKind;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for ThreadPointerKind {
type Scalar = u8;
#[inline]
fn to_little_endian(self) -> u8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: u8) -> Self {
let b = u8::from_le(v);
Self(b)
}
}
impl<'a> ::flatbuffers::Verifiable for ThreadPointerKind {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for ThreadPointerKind {}
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MIN_TIMELINE_BLOCK_KIND: u8 = 0;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
pub const ENUM_MAX_TIMELINE_BLOCK_KIND: u8 = 1;
#[deprecated(
since = "2.0.0",
note = "Use associated constants instead. This will no longer be generated in 2021."
)]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_TIMELINE_BLOCK_KIND: [TimelineBlockKind; 2] =
[TimelineBlockKind::Standalone, TimelineBlockKind::Module];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct TimelineBlockKind(pub u8);
#[allow(non_upper_case_globals)]
impl TimelineBlockKind {
pub const Standalone: Self = Self(0);
pub const Module: Self = Self(1);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 1;
pub const ENUM_VALUES: &'static [Self] = &[Self::Standalone, Self::Module];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::Standalone => Some("Standalone"),
Self::Module => Some("Module"),
_ => None,
}
}
}
impl ::core::fmt::Debug for TimelineBlockKind {
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
if let Some(name) = self.variant_name() {
f.write_str(name)
} else {
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
}
}
}
impl<'a> ::flatbuffers::Follow<'a> for TimelineBlockKind {
type Inner = Self;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
Self(b)
}
}
impl ::flatbuffers::Push for TimelineBlockKind {
type Output = TimelineBlockKind;
#[inline]
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
}
}
impl ::flatbuffers::EndianScalar for TimelineBlockKind {
type Scalar = u8;
#[inline]
fn to_little_endian(self) -> u8 {
self.0.to_le()
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(v: u8) -> Self {
let b = u8::from_le(v);
Self(b)
}
}
impl<'a> ::flatbuffers::Verifiable for TimelineBlockKind {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
u8::run_verifier(v, pos)
}
}
impl ::flatbuffers::SimpleToVerifyInSlice for TimelineBlockKind {}
pub enum ThreadPointerOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ThreadPointer<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ThreadPointer<'a> {
type Inner = ThreadPointer<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ThreadPointer<'a> {
pub const VT_KIND: ::flatbuffers::VOffsetT = 4;
pub const VT_ID: ::flatbuffers::VOffsetT = 6;
pub const VT_COORD: ::flatbuffers::VOffsetT = 8;
pub const VT_URI: ::flatbuffers::VOffsetT = 10;
pub const VT_RELAY: ::flatbuffers::VOffsetT = 12;
pub const VT_HAS_KIND_NUM: ::flatbuffers::VOffsetT = 14;
pub const VT_KIND_NUM: ::flatbuffers::VOffsetT = 16;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ThreadPointer { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: ::flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ThreadPointerArgs<'args>,
) -> ::flatbuffers::WIPOffset<ThreadPointer<'bldr>> {
let mut builder = ThreadPointerBuilder::new(_fbb);
builder.add_kind_num(args.kind_num);
if let Some(x) = args.relay {
builder.add_relay(x);
}
if let Some(x) = args.uri {
builder.add_uri(x);
}
if let Some(x) = args.coord {
builder.add_coord(x);
}
if let Some(x) = args.id {
builder.add_id(x);
}
builder.add_has_kind_num(args.has_kind_num);
builder.add_kind(args.kind);
builder.finish()
}
#[inline]
pub fn kind(&self) -> ThreadPointerKind {
unsafe {
self._tab
.get::<ThreadPointerKind>(
ThreadPointer::VT_KIND,
Some(ThreadPointerKind::Event),
)
.unwrap()
}
}
#[inline]
pub fn id(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(ThreadPointer::VT_ID, None)
}
}
#[inline]
pub fn coord(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(ThreadPointer::VT_COORD, None)
}
}
#[inline]
pub fn uri(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(ThreadPointer::VT_URI, None)
}
}
#[inline]
pub fn relay(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(ThreadPointer::VT_RELAY, None)
}
}
#[inline]
pub fn has_kind_num(&self) -> bool {
unsafe {
self._tab
.get::<bool>(ThreadPointer::VT_HAS_KIND_NUM, Some(false))
.unwrap()
}
}
#[inline]
pub fn kind_num(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(ThreadPointer::VT_KIND_NUM, Some(0))
.unwrap()
}
}
}
impl ::flatbuffers::Verifiable for ThreadPointer<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<ThreadPointerKind>("kind", Self::VT_KIND, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"coord",
Self::VT_COORD,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"uri",
Self::VT_URI,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"relay",
Self::VT_RELAY,
false,
)?
.visit_field::<bool>("has_kind_num", Self::VT_HAS_KIND_NUM, false)?
.visit_field::<u32>("kind_num", Self::VT_KIND_NUM, false)?
.finish();
Ok(())
}
}
pub struct ThreadPointerArgs<'a> {
pub kind: ThreadPointerKind,
pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
pub coord: Option<::flatbuffers::WIPOffset<&'a str>>,
pub uri: Option<::flatbuffers::WIPOffset<&'a str>>,
pub relay: Option<::flatbuffers::WIPOffset<&'a str>>,
pub has_kind_num: bool,
pub kind_num: u32,
}
impl<'a> Default for ThreadPointerArgs<'a> {
#[inline]
fn default() -> Self {
ThreadPointerArgs {
kind: ThreadPointerKind::Event,
id: None,
coord: None,
uri: None,
relay: None,
has_kind_num: false,
kind_num: 0,
}
}
}
pub struct ThreadPointerBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ThreadPointerBuilder<'a, 'b, A> {
#[inline]
pub fn add_kind(&mut self, kind: ThreadPointerKind) {
self.fbb_.push_slot::<ThreadPointerKind>(
ThreadPointer::VT_KIND,
kind,
ThreadPointerKind::Event,
);
}
#[inline]
pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(ThreadPointer::VT_ID, id);
}
#[inline]
pub fn add_coord(&mut self, coord: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadPointer::VT_COORD,
coord,
);
}
#[inline]
pub fn add_uri(&mut self, uri: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(ThreadPointer::VT_URI, uri);
}
#[inline]
pub fn add_relay(&mut self, relay: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadPointer::VT_RELAY,
relay,
);
}
#[inline]
pub fn add_has_kind_num(&mut self, has_kind_num: bool) {
self.fbb_
.push_slot::<bool>(ThreadPointer::VT_HAS_KIND_NUM, has_kind_num, false);
}
#[inline]
pub fn add_kind_num(&mut self, kind_num: u32) {
self.fbb_
.push_slot::<u32>(ThreadPointer::VT_KIND_NUM, kind_num, 0);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ThreadPointerBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ThreadPointerBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ThreadPointer<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ThreadPointer<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ThreadPointer");
ds.field("kind", &self.kind());
ds.field("id", &self.id());
ds.field("coord", &self.coord());
ds.field("uri", &self.uri());
ds.field("relay", &self.relay());
ds.field("has_kind_num", &self.has_kind_num());
ds.field("kind_num", &self.kind_num());
ds.finish()
}
}
pub enum ThreadEdgeOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ThreadEdge<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ThreadEdge<'a> {
type Inner = ThreadEdge<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ThreadEdge<'a> {
pub const VT_EVENT_ID: ::flatbuffers::VOffsetT = 4;
pub const VT_AUTHOR_PUBKEY: ::flatbuffers::VOffsetT = 6;
pub const VT_KIND: ::flatbuffers::VOffsetT = 8;
pub const VT_CREATED_AT: ::flatbuffers::VOffsetT = 10;
pub const VT_PARENT: ::flatbuffers::VOffsetT = 12;
pub const VT_ROOT: ::flatbuffers::VOffsetT = 14;
pub const VT_PARENT_AUTHOR_PUBKEY: ::flatbuffers::VOffsetT = 16;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ThreadEdge { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: ::flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ThreadEdgeArgs<'args>,
) -> ::flatbuffers::WIPOffset<ThreadEdge<'bldr>> {
let mut builder = ThreadEdgeBuilder::new(_fbb);
builder.add_created_at(args.created_at);
if let Some(x) = args.parent_author_pubkey {
builder.add_parent_author_pubkey(x);
}
if let Some(x) = args.root {
builder.add_root(x);
}
if let Some(x) = args.parent {
builder.add_parent(x);
}
builder.add_kind(args.kind);
if let Some(x) = args.author_pubkey {
builder.add_author_pubkey(x);
}
if let Some(x) = args.event_id {
builder.add_event_id(x);
}
builder.finish()
}
#[inline]
pub fn event_id(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(ThreadEdge::VT_EVENT_ID, None)
}
}
#[inline]
pub fn author_pubkey(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
ThreadEdge::VT_AUTHOR_PUBKEY,
None,
)
}
}
#[inline]
pub fn kind(&self) -> u32 {
unsafe { self._tab.get::<u32>(ThreadEdge::VT_KIND, Some(0)).unwrap() }
}
#[inline]
pub fn created_at(&self) -> u64 {
unsafe {
self._tab
.get::<u64>(ThreadEdge::VT_CREATED_AT, Some(0))
.unwrap()
}
}
#[inline]
pub fn parent(&self) -> Option<ThreadPointer<'a>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
ThreadEdge::VT_PARENT,
None,
)
}
}
#[inline]
pub fn root(&self) -> Option<ThreadPointer<'a>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
ThreadEdge::VT_ROOT,
None,
)
}
}
#[inline]
pub fn parent_author_pubkey(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
ThreadEdge::VT_PARENT_AUTHOR_PUBKEY,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for ThreadEdge<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"event_id",
Self::VT_EVENT_ID,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"author_pubkey",
Self::VT_AUTHOR_PUBKEY,
false,
)?
.visit_field::<u32>("kind", Self::VT_KIND, false)?
.visit_field::<u64>("created_at", Self::VT_CREATED_AT, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
"parent",
Self::VT_PARENT,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
"root",
Self::VT_ROOT,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"parent_author_pubkey",
Self::VT_PARENT_AUTHOR_PUBKEY,
false,
)?
.finish();
Ok(())
}
}
pub struct ThreadEdgeArgs<'a> {
pub event_id: Option<::flatbuffers::WIPOffset<&'a str>>,
pub author_pubkey: Option<::flatbuffers::WIPOffset<&'a str>>,
pub kind: u32,
pub created_at: u64,
pub parent: Option<::flatbuffers::WIPOffset<ThreadPointer<'a>>>,
pub root: Option<::flatbuffers::WIPOffset<ThreadPointer<'a>>>,
pub parent_author_pubkey: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for ThreadEdgeArgs<'a> {
#[inline]
fn default() -> Self {
ThreadEdgeArgs {
event_id: None,
author_pubkey: None,
kind: 0,
created_at: 0,
parent: None,
root: None,
parent_author_pubkey: None,
}
}
}
pub struct ThreadEdgeBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ThreadEdgeBuilder<'a, 'b, A> {
#[inline]
pub fn add_event_id(&mut self, event_id: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadEdge::VT_EVENT_ID,
event_id,
);
}
#[inline]
pub fn add_author_pubkey(&mut self, author_pubkey: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadEdge::VT_AUTHOR_PUBKEY,
author_pubkey,
);
}
#[inline]
pub fn add_kind(&mut self, kind: u32) {
self.fbb_.push_slot::<u32>(ThreadEdge::VT_KIND, kind, 0);
}
#[inline]
pub fn add_created_at(&mut self, created_at: u64) {
self.fbb_
.push_slot::<u64>(ThreadEdge::VT_CREATED_AT, created_at, 0);
}
#[inline]
pub fn add_parent(&mut self, parent: ::flatbuffers::WIPOffset<ThreadPointer<'b>>) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<ThreadPointer>>(
ThreadEdge::VT_PARENT,
parent,
);
}
#[inline]
pub fn add_root(&mut self, root: ::flatbuffers::WIPOffset<ThreadPointer<'b>>) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<ThreadPointer>>(
ThreadEdge::VT_ROOT,
root,
);
}
#[inline]
pub fn add_parent_author_pubkey(
&mut self,
parent_author_pubkey: ::flatbuffers::WIPOffset<&'b str>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadEdge::VT_PARENT_AUTHOR_PUBKEY,
parent_author_pubkey,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ThreadEdgeBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ThreadEdgeBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ThreadEdge<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ThreadEdge<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ThreadEdge");
ds.field("event_id", &self.event_id());
ds.field("author_pubkey", &self.author_pubkey());
ds.field("kind", &self.kind());
ds.field("created_at", &self.created_at());
ds.field("parent", &self.parent());
ds.field("root", &self.root());
ds.field("parent_author_pubkey", &self.parent_author_pubkey());
ds.finish()
}
}
pub enum BlockEventIdOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct BlockEventId<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for BlockEventId<'a> {
type Inner = BlockEventId<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> BlockEventId<'a> {
pub const VT_ID: ::flatbuffers::VOffsetT = 4;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
BlockEventId { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: ::flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args BlockEventIdArgs<'args>,
) -> ::flatbuffers::WIPOffset<BlockEventId<'bldr>> {
let mut builder = BlockEventIdBuilder::new(_fbb);
if let Some(x) = args.id {
builder.add_id(x);
}
builder.finish()
}
#[inline]
pub fn id(&self) -> Option<&'a str> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<&str>>(BlockEventId::VT_ID, None)
}
}
}
impl ::flatbuffers::Verifiable for BlockEventId<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
.finish();
Ok(())
}
}
pub struct BlockEventIdArgs<'a> {
pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for BlockEventIdArgs<'a> {
#[inline]
fn default() -> Self {
BlockEventIdArgs { id: None }
}
}
pub struct BlockEventIdBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> BlockEventIdBuilder<'a, 'b, A> {
#[inline]
pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<_>>(BlockEventId::VT_ID, id);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> BlockEventIdBuilder<'a, 'b, A> {
let start = _fbb.start_table();
BlockEventIdBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<BlockEventId<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for BlockEventId<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("BlockEventId");
ds.field("id", &self.id());
ds.finish()
}
}
pub enum TimelineBlockEntryOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct TimelineBlockEntry<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for TimelineBlockEntry<'a> {
type Inner = TimelineBlockEntry<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> TimelineBlockEntry<'a> {
pub const VT_KIND: ::flatbuffers::VOffsetT = 4;
pub const VT_STANDALONE_ID: ::flatbuffers::VOffsetT = 6;
pub const VT_STANDALONE_ROOT: ::flatbuffers::VOffsetT = 8;
pub const VT_MODULE_EVENT_IDS: ::flatbuffers::VOffsetT = 10;
pub const VT_MODULE_HAS_GAP: ::flatbuffers::VOffsetT = 12;
pub const VT_MODULE_ROOT: ::flatbuffers::VOffsetT = 14;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
TimelineBlockEntry { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: ::flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args TimelineBlockEntryArgs<'args>,
) -> ::flatbuffers::WIPOffset<TimelineBlockEntry<'bldr>> {
let mut builder = TimelineBlockEntryBuilder::new(_fbb);
if let Some(x) = args.module_root {
builder.add_module_root(x);
}
if let Some(x) = args.module_event_ids {
builder.add_module_event_ids(x);
}
if let Some(x) = args.standalone_root {
builder.add_standalone_root(x);
}
if let Some(x) = args.standalone_id {
builder.add_standalone_id(x);
}
builder.add_module_has_gap(args.module_has_gap);
builder.add_kind(args.kind);
builder.finish()
}
#[inline]
pub fn kind(&self) -> TimelineBlockKind {
unsafe {
self._tab
.get::<TimelineBlockKind>(
TimelineBlockEntry::VT_KIND,
Some(TimelineBlockKind::Standalone),
)
.unwrap()
}
}
#[inline]
pub fn standalone_id(&self) -> Option<&'a str> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
TimelineBlockEntry::VT_STANDALONE_ID,
None,
)
}
}
#[inline]
pub fn standalone_root(&self) -> Option<ThreadPointer<'a>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
TimelineBlockEntry::VT_STANDALONE_ROOT,
None,
)
}
}
#[inline]
pub fn module_event_ids(
&self,
) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId<'a>>>>
{
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId>>,
>>(TimelineBlockEntry::VT_MODULE_EVENT_IDS, None)
}
}
#[inline]
pub fn module_has_gap(&self) -> bool {
unsafe {
self._tab
.get::<bool>(TimelineBlockEntry::VT_MODULE_HAS_GAP, Some(false))
.unwrap()
}
}
#[inline]
pub fn module_root(&self) -> Option<ThreadPointer<'a>> {
unsafe {
self._tab
.get::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
TimelineBlockEntry::VT_MODULE_ROOT,
None,
)
}
}
}
impl ::flatbuffers::Verifiable for TimelineBlockEntry<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<TimelineBlockKind>("kind", Self::VT_KIND, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
"standalone_id",
Self::VT_STANDALONE_ID,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
"standalone_root",
Self::VT_STANDALONE_ROOT,
false,
)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<BlockEventId>>,
>>("module_event_ids", Self::VT_MODULE_EVENT_IDS, false)?
.visit_field::<bool>("module_has_gap", Self::VT_MODULE_HAS_GAP, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<ThreadPointer>>(
"module_root",
Self::VT_MODULE_ROOT,
false,
)?
.finish();
Ok(())
}
}
pub struct TimelineBlockEntryArgs<'a> {
pub kind: TimelineBlockKind,
pub standalone_id: Option<::flatbuffers::WIPOffset<&'a str>>,
pub standalone_root: Option<::flatbuffers::WIPOffset<ThreadPointer<'a>>>,
pub module_event_ids: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId<'a>>>,
>,
>,
pub module_has_gap: bool,
pub module_root: Option<::flatbuffers::WIPOffset<ThreadPointer<'a>>>,
}
impl<'a> Default for TimelineBlockEntryArgs<'a> {
#[inline]
fn default() -> Self {
TimelineBlockEntryArgs {
kind: TimelineBlockKind::Standalone,
standalone_id: None,
standalone_root: None,
module_event_ids: None,
module_has_gap: false,
module_root: None,
}
}
}
pub struct TimelineBlockEntryBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> TimelineBlockEntryBuilder<'a, 'b, A> {
#[inline]
pub fn add_kind(&mut self, kind: TimelineBlockKind) {
self.fbb_.push_slot::<TimelineBlockKind>(
TimelineBlockEntry::VT_KIND,
kind,
TimelineBlockKind::Standalone,
);
}
#[inline]
pub fn add_standalone_id(&mut self, standalone_id: ::flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TimelineBlockEntry::VT_STANDALONE_ID,
standalone_id,
);
}
#[inline]
pub fn add_standalone_root(
&mut self,
standalone_root: ::flatbuffers::WIPOffset<ThreadPointer<'b>>,
) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<ThreadPointer>>(
TimelineBlockEntry::VT_STANDALONE_ROOT,
standalone_root,
);
}
#[inline]
pub fn add_module_event_ids(
&mut self,
module_event_ids: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<BlockEventId<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
TimelineBlockEntry::VT_MODULE_EVENT_IDS,
module_event_ids,
);
}
#[inline]
pub fn add_module_has_gap(&mut self, module_has_gap: bool) {
self.fbb_.push_slot::<bool>(
TimelineBlockEntry::VT_MODULE_HAS_GAP,
module_has_gap,
false,
);
}
#[inline]
pub fn add_module_root(
&mut self,
module_root: ::flatbuffers::WIPOffset<ThreadPointer<'b>>,
) {
self.fbb_
.push_slot_always::<::flatbuffers::WIPOffset<ThreadPointer>>(
TimelineBlockEntry::VT_MODULE_ROOT,
module_root,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> TimelineBlockEntryBuilder<'a, 'b, A> {
let start = _fbb.start_table();
TimelineBlockEntryBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<TimelineBlockEntry<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for TimelineBlockEntry<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("TimelineBlockEntry");
ds.field("kind", &self.kind());
ds.field("standalone_id", &self.standalone_id());
ds.field("standalone_root", &self.standalone_root());
ds.field("module_event_ids", &self.module_event_ids());
ds.field("module_has_gap", &self.module_has_gap());
ds.field("module_root", &self.module_root());
ds.finish()
}
}
pub enum ThreadingSnapshotOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct ThreadingSnapshot<'a> {
pub _tab: ::flatbuffers::Table<'a>,
}
impl<'a> ::flatbuffers::Follow<'a> for ThreadingSnapshot<'a> {
type Inner = ThreadingSnapshot<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self {
_tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
}
}
}
impl<'a> ThreadingSnapshot<'a> {
pub const VT_SCHEMA_VERSION: ::flatbuffers::VOffsetT = 4;
pub const VT_EDGES: ::flatbuffers::VOffsetT = 6;
pub const VT_BLOCKS: ::flatbuffers::VOffsetT = 8;
pub const VT_PENDING_ANCESTOR_IDS: ::flatbuffers::VOffsetT = 10;
#[inline]
pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
ThreadingSnapshot { _tab: table }
}
#[allow(unused_mut)]
pub fn create<
'bldr: 'args,
'args: 'mut_bldr,
'mut_bldr,
A: ::flatbuffers::Allocator + 'bldr,
>(
_fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args ThreadingSnapshotArgs<'args>,
) -> ::flatbuffers::WIPOffset<ThreadingSnapshot<'bldr>> {
let mut builder = ThreadingSnapshotBuilder::new(_fbb);
if let Some(x) = args.pending_ancestor_ids {
builder.add_pending_ancestor_ids(x);
}
if let Some(x) = args.blocks {
builder.add_blocks(x);
}
if let Some(x) = args.edges {
builder.add_edges(x);
}
builder.add_schema_version(args.schema_version);
builder.finish()
}
#[inline]
pub fn schema_version(&self) -> u32 {
unsafe {
self._tab
.get::<u32>(ThreadingSnapshot::VT_SCHEMA_VERSION, Some(1))
.unwrap()
}
}
#[inline]
pub fn edges(
&self,
) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ThreadEdge<'a>>>>
{
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ThreadEdge>>,
>>(ThreadingSnapshot::VT_EDGES, None)
}
}
#[inline]
pub fn blocks(
&self,
) -> Option<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<TimelineBlockEntry<'a>>>,
> {
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<TimelineBlockEntry>,
>,
>>(ThreadingSnapshot::VT_BLOCKS, None)
}
}
#[inline]
pub fn pending_ancestor_ids(
&self,
) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId<'a>>>>
{
unsafe {
self._tab.get::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId>>,
>>(ThreadingSnapshot::VT_PENDING_ANCESTOR_IDS, None)
}
}
}
impl ::flatbuffers::Verifiable for ThreadingSnapshot<'_> {
#[inline]
fn run_verifier(
v: &mut ::flatbuffers::Verifier,
pos: usize,
) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
v.visit_table(pos)?
.visit_field::<u32>("schema_version", Self::VT_SCHEMA_VERSION, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ThreadEdge>>,
>>("edges", Self::VT_EDGES, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<
'_,
::flatbuffers::ForwardsUOffset<TimelineBlockEntry>,
>,
>>("blocks", Self::VT_BLOCKS, false)?
.visit_field::<::flatbuffers::ForwardsUOffset<
::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<BlockEventId>>,
>>(
"pending_ancestor_ids", Self::VT_PENDING_ANCESTOR_IDS, false
)?
.finish();
Ok(())
}
}
pub struct ThreadingSnapshotArgs<'a> {
pub schema_version: u32,
pub edges: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ThreadEdge<'a>>>,
>,
>,
pub blocks: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'a,
::flatbuffers::ForwardsUOffset<TimelineBlockEntry<'a>>,
>,
>,
>,
pub pending_ancestor_ids: Option<
::flatbuffers::WIPOffset<
::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<BlockEventId<'a>>>,
>,
>,
}
impl<'a> Default for ThreadingSnapshotArgs<'a> {
#[inline]
fn default() -> Self {
ThreadingSnapshotArgs {
schema_version: 1,
edges: None,
blocks: None,
pending_ancestor_ids: None,
}
}
}
pub struct ThreadingSnapshotBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ThreadingSnapshotBuilder<'a, 'b, A> {
#[inline]
pub fn add_schema_version(&mut self, schema_version: u32) {
self.fbb_
.push_slot::<u32>(ThreadingSnapshot::VT_SCHEMA_VERSION, schema_version, 1);
}
#[inline]
pub fn add_edges(
&mut self,
edges: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ThreadEdge<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadingSnapshot::VT_EDGES,
edges,
);
}
#[inline]
pub fn add_blocks(
&mut self,
blocks: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<
'b,
::flatbuffers::ForwardsUOffset<TimelineBlockEntry<'b>>,
>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadingSnapshot::VT_BLOCKS,
blocks,
);
}
#[inline]
pub fn add_pending_ancestor_ids(
&mut self,
pending_ancestor_ids: ::flatbuffers::WIPOffset<
::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<BlockEventId<'b>>>,
>,
) {
self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
ThreadingSnapshot::VT_PENDING_ANCESTOR_IDS,
pending_ancestor_ids,
);
}
#[inline]
pub fn new(
_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
) -> ThreadingSnapshotBuilder<'a, 'b, A> {
let start = _fbb.start_table();
ThreadingSnapshotBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> ::flatbuffers::WIPOffset<ThreadingSnapshot<'a>> {
let o = self.fbb_.end_table(self.start_);
::flatbuffers::WIPOffset::new(o.value())
}
}
impl ::core::fmt::Debug for ThreadingSnapshot<'_> {
fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
let mut ds = f.debug_struct("ThreadingSnapshot");
ds.field("schema_version", &self.schema_version());
ds.field("edges", &self.edges());
ds.field("blocks", &self.blocks());
ds.field("pending_ancestor_ids", &self.pending_ancestor_ids());
ds.finish()
}
}
#[inline]
pub fn root_as_threading_snapshot(
buf: &[u8],
) -> Result<ThreadingSnapshot<'_>, ::flatbuffers::InvalidFlatbuffer> {
::flatbuffers::root::<ThreadingSnapshot>(buf)
}
#[inline]
pub fn size_prefixed_root_as_threading_snapshot(
buf: &[u8],
) -> Result<ThreadingSnapshot<'_>, ::flatbuffers::InvalidFlatbuffer> {
::flatbuffers::size_prefixed_root::<ThreadingSnapshot>(buf)
}
#[inline]
pub fn root_as_threading_snapshot_with_opts<'b, 'o>(
opts: &'o ::flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<ThreadingSnapshot<'b>, ::flatbuffers::InvalidFlatbuffer> {
::flatbuffers::root_with_opts::<ThreadingSnapshot<'b>>(opts, buf)
}
#[inline]
pub fn size_prefixed_root_as_threading_snapshot_with_opts<'b, 'o>(
opts: &'o ::flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<ThreadingSnapshot<'b>, ::flatbuffers::InvalidFlatbuffer> {
::flatbuffers::size_prefixed_root_with_opts::<ThreadingSnapshot<'b>>(opts, buf)
}
#[inline]
pub unsafe fn root_as_threading_snapshot_unchecked(buf: &[u8]) -> ThreadingSnapshot<'_> {
unsafe { ::flatbuffers::root_unchecked::<ThreadingSnapshot>(buf) }
}
#[inline]
pub unsafe fn size_prefixed_root_as_threading_snapshot_unchecked(
buf: &[u8],
) -> ThreadingSnapshot<'_> {
unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ThreadingSnapshot>(buf) }
}
pub const THREADING_SNAPSHOT_IDENTIFIER: &str = "NTHR";
#[inline]
pub fn threading_snapshot_buffer_has_identifier(buf: &[u8]) -> bool {
::flatbuffers::buffer_has_identifier(buf, THREADING_SNAPSHOT_IDENTIFIER, false)
}
#[inline]
pub fn threading_snapshot_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
::flatbuffers::buffer_has_identifier(buf, THREADING_SNAPSHOT_IDENTIFIER, true)
}
#[inline]
pub fn finish_threading_snapshot_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
root: ::flatbuffers::WIPOffset<ThreadingSnapshot<'a>>,
) {
fbb.finish(root, Some(THREADING_SNAPSHOT_IDENTIFIER));
}
#[inline]
pub fn finish_size_prefixed_threading_snapshot_buffer<
'a,
'b,
A: ::flatbuffers::Allocator + 'a,
>(
fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
root: ::flatbuffers::WIPOffset<ThreadingSnapshot<'a>>,
) {
fbb.finish_size_prefixed(root, Some(THREADING_SNAPSHOT_IDENTIFIER));
}
} }