crdt-graph 0.3.0

// automatically generated by the FlatBuffers compiler, do not modify
// @generated

extern crate alloc;

#[allow(unused_imports, dead_code)]
pub mod crdt_graph {

extern crate alloc;
#[allow(unused_imports, dead_code)]
pub mod fb_data {

extern crate alloc;

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_OPERATION: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_OPERATION: u8 = 4;
#[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_OPERATION: [Operation; 5] = [
  Operation::NONE,
  Operation::AddVertex,
  Operation::RemoveVertex,
  Operation::AddEdge,
  Operation::RemoveEdge,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Operation(pub u8);
#[allow(non_upper_case_globals)]
impl Operation {
  pub const NONE: Self = Self(0);
  pub const AddVertex: Self = Self(1);
  pub const RemoveVertex: Self = Self(2);
  pub const AddEdge: Self = Self(3);
  pub const RemoveEdge: Self = Self(4);

  pub const ENUM_MIN: u8 = 0;
  pub const ENUM_MAX: u8 = 4;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::NONE,
    Self::AddVertex,
    Self::RemoveVertex,
    Self::AddEdge,
    Self::RemoveEdge,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::NONE => Some("NONE"),
      Self::AddVertex => Some("AddVertex"),
      Self::RemoveVertex => Some("RemoveVertex"),
      Self::AddEdge => Some("AddEdge"),
      Self::RemoveEdge => Some("RemoveEdge"),
      _ => None,
    }
  }
}
impl ::core::fmt::Debug for Operation {
  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 Operation {
  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 Operation {
    type Output = Operation;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
    }
}

impl ::flatbuffers::EndianScalar for Operation {
  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 Operation {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    u8::run_verifier(v, pos)
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for Operation {}
pub struct OperationUnionTableOffset {}

// struct Uuid, aligned to 1
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq)]
pub struct Uuid(pub [u8; 16]);
impl Default for Uuid { 
  fn default() -> Self { 
    Self([0; 16])
  }
}
impl ::core::fmt::Debug for Uuid {
  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
    f.debug_struct("Uuid")
      .field("bytes", &self.bytes())
      .finish()
  }
}

impl ::flatbuffers::SimpleToVerifyInSlice for Uuid {}
impl<'a> ::flatbuffers::Follow<'a> for Uuid {
  type Inner = &'a Uuid;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { <&'a Uuid>::follow(buf, loc) }
  }
}
impl<'a> ::flatbuffers::Follow<'a> for &'a Uuid {
  type Inner = &'a Uuid;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    unsafe { ::flatbuffers::follow_cast_ref::<Uuid>(buf, loc) }
  }
}
impl<'b> ::flatbuffers::Push for Uuid {
    type Output = Uuid;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        let src = unsafe { ::core::slice::from_raw_parts(self as *const Uuid as *const u8, <Self as ::flatbuffers::Push>::size()) };
        dst.copy_from_slice(src);
    }
    #[inline]
    fn alignment() -> ::flatbuffers::PushAlignment {
        ::flatbuffers::PushAlignment::new(1)
    }
}

impl<'a> ::flatbuffers::Verifiable for Uuid {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.in_buffer::<Self>(pos)
  }
}

impl<'a> Uuid {
  #[allow(clippy::too_many_arguments)]
  pub fn new(
    bytes: &[u8; 16],
  ) -> Self {
    let mut s = Self([0; 16]);
    s.set_bytes(bytes);
    s
  }

  pub fn bytes(&'a self) -> ::flatbuffers::Array<'a, u8, 16> {
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid array in this slot
    use ::flatbuffers::Follow;
    unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
  }

  pub fn set_bytes(&mut self, items: &[u8; 16]) {
    // Safety:
    // Created from a valid Table for this object
    // Which contains a valid array in this slot
    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
  }

}

pub enum AddVertexOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct AddVertex<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for AddVertex<'a> {
  type Inner = AddVertex<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> AddVertex<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_DATA: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AddVertex { _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 AddVertexArgs<'args>
  ) -> ::flatbuffers::WIPOffset<AddVertex<'bldr>> {
    let mut builder = AddVertexBuilder::new(_fbb);
    if let Some(x) = args.data { builder.add_data(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(AddVertex::VT_ID, None).unwrap()}
  }
  /// Arbitrary payload attached to this vertex.
  #[inline]
  pub fn data(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(AddVertex::VT_DATA, None)}
  }
}

impl ::flatbuffers::Verifiable for AddVertex<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Uuid>("id", Self::VT_ID, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("data", Self::VT_DATA, false)?
     .finish();
    Ok(())
  }
}
pub struct AddVertexArgs<'a> {
    pub id: Option<&'a Uuid>,
    pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for AddVertexArgs<'a> {
  #[inline]
  fn default() -> Self {
    AddVertexArgs {
      id: None, // required field
      data: None,
    }
  }
}

pub struct AddVertexBuilder<'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> AddVertexBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(AddVertex::VT_ID, id);
  }
  #[inline]
  pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddVertex::VT_DATA, data);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AddVertexBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AddVertexBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AddVertex<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AddVertex::VT_ID,"id");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for AddVertex<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("AddVertex");
      ds.field("id", &self.id());
      ds.field("data", &self.data());
      ds.finish()
  }
}
pub enum RemoveVertexOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct RemoveVertex<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for RemoveVertex<'a> {
  type Inner = RemoveVertex<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> RemoveVertex<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_ADD_VERTEX_ID: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    RemoveVertex { _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 RemoveVertexArgs<'args>
  ) -> ::flatbuffers::WIPOffset<RemoveVertex<'bldr>> {
    let mut builder = RemoveVertexBuilder::new(_fbb);
    if let Some(x) = args.add_vertex_id { builder.add_add_vertex_id(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(RemoveVertex::VT_ID, None).unwrap()}
  }
  #[inline]
  pub fn add_vertex_id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(RemoveVertex::VT_ADD_VERTEX_ID, None).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for RemoveVertex<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Uuid>("id", Self::VT_ID, true)?
     .visit_field::<Uuid>("add_vertex_id", Self::VT_ADD_VERTEX_ID, true)?
     .finish();
    Ok(())
  }
}
pub struct RemoveVertexArgs<'a> {
    pub id: Option<&'a Uuid>,
    pub add_vertex_id: Option<&'a Uuid>,
}
impl<'a> Default for RemoveVertexArgs<'a> {
  #[inline]
  fn default() -> Self {
    RemoveVertexArgs {
      id: None, // required field
      add_vertex_id: None, // required field
    }
  }
}

pub struct RemoveVertexBuilder<'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> RemoveVertexBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(RemoveVertex::VT_ID, id);
  }
  #[inline]
  pub fn add_add_vertex_id(&mut self, add_vertex_id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(RemoveVertex::VT_ADD_VERTEX_ID, add_vertex_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RemoveVertexBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RemoveVertexBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<RemoveVertex<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RemoveVertex::VT_ID,"id");
    self.fbb_.required(o, RemoveVertex::VT_ADD_VERTEX_ID,"add_vertex_id");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for RemoveVertex<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("RemoveVertex");
      ds.field("id", &self.id());
      ds.field("add_vertex_id", &self.add_vertex_id());
      ds.finish()
  }
}
pub enum AddEdgeOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct AddEdge<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for AddEdge<'a> {
  type Inner = AddEdge<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> AddEdge<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_SOURCE: ::flatbuffers::VOffsetT = 6;
  pub const VT_TARGET: ::flatbuffers::VOffsetT = 8;
  pub const VT_DATA: ::flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    AddEdge { _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 AddEdgeArgs<'args>
  ) -> ::flatbuffers::WIPOffset<AddEdge<'bldr>> {
    let mut builder = AddEdgeBuilder::new(_fbb);
    if let Some(x) = args.data { builder.add_data(x); }
    if let Some(x) = args.target { builder.add_target(x); }
    if let Some(x) = args.source { builder.add_source(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(AddEdge::VT_ID, None).unwrap()}
  }
  #[inline]
  pub fn source(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(AddEdge::VT_SOURCE, None).unwrap()}
  }
  #[inline]
  pub fn target(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(AddEdge::VT_TARGET, None).unwrap()}
  }
  /// Arbitrary payload attached to this edge.
  #[inline]
  pub fn data(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(AddEdge::VT_DATA, None)}
  }
}

impl ::flatbuffers::Verifiable for AddEdge<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Uuid>("id", Self::VT_ID, true)?
     .visit_field::<Uuid>("source", Self::VT_SOURCE, true)?
     .visit_field::<Uuid>("target", Self::VT_TARGET, true)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>("data", Self::VT_DATA, false)?
     .finish();
    Ok(())
  }
}
pub struct AddEdgeArgs<'a> {
    pub id: Option<&'a Uuid>,
    pub source: Option<&'a Uuid>,
    pub target: Option<&'a Uuid>,
    pub data: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for AddEdgeArgs<'a> {
  #[inline]
  fn default() -> Self {
    AddEdgeArgs {
      id: None, // required field
      source: None, // required field
      target: None, // required field
      data: None,
    }
  }
}

pub struct AddEdgeBuilder<'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> AddEdgeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(AddEdge::VT_ID, id);
  }
  #[inline]
  pub fn add_source(&mut self, source: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(AddEdge::VT_SOURCE, source);
  }
  #[inline]
  pub fn add_target(&mut self, target: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(AddEdge::VT_TARGET, target);
  }
  #[inline]
  pub fn add_data(&mut self, data: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(AddEdge::VT_DATA, data);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> AddEdgeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AddEdgeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<AddEdge<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, AddEdge::VT_ID,"id");
    self.fbb_.required(o, AddEdge::VT_SOURCE,"source");
    self.fbb_.required(o, AddEdge::VT_TARGET,"target");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for AddEdge<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("AddEdge");
      ds.field("id", &self.id());
      ds.field("source", &self.source());
      ds.field("target", &self.target());
      ds.field("data", &self.data());
      ds.finish()
  }
}
pub enum RemoveEdgeOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct RemoveEdge<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for RemoveEdge<'a> {
  type Inner = RemoveEdge<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> RemoveEdge<'a> {
  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
  pub const VT_ADD_EDGE_ID: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    RemoveEdge { _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 RemoveEdgeArgs<'args>
  ) -> ::flatbuffers::WIPOffset<RemoveEdge<'bldr>> {
    let mut builder = RemoveEdgeBuilder::new(_fbb);
    if let Some(x) = args.add_edge_id { builder.add_add_edge_id(x); }
    if let Some(x) = args.id { builder.add_id(x); }
    builder.finish()
  }


  #[inline]
  pub fn id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(RemoveEdge::VT_ID, None).unwrap()}
  }
  #[inline]
  pub fn add_edge_id(&self) -> &'a Uuid {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Uuid>(RemoveEdge::VT_ADD_EDGE_ID, None).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for RemoveEdge<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<Uuid>("id", Self::VT_ID, true)?
     .visit_field::<Uuid>("add_edge_id", Self::VT_ADD_EDGE_ID, true)?
     .finish();
    Ok(())
  }
}
pub struct RemoveEdgeArgs<'a> {
    pub id: Option<&'a Uuid>,
    pub add_edge_id: Option<&'a Uuid>,
}
impl<'a> Default for RemoveEdgeArgs<'a> {
  #[inline]
  fn default() -> Self {
    RemoveEdgeArgs {
      id: None, // required field
      add_edge_id: None, // required field
    }
  }
}

pub struct RemoveEdgeBuilder<'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> RemoveEdgeBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_id(&mut self, id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(RemoveEdge::VT_ID, id);
  }
  #[inline]
  pub fn add_add_edge_id(&mut self, add_edge_id: &Uuid) {
    self.fbb_.push_slot_always::<&Uuid>(RemoveEdge::VT_ADD_EDGE_ID, add_edge_id);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RemoveEdgeBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RemoveEdgeBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<RemoveEdge<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, RemoveEdge::VT_ID,"id");
    self.fbb_.required(o, RemoveEdge::VT_ADD_EDGE_ID,"add_edge_id");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for RemoveEdge<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("RemoveEdge");
      ds.field("id", &self.id());
      ds.field("add_edge_id", &self.add_edge_id());
      ds.finish()
  }
}
pub enum UpdateOperationOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct UpdateOperation<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for UpdateOperation<'a> {
  type Inner = UpdateOperation<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> UpdateOperation<'a> {
  pub const VT_OPERATION_TYPE: ::flatbuffers::VOffsetT = 4;
  pub const VT_OPERATION: ::flatbuffers::VOffsetT = 6;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    UpdateOperation { _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 UpdateOperationArgs
  ) -> ::flatbuffers::WIPOffset<UpdateOperation<'bldr>> {
    let mut builder = UpdateOperationBuilder::new(_fbb);
    if let Some(x) = args.operation { builder.add_operation(x); }
    builder.add_operation_type(args.operation_type);
    builder.finish()
  }


  #[inline]
  pub fn operation_type(&self) -> Operation {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<Operation>(UpdateOperation::VT_OPERATION_TYPE, Some(Operation::NONE)).unwrap()}
  }
  #[inline]
  pub fn operation(&self) -> ::flatbuffers::Table<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(UpdateOperation::VT_OPERATION, None).unwrap()}
  }
  #[inline]
  #[allow(non_snake_case)]
  pub fn operation_as_add_vertex(&self) -> Option<AddVertex<'a>> {
    if self.operation_type() == Operation::AddVertex {
      let u = self.operation();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { AddVertex::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn operation_as_remove_vertex(&self) -> Option<RemoveVertex<'a>> {
    if self.operation_type() == Operation::RemoveVertex {
      let u = self.operation();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { RemoveVertex::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn operation_as_add_edge(&self) -> Option<AddEdge<'a>> {
    if self.operation_type() == Operation::AddEdge {
      let u = self.operation();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { AddEdge::init_from_table(u) })
    } else {
      None
    }
  }

  #[inline]
  #[allow(non_snake_case)]
  pub fn operation_as_remove_edge(&self) -> Option<RemoveEdge<'a>> {
    if self.operation_type() == Operation::RemoveEdge {
      let u = self.operation();
      // Safety:
      // Created from a valid Table for this object
      // Which contains a valid union in this slot
      Some(unsafe { RemoveEdge::init_from_table(u) })
    } else {
      None
    }
  }

}

impl ::flatbuffers::Verifiable for UpdateOperation<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_union::<Operation, _>("operation_type", Self::VT_OPERATION_TYPE, "operation", Self::VT_OPERATION, true, |key, v, pos| {
        match key {
          Operation::AddVertex => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AddVertex>>("Operation::AddVertex", pos),
          Operation::RemoveVertex => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RemoveVertex>>("Operation::RemoveVertex", pos),
          Operation::AddEdge => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<AddEdge>>("Operation::AddEdge", pos),
          Operation::RemoveEdge => v.verify_union_variant::<::flatbuffers::ForwardsUOffset<RemoveEdge>>("Operation::RemoveEdge", pos),
          _ => Ok(()),
        }
     })?
     .finish();
    Ok(())
  }
}
pub struct UpdateOperationArgs {
    pub operation_type: Operation,
    pub operation: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for UpdateOperationArgs {
  #[inline]
  fn default() -> Self {
    UpdateOperationArgs {
      operation_type: Operation::NONE,
      operation: None, // required field
    }
  }
}

pub struct UpdateOperationBuilder<'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> UpdateOperationBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_operation_type(&mut self, operation_type: Operation) {
    self.fbb_.push_slot::<Operation>(UpdateOperation::VT_OPERATION_TYPE, operation_type, Operation::NONE);
  }
  #[inline]
  pub fn add_operation(&mut self, operation: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(UpdateOperation::VT_OPERATION, operation);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UpdateOperationBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    UpdateOperationBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<UpdateOperation<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, UpdateOperation::VT_OPERATION,"operation");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for UpdateOperation<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("UpdateOperation");
      ds.field("operation_type", &self.operation_type());
      match self.operation_type() {
        Operation::AddVertex => {
          if let Some(x) = self.operation_as_add_vertex() {
            ds.field("operation", &x)
          } else {
            ds.field("operation", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Operation::RemoveVertex => {
          if let Some(x) = self.operation_as_remove_vertex() {
            ds.field("operation", &x)
          } else {
            ds.field("operation", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Operation::AddEdge => {
          if let Some(x) = self.operation_as_add_edge() {
            ds.field("operation", &x)
          } else {
            ds.field("operation", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        Operation::RemoveEdge => {
          if let Some(x) = self.operation_as_remove_edge() {
            ds.field("operation", &x)
          } else {
            ds.field("operation", &"InvalidFlatbuffer: Union discriminant does not match value.")
          }
        },
        _ => {
          let x: Option<()> = None;
          ds.field("operation", &x)
        },
      };
      ds.finish()
  }
}
pub enum OperationLogOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct OperationLog<'a> {
  pub _tab: ::flatbuffers::Table<'a>,
}

impl<'a> ::flatbuffers::Follow<'a> for OperationLog<'a> {
  type Inner = OperationLog<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
  }
}

impl<'a> OperationLog<'a> {
  pub const VT_OPERATIONS: ::flatbuffers::VOffsetT = 4;

  #[inline]
  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
    OperationLog { _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 OperationLogArgs<'args>
  ) -> ::flatbuffers::WIPOffset<OperationLog<'bldr>> {
    let mut builder = OperationLogBuilder::new(_fbb);
    if let Some(x) = args.operations { builder.add_operations(x); }
    builder.finish()
  }


  #[inline]
  pub fn operations(&self) -> ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<UpdateOperation<'a>>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<UpdateOperation>>>>(OperationLog::VT_OPERATIONS, None).unwrap()}
  }
}

impl ::flatbuffers::Verifiable for OperationLog<'_> {
  #[inline]
  fn run_verifier(
    v: &mut ::flatbuffers::Verifier, pos: usize
  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
    v.visit_table(pos)?
     .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<UpdateOperation>>>>("operations", Self::VT_OPERATIONS, true)?
     .finish();
    Ok(())
  }
}
pub struct OperationLogArgs<'a> {
    pub operations: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<UpdateOperation<'a>>>>>,
}
impl<'a> Default for OperationLogArgs<'a> {
  #[inline]
  fn default() -> Self {
    OperationLogArgs {
      operations: None, // required field
    }
  }
}

pub struct OperationLogBuilder<'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> OperationLogBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_operations(&mut self, operations: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<UpdateOperation<'b >>>>) {
    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(OperationLog::VT_OPERATIONS, operations);
  }
  #[inline]
  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> OperationLogBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    OperationLogBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> ::flatbuffers::WIPOffset<OperationLog<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, OperationLog::VT_OPERATIONS,"operations");
    ::flatbuffers::WIPOffset::new(o.value())
  }
}

impl ::core::fmt::Debug for OperationLog<'_> {
  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
    let mut ds = f.debug_struct("OperationLog");
      ds.field("operations", &self.operations());
      ds.finish()
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `OperationLog`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_operation_log_unchecked`.
pub fn root_as_operation_log(buf: &[u8]) -> Result<OperationLog<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root::<OperationLog>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `OperationLog` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_operation_log_unchecked`.
pub fn size_prefixed_root_as_operation_log(buf: &[u8]) -> Result<OperationLog<'_>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root::<OperationLog>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `OperationLog` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_operation_log_unchecked`.
pub fn root_as_operation_log_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<OperationLog<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::root_with_opts::<OperationLog<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `OperationLog` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_operation_log_unchecked`.
pub fn size_prefixed_root_as_operation_log_with_opts<'b, 'o>(
  opts: &'o ::flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<OperationLog<'b>, ::flatbuffers::InvalidFlatbuffer> {
  ::flatbuffers::size_prefixed_root_with_opts::<OperationLog<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a OperationLog and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `OperationLog`.
pub unsafe fn root_as_operation_log_unchecked(buf: &[u8]) -> OperationLog<'_> {
  unsafe { ::flatbuffers::root_unchecked::<OperationLog>(buf) }
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed OperationLog and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `OperationLog`.
pub unsafe fn size_prefixed_root_as_operation_log_unchecked(buf: &[u8]) -> OperationLog<'_> {
  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<OperationLog>(buf) }
}
pub const OPERATION_LOG_IDENTIFIER: &str = "CRD2";

#[inline]
pub fn operation_log_buffer_has_identifier(buf: &[u8]) -> bool {
  ::flatbuffers::buffer_has_identifier(buf, OPERATION_LOG_IDENTIFIER, false)
}

#[inline]
pub fn operation_log_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
  ::flatbuffers::buffer_has_identifier(buf, OPERATION_LOG_IDENTIFIER, true)
}

#[inline]
pub fn finish_operation_log_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
    root: ::flatbuffers::WIPOffset<OperationLog<'a>>) {
  fbb.finish(root, Some(OPERATION_LOG_IDENTIFIER));
}

#[inline]
pub fn finish_size_prefixed_operation_log_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<OperationLog<'a>>) {
  fbb.finish_size_prefixed(root, Some(OPERATION_LOG_IDENTIFIER));
}
}  // pub mod fb_data
}  // pub mod crdt_graph