Grcov report - status_v1

1

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

2

3

4

// @generated

5

6

use core::mem;

7

use core::cmp::Ordering;

8

9

extern crate flatbuffers;

10

use self::flatbuffers::{EndianScalar, Follow};

11

12

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]

13

pub const ENUM_MIN_STATUS_TYPES: u8 = 0;

14

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]

15

pub const ENUM_MAX_STATUS_TYPES: u8 = 4;

16

#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]

17

#[allow(non_camel_case_types)]

18

pub const ENUM_VALUES_STATUS_TYPES: [StatusTypes; 5] = [

19

  StatusTypes::Unknown,

20

  StatusTypes::Queued,

21

  StatusTypes::Claimed,

22

  StatusTypes::Completed,

23

  StatusTypes::Failed,

24

];

25

26

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]

27

#[repr(transparent)]

28

pub struct StatusTypes(pub u8);

29

#[allow(non_upper_case_globals)]

30

impl StatusTypes {

31

  pub const Unknown: Self = Self(0);

32

  pub const Queued: Self = Self(1);

33

  pub const Claimed: Self = Self(2);

34

  pub const Completed: Self = Self(3);

35

  pub const Failed: Self = Self(4);

36

37

  pub const ENUM_MIN: u8 = 0;

38

  pub const ENUM_MAX: u8 = 4;

39

  pub const ENUM_VALUES: &'static [Self] = &[

40

    Self::Unknown,

41

    Self::Queued,

42

    Self::Claimed,

43

    Self::Completed,

44

    Self::Failed,

45

];

46

  /// Returns the variant's name or "" if unknown.

47

  pub fn variant_name(self) -> Option<&'static str> {

48

    match self {

49

      Self::Unknown => Some("Unknown"),

50

      Self::Queued => Some("Queued"),

51

      Self::Claimed => Some("Claimed"),

52

      Self::Completed => Some("Completed"),

53

      Self::Failed => Some("Failed"),

54

      _ => None,

55

56

57

58

impl core::fmt::Debug for StatusTypes {

59

  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {

60

    if let Some(name) = self.variant_name() {

61

      f.write_str(name)

62

    } else {

63

      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))

64

65

66

67

impl<'a> flatbuffers::Follow<'a> for StatusTypes {

68

  type Inner = Self;

69

  #[inline]

70

  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {

71

    let b = flatbuffers::read_scalar_at::<u8>(buf, loc);

72

    Self(b)

73

74

75

76

impl flatbuffers::Push for StatusTypes {

77

    type Output = StatusTypes;

78

    #[inline]

79

    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {

80

        flatbuffers::emplace_scalar::<u8>(dst, self.0);

81

82

83

84

impl flatbuffers::EndianScalar for StatusTypes {

85

  type Scalar = u8;

86

  #[inline]

87

  fn to_little_endian(self) -> u8 {

88

    self.0.to_le()

89

90

  #[inline]

91

  #[allow(clippy::wrong_self_convention)]

92

  fn from_little_endian(v: u8) -> Self {

93

    let b = u8::from_le(v);

94

    Self(b)

95

96

97

98

impl<'a> flatbuffers::Verifiable for StatusTypes {

99

  #[inline]

100

  fn run_verifier(

101

    v: &mut flatbuffers::Verifier, pos: usize

102

  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {

103

    use self::flatbuffers::Verifiable;

104

    u8::run_verifier(v, pos)

105

106

107

108

impl flatbuffers::SimpleToVerifyInSlice for StatusTypes {}

109

pub enum StatusV1Offset {}

110

#[derive(Copy, Clone, PartialEq)]

111

112

pub struct StatusV1<'a> {

113

  pub _tab: flatbuffers::Table<'a>,

114

115

116

impl<'a> flatbuffers::Follow<'a> for StatusV1<'a> {

117

  type Inner = StatusV1<'a>;

118

  #[inline]

119

  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {

120

    Self { _tab: flatbuffers::Table::new(buf, loc) }

121

122

123

124

impl<'a> StatusV1<'a> {

125

  pub const VT_EXECUTION_ID: flatbuffers::VOffsetT = 4;

126

  pub const VT_STATUS: flatbuffers::VOffsetT = 6;

127

  pub const VT_PROOF: flatbuffers::VOffsetT = 8;

128

  pub const VT_EXECUTION_DIGEST: flatbuffers::VOffsetT = 10;

129

  pub const VT_INPUT_DIGEST: flatbuffers::VOffsetT = 12;

130

  pub const VT_COMMITTED_OUTPUTS: flatbuffers::VOffsetT = 14;

131

  pub const VT_ASSUMPTION_DIGEST: flatbuffers::VOffsetT = 16;

132

  pub const VT_EXIT_CODE_SYSTEM: flatbuffers::VOffsetT = 18;

133

  pub const VT_EXIT_CODE_USER: flatbuffers::VOffsetT = 20;

134

135

  #[inline]

136

  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {

137

    StatusV1 { _tab: table }

138

139

  #[allow(unused_mut)]

140

  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(

141

    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,

142

    args: &'args StatusV1Args<'args>

143

  ) -> flatbuffers::WIPOffset<StatusV1<'bldr>> {

144

    let mut builder = StatusV1Builder::new(_fbb);

145

    builder.add_exit_code_user(args.exit_code_user);

146

    builder.add_exit_code_system(args.exit_code_system);

147

    if let Some(x) = args.assumption_digest { builder.add_assumption_digest(x); }

148

    if let Some(x) = args.committed_outputs { builder.add_committed_outputs(x); }

149

    if let Some(x) = args.input_digest { builder.add_input_digest(x); }

150

    if let Some(x) = args.execution_digest { builder.add_execution_digest(x); }

151

    if let Some(x) = args.proof { builder.add_proof(x); }

152

    if let Some(x) = args.execution_id { builder.add_execution_id(x); }

153

    builder.add_status(args.status);

154

    builder.finish()

155

156

157

  pub fn unpack(&self) -> StatusV1T {

158

    let execution_id = self.execution_id().map(|x| {

159

      x.to_string()

160

});

161

    let status = self.status();

162

    let proof = self.proof().map(|x| {

163

      x.into_iter().collect()

164

});

165

    let execution_digest = self.execution_digest().map(|x| {

166

      x.into_iter().collect()

167

});

168

    let input_digest = self.input_digest().map(|x| {

169

      x.into_iter().collect()

170

});

171

    let committed_outputs = self.committed_outputs().map(|x| {

172

      x.into_iter().collect()

173

});

174

    let assumption_digest = self.assumption_digest().map(|x| {

175

      x.into_iter().collect()

176

});

177

    let exit_code_system = self.exit_code_system();

178

    let exit_code_user = self.exit_code_user();

179

    StatusV1T {

180

      execution_id,

181

      status,

182

      proof,

183

      execution_digest,

184

      input_digest,

185

      committed_outputs,

186

      assumption_digest,

187

      exit_code_system,

188

      exit_code_user,

189

190

191

192

  #[inline]

193

  pub fn execution_id(&self) -> Option<&'a str> {

194

    // Safety:

195

    // Created from valid Table for this object

196

    // which contains a valid value in this slot

197

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(StatusV1::VT_EXECUTION_ID, None)}

198

199

  #[inline]

200

  pub fn status(&self) -> StatusTypes {

201

    // Safety:

202

    // Created from valid Table for this object

203

    // which contains a valid value in this slot

204

    unsafe { self._tab.get::<StatusTypes>(StatusV1::VT_STATUS, Some(StatusTypes::Unknown)).unwrap()}

205

206

  #[inline]

207

  pub fn proof(&self) -> Option<flatbuffers::Vector<'a, u8>> {

208

    // Safety:

209

    // Created from valid Table for this object

210

    // which contains a valid value in this slot

211

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(StatusV1::VT_PROOF, None)}

212

213

  #[inline]

214

  pub fn execution_digest(&self) -> Option<flatbuffers::Vector<'a, u8>> {

215

    // Safety:

216

    // Created from valid Table for this object

217

    // which contains a valid value in this slot

218

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(StatusV1::VT_EXECUTION_DIGEST, None)}

219

220

  #[inline]

221

  pub fn input_digest(&self) -> Option<flatbuffers::Vector<'a, u8>> {

222

    // Safety:

223

    // Created from valid Table for this object

224

    // which contains a valid value in this slot

225

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(StatusV1::VT_INPUT_DIGEST, None)}

226

227

  #[inline]

228

  pub fn committed_outputs(&self) -> Option<flatbuffers::Vector<'a, u8>> {

229

    // Safety:

230

    // Created from valid Table for this object

231

    // which contains a valid value in this slot

232

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(StatusV1::VT_COMMITTED_OUTPUTS, None)}

233

234

  #[inline]

235

  pub fn assumption_digest(&self) -> Option<flatbuffers::Vector<'a, u8>> {

236

    // Safety:

237

    // Created from valid Table for this object

238

    // which contains a valid value in this slot

239

    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(StatusV1::VT_ASSUMPTION_DIGEST, None)}

240

241

  #[inline]

242

  pub fn exit_code_system(&self) -> u32 {

243

    // Safety:

244

    // Created from valid Table for this object

245

    // which contains a valid value in this slot

246

    unsafe { self._tab.get::<u32>(StatusV1::VT_EXIT_CODE_SYSTEM, Some(0)).unwrap()}

247

248

  #[inline]

249

  pub fn exit_code_user(&self) -> u32 {

250

    // Safety:

251

    // Created from valid Table for this object

252

    // which contains a valid value in this slot

253

    unsafe { self._tab.get::<u32>(StatusV1::VT_EXIT_CODE_USER, Some(0)).unwrap()}

254

255

256

257

impl flatbuffers::Verifiable for StatusV1<'_> {

258

  #[inline]

259

  fn run_verifier(

260

    v: &mut flatbuffers::Verifier, pos: usize

261

  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {

262

    use self::flatbuffers::Verifiable;

263

    v.visit_table(pos)?

264

     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("execution_id", Self::VT_EXECUTION_ID, false)?

265

     .visit_field::<StatusTypes>("status", Self::VT_STATUS, false)?

266

     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("proof", Self::VT_PROOF, false)?

267

     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("execution_digest", Self::VT_EXECUTION_DIGEST, false)?

268

     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("input_digest", Self::VT_INPUT_DIGEST, false)?

269

     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("committed_outputs", Self::VT_COMMITTED_OUTPUTS, false)?

270

     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("assumption_digest", Self::VT_ASSUMPTION_DIGEST, false)?

271

     .visit_field::<u32>("exit_code_system", Self::VT_EXIT_CODE_SYSTEM, false)?

272

     .visit_field::<u32>("exit_code_user", Self::VT_EXIT_CODE_USER, false)?

273

     .finish();

274

    Ok(())

275

276

277

pub struct StatusV1Args<'a> {

278

    pub execution_id: Option<flatbuffers::WIPOffset<&'a str>>,

279

    pub status: StatusTypes,

280

    pub proof: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,

281

    pub execution_digest: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,

282

    pub input_digest: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,

283

    pub committed_outputs: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,

284

    pub assumption_digest: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,

285

    pub exit_code_system: u32,

286

    pub exit_code_user: u32,

287

288

impl<'a> Default for StatusV1Args<'a> {

289

  #[inline]

290

  fn default() -> Self {

291

    StatusV1Args {

292

      execution_id: None,

293

      status: StatusTypes::Unknown,

294

      proof: None,

295

      execution_digest: None,

296

      input_digest: None,

297

      committed_outputs: None,

298

      assumption_digest: None,

299

      exit_code_system: 0,

300

      exit_code_user: 0,

301

302

303

304

305

pub struct StatusV1Builder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {

306

  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,

307

  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,

308

309

impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> StatusV1Builder<'a, 'b, A> {

310

  #[inline]

311

  pub fn add_execution_id(&mut self, execution_id: flatbuffers::WIPOffset<&'b  str>) {

312

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_EXECUTION_ID, execution_id);

313

314

  #[inline]

315

  pub fn add_status(&mut self, status: StatusTypes) {

316

    self.fbb_.push_slot::<StatusTypes>(StatusV1::VT_STATUS, status, StatusTypes::Unknown);

317

318

  #[inline]

319

  pub fn add_proof(&mut self, proof: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {

320

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_PROOF, proof);

321

322

  #[inline]

323

  pub fn add_execution_digest(&mut self, execution_digest: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {

324

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_EXECUTION_DIGEST, execution_digest);

325

326

  #[inline]

327

  pub fn add_input_digest(&mut self, input_digest: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {

328

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_INPUT_DIGEST, input_digest);

329

330

  #[inline]

331

  pub fn add_committed_outputs(&mut self, committed_outputs: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {

332

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_COMMITTED_OUTPUTS, committed_outputs);

333

334

  #[inline]

335

  pub fn add_assumption_digest(&mut self, assumption_digest: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {

336

    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(StatusV1::VT_ASSUMPTION_DIGEST, assumption_digest);

337

338

  #[inline]

339

  pub fn add_exit_code_system(&mut self, exit_code_system: u32) {

340

    self.fbb_.push_slot::<u32>(StatusV1::VT_EXIT_CODE_SYSTEM, exit_code_system, 0);

341

342

  #[inline]

343

  pub fn add_exit_code_user(&mut self, exit_code_user: u32) {

344

    self.fbb_.push_slot::<u32>(StatusV1::VT_EXIT_CODE_USER, exit_code_user, 0);

345

346

  #[inline]

347

  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> StatusV1Builder<'a, 'b, A> {

348

    let start = _fbb.start_table();

349

    StatusV1Builder {

350

      fbb_: _fbb,

351

      start_: start,

352

353

354

  #[inline]

355

  pub fn finish(self) -> flatbuffers::WIPOffset<StatusV1<'a>> {

356

    let o = self.fbb_.end_table(self.start_);

357

    flatbuffers::WIPOffset::new(o.value())

358

359

360

361

impl core::fmt::Debug for StatusV1<'_> {

362

  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

363

    let mut ds = f.debug_struct("StatusV1");

364

      ds.field("execution_id", &self.execution_id());

365

      ds.field("status", &self.status());

366

      ds.field("proof", &self.proof());

367

      ds.field("execution_digest", &self.execution_digest());

368

      ds.field("input_digest", &self.input_digest());

369

      ds.field("committed_outputs", &self.committed_outputs());

370

      ds.field("assumption_digest", &self.assumption_digest());

371

      ds.field("exit_code_system", &self.exit_code_system());

372

      ds.field("exit_code_user", &self.exit_code_user());

373

      ds.finish()

374

375

376

#[non_exhaustive]

377

#[derive(Debug, Clone, PartialEq)]

378

pub struct StatusV1T {

379

  pub execution_id: Option<String>,

380

  pub status: StatusTypes,

381

  pub proof: Option<Vec<u8>>,

382

  pub execution_digest: Option<Vec<u8>>,

383

  pub input_digest: Option<Vec<u8>>,

384

  pub committed_outputs: Option<Vec<u8>>,

385

  pub assumption_digest: Option<Vec<u8>>,

386

  pub exit_code_system: u32,

387

  pub exit_code_user: u32,

388

389

impl Default for StatusV1T {

390

  fn default() -> Self {

391

    Self {

392

      execution_id: None,

393

      status: StatusTypes::Unknown,

394

      proof: None,

395

      execution_digest: None,

396

      input_digest: None,

397

      committed_outputs: None,

398

      assumption_digest: None,

399

      exit_code_system: 0,

400

      exit_code_user: 0,

401

402

403

404

impl StatusV1T {

405

  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(

406

    &self,

407

    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>

408

  ) -> flatbuffers::WIPOffset<StatusV1<'b>> {

409

    let execution_id = self.execution_id.as_ref().map(|x|{

410

      _fbb.create_string(x)

411

});

412

    let status = self.status;

413

    let proof = self.proof.as_ref().map(|x|{

414

      _fbb.create_vector(x)

415

});

416

    let execution_digest = self.execution_digest.as_ref().map(|x|{

417

      _fbb.create_vector(x)

418

});

419

    let input_digest = self.input_digest.as_ref().map(|x|{

420

      _fbb.create_vector(x)

421

});

422

    let committed_outputs = self.committed_outputs.as_ref().map(|x|{

423

      _fbb.create_vector(x)

424

});

425

    let assumption_digest = self.assumption_digest.as_ref().map(|x|{

426

      _fbb.create_vector(x)

427

});

428

    let exit_code_system = self.exit_code_system;

429

    let exit_code_user = self.exit_code_user;

430

    StatusV1::create(_fbb, &StatusV1Args{

431

      execution_id,

432

      status,

433

      proof,

434

      execution_digest,

435

      input_digest,

436

      committed_outputs,

437

      assumption_digest,

438

      exit_code_system,

439

      exit_code_user,

440

})

441

442

443

#[inline]

444

/// Verifies that a buffer of bytes contains a `StatusV1`

445

/// and returns it.

446

/// Note that verification is still experimental and may not

447

/// catch every error, or be maximally performant. For the

448

/// previous, unchecked, behavior use

449

/// `root_as_status_v1_unchecked`.

450

pub fn root_as_status_v1(buf: &[u8]) -> Result<StatusV1, flatbuffers::InvalidFlatbuffer> {

451

  flatbuffers::root::<StatusV1>(buf)

452

453

#[inline]

454

/// Verifies that a buffer of bytes contains a size prefixed

455

/// `StatusV1` and returns it.

456

/// Note that verification is still experimental and may not

457

/// catch every error, or be maximally performant. For the

458

/// previous, unchecked, behavior use

459

/// `size_prefixed_root_as_status_v1_unchecked`.

460

pub fn size_prefixed_root_as_status_v1(buf: &[u8]) -> Result<StatusV1, flatbuffers::InvalidFlatbuffer> {

461

  flatbuffers::size_prefixed_root::<StatusV1>(buf)

462

463

#[inline]

464

/// Verifies, with the given options, that a buffer of bytes

465

/// contains a `StatusV1` and returns it.

466

/// Note that verification is still experimental and may not

467

/// catch every error, or be maximally performant. For the

468

/// previous, unchecked, behavior use

469

/// `root_as_status_v1_unchecked`.

470

pub fn root_as_status_v1_with_opts<'b, 'o>(

471

  opts: &'o flatbuffers::VerifierOptions,

472

  buf: &'b [u8],

473

) -> Result<StatusV1<'b>, flatbuffers::InvalidFlatbuffer> {

474

  flatbuffers::root_with_opts::<StatusV1<'b>>(opts, buf)

475

476

#[inline]

477

/// Verifies, with the given verifier options, that a buffer of

478

/// bytes contains a size prefixed `StatusV1` and returns

479

/// it. Note that verification is still experimental and may not

480

/// catch every error, or be maximally performant. For the

481

/// previous, unchecked, behavior use

482

/// `root_as_status_v1_unchecked`.

483

pub fn size_prefixed_root_as_status_v1_with_opts<'b, 'o>(

484

  opts: &'o flatbuffers::VerifierOptions,

485

  buf: &'b [u8],

486

) -> Result<StatusV1<'b>, flatbuffers::InvalidFlatbuffer> {

487

  flatbuffers::size_prefixed_root_with_opts::<StatusV1<'b>>(opts, buf)

488

489

#[inline]

490

/// Assumes, without verification, that a buffer of bytes contains a StatusV1 and returns it.

491

/// # Safety

492

/// Callers must trust the given bytes do indeed contain a valid `StatusV1`.

493

pub unsafe fn root_as_status_v1_unchecked(buf: &[u8]) -> StatusV1 {

494

  flatbuffers::root_unchecked::<StatusV1>(buf)

495

496

#[inline]

497

/// Assumes, without verification, that a buffer of bytes contains a size prefixed StatusV1 and returns it.

498

/// # Safety

499

/// Callers must trust the given bytes do indeed contain a valid size prefixed `StatusV1`.

500

pub unsafe fn size_prefixed_root_as_status_v1_unchecked(buf: &[u8]) -> StatusV1 {

501

  flatbuffers::size_prefixed_root_unchecked::<StatusV1>(buf)

502

503

#[inline]

504

pub fn finish_status_v1_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(

505

    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,

506

    root: flatbuffers::WIPOffset<StatusV1<'a>>) {

507

  fbb.finish(root, None);

508

509

510

#[inline]

511

pub fn finish_size_prefixed_status_v1_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<StatusV1<'a>>) {

512

  fbb.finish_size_prefixed(root, None);

513