• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1<?php
2// automatically generated by the FlatBuffers compiler, do not modify
3
4namespace MyGame\Example;
5
6use \Google\FlatBuffers\Struct;
7use \Google\FlatBuffers\Table;
8use \Google\FlatBuffers\ByteBuffer;
9use \Google\FlatBuffers\FlatBufferBuilder;
10
11/// an example documentation comment: "monster object"
12class Monster extends Table
13{
14    /**
15     * @param ByteBuffer $bb
16     * @return Monster
17     */
18    public static function getRootAsMonster(ByteBuffer $bb)
19    {
20        $obj = new Monster();
21        return ($obj->init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb));
22    }
23
24    public static function MonsterIdentifier()
25    {
26        return "MONS";
27    }
28
29    public static function MonsterBufferHasIdentifier(ByteBuffer $buf)
30    {
31        return self::__has_identifier($buf, self::MonsterIdentifier());
32    }
33
34    public static function MonsterExtension()
35    {
36        return "mon";
37    }
38
39    /**
40     * @param int $_i offset
41     * @param ByteBuffer $_bb
42     * @return Monster
43     **/
44    public function init($_i, ByteBuffer $_bb)
45    {
46        $this->bb_pos = $_i;
47        $this->bb = $_bb;
48        return $this;
49    }
50
51    public function getPos()
52    {
53        $obj = new Vec3();
54        $o = $this->__offset(4);
55        return $o != 0 ? $obj->init($o + $this->bb_pos, $this->bb) : 0;
56    }
57
58    /**
59     * @return short
60     */
61    public function getMana()
62    {
63        $o = $this->__offset(6);
64        return $o != 0 ? $this->bb->getShort($o + $this->bb_pos) : 150;
65    }
66
67    /**
68     * @return short
69     */
70    public function getHp()
71    {
72        $o = $this->__offset(8);
73        return $o != 0 ? $this->bb->getShort($o + $this->bb_pos) : 100;
74    }
75
76    public function getName()
77    {
78        $o = $this->__offset(10);
79        return $o != 0 ? $this->__string($o + $this->bb_pos) : null;
80    }
81
82    /**
83     * @param int offset
84     * @return byte
85     */
86    public function getInventory($j)
87    {
88        $o = $this->__offset(14);
89        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
90    }
91
92    /**
93     * @return int
94     */
95    public function getInventoryLength()
96    {
97        $o = $this->__offset(14);
98        return $o != 0 ? $this->__vector_len($o) : 0;
99    }
100
101    /**
102     * @return string
103     */
104    public function getInventoryBytes()
105    {
106        return $this->__vector_as_bytes(14);
107    }
108
109    /**
110     * @return byte
111     */
112    public function getColor()
113    {
114        $o = $this->__offset(16);
115        return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \MyGame\Example\Color::Blue;
116    }
117
118    /**
119     * @return byte
120     */
121    public function getTestType()
122    {
123        $o = $this->__offset(18);
124        return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \MyGame\Example\Any::NONE;
125    }
126
127    /**
128     * @returnint
129     */
130    public function getTest($obj)
131    {
132        $o = $this->__offset(20);
133        return $o != 0 ? $this->__union($obj, $o) : null;
134    }
135
136    /**
137     * @returnVectorOffset
138     */
139    public function getTest4($j)
140    {
141        $o = $this->__offset(22);
142        $obj = new Test();
143        return $o != 0 ? $obj->init($this->__vector($o) + $j *4, $this->bb) : null;
144    }
145
146    /**
147     * @return int
148     */
149    public function getTest4Length()
150    {
151        $o = $this->__offset(22);
152        return $o != 0 ? $this->__vector_len($o) : 0;
153    }
154
155    /**
156     * @param int offset
157     * @return string
158     */
159    public function getTestarrayofstring($j)
160    {
161        $o = $this->__offset(24);
162        return $o != 0 ? $this->__string($this->__vector($o) + $j * 4) : 0;
163    }
164
165    /**
166     * @return int
167     */
168    public function getTestarrayofstringLength()
169    {
170        $o = $this->__offset(24);
171        return $o != 0 ? $this->__vector_len($o) : 0;
172    }
173
174    /// an example documentation comment: this will end up in the generated code
175    /// multiline too
176    /**
177     * @returnVectorOffset
178     */
179    public function getTestarrayoftables($j)
180    {
181        $o = $this->__offset(26);
182        $obj = new Monster();
183        return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
184    }
185
186    /**
187     * @return int
188     */
189    public function getTestarrayoftablesLength()
190    {
191        $o = $this->__offset(26);
192        return $o != 0 ? $this->__vector_len($o) : 0;
193    }
194
195    public function getEnemy()
196    {
197        $obj = new Monster();
198        $o = $this->__offset(28);
199        return $o != 0 ? $obj->init($this->__indirect($o + $this->bb_pos), $this->bb) : 0;
200    }
201
202    /**
203     * @param int offset
204     * @return byte
205     */
206    public function getTestnestedflatbuffer($j)
207    {
208        $o = $this->__offset(30);
209        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
210    }
211
212    /**
213     * @return int
214     */
215    public function getTestnestedflatbufferLength()
216    {
217        $o = $this->__offset(30);
218        return $o != 0 ? $this->__vector_len($o) : 0;
219    }
220
221    /**
222     * @return string
223     */
224    public function getTestnestedflatbufferBytes()
225    {
226        return $this->__vector_as_bytes(30);
227    }
228
229    public function getTestempty()
230    {
231        $obj = new Stat();
232        $o = $this->__offset(32);
233        return $o != 0 ? $obj->init($this->__indirect($o + $this->bb_pos), $this->bb) : 0;
234    }
235
236    /**
237     * @return bool
238     */
239    public function getTestbool()
240    {
241        $o = $this->__offset(34);
242        return $o != 0 ? $this->bb->getBool($o + $this->bb_pos) : false;
243    }
244
245    /**
246     * @return int
247     */
248    public function getTesthashs32Fnv1()
249    {
250        $o = $this->__offset(36);
251        return $o != 0 ? $this->bb->getInt($o + $this->bb_pos) : 0;
252    }
253
254    /**
255     * @return uint
256     */
257    public function getTesthashu32Fnv1()
258    {
259        $o = $this->__offset(38);
260        return $o != 0 ? $this->bb->getUint($o + $this->bb_pos) : 0;
261    }
262
263    /**
264     * @return long
265     */
266    public function getTesthashs64Fnv1()
267    {
268        $o = $this->__offset(40);
269        return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0;
270    }
271
272    /**
273     * @return ulong
274     */
275    public function getTesthashu64Fnv1()
276    {
277        $o = $this->__offset(42);
278        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
279    }
280
281    /**
282     * @return int
283     */
284    public function getTesthashs32Fnv1a()
285    {
286        $o = $this->__offset(44);
287        return $o != 0 ? $this->bb->getInt($o + $this->bb_pos) : 0;
288    }
289
290    /**
291     * @return uint
292     */
293    public function getTesthashu32Fnv1a()
294    {
295        $o = $this->__offset(46);
296        return $o != 0 ? $this->bb->getUint($o + $this->bb_pos) : 0;
297    }
298
299    /**
300     * @return long
301     */
302    public function getTesthashs64Fnv1a()
303    {
304        $o = $this->__offset(48);
305        return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0;
306    }
307
308    /**
309     * @return ulong
310     */
311    public function getTesthashu64Fnv1a()
312    {
313        $o = $this->__offset(50);
314        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
315    }
316
317    /**
318     * @param int offset
319     * @return bool
320     */
321    public function getTestarrayofbools($j)
322    {
323        $o = $this->__offset(52);
324        return $o != 0 ? $this->bb->getBool($this->__vector($o) + $j * 1) : 0;
325    }
326
327    /**
328     * @return int
329     */
330    public function getTestarrayofboolsLength()
331    {
332        $o = $this->__offset(52);
333        return $o != 0 ? $this->__vector_len($o) : 0;
334    }
335
336    /**
337     * @return float
338     */
339    public function getTestf()
340    {
341        $o = $this->__offset(54);
342        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : 3.14159;
343    }
344
345    /**
346     * @return float
347     */
348    public function getTestf2()
349    {
350        $o = $this->__offset(56);
351        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : 3.0;
352    }
353
354    /**
355     * @return float
356     */
357    public function getTestf3()
358    {
359        $o = $this->__offset(58);
360        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : 0.0;
361    }
362
363    /**
364     * @param int offset
365     * @return string
366     */
367    public function getTestarrayofstring2($j)
368    {
369        $o = $this->__offset(60);
370        return $o != 0 ? $this->__string($this->__vector($o) + $j * 4) : 0;
371    }
372
373    /**
374     * @return int
375     */
376    public function getTestarrayofstring2Length()
377    {
378        $o = $this->__offset(60);
379        return $o != 0 ? $this->__vector_len($o) : 0;
380    }
381
382    /**
383     * @returnVectorOffset
384     */
385    public function getTestarrayofsortedstruct($j)
386    {
387        $o = $this->__offset(62);
388        $obj = new Ability();
389        return $o != 0 ? $obj->init($this->__vector($o) + $j *8, $this->bb) : null;
390    }
391
392    /**
393     * @return int
394     */
395    public function getTestarrayofsortedstructLength()
396    {
397        $o = $this->__offset(62);
398        return $o != 0 ? $this->__vector_len($o) : 0;
399    }
400
401    /**
402     * @param int offset
403     * @return byte
404     */
405    public function getFlex($j)
406    {
407        $o = $this->__offset(64);
408        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
409    }
410
411    /**
412     * @return int
413     */
414    public function getFlexLength()
415    {
416        $o = $this->__offset(64);
417        return $o != 0 ? $this->__vector_len($o) : 0;
418    }
419
420    /**
421     * @return string
422     */
423    public function getFlexBytes()
424    {
425        return $this->__vector_as_bytes(64);
426    }
427
428    /**
429     * @returnVectorOffset
430     */
431    public function getTest5($j)
432    {
433        $o = $this->__offset(66);
434        $obj = new Test();
435        return $o != 0 ? $obj->init($this->__vector($o) + $j *4, $this->bb) : null;
436    }
437
438    /**
439     * @return int
440     */
441    public function getTest5Length()
442    {
443        $o = $this->__offset(66);
444        return $o != 0 ? $this->__vector_len($o) : 0;
445    }
446
447    /**
448     * @param int offset
449     * @return long
450     */
451    public function getVectorOfLongs($j)
452    {
453        $o = $this->__offset(68);
454        return $o != 0 ? $this->bb->getLong($this->__vector($o) + $j * 8) : 0;
455    }
456
457    /**
458     * @return int
459     */
460    public function getVectorOfLongsLength()
461    {
462        $o = $this->__offset(68);
463        return $o != 0 ? $this->__vector_len($o) : 0;
464    }
465
466    /**
467     * @param int offset
468     * @return double
469     */
470    public function getVectorOfDoubles($j)
471    {
472        $o = $this->__offset(70);
473        return $o != 0 ? $this->bb->getDouble($this->__vector($o) + $j * 8) : 0;
474    }
475
476    /**
477     * @return int
478     */
479    public function getVectorOfDoublesLength()
480    {
481        $o = $this->__offset(70);
482        return $o != 0 ? $this->__vector_len($o) : 0;
483    }
484
485    public function getParentNamespaceTest()
486    {
487        $obj = new InParentNamespace();
488        $o = $this->__offset(72);
489        return $o != 0 ? $obj->init($this->__indirect($o + $this->bb_pos), $this->bb) : 0;
490    }
491
492    /**
493     * @returnVectorOffset
494     */
495    public function getVectorOfReferrables($j)
496    {
497        $o = $this->__offset(74);
498        $obj = new Referrable();
499        return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
500    }
501
502    /**
503     * @return int
504     */
505    public function getVectorOfReferrablesLength()
506    {
507        $o = $this->__offset(74);
508        return $o != 0 ? $this->__vector_len($o) : 0;
509    }
510
511    /**
512     * @return ulong
513     */
514    public function getSingleWeakReference()
515    {
516        $o = $this->__offset(76);
517        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
518    }
519
520    /**
521     * @param int offset
522     * @return ulong
523     */
524    public function getVectorOfWeakReferences($j)
525    {
526        $o = $this->__offset(78);
527        return $o != 0 ? $this->bb->getUlong($this->__vector($o) + $j * 8) : 0;
528    }
529
530    /**
531     * @return int
532     */
533    public function getVectorOfWeakReferencesLength()
534    {
535        $o = $this->__offset(78);
536        return $o != 0 ? $this->__vector_len($o) : 0;
537    }
538
539    /**
540     * @returnVectorOffset
541     */
542    public function getVectorOfStrongReferrables($j)
543    {
544        $o = $this->__offset(80);
545        $obj = new Referrable();
546        return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
547    }
548
549    /**
550     * @return int
551     */
552    public function getVectorOfStrongReferrablesLength()
553    {
554        $o = $this->__offset(80);
555        return $o != 0 ? $this->__vector_len($o) : 0;
556    }
557
558    /**
559     * @return ulong
560     */
561    public function getCoOwningReference()
562    {
563        $o = $this->__offset(82);
564        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
565    }
566
567    /**
568     * @param int offset
569     * @return ulong
570     */
571    public function getVectorOfCoOwningReferences($j)
572    {
573        $o = $this->__offset(84);
574        return $o != 0 ? $this->bb->getUlong($this->__vector($o) + $j * 8) : 0;
575    }
576
577    /**
578     * @return int
579     */
580    public function getVectorOfCoOwningReferencesLength()
581    {
582        $o = $this->__offset(84);
583        return $o != 0 ? $this->__vector_len($o) : 0;
584    }
585
586    /**
587     * @return ulong
588     */
589    public function getNonOwningReference()
590    {
591        $o = $this->__offset(86);
592        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
593    }
594
595    /**
596     * @param int offset
597     * @return ulong
598     */
599    public function getVectorOfNonOwningReferences($j)
600    {
601        $o = $this->__offset(88);
602        return $o != 0 ? $this->bb->getUlong($this->__vector($o) + $j * 8) : 0;
603    }
604
605    /**
606     * @return int
607     */
608    public function getVectorOfNonOwningReferencesLength()
609    {
610        $o = $this->__offset(88);
611        return $o != 0 ? $this->__vector_len($o) : 0;
612    }
613
614    /**
615     * @return byte
616     */
617    public function getAnyUniqueType()
618    {
619        $o = $this->__offset(90);
620        return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \MyGame\Example\AnyUniqueAliases::NONE;
621    }
622
623    /**
624     * @returnint
625     */
626    public function getAnyUnique($obj)
627    {
628        $o = $this->__offset(92);
629        return $o != 0 ? $this->__union($obj, $o) : null;
630    }
631
632    /**
633     * @return byte
634     */
635    public function getAnyAmbiguousType()
636    {
637        $o = $this->__offset(94);
638        return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : \MyGame\Example\AnyAmbiguousAliases::NONE;
639    }
640
641    /**
642     * @returnint
643     */
644    public function getAnyAmbiguous($obj)
645    {
646        $o = $this->__offset(96);
647        return $o != 0 ? $this->__union($obj, $o) : null;
648    }
649
650    /**
651     * @param int offset
652     * @return byte
653     */
654    public function getVectorOfEnums($j)
655    {
656        $o = $this->__offset(98);
657        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
658    }
659
660    /**
661     * @return int
662     */
663    public function getVectorOfEnumsLength()
664    {
665        $o = $this->__offset(98);
666        return $o != 0 ? $this->__vector_len($o) : 0;
667    }
668
669    /**
670     * @return string
671     */
672    public function getVectorOfEnumsBytes()
673    {
674        return $this->__vector_as_bytes(98);
675    }
676
677    /**
678     * @return sbyte
679     */
680    public function getSignedEnum()
681    {
682        $o = $this->__offset(100);
683        return $o != 0 ? $this->bb->getSbyte($o + $this->bb_pos) : \MyGame\Example\Race::None;
684    }
685
686    /**
687     * @param int offset
688     * @return byte
689     */
690    public function getTestrequirednestedflatbuffer($j)
691    {
692        $o = $this->__offset(102);
693        return $o != 0 ? $this->bb->getByte($this->__vector($o) + $j * 1) : 0;
694    }
695
696    /**
697     * @return int
698     */
699    public function getTestrequirednestedflatbufferLength()
700    {
701        $o = $this->__offset(102);
702        return $o != 0 ? $this->__vector_len($o) : 0;
703    }
704
705    /**
706     * @return string
707     */
708    public function getTestrequirednestedflatbufferBytes()
709    {
710        return $this->__vector_as_bytes(102);
711    }
712
713    /**
714     * @returnVectorOffset
715     */
716    public function getScalarKeySortedTables($j)
717    {
718        $o = $this->__offset(104);
719        $obj = new Stat();
720        return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null;
721    }
722
723    /**
724     * @return int
725     */
726    public function getScalarKeySortedTablesLength()
727    {
728        $o = $this->__offset(104);
729        return $o != 0 ? $this->__vector_len($o) : 0;
730    }
731
732    public function getNativeInline()
733    {
734        $obj = new Test();
735        $o = $this->__offset(106);
736        return $o != 0 ? $obj->init($o + $this->bb_pos, $this->bb) : 0;
737    }
738
739    /**
740     * @return ulong
741     */
742    public function getLongEnumNonEnumDefault()
743    {
744        $o = $this->__offset(108);
745        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0;
746    }
747
748    /**
749     * @return ulong
750     */
751    public function getLongEnumNormalDefault()
752    {
753        $o = $this->__offset(110);
754        return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : \MyGame\Example\LongEnum::LongOne;
755    }
756
757    /**
758     * @return float
759     */
760    public function getNanDefault()
761    {
762        $o = $this->__offset(112);
763        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : nan;
764    }
765
766    /**
767     * @return float
768     */
769    public function getInfDefault()
770    {
771        $o = $this->__offset(114);
772        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : inf;
773    }
774
775    /**
776     * @return float
777     */
778    public function getPositiveInfDefault()
779    {
780        $o = $this->__offset(116);
781        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +inf;
782    }
783
784    /**
785     * @return float
786     */
787    public function getInfinityDefault()
788    {
789        $o = $this->__offset(118);
790        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : infinity;
791    }
792
793    /**
794     * @return float
795     */
796    public function getPositiveInfinityDefault()
797    {
798        $o = $this->__offset(120);
799        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +infinity;
800    }
801
802    /**
803     * @return float
804     */
805    public function getNegativeInfDefault()
806    {
807        $o = $this->__offset(122);
808        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -inf;
809    }
810
811    /**
812     * @return float
813     */
814    public function getNegativeInfinityDefault()
815    {
816        $o = $this->__offset(124);
817        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -infinity;
818    }
819
820    /**
821     * @return double
822     */
823    public function getDoubleInfDefault()
824    {
825        $o = $this->__offset(126);
826        return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : inf;
827    }
828
829    /**
830     * @param FlatBufferBuilder $builder
831     * @return void
832     */
833    public static function startMonster(FlatBufferBuilder $builder)
834    {
835        $builder->StartObject(62);
836    }
837
838    /**
839     * @param FlatBufferBuilder $builder
840     * @return Monster
841     */
842    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default, $nan_default, $inf_default, $positive_inf_default, $infinity_default, $positive_infinity_default, $negative_inf_default, $negative_infinity_default, $double_inf_default)
843    {
844        $builder->startObject(62);
845        self::addPos($builder, $pos);
846        self::addMana($builder, $mana);
847        self::addHp($builder, $hp);
848        self::addName($builder, $name);
849        self::addInventory($builder, $inventory);
850        self::addColor($builder, $color);
851        self::addTestType($builder, $test_type);
852        self::addTest($builder, $test);
853        self::addTest4($builder, $test4);
854        self::addTestarrayofstring($builder, $testarrayofstring);
855        self::addTestarrayoftables($builder, $testarrayoftables);
856        self::addEnemy($builder, $enemy);
857        self::addTestnestedflatbuffer($builder, $testnestedflatbuffer);
858        self::addTestempty($builder, $testempty);
859        self::addTestbool($builder, $testbool);
860        self::addTesthashs32Fnv1($builder, $testhashs32_fnv1);
861        self::addTesthashu32Fnv1($builder, $testhashu32_fnv1);
862        self::addTesthashs64Fnv1($builder, $testhashs64_fnv1);
863        self::addTesthashu64Fnv1($builder, $testhashu64_fnv1);
864        self::addTesthashs32Fnv1a($builder, $testhashs32_fnv1a);
865        self::addTesthashu32Fnv1a($builder, $testhashu32_fnv1a);
866        self::addTesthashs64Fnv1a($builder, $testhashs64_fnv1a);
867        self::addTesthashu64Fnv1a($builder, $testhashu64_fnv1a);
868        self::addTestarrayofbools($builder, $testarrayofbools);
869        self::addTestf($builder, $testf);
870        self::addTestf2($builder, $testf2);
871        self::addTestf3($builder, $testf3);
872        self::addTestarrayofstring2($builder, $testarrayofstring2);
873        self::addTestarrayofsortedstruct($builder, $testarrayofsortedstruct);
874        self::addFlex($builder, $flex);
875        self::addTest5($builder, $test5);
876        self::addVectorOfLongs($builder, $vector_of_longs);
877        self::addVectorOfDoubles($builder, $vector_of_doubles);
878        self::addParentNamespaceTest($builder, $parent_namespace_test);
879        self::addVectorOfReferrables($builder, $vector_of_referrables);
880        self::addSingleWeakReference($builder, $single_weak_reference);
881        self::addVectorOfWeakReferences($builder, $vector_of_weak_references);
882        self::addVectorOfStrongReferrables($builder, $vector_of_strong_referrables);
883        self::addCoOwningReference($builder, $co_owning_reference);
884        self::addVectorOfCoOwningReferences($builder, $vector_of_co_owning_references);
885        self::addNonOwningReference($builder, $non_owning_reference);
886        self::addVectorOfNonOwningReferences($builder, $vector_of_non_owning_references);
887        self::addAnyUniqueType($builder, $any_unique_type);
888        self::addAnyUnique($builder, $any_unique);
889        self::addAnyAmbiguousType($builder, $any_ambiguous_type);
890        self::addAnyAmbiguous($builder, $any_ambiguous);
891        self::addVectorOfEnums($builder, $vector_of_enums);
892        self::addSignedEnum($builder, $signed_enum);
893        self::addTestrequirednestedflatbuffer($builder, $testrequirednestedflatbuffer);
894        self::addScalarKeySortedTables($builder, $scalar_key_sorted_tables);
895        self::addNativeInline($builder, $native_inline);
896        self::addLongEnumNonEnumDefault($builder, $long_enum_non_enum_default);
897        self::addLongEnumNormalDefault($builder, $long_enum_normal_default);
898        self::addNanDefault($builder, $nan_default);
899        self::addInfDefault($builder, $inf_default);
900        self::addPositiveInfDefault($builder, $positive_inf_default);
901        self::addInfinityDefault($builder, $infinity_default);
902        self::addPositiveInfinityDefault($builder, $positive_infinity_default);
903        self::addNegativeInfDefault($builder, $negative_inf_default);
904        self::addNegativeInfinityDefault($builder, $negative_infinity_default);
905        self::addDoubleInfDefault($builder, $double_inf_default);
906        $o = $builder->endObject();
907        $builder->required($o, 10);  // name
908        return $o;
909    }
910
911    /**
912     * @param FlatBufferBuilder $builder
913     * @param VectorOffset
914     * @return void
915     */
916    public static function addPos(FlatBufferBuilder $builder, $pos)
917    {
918        $builder->addStructX(0, $pos, 0);
919    }
920
921    /**
922     * @param FlatBufferBuilder $builder
923     * @param short
924     * @return void
925     */
926    public static function addMana(FlatBufferBuilder $builder, $mana)
927    {
928        $builder->addShortX(1, $mana, 150);
929    }
930
931    /**
932     * @param FlatBufferBuilder $builder
933     * @param short
934     * @return void
935     */
936    public static function addHp(FlatBufferBuilder $builder, $hp)
937    {
938        $builder->addShortX(2, $hp, 100);
939    }
940
941    /**
942     * @param FlatBufferBuilder $builder
943     * @param StringOffset
944     * @return void
945     */
946    public static function addName(FlatBufferBuilder $builder, $name)
947    {
948        $builder->addOffsetX(3, $name, 0);
949    }
950
951    /**
952     * @param FlatBufferBuilder $builder
953     * @param VectorOffset
954     * @return void
955     */
956    public static function addInventory(FlatBufferBuilder $builder, $inventory)
957    {
958        $builder->addOffsetX(5, $inventory, 0);
959    }
960
961    /**
962     * @param FlatBufferBuilder $builder
963     * @param array offset array
964     * @return int vector offset
965     */
966    public static function createInventoryVector(FlatBufferBuilder $builder, array $data)
967    {
968        $builder->startVector(1, count($data), 1);
969        for ($i = count($data) - 1; $i >= 0; $i--) {
970            $builder->putByte($data[$i]);
971        }
972        return $builder->endVector();
973    }
974
975    /**
976     * @param FlatBufferBuilder $builder
977     * @param int $numElems
978     * @return void
979     */
980    public static function startInventoryVector(FlatBufferBuilder $builder, $numElems)
981    {
982        $builder->startVector(1, $numElems, 1);
983    }
984
985    /**
986     * @param FlatBufferBuilder $builder
987     * @param byte
988     * @return void
989     */
990    public static function addColor(FlatBufferBuilder $builder, $color)
991    {
992        $builder->addByteX(6, $color, 8);
993    }
994
995    /**
996     * @param FlatBufferBuilder $builder
997     * @param byte
998     * @return void
999     */
1000    public static function addTestType(FlatBufferBuilder $builder, $testType)
1001    {
1002        $builder->addByteX(7, $testType, 0);
1003    }
1004
1005    public static function addTest(FlatBufferBuilder $builder, $offset)
1006    {
1007        $builder->addOffsetX(8, $offset, 0);
1008    }
1009
1010    /**
1011     * @param FlatBufferBuilder $builder
1012     * @param VectorOffset
1013     * @return void
1014     */
1015    public static function addTest4(FlatBufferBuilder $builder, $test4)
1016    {
1017        $builder->addOffsetX(9, $test4, 0);
1018    }
1019
1020    /**
1021     * @param FlatBufferBuilder $builder
1022     * @param array offset array
1023     * @return int vector offset
1024     */
1025    public static function createTest4Vector(FlatBufferBuilder $builder, array $data)
1026    {
1027        $builder->startVector(4, count($data), 2);
1028        for ($i = count($data) - 1; $i >= 0; $i--) {
1029            $builder->putOffset($data[$i]);
1030        }
1031        return $builder->endVector();
1032    }
1033
1034    /**
1035     * @param FlatBufferBuilder $builder
1036     * @param int $numElems
1037     * @return void
1038     */
1039    public static function startTest4Vector(FlatBufferBuilder $builder, $numElems)
1040    {
1041        $builder->startVector(4, $numElems, 2);
1042    }
1043
1044    /**
1045     * @param FlatBufferBuilder $builder
1046     * @param VectorOffset
1047     * @return void
1048     */
1049    public static function addTestarrayofstring(FlatBufferBuilder $builder, $testarrayofstring)
1050    {
1051        $builder->addOffsetX(10, $testarrayofstring, 0);
1052    }
1053
1054    /**
1055     * @param FlatBufferBuilder $builder
1056     * @param array offset array
1057     * @return int vector offset
1058     */
1059    public static function createTestarrayofstringVector(FlatBufferBuilder $builder, array $data)
1060    {
1061        $builder->startVector(4, count($data), 4);
1062        for ($i = count($data) - 1; $i >= 0; $i--) {
1063            $builder->putOffset($data[$i]);
1064        }
1065        return $builder->endVector();
1066    }
1067
1068    /**
1069     * @param FlatBufferBuilder $builder
1070     * @param int $numElems
1071     * @return void
1072     */
1073    public static function startTestarrayofstringVector(FlatBufferBuilder $builder, $numElems)
1074    {
1075        $builder->startVector(4, $numElems, 4);
1076    }
1077
1078    /**
1079     * @param FlatBufferBuilder $builder
1080     * @param VectorOffset
1081     * @return void
1082     */
1083    public static function addTestarrayoftables(FlatBufferBuilder $builder, $testarrayoftables)
1084    {
1085        $builder->addOffsetX(11, $testarrayoftables, 0);
1086    }
1087
1088    /**
1089     * @param FlatBufferBuilder $builder
1090     * @param array offset array
1091     * @return int vector offset
1092     */
1093    public static function createTestarrayoftablesVector(FlatBufferBuilder $builder, array $data)
1094    {
1095        $builder->startVector(4, count($data), 4);
1096        for ($i = count($data) - 1; $i >= 0; $i--) {
1097            $builder->putOffset($data[$i]);
1098        }
1099        return $builder->endVector();
1100    }
1101
1102    /**
1103     * @param FlatBufferBuilder $builder
1104     * @param int $numElems
1105     * @return void
1106     */
1107    public static function startTestarrayoftablesVector(FlatBufferBuilder $builder, $numElems)
1108    {
1109        $builder->startVector(4, $numElems, 4);
1110    }
1111
1112    /**
1113     * @param FlatBufferBuilder $builder
1114     * @param VectorOffset
1115     * @return void
1116     */
1117    public static function addEnemy(FlatBufferBuilder $builder, $enemy)
1118    {
1119        $builder->addOffsetX(12, $enemy, 0);
1120    }
1121
1122    /**
1123     * @param FlatBufferBuilder $builder
1124     * @param VectorOffset
1125     * @return void
1126     */
1127    public static function addTestnestedflatbuffer(FlatBufferBuilder $builder, $testnestedflatbuffer)
1128    {
1129        $builder->addOffsetX(13, $testnestedflatbuffer, 0);
1130    }
1131
1132    /**
1133     * @param FlatBufferBuilder $builder
1134     * @param array offset array
1135     * @return int vector offset
1136     */
1137    public static function createTestnestedflatbufferVector(FlatBufferBuilder $builder, array $data)
1138    {
1139        $builder->startVector(1, count($data), 1);
1140        for ($i = count($data) - 1; $i >= 0; $i--) {
1141            $builder->putByte($data[$i]);
1142        }
1143        return $builder->endVector();
1144    }
1145
1146    /**
1147     * @param FlatBufferBuilder $builder
1148     * @param int $numElems
1149     * @return void
1150     */
1151    public static function startTestnestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
1152    {
1153        $builder->startVector(1, $numElems, 1);
1154    }
1155
1156    /**
1157     * @param FlatBufferBuilder $builder
1158     * @param VectorOffset
1159     * @return void
1160     */
1161    public static function addTestempty(FlatBufferBuilder $builder, $testempty)
1162    {
1163        $builder->addOffsetX(14, $testempty, 0);
1164    }
1165
1166    /**
1167     * @param FlatBufferBuilder $builder
1168     * @param bool
1169     * @return void
1170     */
1171    public static function addTestbool(FlatBufferBuilder $builder, $testbool)
1172    {
1173        $builder->addBoolX(15, $testbool, false);
1174    }
1175
1176    /**
1177     * @param FlatBufferBuilder $builder
1178     * @param int
1179     * @return void
1180     */
1181    public static function addTesthashs32Fnv1(FlatBufferBuilder $builder, $testhashs32Fnv1)
1182    {
1183        $builder->addIntX(16, $testhashs32Fnv1, 0);
1184    }
1185
1186    /**
1187     * @param FlatBufferBuilder $builder
1188     * @param uint
1189     * @return void
1190     */
1191    public static function addTesthashu32Fnv1(FlatBufferBuilder $builder, $testhashu32Fnv1)
1192    {
1193        $builder->addUintX(17, $testhashu32Fnv1, 0);
1194    }
1195
1196    /**
1197     * @param FlatBufferBuilder $builder
1198     * @param long
1199     * @return void
1200     */
1201    public static function addTesthashs64Fnv1(FlatBufferBuilder $builder, $testhashs64Fnv1)
1202    {
1203        $builder->addLongX(18, $testhashs64Fnv1, 0);
1204    }
1205
1206    /**
1207     * @param FlatBufferBuilder $builder
1208     * @param ulong
1209     * @return void
1210     */
1211    public static function addTesthashu64Fnv1(FlatBufferBuilder $builder, $testhashu64Fnv1)
1212    {
1213        $builder->addUlongX(19, $testhashu64Fnv1, 0);
1214    }
1215
1216    /**
1217     * @param FlatBufferBuilder $builder
1218     * @param int
1219     * @return void
1220     */
1221    public static function addTesthashs32Fnv1a(FlatBufferBuilder $builder, $testhashs32Fnv1a)
1222    {
1223        $builder->addIntX(20, $testhashs32Fnv1a, 0);
1224    }
1225
1226    /**
1227     * @param FlatBufferBuilder $builder
1228     * @param uint
1229     * @return void
1230     */
1231    public static function addTesthashu32Fnv1a(FlatBufferBuilder $builder, $testhashu32Fnv1a)
1232    {
1233        $builder->addUintX(21, $testhashu32Fnv1a, 0);
1234    }
1235
1236    /**
1237     * @param FlatBufferBuilder $builder
1238     * @param long
1239     * @return void
1240     */
1241    public static function addTesthashs64Fnv1a(FlatBufferBuilder $builder, $testhashs64Fnv1a)
1242    {
1243        $builder->addLongX(22, $testhashs64Fnv1a, 0);
1244    }
1245
1246    /**
1247     * @param FlatBufferBuilder $builder
1248     * @param ulong
1249     * @return void
1250     */
1251    public static function addTesthashu64Fnv1a(FlatBufferBuilder $builder, $testhashu64Fnv1a)
1252    {
1253        $builder->addUlongX(23, $testhashu64Fnv1a, 0);
1254    }
1255
1256    /**
1257     * @param FlatBufferBuilder $builder
1258     * @param VectorOffset
1259     * @return void
1260     */
1261    public static function addTestarrayofbools(FlatBufferBuilder $builder, $testarrayofbools)
1262    {
1263        $builder->addOffsetX(24, $testarrayofbools, 0);
1264    }
1265
1266    /**
1267     * @param FlatBufferBuilder $builder
1268     * @param array offset array
1269     * @return int vector offset
1270     */
1271    public static function createTestarrayofboolsVector(FlatBufferBuilder $builder, array $data)
1272    {
1273        $builder->startVector(1, count($data), 1);
1274        for ($i = count($data) - 1; $i >= 0; $i--) {
1275            $builder->putBool($data[$i]);
1276        }
1277        return $builder->endVector();
1278    }
1279
1280    /**
1281     * @param FlatBufferBuilder $builder
1282     * @param int $numElems
1283     * @return void
1284     */
1285    public static function startTestarrayofboolsVector(FlatBufferBuilder $builder, $numElems)
1286    {
1287        $builder->startVector(1, $numElems, 1);
1288    }
1289
1290    /**
1291     * @param FlatBufferBuilder $builder
1292     * @param float
1293     * @return void
1294     */
1295    public static function addTestf(FlatBufferBuilder $builder, $testf)
1296    {
1297        $builder->addFloatX(25, $testf, 3.14159);
1298    }
1299
1300    /**
1301     * @param FlatBufferBuilder $builder
1302     * @param float
1303     * @return void
1304     */
1305    public static function addTestf2(FlatBufferBuilder $builder, $testf2)
1306    {
1307        $builder->addFloatX(26, $testf2, 3.0);
1308    }
1309
1310    /**
1311     * @param FlatBufferBuilder $builder
1312     * @param float
1313     * @return void
1314     */
1315    public static function addTestf3(FlatBufferBuilder $builder, $testf3)
1316    {
1317        $builder->addFloatX(27, $testf3, 0.0);
1318    }
1319
1320    /**
1321     * @param FlatBufferBuilder $builder
1322     * @param VectorOffset
1323     * @return void
1324     */
1325    public static function addTestarrayofstring2(FlatBufferBuilder $builder, $testarrayofstring2)
1326    {
1327        $builder->addOffsetX(28, $testarrayofstring2, 0);
1328    }
1329
1330    /**
1331     * @param FlatBufferBuilder $builder
1332     * @param array offset array
1333     * @return int vector offset
1334     */
1335    public static function createTestarrayofstring2Vector(FlatBufferBuilder $builder, array $data)
1336    {
1337        $builder->startVector(4, count($data), 4);
1338        for ($i = count($data) - 1; $i >= 0; $i--) {
1339            $builder->putOffset($data[$i]);
1340        }
1341        return $builder->endVector();
1342    }
1343
1344    /**
1345     * @param FlatBufferBuilder $builder
1346     * @param int $numElems
1347     * @return void
1348     */
1349    public static function startTestarrayofstring2Vector(FlatBufferBuilder $builder, $numElems)
1350    {
1351        $builder->startVector(4, $numElems, 4);
1352    }
1353
1354    /**
1355     * @param FlatBufferBuilder $builder
1356     * @param VectorOffset
1357     * @return void
1358     */
1359    public static function addTestarrayofsortedstruct(FlatBufferBuilder $builder, $testarrayofsortedstruct)
1360    {
1361        $builder->addOffsetX(29, $testarrayofsortedstruct, 0);
1362    }
1363
1364    /**
1365     * @param FlatBufferBuilder $builder
1366     * @param array offset array
1367     * @return int vector offset
1368     */
1369    public static function createTestarrayofsortedstructVector(FlatBufferBuilder $builder, array $data)
1370    {
1371        $builder->startVector(8, count($data), 4);
1372        for ($i = count($data) - 1; $i >= 0; $i--) {
1373            $builder->putOffset($data[$i]);
1374        }
1375        return $builder->endVector();
1376    }
1377
1378    /**
1379     * @param FlatBufferBuilder $builder
1380     * @param int $numElems
1381     * @return void
1382     */
1383    public static function startTestarrayofsortedstructVector(FlatBufferBuilder $builder, $numElems)
1384    {
1385        $builder->startVector(8, $numElems, 4);
1386    }
1387
1388    /**
1389     * @param FlatBufferBuilder $builder
1390     * @param VectorOffset
1391     * @return void
1392     */
1393    public static function addFlex(FlatBufferBuilder $builder, $flex)
1394    {
1395        $builder->addOffsetX(30, $flex, 0);
1396    }
1397
1398    /**
1399     * @param FlatBufferBuilder $builder
1400     * @param array offset array
1401     * @return int vector offset
1402     */
1403    public static function createFlexVector(FlatBufferBuilder $builder, array $data)
1404    {
1405        $builder->startVector(1, count($data), 1);
1406        for ($i = count($data) - 1; $i >= 0; $i--) {
1407            $builder->putByte($data[$i]);
1408        }
1409        return $builder->endVector();
1410    }
1411
1412    /**
1413     * @param FlatBufferBuilder $builder
1414     * @param int $numElems
1415     * @return void
1416     */
1417    public static function startFlexVector(FlatBufferBuilder $builder, $numElems)
1418    {
1419        $builder->startVector(1, $numElems, 1);
1420    }
1421
1422    /**
1423     * @param FlatBufferBuilder $builder
1424     * @param VectorOffset
1425     * @return void
1426     */
1427    public static function addTest5(FlatBufferBuilder $builder, $test5)
1428    {
1429        $builder->addOffsetX(31, $test5, 0);
1430    }
1431
1432    /**
1433     * @param FlatBufferBuilder $builder
1434     * @param array offset array
1435     * @return int vector offset
1436     */
1437    public static function createTest5Vector(FlatBufferBuilder $builder, array $data)
1438    {
1439        $builder->startVector(4, count($data), 2);
1440        for ($i = count($data) - 1; $i >= 0; $i--) {
1441            $builder->putOffset($data[$i]);
1442        }
1443        return $builder->endVector();
1444    }
1445
1446    /**
1447     * @param FlatBufferBuilder $builder
1448     * @param int $numElems
1449     * @return void
1450     */
1451    public static function startTest5Vector(FlatBufferBuilder $builder, $numElems)
1452    {
1453        $builder->startVector(4, $numElems, 2);
1454    }
1455
1456    /**
1457     * @param FlatBufferBuilder $builder
1458     * @param VectorOffset
1459     * @return void
1460     */
1461    public static function addVectorOfLongs(FlatBufferBuilder $builder, $vectorOfLongs)
1462    {
1463        $builder->addOffsetX(32, $vectorOfLongs, 0);
1464    }
1465
1466    /**
1467     * @param FlatBufferBuilder $builder
1468     * @param array offset array
1469     * @return int vector offset
1470     */
1471    public static function createVectorOfLongsVector(FlatBufferBuilder $builder, array $data)
1472    {
1473        $builder->startVector(8, count($data), 8);
1474        for ($i = count($data) - 1; $i >= 0; $i--) {
1475            $builder->putLong($data[$i]);
1476        }
1477        return $builder->endVector();
1478    }
1479
1480    /**
1481     * @param FlatBufferBuilder $builder
1482     * @param int $numElems
1483     * @return void
1484     */
1485    public static function startVectorOfLongsVector(FlatBufferBuilder $builder, $numElems)
1486    {
1487        $builder->startVector(8, $numElems, 8);
1488    }
1489
1490    /**
1491     * @param FlatBufferBuilder $builder
1492     * @param VectorOffset
1493     * @return void
1494     */
1495    public static function addVectorOfDoubles(FlatBufferBuilder $builder, $vectorOfDoubles)
1496    {
1497        $builder->addOffsetX(33, $vectorOfDoubles, 0);
1498    }
1499
1500    /**
1501     * @param FlatBufferBuilder $builder
1502     * @param array offset array
1503     * @return int vector offset
1504     */
1505    public static function createVectorOfDoublesVector(FlatBufferBuilder $builder, array $data)
1506    {
1507        $builder->startVector(8, count($data), 8);
1508        for ($i = count($data) - 1; $i >= 0; $i--) {
1509            $builder->putDouble($data[$i]);
1510        }
1511        return $builder->endVector();
1512    }
1513
1514    /**
1515     * @param FlatBufferBuilder $builder
1516     * @param int $numElems
1517     * @return void
1518     */
1519    public static function startVectorOfDoublesVector(FlatBufferBuilder $builder, $numElems)
1520    {
1521        $builder->startVector(8, $numElems, 8);
1522    }
1523
1524    /**
1525     * @param FlatBufferBuilder $builder
1526     * @param VectorOffset
1527     * @return void
1528     */
1529    public static function addParentNamespaceTest(FlatBufferBuilder $builder, $parentNamespaceTest)
1530    {
1531        $builder->addOffsetX(34, $parentNamespaceTest, 0);
1532    }
1533
1534    /**
1535     * @param FlatBufferBuilder $builder
1536     * @param VectorOffset
1537     * @return void
1538     */
1539    public static function addVectorOfReferrables(FlatBufferBuilder $builder, $vectorOfReferrables)
1540    {
1541        $builder->addOffsetX(35, $vectorOfReferrables, 0);
1542    }
1543
1544    /**
1545     * @param FlatBufferBuilder $builder
1546     * @param array offset array
1547     * @return int vector offset
1548     */
1549    public static function createVectorOfReferrablesVector(FlatBufferBuilder $builder, array $data)
1550    {
1551        $builder->startVector(4, count($data), 4);
1552        for ($i = count($data) - 1; $i >= 0; $i--) {
1553            $builder->putOffset($data[$i]);
1554        }
1555        return $builder->endVector();
1556    }
1557
1558    /**
1559     * @param FlatBufferBuilder $builder
1560     * @param int $numElems
1561     * @return void
1562     */
1563    public static function startVectorOfReferrablesVector(FlatBufferBuilder $builder, $numElems)
1564    {
1565        $builder->startVector(4, $numElems, 4);
1566    }
1567
1568    /**
1569     * @param FlatBufferBuilder $builder
1570     * @param ulong
1571     * @return void
1572     */
1573    public static function addSingleWeakReference(FlatBufferBuilder $builder, $singleWeakReference)
1574    {
1575        $builder->addUlongX(36, $singleWeakReference, 0);
1576    }
1577
1578    /**
1579     * @param FlatBufferBuilder $builder
1580     * @param VectorOffset
1581     * @return void
1582     */
1583    public static function addVectorOfWeakReferences(FlatBufferBuilder $builder, $vectorOfWeakReferences)
1584    {
1585        $builder->addOffsetX(37, $vectorOfWeakReferences, 0);
1586    }
1587
1588    /**
1589     * @param FlatBufferBuilder $builder
1590     * @param array offset array
1591     * @return int vector offset
1592     */
1593    public static function createVectorOfWeakReferencesVector(FlatBufferBuilder $builder, array $data)
1594    {
1595        $builder->startVector(8, count($data), 8);
1596        for ($i = count($data) - 1; $i >= 0; $i--) {
1597            $builder->putUlong($data[$i]);
1598        }
1599        return $builder->endVector();
1600    }
1601
1602    /**
1603     * @param FlatBufferBuilder $builder
1604     * @param int $numElems
1605     * @return void
1606     */
1607    public static function startVectorOfWeakReferencesVector(FlatBufferBuilder $builder, $numElems)
1608    {
1609        $builder->startVector(8, $numElems, 8);
1610    }
1611
1612    /**
1613     * @param FlatBufferBuilder $builder
1614     * @param VectorOffset
1615     * @return void
1616     */
1617    public static function addVectorOfStrongReferrables(FlatBufferBuilder $builder, $vectorOfStrongReferrables)
1618    {
1619        $builder->addOffsetX(38, $vectorOfStrongReferrables, 0);
1620    }
1621
1622    /**
1623     * @param FlatBufferBuilder $builder
1624     * @param array offset array
1625     * @return int vector offset
1626     */
1627    public static function createVectorOfStrongReferrablesVector(FlatBufferBuilder $builder, array $data)
1628    {
1629        $builder->startVector(4, count($data), 4);
1630        for ($i = count($data) - 1; $i >= 0; $i--) {
1631            $builder->putOffset($data[$i]);
1632        }
1633        return $builder->endVector();
1634    }
1635
1636    /**
1637     * @param FlatBufferBuilder $builder
1638     * @param int $numElems
1639     * @return void
1640     */
1641    public static function startVectorOfStrongReferrablesVector(FlatBufferBuilder $builder, $numElems)
1642    {
1643        $builder->startVector(4, $numElems, 4);
1644    }
1645
1646    /**
1647     * @param FlatBufferBuilder $builder
1648     * @param ulong
1649     * @return void
1650     */
1651    public static function addCoOwningReference(FlatBufferBuilder $builder, $coOwningReference)
1652    {
1653        $builder->addUlongX(39, $coOwningReference, 0);
1654    }
1655
1656    /**
1657     * @param FlatBufferBuilder $builder
1658     * @param VectorOffset
1659     * @return void
1660     */
1661    public static function addVectorOfCoOwningReferences(FlatBufferBuilder $builder, $vectorOfCoOwningReferences)
1662    {
1663        $builder->addOffsetX(40, $vectorOfCoOwningReferences, 0);
1664    }
1665
1666    /**
1667     * @param FlatBufferBuilder $builder
1668     * @param array offset array
1669     * @return int vector offset
1670     */
1671    public static function createVectorOfCoOwningReferencesVector(FlatBufferBuilder $builder, array $data)
1672    {
1673        $builder->startVector(8, count($data), 8);
1674        for ($i = count($data) - 1; $i >= 0; $i--) {
1675            $builder->putUlong($data[$i]);
1676        }
1677        return $builder->endVector();
1678    }
1679
1680    /**
1681     * @param FlatBufferBuilder $builder
1682     * @param int $numElems
1683     * @return void
1684     */
1685    public static function startVectorOfCoOwningReferencesVector(FlatBufferBuilder $builder, $numElems)
1686    {
1687        $builder->startVector(8, $numElems, 8);
1688    }
1689
1690    /**
1691     * @param FlatBufferBuilder $builder
1692     * @param ulong
1693     * @return void
1694     */
1695    public static function addNonOwningReference(FlatBufferBuilder $builder, $nonOwningReference)
1696    {
1697        $builder->addUlongX(41, $nonOwningReference, 0);
1698    }
1699
1700    /**
1701     * @param FlatBufferBuilder $builder
1702     * @param VectorOffset
1703     * @return void
1704     */
1705    public static function addVectorOfNonOwningReferences(FlatBufferBuilder $builder, $vectorOfNonOwningReferences)
1706    {
1707        $builder->addOffsetX(42, $vectorOfNonOwningReferences, 0);
1708    }
1709
1710    /**
1711     * @param FlatBufferBuilder $builder
1712     * @param array offset array
1713     * @return int vector offset
1714     */
1715    public static function createVectorOfNonOwningReferencesVector(FlatBufferBuilder $builder, array $data)
1716    {
1717        $builder->startVector(8, count($data), 8);
1718        for ($i = count($data) - 1; $i >= 0; $i--) {
1719            $builder->putUlong($data[$i]);
1720        }
1721        return $builder->endVector();
1722    }
1723
1724    /**
1725     * @param FlatBufferBuilder $builder
1726     * @param int $numElems
1727     * @return void
1728     */
1729    public static function startVectorOfNonOwningReferencesVector(FlatBufferBuilder $builder, $numElems)
1730    {
1731        $builder->startVector(8, $numElems, 8);
1732    }
1733
1734    /**
1735     * @param FlatBufferBuilder $builder
1736     * @param byte
1737     * @return void
1738     */
1739    public static function addAnyUniqueType(FlatBufferBuilder $builder, $anyUniqueType)
1740    {
1741        $builder->addByteX(43, $anyUniqueType, 0);
1742    }
1743
1744    public static function addAnyUnique(FlatBufferBuilder $builder, $offset)
1745    {
1746        $builder->addOffsetX(44, $offset, 0);
1747    }
1748
1749    /**
1750     * @param FlatBufferBuilder $builder
1751     * @param byte
1752     * @return void
1753     */
1754    public static function addAnyAmbiguousType(FlatBufferBuilder $builder, $anyAmbiguousType)
1755    {
1756        $builder->addByteX(45, $anyAmbiguousType, 0);
1757    }
1758
1759    public static function addAnyAmbiguous(FlatBufferBuilder $builder, $offset)
1760    {
1761        $builder->addOffsetX(46, $offset, 0);
1762    }
1763
1764    /**
1765     * @param FlatBufferBuilder $builder
1766     * @param VectorOffset
1767     * @return void
1768     */
1769    public static function addVectorOfEnums(FlatBufferBuilder $builder, $vectorOfEnums)
1770    {
1771        $builder->addOffsetX(47, $vectorOfEnums, 0);
1772    }
1773
1774    /**
1775     * @param FlatBufferBuilder $builder
1776     * @param array offset array
1777     * @return int vector offset
1778     */
1779    public static function createVectorOfEnumsVector(FlatBufferBuilder $builder, array $data)
1780    {
1781        $builder->startVector(1, count($data), 1);
1782        for ($i = count($data) - 1; $i >= 0; $i--) {
1783            $builder->putByte($data[$i]);
1784        }
1785        return $builder->endVector();
1786    }
1787
1788    /**
1789     * @param FlatBufferBuilder $builder
1790     * @param int $numElems
1791     * @return void
1792     */
1793    public static function startVectorOfEnumsVector(FlatBufferBuilder $builder, $numElems)
1794    {
1795        $builder->startVector(1, $numElems, 1);
1796    }
1797
1798    /**
1799     * @param FlatBufferBuilder $builder
1800     * @param sbyte
1801     * @return void
1802     */
1803    public static function addSignedEnum(FlatBufferBuilder $builder, $signedEnum)
1804    {
1805        $builder->addSbyteX(48, $signedEnum, -1);
1806    }
1807
1808    /**
1809     * @param FlatBufferBuilder $builder
1810     * @param VectorOffset
1811     * @return void
1812     */
1813    public static function addTestrequirednestedflatbuffer(FlatBufferBuilder $builder, $testrequirednestedflatbuffer)
1814    {
1815        $builder->addOffsetX(49, $testrequirednestedflatbuffer, 0);
1816    }
1817
1818    /**
1819     * @param FlatBufferBuilder $builder
1820     * @param array offset array
1821     * @return int vector offset
1822     */
1823    public static function createTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, array $data)
1824    {
1825        $builder->startVector(1, count($data), 1);
1826        for ($i = count($data) - 1; $i >= 0; $i--) {
1827            $builder->putByte($data[$i]);
1828        }
1829        return $builder->endVector();
1830    }
1831
1832    /**
1833     * @param FlatBufferBuilder $builder
1834     * @param int $numElems
1835     * @return void
1836     */
1837    public static function startTestrequirednestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
1838    {
1839        $builder->startVector(1, $numElems, 1);
1840    }
1841
1842    /**
1843     * @param FlatBufferBuilder $builder
1844     * @param VectorOffset
1845     * @return void
1846     */
1847    public static function addScalarKeySortedTables(FlatBufferBuilder $builder, $scalarKeySortedTables)
1848    {
1849        $builder->addOffsetX(50, $scalarKeySortedTables, 0);
1850    }
1851
1852    /**
1853     * @param FlatBufferBuilder $builder
1854     * @param array offset array
1855     * @return int vector offset
1856     */
1857    public static function createScalarKeySortedTablesVector(FlatBufferBuilder $builder, array $data)
1858    {
1859        $builder->startVector(4, count($data), 4);
1860        for ($i = count($data) - 1; $i >= 0; $i--) {
1861            $builder->putOffset($data[$i]);
1862        }
1863        return $builder->endVector();
1864    }
1865
1866    /**
1867     * @param FlatBufferBuilder $builder
1868     * @param int $numElems
1869     * @return void
1870     */
1871    public static function startScalarKeySortedTablesVector(FlatBufferBuilder $builder, $numElems)
1872    {
1873        $builder->startVector(4, $numElems, 4);
1874    }
1875
1876    /**
1877     * @param FlatBufferBuilder $builder
1878     * @param VectorOffset
1879     * @return void
1880     */
1881    public static function addNativeInline(FlatBufferBuilder $builder, $nativeInline)
1882    {
1883        $builder->addStructX(51, $nativeInline, 0);
1884    }
1885
1886    /**
1887     * @param FlatBufferBuilder $builder
1888     * @param ulong
1889     * @return void
1890     */
1891    public static function addLongEnumNonEnumDefault(FlatBufferBuilder $builder, $longEnumNonEnumDefault)
1892    {
1893        $builder->addUlongX(52, $longEnumNonEnumDefault, 0);
1894    }
1895
1896    /**
1897     * @param FlatBufferBuilder $builder
1898     * @param ulong
1899     * @return void
1900     */
1901    public static function addLongEnumNormalDefault(FlatBufferBuilder $builder, $longEnumNormalDefault)
1902    {
1903        $builder->addUlongX(53, $longEnumNormalDefault, 2);
1904    }
1905
1906    /**
1907     * @param FlatBufferBuilder $builder
1908     * @param float
1909     * @return void
1910     */
1911    public static function addNanDefault(FlatBufferBuilder $builder, $nanDefault)
1912    {
1913        $builder->addFloatX(54, $nanDefault, nan);
1914    }
1915
1916    /**
1917     * @param FlatBufferBuilder $builder
1918     * @param float
1919     * @return void
1920     */
1921    public static function addInfDefault(FlatBufferBuilder $builder, $infDefault)
1922    {
1923        $builder->addFloatX(55, $infDefault, inf);
1924    }
1925
1926    /**
1927     * @param FlatBufferBuilder $builder
1928     * @param float
1929     * @return void
1930     */
1931    public static function addPositiveInfDefault(FlatBufferBuilder $builder, $positiveInfDefault)
1932    {
1933        $builder->addFloatX(56, $positiveInfDefault, +inf);
1934    }
1935
1936    /**
1937     * @param FlatBufferBuilder $builder
1938     * @param float
1939     * @return void
1940     */
1941    public static function addInfinityDefault(FlatBufferBuilder $builder, $infinityDefault)
1942    {
1943        $builder->addFloatX(57, $infinityDefault, infinity);
1944    }
1945
1946    /**
1947     * @param FlatBufferBuilder $builder
1948     * @param float
1949     * @return void
1950     */
1951    public static function addPositiveInfinityDefault(FlatBufferBuilder $builder, $positiveInfinityDefault)
1952    {
1953        $builder->addFloatX(58, $positiveInfinityDefault, +infinity);
1954    }
1955
1956    /**
1957     * @param FlatBufferBuilder $builder
1958     * @param float
1959     * @return void
1960     */
1961    public static function addNegativeInfDefault(FlatBufferBuilder $builder, $negativeInfDefault)
1962    {
1963        $builder->addFloatX(59, $negativeInfDefault, -inf);
1964    }
1965
1966    /**
1967     * @param FlatBufferBuilder $builder
1968     * @param float
1969     * @return void
1970     */
1971    public static function addNegativeInfinityDefault(FlatBufferBuilder $builder, $negativeInfinityDefault)
1972    {
1973        $builder->addFloatX(60, $negativeInfinityDefault, -infinity);
1974    }
1975
1976    /**
1977     * @param FlatBufferBuilder $builder
1978     * @param double
1979     * @return void
1980     */
1981    public static function addDoubleInfDefault(FlatBufferBuilder $builder, $doubleInfDefault)
1982    {
1983        $builder->addDoubleX(61, $doubleInfDefault, inf);
1984    }
1985
1986    /**
1987     * @param FlatBufferBuilder $builder
1988     * @return int table offset
1989     */
1990    public static function endMonster(FlatBufferBuilder $builder)
1991    {
1992        $o = $builder->endObject();
1993        $builder->required($o, 10);  // name
1994        return $o;
1995    }
1996
1997    public static function finishMonsterBuffer(FlatBufferBuilder $builder, $offset)
1998    {
1999        $builder->finish($offset, "MONS");
2000    }
2001}
2002