• 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 sbyte
111     */
112    public function getColor()
113    {
114        $o = $this->__offset(16);
115        return $o != 0 ? $this->bb->getSbyte($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     * @param FlatBufferBuilder $builder
494     * @return void
495     */
496    public static function startMonster(FlatBufferBuilder $builder)
497    {
498        $builder->StartObject(35);
499    }
500
501    /**
502     * @param FlatBufferBuilder $builder
503     * @return Monster
504     */
505    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)
506    {
507        $builder->startObject(35);
508        self::addPos($builder, $pos);
509        self::addMana($builder, $mana);
510        self::addHp($builder, $hp);
511        self::addName($builder, $name);
512        self::addInventory($builder, $inventory);
513        self::addColor($builder, $color);
514        self::addTestType($builder, $test_type);
515        self::addTest($builder, $test);
516        self::addTest4($builder, $test4);
517        self::addTestarrayofstring($builder, $testarrayofstring);
518        self::addTestarrayoftables($builder, $testarrayoftables);
519        self::addEnemy($builder, $enemy);
520        self::addTestnestedflatbuffer($builder, $testnestedflatbuffer);
521        self::addTestempty($builder, $testempty);
522        self::addTestbool($builder, $testbool);
523        self::addTesthashs32Fnv1($builder, $testhashs32_fnv1);
524        self::addTesthashu32Fnv1($builder, $testhashu32_fnv1);
525        self::addTesthashs64Fnv1($builder, $testhashs64_fnv1);
526        self::addTesthashu64Fnv1($builder, $testhashu64_fnv1);
527        self::addTesthashs32Fnv1a($builder, $testhashs32_fnv1a);
528        self::addTesthashu32Fnv1a($builder, $testhashu32_fnv1a);
529        self::addTesthashs64Fnv1a($builder, $testhashs64_fnv1a);
530        self::addTesthashu64Fnv1a($builder, $testhashu64_fnv1a);
531        self::addTestarrayofbools($builder, $testarrayofbools);
532        self::addTestf($builder, $testf);
533        self::addTestf2($builder, $testf2);
534        self::addTestf3($builder, $testf3);
535        self::addTestarrayofstring2($builder, $testarrayofstring2);
536        self::addTestarrayofsortedstruct($builder, $testarrayofsortedstruct);
537        self::addFlex($builder, $flex);
538        self::addTest5($builder, $test5);
539        self::addVectorOfLongs($builder, $vector_of_longs);
540        self::addVectorOfDoubles($builder, $vector_of_doubles);
541        self::addParentNamespaceTest($builder, $parent_namespace_test);
542        $o = $builder->endObject();
543        $builder->required($o, 10);  // name
544        return $o;
545    }
546
547    /**
548     * @param FlatBufferBuilder $builder
549     * @param int
550     * @return void
551     */
552    public static function addPos(FlatBufferBuilder $builder, $pos)
553    {
554        $builder->addStructX(0, $pos, 0);
555    }
556
557    /**
558     * @param FlatBufferBuilder $builder
559     * @param short
560     * @return void
561     */
562    public static function addMana(FlatBufferBuilder $builder, $mana)
563    {
564        $builder->addShortX(1, $mana, 150);
565    }
566
567    /**
568     * @param FlatBufferBuilder $builder
569     * @param short
570     * @return void
571     */
572    public static function addHp(FlatBufferBuilder $builder, $hp)
573    {
574        $builder->addShortX(2, $hp, 100);
575    }
576
577    /**
578     * @param FlatBufferBuilder $builder
579     * @param StringOffset
580     * @return void
581     */
582    public static function addName(FlatBufferBuilder $builder, $name)
583    {
584        $builder->addOffsetX(3, $name, 0);
585    }
586
587    /**
588     * @param FlatBufferBuilder $builder
589     * @param VectorOffset
590     * @return void
591     */
592    public static function addInventory(FlatBufferBuilder $builder, $inventory)
593    {
594        $builder->addOffsetX(5, $inventory, 0);
595    }
596
597    /**
598     * @param FlatBufferBuilder $builder
599     * @param array offset array
600     * @return int vector offset
601     */
602    public static function createInventoryVector(FlatBufferBuilder $builder, array $data)
603    {
604        $builder->startVector(1, count($data), 1);
605        for ($i = count($data) - 1; $i >= 0; $i--) {
606            $builder->addByte($data[$i]);
607        }
608        return $builder->endVector();
609    }
610
611    /**
612     * @param FlatBufferBuilder $builder
613     * @param int $numElems
614     * @return void
615     */
616    public static function startInventoryVector(FlatBufferBuilder $builder, $numElems)
617    {
618        $builder->startVector(1, $numElems, 1);
619    }
620
621    /**
622     * @param FlatBufferBuilder $builder
623     * @param sbyte
624     * @return void
625     */
626    public static function addColor(FlatBufferBuilder $builder, $color)
627    {
628        $builder->addSbyteX(6, $color, 8);
629    }
630
631    /**
632     * @param FlatBufferBuilder $builder
633     * @param byte
634     * @return void
635     */
636    public static function addTestType(FlatBufferBuilder $builder, $testType)
637    {
638        $builder->addByteX(7, $testType, 0);
639    }
640
641    public static function addTest(FlatBufferBuilder $builder, $offset)
642    {
643        $builder->addOffsetX(8, $offset, 0);
644    }
645
646    /**
647     * @param FlatBufferBuilder $builder
648     * @param VectorOffset
649     * @return void
650     */
651    public static function addTest4(FlatBufferBuilder $builder, $test4)
652    {
653        $builder->addOffsetX(9, $test4, 0);
654    }
655
656    /**
657     * @param FlatBufferBuilder $builder
658     * @param array offset array
659     * @return int vector offset
660     */
661    public static function createTest4Vector(FlatBufferBuilder $builder, array $data)
662    {
663        $builder->startVector(4, count($data), 2);
664        for ($i = count($data) - 1; $i >= 0; $i--) {
665            $builder->addOffset($data[$i]);
666        }
667        return $builder->endVector();
668    }
669
670    /**
671     * @param FlatBufferBuilder $builder
672     * @param int $numElems
673     * @return void
674     */
675    public static function startTest4Vector(FlatBufferBuilder $builder, $numElems)
676    {
677        $builder->startVector(4, $numElems, 2);
678    }
679
680    /**
681     * @param FlatBufferBuilder $builder
682     * @param VectorOffset
683     * @return void
684     */
685    public static function addTestarrayofstring(FlatBufferBuilder $builder, $testarrayofstring)
686    {
687        $builder->addOffsetX(10, $testarrayofstring, 0);
688    }
689
690    /**
691     * @param FlatBufferBuilder $builder
692     * @param array offset array
693     * @return int vector offset
694     */
695    public static function createTestarrayofstringVector(FlatBufferBuilder $builder, array $data)
696    {
697        $builder->startVector(4, count($data), 4);
698        for ($i = count($data) - 1; $i >= 0; $i--) {
699            $builder->addOffset($data[$i]);
700        }
701        return $builder->endVector();
702    }
703
704    /**
705     * @param FlatBufferBuilder $builder
706     * @param int $numElems
707     * @return void
708     */
709    public static function startTestarrayofstringVector(FlatBufferBuilder $builder, $numElems)
710    {
711        $builder->startVector(4, $numElems, 4);
712    }
713
714    /**
715     * @param FlatBufferBuilder $builder
716     * @param VectorOffset
717     * @return void
718     */
719    public static function addTestarrayoftables(FlatBufferBuilder $builder, $testarrayoftables)
720    {
721        $builder->addOffsetX(11, $testarrayoftables, 0);
722    }
723
724    /**
725     * @param FlatBufferBuilder $builder
726     * @param array offset array
727     * @return int vector offset
728     */
729    public static function createTestarrayoftablesVector(FlatBufferBuilder $builder, array $data)
730    {
731        $builder->startVector(4, count($data), 4);
732        for ($i = count($data) - 1; $i >= 0; $i--) {
733            $builder->addOffset($data[$i]);
734        }
735        return $builder->endVector();
736    }
737
738    /**
739     * @param FlatBufferBuilder $builder
740     * @param int $numElems
741     * @return void
742     */
743    public static function startTestarrayoftablesVector(FlatBufferBuilder $builder, $numElems)
744    {
745        $builder->startVector(4, $numElems, 4);
746    }
747
748    /**
749     * @param FlatBufferBuilder $builder
750     * @param int
751     * @return void
752     */
753    public static function addEnemy(FlatBufferBuilder $builder, $enemy)
754    {
755        $builder->addOffsetX(12, $enemy, 0);
756    }
757
758    /**
759     * @param FlatBufferBuilder $builder
760     * @param VectorOffset
761     * @return void
762     */
763    public static function addTestnestedflatbuffer(FlatBufferBuilder $builder, $testnestedflatbuffer)
764    {
765        $builder->addOffsetX(13, $testnestedflatbuffer, 0);
766    }
767
768    /**
769     * @param FlatBufferBuilder $builder
770     * @param array offset array
771     * @return int vector offset
772     */
773    public static function createTestnestedflatbufferVector(FlatBufferBuilder $builder, array $data)
774    {
775        $builder->startVector(1, count($data), 1);
776        for ($i = count($data) - 1; $i >= 0; $i--) {
777            $builder->addByte($data[$i]);
778        }
779        return $builder->endVector();
780    }
781
782    /**
783     * @param FlatBufferBuilder $builder
784     * @param int $numElems
785     * @return void
786     */
787    public static function startTestnestedflatbufferVector(FlatBufferBuilder $builder, $numElems)
788    {
789        $builder->startVector(1, $numElems, 1);
790    }
791
792    /**
793     * @param FlatBufferBuilder $builder
794     * @param int
795     * @return void
796     */
797    public static function addTestempty(FlatBufferBuilder $builder, $testempty)
798    {
799        $builder->addOffsetX(14, $testempty, 0);
800    }
801
802    /**
803     * @param FlatBufferBuilder $builder
804     * @param bool
805     * @return void
806     */
807    public static function addTestbool(FlatBufferBuilder $builder, $testbool)
808    {
809        $builder->addBoolX(15, $testbool, false);
810    }
811
812    /**
813     * @param FlatBufferBuilder $builder
814     * @param int
815     * @return void
816     */
817    public static function addTesthashs32Fnv1(FlatBufferBuilder $builder, $testhashs32Fnv1)
818    {
819        $builder->addIntX(16, $testhashs32Fnv1, 0);
820    }
821
822    /**
823     * @param FlatBufferBuilder $builder
824     * @param uint
825     * @return void
826     */
827    public static function addTesthashu32Fnv1(FlatBufferBuilder $builder, $testhashu32Fnv1)
828    {
829        $builder->addUintX(17, $testhashu32Fnv1, 0);
830    }
831
832    /**
833     * @param FlatBufferBuilder $builder
834     * @param long
835     * @return void
836     */
837    public static function addTesthashs64Fnv1(FlatBufferBuilder $builder, $testhashs64Fnv1)
838    {
839        $builder->addLongX(18, $testhashs64Fnv1, 0);
840    }
841
842    /**
843     * @param FlatBufferBuilder $builder
844     * @param ulong
845     * @return void
846     */
847    public static function addTesthashu64Fnv1(FlatBufferBuilder $builder, $testhashu64Fnv1)
848    {
849        $builder->addUlongX(19, $testhashu64Fnv1, 0);
850    }
851
852    /**
853     * @param FlatBufferBuilder $builder
854     * @param int
855     * @return void
856     */
857    public static function addTesthashs32Fnv1a(FlatBufferBuilder $builder, $testhashs32Fnv1a)
858    {
859        $builder->addIntX(20, $testhashs32Fnv1a, 0);
860    }
861
862    /**
863     * @param FlatBufferBuilder $builder
864     * @param uint
865     * @return void
866     */
867    public static function addTesthashu32Fnv1a(FlatBufferBuilder $builder, $testhashu32Fnv1a)
868    {
869        $builder->addUintX(21, $testhashu32Fnv1a, 0);
870    }
871
872    /**
873     * @param FlatBufferBuilder $builder
874     * @param long
875     * @return void
876     */
877    public static function addTesthashs64Fnv1a(FlatBufferBuilder $builder, $testhashs64Fnv1a)
878    {
879        $builder->addLongX(22, $testhashs64Fnv1a, 0);
880    }
881
882    /**
883     * @param FlatBufferBuilder $builder
884     * @param ulong
885     * @return void
886     */
887    public static function addTesthashu64Fnv1a(FlatBufferBuilder $builder, $testhashu64Fnv1a)
888    {
889        $builder->addUlongX(23, $testhashu64Fnv1a, 0);
890    }
891
892    /**
893     * @param FlatBufferBuilder $builder
894     * @param VectorOffset
895     * @return void
896     */
897    public static function addTestarrayofbools(FlatBufferBuilder $builder, $testarrayofbools)
898    {
899        $builder->addOffsetX(24, $testarrayofbools, 0);
900    }
901
902    /**
903     * @param FlatBufferBuilder $builder
904     * @param array offset array
905     * @return int vector offset
906     */
907    public static function createTestarrayofboolsVector(FlatBufferBuilder $builder, array $data)
908    {
909        $builder->startVector(1, count($data), 1);
910        for ($i = count($data) - 1; $i >= 0; $i--) {
911            $builder->addBool($data[$i]);
912        }
913        return $builder->endVector();
914    }
915
916    /**
917     * @param FlatBufferBuilder $builder
918     * @param int $numElems
919     * @return void
920     */
921    public static function startTestarrayofboolsVector(FlatBufferBuilder $builder, $numElems)
922    {
923        $builder->startVector(1, $numElems, 1);
924    }
925
926    /**
927     * @param FlatBufferBuilder $builder
928     * @param float
929     * @return void
930     */
931    public static function addTestf(FlatBufferBuilder $builder, $testf)
932    {
933        $builder->addFloatX(25, $testf, 3.14159);
934    }
935
936    /**
937     * @param FlatBufferBuilder $builder
938     * @param float
939     * @return void
940     */
941    public static function addTestf2(FlatBufferBuilder $builder, $testf2)
942    {
943        $builder->addFloatX(26, $testf2, 3.0);
944    }
945
946    /**
947     * @param FlatBufferBuilder $builder
948     * @param float
949     * @return void
950     */
951    public static function addTestf3(FlatBufferBuilder $builder, $testf3)
952    {
953        $builder->addFloatX(27, $testf3, 0.0);
954    }
955
956    /**
957     * @param FlatBufferBuilder $builder
958     * @param VectorOffset
959     * @return void
960     */
961    public static function addTestarrayofstring2(FlatBufferBuilder $builder, $testarrayofstring2)
962    {
963        $builder->addOffsetX(28, $testarrayofstring2, 0);
964    }
965
966    /**
967     * @param FlatBufferBuilder $builder
968     * @param array offset array
969     * @return int vector offset
970     */
971    public static function createTestarrayofstring2Vector(FlatBufferBuilder $builder, array $data)
972    {
973        $builder->startVector(4, count($data), 4);
974        for ($i = count($data) - 1; $i >= 0; $i--) {
975            $builder->addOffset($data[$i]);
976        }
977        return $builder->endVector();
978    }
979
980    /**
981     * @param FlatBufferBuilder $builder
982     * @param int $numElems
983     * @return void
984     */
985    public static function startTestarrayofstring2Vector(FlatBufferBuilder $builder, $numElems)
986    {
987        $builder->startVector(4, $numElems, 4);
988    }
989
990    /**
991     * @param FlatBufferBuilder $builder
992     * @param VectorOffset
993     * @return void
994     */
995    public static function addTestarrayofsortedstruct(FlatBufferBuilder $builder, $testarrayofsortedstruct)
996    {
997        $builder->addOffsetX(29, $testarrayofsortedstruct, 0);
998    }
999
1000    /**
1001     * @param FlatBufferBuilder $builder
1002     * @param array offset array
1003     * @return int vector offset
1004     */
1005    public static function createTestarrayofsortedstructVector(FlatBufferBuilder $builder, array $data)
1006    {
1007        $builder->startVector(8, count($data), 4);
1008        for ($i = count($data) - 1; $i >= 0; $i--) {
1009            $builder->addOffset($data[$i]);
1010        }
1011        return $builder->endVector();
1012    }
1013
1014    /**
1015     * @param FlatBufferBuilder $builder
1016     * @param int $numElems
1017     * @return void
1018     */
1019    public static function startTestarrayofsortedstructVector(FlatBufferBuilder $builder, $numElems)
1020    {
1021        $builder->startVector(8, $numElems, 4);
1022    }
1023
1024    /**
1025     * @param FlatBufferBuilder $builder
1026     * @param VectorOffset
1027     * @return void
1028     */
1029    public static function addFlex(FlatBufferBuilder $builder, $flex)
1030    {
1031        $builder->addOffsetX(30, $flex, 0);
1032    }
1033
1034    /**
1035     * @param FlatBufferBuilder $builder
1036     * @param array offset array
1037     * @return int vector offset
1038     */
1039    public static function createFlexVector(FlatBufferBuilder $builder, array $data)
1040    {
1041        $builder->startVector(1, count($data), 1);
1042        for ($i = count($data) - 1; $i >= 0; $i--) {
1043            $builder->addByte($data[$i]);
1044        }
1045        return $builder->endVector();
1046    }
1047
1048    /**
1049     * @param FlatBufferBuilder $builder
1050     * @param int $numElems
1051     * @return void
1052     */
1053    public static function startFlexVector(FlatBufferBuilder $builder, $numElems)
1054    {
1055        $builder->startVector(1, $numElems, 1);
1056    }
1057
1058    /**
1059     * @param FlatBufferBuilder $builder
1060     * @param VectorOffset
1061     * @return void
1062     */
1063    public static function addTest5(FlatBufferBuilder $builder, $test5)
1064    {
1065        $builder->addOffsetX(31, $test5, 0);
1066    }
1067
1068    /**
1069     * @param FlatBufferBuilder $builder
1070     * @param array offset array
1071     * @return int vector offset
1072     */
1073    public static function createTest5Vector(FlatBufferBuilder $builder, array $data)
1074    {
1075        $builder->startVector(4, count($data), 2);
1076        for ($i = count($data) - 1; $i >= 0; $i--) {
1077            $builder->addOffset($data[$i]);
1078        }
1079        return $builder->endVector();
1080    }
1081
1082    /**
1083     * @param FlatBufferBuilder $builder
1084     * @param int $numElems
1085     * @return void
1086     */
1087    public static function startTest5Vector(FlatBufferBuilder $builder, $numElems)
1088    {
1089        $builder->startVector(4, $numElems, 2);
1090    }
1091
1092    /**
1093     * @param FlatBufferBuilder $builder
1094     * @param VectorOffset
1095     * @return void
1096     */
1097    public static function addVectorOfLongs(FlatBufferBuilder $builder, $vectorOfLongs)
1098    {
1099        $builder->addOffsetX(32, $vectorOfLongs, 0);
1100    }
1101
1102    /**
1103     * @param FlatBufferBuilder $builder
1104     * @param array offset array
1105     * @return int vector offset
1106     */
1107    public static function createVectorOfLongsVector(FlatBufferBuilder $builder, array $data)
1108    {
1109        $builder->startVector(8, count($data), 8);
1110        for ($i = count($data) - 1; $i >= 0; $i--) {
1111            $builder->addLong($data[$i]);
1112        }
1113        return $builder->endVector();
1114    }
1115
1116    /**
1117     * @param FlatBufferBuilder $builder
1118     * @param int $numElems
1119     * @return void
1120     */
1121    public static function startVectorOfLongsVector(FlatBufferBuilder $builder, $numElems)
1122    {
1123        $builder->startVector(8, $numElems, 8);
1124    }
1125
1126    /**
1127     * @param FlatBufferBuilder $builder
1128     * @param VectorOffset
1129     * @return void
1130     */
1131    public static function addVectorOfDoubles(FlatBufferBuilder $builder, $vectorOfDoubles)
1132    {
1133        $builder->addOffsetX(33, $vectorOfDoubles, 0);
1134    }
1135
1136    /**
1137     * @param FlatBufferBuilder $builder
1138     * @param array offset array
1139     * @return int vector offset
1140     */
1141    public static function createVectorOfDoublesVector(FlatBufferBuilder $builder, array $data)
1142    {
1143        $builder->startVector(8, count($data), 8);
1144        for ($i = count($data) - 1; $i >= 0; $i--) {
1145            $builder->addDouble($data[$i]);
1146        }
1147        return $builder->endVector();
1148    }
1149
1150    /**
1151     * @param FlatBufferBuilder $builder
1152     * @param int $numElems
1153     * @return void
1154     */
1155    public static function startVectorOfDoublesVector(FlatBufferBuilder $builder, $numElems)
1156    {
1157        $builder->startVector(8, $numElems, 8);
1158    }
1159
1160    /**
1161     * @param FlatBufferBuilder $builder
1162     * @param int
1163     * @return void
1164     */
1165    public static function addParentNamespaceTest(FlatBufferBuilder $builder, $parentNamespaceTest)
1166    {
1167        $builder->addOffsetX(34, $parentNamespaceTest, 0);
1168    }
1169
1170    /**
1171     * @param FlatBufferBuilder $builder
1172     * @return int table offset
1173     */
1174    public static function endMonster(FlatBufferBuilder $builder)
1175    {
1176        $o = $builder->endObject();
1177        $builder->required($o, 10);  // name
1178        return $o;
1179    }
1180
1181    public static function finishMonsterBuffer(FlatBufferBuilder $builder, $offset)
1182    {
1183        $builder->finish($offset, "MONS");
1184    }
1185}
1186