1// This file was automatically generated by genny.
2// Any changes will be lost if this file is regenerated.
3// see https://github.com/cheekybits/genny
4
5package data
6
7import "time"
8
9type nullableUint8Vector []*uint8
10
11func newNullableUint8Vector(n int) *nullableUint8Vector {
12	v := nullableUint8Vector(make([]*uint8, n))
13	return &v
14}
15
16func (v *nullableUint8Vector) Set(idx int, i interface{}) {
17	if i == nil {
18		(*v)[idx] = nil
19		return
20	}
21	(*v)[idx] = i.(*uint8)
22}
23
24func (v *nullableUint8Vector) SetConcrete(idx int, i interface{}) {
25	val := i.(uint8)
26	(*v)[idx] = &val
27}
28
29func (v *nullableUint8Vector) Append(i interface{}) {
30	if i == nil {
31		*v = append(*v, nil)
32		return
33	}
34	*v = append(*v, i.(*uint8))
35}
36
37func (v *nullableUint8Vector) At(i int) interface{} {
38	return (*v)[i]
39}
40
41func (v *nullableUint8Vector) CopyAt(i int) interface{} {
42	if (*v)[i] == nil {
43		var g *uint8
44		return g
45	}
46	var g uint8
47	g = *(*v)[i]
48	return &g
49}
50
51func (v *nullableUint8Vector) ConcreteAt(i int) (interface{}, bool) {
52	var g uint8
53	val := (*v)[i]
54	if val == nil {
55		return g, false
56	}
57	g = *val
58	return g, true
59}
60
61func (v *nullableUint8Vector) PointerAt(i int) interface{} {
62	return &(*v)[i]
63}
64
65func (v *nullableUint8Vector) Len() int {
66	return len(*v)
67}
68
69func (v *nullableUint8Vector) Type() FieldType {
70	return vectorFieldType(v)
71}
72
73func (v *nullableUint8Vector) Extend(i int) {
74	*v = append(*v, make([]*uint8, i)...)
75}
76
77func (v *nullableUint8Vector) Insert(i int, val interface{}) {
78	switch {
79	case i < v.Len():
80		v.Extend(1)
81		copy((*v)[i+1:], (*v)[i:])
82		v.Set(i, val)
83	case i == v.Len():
84		v.Append(val)
85	case i > v.Len():
86		panic("Invalid index; vector length should be greater or equal to that index")
87	}
88}
89
90func (v *nullableUint8Vector) Delete(i int) {
91	*v = append((*v)[:i], (*v)[i+1:]...)
92}
93
94type nullableUint16Vector []*uint16
95
96func newNullableUint16Vector(n int) *nullableUint16Vector {
97	v := nullableUint16Vector(make([]*uint16, n))
98	return &v
99}
100
101func (v *nullableUint16Vector) Set(idx int, i interface{}) {
102	if i == nil {
103		(*v)[idx] = nil
104		return
105	}
106	(*v)[idx] = i.(*uint16)
107}
108
109func (v *nullableUint16Vector) SetConcrete(idx int, i interface{}) {
110	val := i.(uint16)
111	(*v)[idx] = &val
112}
113
114func (v *nullableUint16Vector) Append(i interface{}) {
115	if i == nil {
116		*v = append(*v, nil)
117		return
118	}
119	*v = append(*v, i.(*uint16))
120}
121
122func (v *nullableUint16Vector) At(i int) interface{} {
123	return (*v)[i]
124}
125
126func (v *nullableUint16Vector) CopyAt(i int) interface{} {
127	if (*v)[i] == nil {
128		var g *uint16
129		return g
130	}
131	var g uint16
132	g = *(*v)[i]
133	return &g
134}
135
136func (v *nullableUint16Vector) ConcreteAt(i int) (interface{}, bool) {
137	var g uint16
138	val := (*v)[i]
139	if val == nil {
140		return g, false
141	}
142	g = *val
143	return g, true
144}
145
146func (v *nullableUint16Vector) PointerAt(i int) interface{} {
147	return &(*v)[i]
148}
149
150func (v *nullableUint16Vector) Len() int {
151	return len(*v)
152}
153
154func (v *nullableUint16Vector) Type() FieldType {
155	return vectorFieldType(v)
156}
157
158func (v *nullableUint16Vector) Extend(i int) {
159	*v = append(*v, make([]*uint16, i)...)
160}
161
162func (v *nullableUint16Vector) Insert(i int, val interface{}) {
163	switch {
164	case i < v.Len():
165		v.Extend(1)
166		copy((*v)[i+1:], (*v)[i:])
167		v.Set(i, val)
168	case i == v.Len():
169		v.Append(val)
170	case i > v.Len():
171		panic("Invalid index; vector length should be greater or equal to that index")
172	}
173}
174
175func (v *nullableUint16Vector) Delete(i int) {
176	*v = append((*v)[:i], (*v)[i+1:]...)
177}
178
179type nullableUint32Vector []*uint32
180
181func newNullableUint32Vector(n int) *nullableUint32Vector {
182	v := nullableUint32Vector(make([]*uint32, n))
183	return &v
184}
185
186func (v *nullableUint32Vector) Set(idx int, i interface{}) {
187	if i == nil {
188		(*v)[idx] = nil
189		return
190	}
191	(*v)[idx] = i.(*uint32)
192}
193
194func (v *nullableUint32Vector) SetConcrete(idx int, i interface{}) {
195	val := i.(uint32)
196	(*v)[idx] = &val
197}
198
199func (v *nullableUint32Vector) Append(i interface{}) {
200	if i == nil {
201		*v = append(*v, nil)
202		return
203	}
204	*v = append(*v, i.(*uint32))
205}
206
207func (v *nullableUint32Vector) At(i int) interface{} {
208	return (*v)[i]
209}
210
211func (v *nullableUint32Vector) CopyAt(i int) interface{} {
212	if (*v)[i] == nil {
213		var g *uint32
214		return g
215	}
216	var g uint32
217	g = *(*v)[i]
218	return &g
219}
220
221func (v *nullableUint32Vector) ConcreteAt(i int) (interface{}, bool) {
222	var g uint32
223	val := (*v)[i]
224	if val == nil {
225		return g, false
226	}
227	g = *val
228	return g, true
229}
230
231func (v *nullableUint32Vector) PointerAt(i int) interface{} {
232	return &(*v)[i]
233}
234
235func (v *nullableUint32Vector) Len() int {
236	return len(*v)
237}
238
239func (v *nullableUint32Vector) Type() FieldType {
240	return vectorFieldType(v)
241}
242
243func (v *nullableUint32Vector) Extend(i int) {
244	*v = append(*v, make([]*uint32, i)...)
245}
246
247func (v *nullableUint32Vector) Insert(i int, val interface{}) {
248	switch {
249	case i < v.Len():
250		v.Extend(1)
251		copy((*v)[i+1:], (*v)[i:])
252		v.Set(i, val)
253	case i == v.Len():
254		v.Append(val)
255	case i > v.Len():
256		panic("Invalid index; vector length should be greater or equal to that index")
257	}
258}
259
260func (v *nullableUint32Vector) Delete(i int) {
261	*v = append((*v)[:i], (*v)[i+1:]...)
262}
263
264type nullableUint64Vector []*uint64
265
266func newNullableUint64Vector(n int) *nullableUint64Vector {
267	v := nullableUint64Vector(make([]*uint64, n))
268	return &v
269}
270
271func (v *nullableUint64Vector) Set(idx int, i interface{}) {
272	if i == nil {
273		(*v)[idx] = nil
274		return
275	}
276	(*v)[idx] = i.(*uint64)
277}
278
279func (v *nullableUint64Vector) SetConcrete(idx int, i interface{}) {
280	val := i.(uint64)
281	(*v)[idx] = &val
282}
283
284func (v *nullableUint64Vector) Append(i interface{}) {
285	if i == nil {
286		*v = append(*v, nil)
287		return
288	}
289	*v = append(*v, i.(*uint64))
290}
291
292func (v *nullableUint64Vector) At(i int) interface{} {
293	return (*v)[i]
294}
295
296func (v *nullableUint64Vector) CopyAt(i int) interface{} {
297	if (*v)[i] == nil {
298		var g *uint64
299		return g
300	}
301	var g uint64
302	g = *(*v)[i]
303	return &g
304}
305
306func (v *nullableUint64Vector) ConcreteAt(i int) (interface{}, bool) {
307	var g uint64
308	val := (*v)[i]
309	if val == nil {
310		return g, false
311	}
312	g = *val
313	return g, true
314}
315
316func (v *nullableUint64Vector) PointerAt(i int) interface{} {
317	return &(*v)[i]
318}
319
320func (v *nullableUint64Vector) Len() int {
321	return len(*v)
322}
323
324func (v *nullableUint64Vector) Type() FieldType {
325	return vectorFieldType(v)
326}
327
328func (v *nullableUint64Vector) Extend(i int) {
329	*v = append(*v, make([]*uint64, i)...)
330}
331
332func (v *nullableUint64Vector) Insert(i int, val interface{}) {
333	switch {
334	case i < v.Len():
335		v.Extend(1)
336		copy((*v)[i+1:], (*v)[i:])
337		v.Set(i, val)
338	case i == v.Len():
339		v.Append(val)
340	case i > v.Len():
341		panic("Invalid index; vector length should be greater or equal to that index")
342	}
343}
344
345func (v *nullableUint64Vector) Delete(i int) {
346	*v = append((*v)[:i], (*v)[i+1:]...)
347}
348
349type nullableInt8Vector []*int8
350
351func newNullableInt8Vector(n int) *nullableInt8Vector {
352	v := nullableInt8Vector(make([]*int8, n))
353	return &v
354}
355
356func (v *nullableInt8Vector) Set(idx int, i interface{}) {
357	if i == nil {
358		(*v)[idx] = nil
359		return
360	}
361	(*v)[idx] = i.(*int8)
362}
363
364func (v *nullableInt8Vector) SetConcrete(idx int, i interface{}) {
365	val := i.(int8)
366	(*v)[idx] = &val
367}
368
369func (v *nullableInt8Vector) Append(i interface{}) {
370	if i == nil {
371		*v = append(*v, nil)
372		return
373	}
374	*v = append(*v, i.(*int8))
375}
376
377func (v *nullableInt8Vector) At(i int) interface{} {
378	return (*v)[i]
379}
380
381func (v *nullableInt8Vector) CopyAt(i int) interface{} {
382	if (*v)[i] == nil {
383		var g *int8
384		return g
385	}
386	var g int8
387	g = *(*v)[i]
388	return &g
389}
390
391func (v *nullableInt8Vector) ConcreteAt(i int) (interface{}, bool) {
392	var g int8
393	val := (*v)[i]
394	if val == nil {
395		return g, false
396	}
397	g = *val
398	return g, true
399}
400
401func (v *nullableInt8Vector) PointerAt(i int) interface{} {
402	return &(*v)[i]
403}
404
405func (v *nullableInt8Vector) Len() int {
406	return len(*v)
407}
408
409func (v *nullableInt8Vector) Type() FieldType {
410	return vectorFieldType(v)
411}
412
413func (v *nullableInt8Vector) Extend(i int) {
414	*v = append(*v, make([]*int8, i)...)
415}
416
417func (v *nullableInt8Vector) Insert(i int, val interface{}) {
418	switch {
419	case i < v.Len():
420		v.Extend(1)
421		copy((*v)[i+1:], (*v)[i:])
422		v.Set(i, val)
423	case i == v.Len():
424		v.Append(val)
425	case i > v.Len():
426		panic("Invalid index; vector length should be greater or equal to that index")
427	}
428}
429
430func (v *nullableInt8Vector) Delete(i int) {
431	*v = append((*v)[:i], (*v)[i+1:]...)
432}
433
434type nullableInt16Vector []*int16
435
436func newNullableInt16Vector(n int) *nullableInt16Vector {
437	v := nullableInt16Vector(make([]*int16, n))
438	return &v
439}
440
441func (v *nullableInt16Vector) Set(idx int, i interface{}) {
442	if i == nil {
443		(*v)[idx] = nil
444		return
445	}
446	(*v)[idx] = i.(*int16)
447}
448
449func (v *nullableInt16Vector) SetConcrete(idx int, i interface{}) {
450	val := i.(int16)
451	(*v)[idx] = &val
452}
453
454func (v *nullableInt16Vector) Append(i interface{}) {
455	if i == nil {
456		*v = append(*v, nil)
457		return
458	}
459	*v = append(*v, i.(*int16))
460}
461
462func (v *nullableInt16Vector) At(i int) interface{} {
463	return (*v)[i]
464}
465
466func (v *nullableInt16Vector) CopyAt(i int) interface{} {
467	if (*v)[i] == nil {
468		var g *int16
469		return g
470	}
471	var g int16
472	g = *(*v)[i]
473	return &g
474}
475
476func (v *nullableInt16Vector) ConcreteAt(i int) (interface{}, bool) {
477	var g int16
478	val := (*v)[i]
479	if val == nil {
480		return g, false
481	}
482	g = *val
483	return g, true
484}
485
486func (v *nullableInt16Vector) PointerAt(i int) interface{} {
487	return &(*v)[i]
488}
489
490func (v *nullableInt16Vector) Len() int {
491	return len(*v)
492}
493
494func (v *nullableInt16Vector) Type() FieldType {
495	return vectorFieldType(v)
496}
497
498func (v *nullableInt16Vector) Extend(i int) {
499	*v = append(*v, make([]*int16, i)...)
500}
501
502func (v *nullableInt16Vector) Insert(i int, val interface{}) {
503	switch {
504	case i < v.Len():
505		v.Extend(1)
506		copy((*v)[i+1:], (*v)[i:])
507		v.Set(i, val)
508	case i == v.Len():
509		v.Append(val)
510	case i > v.Len():
511		panic("Invalid index; vector length should be greater or equal to that index")
512	}
513}
514
515func (v *nullableInt16Vector) Delete(i int) {
516	*v = append((*v)[:i], (*v)[i+1:]...)
517}
518
519type nullableInt32Vector []*int32
520
521func newNullableInt32Vector(n int) *nullableInt32Vector {
522	v := nullableInt32Vector(make([]*int32, n))
523	return &v
524}
525
526func (v *nullableInt32Vector) Set(idx int, i interface{}) {
527	if i == nil {
528		(*v)[idx] = nil
529		return
530	}
531	(*v)[idx] = i.(*int32)
532}
533
534func (v *nullableInt32Vector) SetConcrete(idx int, i interface{}) {
535	val := i.(int32)
536	(*v)[idx] = &val
537}
538
539func (v *nullableInt32Vector) Append(i interface{}) {
540	if i == nil {
541		*v = append(*v, nil)
542		return
543	}
544	*v = append(*v, i.(*int32))
545}
546
547func (v *nullableInt32Vector) At(i int) interface{} {
548	return (*v)[i]
549}
550
551func (v *nullableInt32Vector) CopyAt(i int) interface{} {
552	if (*v)[i] == nil {
553		var g *int32
554		return g
555	}
556	var g int32
557	g = *(*v)[i]
558	return &g
559}
560
561func (v *nullableInt32Vector) ConcreteAt(i int) (interface{}, bool) {
562	var g int32
563	val := (*v)[i]
564	if val == nil {
565		return g, false
566	}
567	g = *val
568	return g, true
569}
570
571func (v *nullableInt32Vector) PointerAt(i int) interface{} {
572	return &(*v)[i]
573}
574
575func (v *nullableInt32Vector) Len() int {
576	return len(*v)
577}
578
579func (v *nullableInt32Vector) Type() FieldType {
580	return vectorFieldType(v)
581}
582
583func (v *nullableInt32Vector) Extend(i int) {
584	*v = append(*v, make([]*int32, i)...)
585}
586
587func (v *nullableInt32Vector) Insert(i int, val interface{}) {
588	switch {
589	case i < v.Len():
590		v.Extend(1)
591		copy((*v)[i+1:], (*v)[i:])
592		v.Set(i, val)
593	case i == v.Len():
594		v.Append(val)
595	case i > v.Len():
596		panic("Invalid index; vector length should be greater or equal to that index")
597	}
598}
599
600func (v *nullableInt32Vector) Delete(i int) {
601	*v = append((*v)[:i], (*v)[i+1:]...)
602}
603
604type nullableInt64Vector []*int64
605
606func newNullableInt64Vector(n int) *nullableInt64Vector {
607	v := nullableInt64Vector(make([]*int64, n))
608	return &v
609}
610
611func (v *nullableInt64Vector) Set(idx int, i interface{}) {
612	if i == nil {
613		(*v)[idx] = nil
614		return
615	}
616	(*v)[idx] = i.(*int64)
617}
618
619func (v *nullableInt64Vector) SetConcrete(idx int, i interface{}) {
620	val := i.(int64)
621	(*v)[idx] = &val
622}
623
624func (v *nullableInt64Vector) Append(i interface{}) {
625	if i == nil {
626		*v = append(*v, nil)
627		return
628	}
629	*v = append(*v, i.(*int64))
630}
631
632func (v *nullableInt64Vector) At(i int) interface{} {
633	return (*v)[i]
634}
635
636func (v *nullableInt64Vector) CopyAt(i int) interface{} {
637	if (*v)[i] == nil {
638		var g *int64
639		return g
640	}
641	var g int64
642	g = *(*v)[i]
643	return &g
644}
645
646func (v *nullableInt64Vector) ConcreteAt(i int) (interface{}, bool) {
647	var g int64
648	val := (*v)[i]
649	if val == nil {
650		return g, false
651	}
652	g = *val
653	return g, true
654}
655
656func (v *nullableInt64Vector) PointerAt(i int) interface{} {
657	return &(*v)[i]
658}
659
660func (v *nullableInt64Vector) Len() int {
661	return len(*v)
662}
663
664func (v *nullableInt64Vector) Type() FieldType {
665	return vectorFieldType(v)
666}
667
668func (v *nullableInt64Vector) Extend(i int) {
669	*v = append(*v, make([]*int64, i)...)
670}
671
672func (v *nullableInt64Vector) Insert(i int, val interface{}) {
673	switch {
674	case i < v.Len():
675		v.Extend(1)
676		copy((*v)[i+1:], (*v)[i:])
677		v.Set(i, val)
678	case i == v.Len():
679		v.Append(val)
680	case i > v.Len():
681		panic("Invalid index; vector length should be greater or equal to that index")
682	}
683}
684
685func (v *nullableInt64Vector) Delete(i int) {
686	*v = append((*v)[:i], (*v)[i+1:]...)
687}
688
689type nullableFloat32Vector []*float32
690
691func newNullableFloat32Vector(n int) *nullableFloat32Vector {
692	v := nullableFloat32Vector(make([]*float32, n))
693	return &v
694}
695
696func (v *nullableFloat32Vector) Set(idx int, i interface{}) {
697	if i == nil {
698		(*v)[idx] = nil
699		return
700	}
701	(*v)[idx] = i.(*float32)
702}
703
704func (v *nullableFloat32Vector) SetConcrete(idx int, i interface{}) {
705	val := i.(float32)
706	(*v)[idx] = &val
707}
708
709func (v *nullableFloat32Vector) Append(i interface{}) {
710	if i == nil {
711		*v = append(*v, nil)
712		return
713	}
714	*v = append(*v, i.(*float32))
715}
716
717func (v *nullableFloat32Vector) At(i int) interface{} {
718	return (*v)[i]
719}
720
721func (v *nullableFloat32Vector) CopyAt(i int) interface{} {
722	if (*v)[i] == nil {
723		var g *float32
724		return g
725	}
726	var g float32
727	g = *(*v)[i]
728	return &g
729}
730
731func (v *nullableFloat32Vector) ConcreteAt(i int) (interface{}, bool) {
732	var g float32
733	val := (*v)[i]
734	if val == nil {
735		return g, false
736	}
737	g = *val
738	return g, true
739}
740
741func (v *nullableFloat32Vector) PointerAt(i int) interface{} {
742	return &(*v)[i]
743}
744
745func (v *nullableFloat32Vector) Len() int {
746	return len(*v)
747}
748
749func (v *nullableFloat32Vector) Type() FieldType {
750	return vectorFieldType(v)
751}
752
753func (v *nullableFloat32Vector) Extend(i int) {
754	*v = append(*v, make([]*float32, i)...)
755}
756
757func (v *nullableFloat32Vector) Insert(i int, val interface{}) {
758	switch {
759	case i < v.Len():
760		v.Extend(1)
761		copy((*v)[i+1:], (*v)[i:])
762		v.Set(i, val)
763	case i == v.Len():
764		v.Append(val)
765	case i > v.Len():
766		panic("Invalid index; vector length should be greater or equal to that index")
767	}
768}
769
770func (v *nullableFloat32Vector) Delete(i int) {
771	*v = append((*v)[:i], (*v)[i+1:]...)
772}
773
774type nullableFloat64Vector []*float64
775
776func newNullableFloat64Vector(n int) *nullableFloat64Vector {
777	v := nullableFloat64Vector(make([]*float64, n))
778	return &v
779}
780
781func (v *nullableFloat64Vector) Set(idx int, i interface{}) {
782	if i == nil {
783		(*v)[idx] = nil
784		return
785	}
786	(*v)[idx] = i.(*float64)
787}
788
789func (v *nullableFloat64Vector) SetConcrete(idx int, i interface{}) {
790	val := i.(float64)
791	(*v)[idx] = &val
792}
793
794func (v *nullableFloat64Vector) Append(i interface{}) {
795	if i == nil {
796		*v = append(*v, nil)
797		return
798	}
799	*v = append(*v, i.(*float64))
800}
801
802func (v *nullableFloat64Vector) At(i int) interface{} {
803	return (*v)[i]
804}
805
806func (v *nullableFloat64Vector) CopyAt(i int) interface{} {
807	if (*v)[i] == nil {
808		var g *float64
809		return g
810	}
811	var g float64
812	g = *(*v)[i]
813	return &g
814}
815
816func (v *nullableFloat64Vector) ConcreteAt(i int) (interface{}, bool) {
817	var g float64
818	val := (*v)[i]
819	if val == nil {
820		return g, false
821	}
822	g = *val
823	return g, true
824}
825
826func (v *nullableFloat64Vector) PointerAt(i int) interface{} {
827	return &(*v)[i]
828}
829
830func (v *nullableFloat64Vector) Len() int {
831	return len(*v)
832}
833
834func (v *nullableFloat64Vector) Type() FieldType {
835	return vectorFieldType(v)
836}
837
838func (v *nullableFloat64Vector) Extend(i int) {
839	*v = append(*v, make([]*float64, i)...)
840}
841
842func (v *nullableFloat64Vector) Insert(i int, val interface{}) {
843	switch {
844	case i < v.Len():
845		v.Extend(1)
846		copy((*v)[i+1:], (*v)[i:])
847		v.Set(i, val)
848	case i == v.Len():
849		v.Append(val)
850	case i > v.Len():
851		panic("Invalid index; vector length should be greater or equal to that index")
852	}
853}
854
855func (v *nullableFloat64Vector) Delete(i int) {
856	*v = append((*v)[:i], (*v)[i+1:]...)
857}
858
859type nullableStringVector []*string
860
861func newNullableStringVector(n int) *nullableStringVector {
862	v := nullableStringVector(make([]*string, n))
863	return &v
864}
865
866func (v *nullableStringVector) Set(idx int, i interface{}) {
867	if i == nil {
868		(*v)[idx] = nil
869		return
870	}
871	(*v)[idx] = i.(*string)
872}
873
874func (v *nullableStringVector) SetConcrete(idx int, i interface{}) {
875	val := i.(string)
876	(*v)[idx] = &val
877}
878
879func (v *nullableStringVector) Append(i interface{}) {
880	if i == nil {
881		*v = append(*v, nil)
882		return
883	}
884	*v = append(*v, i.(*string))
885}
886
887func (v *nullableStringVector) At(i int) interface{} {
888	return (*v)[i]
889}
890
891func (v *nullableStringVector) CopyAt(i int) interface{} {
892	if (*v)[i] == nil {
893		var g *string
894		return g
895	}
896	var g string
897	g = *(*v)[i]
898	return &g
899}
900
901func (v *nullableStringVector) ConcreteAt(i int) (interface{}, bool) {
902	var g string
903	val := (*v)[i]
904	if val == nil {
905		return g, false
906	}
907	g = *val
908	return g, true
909}
910
911func (v *nullableStringVector) PointerAt(i int) interface{} {
912	return &(*v)[i]
913}
914
915func (v *nullableStringVector) Len() int {
916	return len(*v)
917}
918
919func (v *nullableStringVector) Type() FieldType {
920	return vectorFieldType(v)
921}
922
923func (v *nullableStringVector) Extend(i int) {
924	*v = append(*v, make([]*string, i)...)
925}
926
927func (v *nullableStringVector) Insert(i int, val interface{}) {
928	switch {
929	case i < v.Len():
930		v.Extend(1)
931		copy((*v)[i+1:], (*v)[i:])
932		v.Set(i, val)
933	case i == v.Len():
934		v.Append(val)
935	case i > v.Len():
936		panic("Invalid index; vector length should be greater or equal to that index")
937	}
938}
939
940func (v *nullableStringVector) Delete(i int) {
941	*v = append((*v)[:i], (*v)[i+1:]...)
942}
943
944type nullableBoolVector []*bool
945
946func newNullableBoolVector(n int) *nullableBoolVector {
947	v := nullableBoolVector(make([]*bool, n))
948	return &v
949}
950
951func (v *nullableBoolVector) Set(idx int, i interface{}) {
952	if i == nil {
953		(*v)[idx] = nil
954		return
955	}
956	(*v)[idx] = i.(*bool)
957}
958
959func (v *nullableBoolVector) SetConcrete(idx int, i interface{}) {
960	val := i.(bool)
961	(*v)[idx] = &val
962}
963
964func (v *nullableBoolVector) Append(i interface{}) {
965	if i == nil {
966		*v = append(*v, nil)
967		return
968	}
969	*v = append(*v, i.(*bool))
970}
971
972func (v *nullableBoolVector) At(i int) interface{} {
973	return (*v)[i]
974}
975
976func (v *nullableBoolVector) CopyAt(i int) interface{} {
977	if (*v)[i] == nil {
978		var g *bool
979		return g
980	}
981	var g bool
982	g = *(*v)[i]
983	return &g
984}
985
986func (v *nullableBoolVector) ConcreteAt(i int) (interface{}, bool) {
987	var g bool
988	val := (*v)[i]
989	if val == nil {
990		return g, false
991	}
992	g = *val
993	return g, true
994}
995
996func (v *nullableBoolVector) PointerAt(i int) interface{} {
997	return &(*v)[i]
998}
999
1000func (v *nullableBoolVector) Len() int {
1001	return len(*v)
1002}
1003
1004func (v *nullableBoolVector) Type() FieldType {
1005	return vectorFieldType(v)
1006}
1007
1008func (v *nullableBoolVector) Extend(i int) {
1009	*v = append(*v, make([]*bool, i)...)
1010}
1011
1012func (v *nullableBoolVector) Insert(i int, val interface{}) {
1013	switch {
1014	case i < v.Len():
1015		v.Extend(1)
1016		copy((*v)[i+1:], (*v)[i:])
1017		v.Set(i, val)
1018	case i == v.Len():
1019		v.Append(val)
1020	case i > v.Len():
1021		panic("Invalid index; vector length should be greater or equal to that index")
1022	}
1023}
1024
1025func (v *nullableBoolVector) Delete(i int) {
1026	*v = append((*v)[:i], (*v)[i+1:]...)
1027}
1028
1029type nullableTimeTimeVector []*time.Time
1030
1031func newNullableTimeTimeVector(n int) *nullableTimeTimeVector {
1032	v := nullableTimeTimeVector(make([]*time.Time, n))
1033	return &v
1034}
1035
1036func (v *nullableTimeTimeVector) Set(idx int, i interface{}) {
1037	if i == nil {
1038		(*v)[idx] = nil
1039		return
1040	}
1041	(*v)[idx] = i.(*time.Time)
1042}
1043
1044func (v *nullableTimeTimeVector) SetConcrete(idx int, i interface{}) {
1045	val := i.(time.Time)
1046	(*v)[idx] = &val
1047}
1048
1049func (v *nullableTimeTimeVector) Append(i interface{}) {
1050	if i == nil {
1051		*v = append(*v, nil)
1052		return
1053	}
1054	*v = append(*v, i.(*time.Time))
1055}
1056
1057func (v *nullableTimeTimeVector) At(i int) interface{} {
1058	return (*v)[i]
1059}
1060
1061func (v *nullableTimeTimeVector) CopyAt(i int) interface{} {
1062	if (*v)[i] == nil {
1063		var g *time.Time
1064		return g
1065	}
1066	var g time.Time
1067	g = *(*v)[i]
1068	return &g
1069}
1070
1071func (v *nullableTimeTimeVector) ConcreteAt(i int) (interface{}, bool) {
1072	var g time.Time
1073	val := (*v)[i]
1074	if val == nil {
1075		return g, false
1076	}
1077	g = *val
1078	return g, true
1079}
1080
1081func (v *nullableTimeTimeVector) PointerAt(i int) interface{} {
1082	return &(*v)[i]
1083}
1084
1085func (v *nullableTimeTimeVector) Len() int {
1086	return len(*v)
1087}
1088
1089func (v *nullableTimeTimeVector) Type() FieldType {
1090	return vectorFieldType(v)
1091}
1092
1093func (v *nullableTimeTimeVector) Extend(i int) {
1094	*v = append(*v, make([]*time.Time, i)...)
1095}
1096
1097func (v *nullableTimeTimeVector) Insert(i int, val interface{}) {
1098	switch {
1099	case i < v.Len():
1100		v.Extend(1)
1101		copy((*v)[i+1:], (*v)[i:])
1102		v.Set(i, val)
1103	case i == v.Len():
1104		v.Append(val)
1105	case i > v.Len():
1106		panic("Invalid index; vector length should be greater or equal to that index")
1107	}
1108}
1109
1110func (v *nullableTimeTimeVector) Delete(i int) {
1111	*v = append((*v)[:i], (*v)[i+1:]...)
1112}
1113