hunt.database.base.impl.ArrayTuple source code

1 /*
2  * Copyright (C) 2019, HuntLabs
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 
18 module hunt.database.base.impl.ArrayTuple;
19 
20 import hunt.database.base.Tuple;
21 // import io.vertx.core.buffer.Buffer;
22 
23 // import java.math.BigDecimal;
24 // import java.time.*;
25 // import java.time.temporal.Temporal;
26 // import java.util.ArrayList;
27 // import java.util.Collection;
28 // import java.util.UUID;
29 
30 import hunt.collection.ArrayList;
31 import hunt.collection.Collection;
32 
33 import std.conv;
34 import std.concurrency : initOnce;
35 import std.variant;
36 
37 /**
38 */
39 class ArrayTuple : ArrayList!(Variant), Tuple {
40 
41     static Tuple EMPTY() {
42         __gshared Tuple inst;
43         return initOnce!inst(new ArrayTuple(0));
44     }
45 
46     this(int len) {
47         super(len);
48     }
49 
50     this(Collection!(Variant) c) {
51         super(c);
52     }
53 
54     override int size() {
55         return super.size();
56     }
57 
58     override void clear() {
59         super.clear();
60     }
61 
62 
63     // override
64     // <T> T get(Class!(T) type, int pos) {
65     //     throw new UnsupportedOperationException();
66     // }
67 
68     // override
69     // <T> T[] getValues(Class!(T) type, int pos) {
70     //     throw new UnsupportedOperationException();
71     // }
72 
73     override
74     bool getBoolean(int pos) {
75         Variant v = get(pos);
76         if(v == null) {
77             return bool.init;
78         }else{
79             return v.get!bool();
80         }
81     }
82 
83     Variant getValue(int pos) {
84         return get(pos);
85     }
86 
87     override
88     short getShort(int pos) {
89         Variant v = get(pos);
90         if(v == null) {
91             return short.init;
92         }else{
93             return v.get!short();
94         }
95     }
96 
97     override
98     int getInteger(int pos) {
99         Variant v = get(pos);
100         if(v == null) {
101             return 0;
102         }
103 
104         if(v.type == typeid(int)) {
105             return v.get!int();
106         } else {
107             string str = v.toString();
108             return to!int(str);
109         }
110     }
111 
112     override
113     long getLong(int pos) {
114         Variant v = get(pos);
115         if(v == null) {
116             return long.init;
117         }else{
118             return v.get!long();
119         }
120         
121         // Object val = get(pos);
122         // if (val instanceof Long) {
123         //     return (Long) val;
124         // } else if (val instanceof Number) {
125         //     return ((Number) val).longValue();
126         // }
127         // return null;
128     }
129 
130     override
131     float getFloat(int pos) {
132         Variant v = get(pos);
133         if(v == null) {
134             return float.init;
135         }else{
136             return v.get!float();
137         }
138         // Object val = get(pos);
139         // if (val instanceof Float) {
140         //     return (Float) val;
141         // } else if (val instanceof Number) {
142         //     return ((Number) val).floatValue();
143         // }
144         // return null;
145     }
146 
147     override
148     double getDouble(int pos) {
149         Variant v = get(pos);
150         if(v == null) {
151             return double.init;
152         }else{
153             return v.get!double();
154         }
155         // Object val = get(pos);
156         // if (val instanceof Double) {
157         //     return (Double) val;
158         // } else if (val instanceof Number) {
159         //     return ((Number) val).doubleValue();
160         // }
161         // return null;
162     }
163 
164     // override
165     // BigDecimal getBigDecimal(int pos) {
166     //     Object val = get(pos);
167     //     if (val instanceof BigDecimal) {
168     //         return (BigDecimal) val;
169     //     } else if (val instanceof Number) {
170     //         return new BigDecimal(val.toString());
171     //     }
172     //     return null;
173     // }
174 
175     // override
176     // Integer[] getIntegerArray(int pos) {
177     //     Object val = get(pos);
178     //     if (val instanceof Integer[]) {
179     //         return (Integer[]) val;
180     //     } else {
181     //         return null;
182     //     }
183     // }
184 
185     // override
186     // Boolean[] getBooleanArray(int pos) {
187     //     Object val = get(pos);
188     //     if (val instanceof Boolean[]) {
189     //         return (Boolean[]) val;
190     //     } else {
191     //         return null;
192     //     }
193     // }
194 
195     // override
196     // Short[] getShortArray(int pos) {
197     //     Object val = get(pos);
198     //     if (val instanceof Short[]) {
199     //         return (Short[]) val;
200     //     } else {
201     //         return null;
202     //     }
203     // }
204 
205     // override
206     // Long[] getLongArray(int pos) {
207     //     Object val = get(pos);
208     //     if (val instanceof Long[]) {
209     //         return (Long[]) val;
210     //     } else {
211     //         return null;
212     //     }
213     // }
214 
215     // override
216     // Float[] getFloatArray(int pos) {
217     //     Object val = get(pos);
218     //     if (val instanceof Float[]) {
219     //         return (Float[]) val;
220     //     } else {
221     //         return null;
222     //     }
223     // }
224 
225     // override
226     // Double[] getDoubleArray(int pos) {
227     //     Object val = get(pos);
228     //     if (val instanceof Double[]) {
229     //         return (Double[]) val;
230     //     } else {
231     //         return null;
232     //     }
233     // }
234 
235     // override
236     // String[] getStringArray(int pos) {
237     //     Object val = get(pos);
238     //     if (val instanceof String[]) {
239     //         return (String[]) val;
240     //     } else {
241     //         return null;
242     //     }
243     // }
244 
245     // override
246     // LocalDate[] getLocalDateArray(int pos) {
247     //     Object val = get(pos);
248     //     if (val instanceof LocalDate[]) {
249     //         return (LocalDate[]) val;
250     //     } else {
251     //         return null;
252     //     }
253     // }
254 
255     // override
256     // LocalTime[] getLocalTimeArray(int pos) {
257     //     Object val = get(pos);
258     //     if (val instanceof LocalTime[]) {
259     //         return (LocalTime[]) val;
260     //     } else {
261     //         return null;
262     //     }
263     // }
264 
265     // override
266     // OffsetTime[] getOffsetTimeArray(int pos) {
267     //     Object val = get(pos);
268     //     if (val instanceof OffsetTime[]) {
269     //         return (OffsetTime[]) val;
270     //     } else {
271     //         return null;
272     //     }
273     // }
274 
275     // override
276     // LocalDateTime[] getLocalDateTimeArray(int pos) {
277     //     Object val = get(pos);
278     //     if (val instanceof LocalDateTime[]) {
279     //         return (LocalDateTime[]) val;
280     //     } else {
281     //         return null;
282     //     }
283     // }
284 
285     // override
286     // OffsetDateTime[] getOffsetDateTimeArray(int pos) {
287     //     Object val = get(pos);
288     //     if (val instanceof OffsetDateTime[]) {
289     //         return (OffsetDateTime[]) val;
290     //     } else {
291     //         return null;
292     //     }
293     // }
294 
295     // override
296     // Buffer[] getBufferArray(int pos) {
297     //     Object val = get(pos);
298     //     if (val instanceof Buffer[]) {
299     //         return (Buffer[]) val;
300     //     } else {
301     //         return null;
302     //     }
303     // }
304 
305     // override
306     // UUID[] getUUIDArray(int pos) {
307     //     Object val = get(pos);
308     //     if (val instanceof UUID[]) {
309     //         return (UUID[]) val;
310     //     } else {
311     //         return null;
312     //     }
313     // }
314 
315     override
316     string getString(int pos) {
317         Variant v = get(pos);
318         if(v == null) {
319             return string.init;
320         }else{
321             return v.get!string();
322         }
323         // Object val = get(pos);
324         // if (val instanceof String) {
325         //     return (String) val;
326         // }
327         // return null;
328     }
329 
330     override
331     byte[] getBuffer(int pos) {
332         Variant v = get(pos);
333         if(v == null) {
334             return [];
335         }else{
336             return v.get!(byte[])();
337         }
338         // Object val = get(pos);
339         // if (val instanceof Buffer) {
340         //     return (Buffer) val;
341         // }
342         // return null;
343     }
344 
345     // override
346     // Temporal getTemporal(int pos) {
347     //     Object val = get(pos);
348     //     if (val instanceof Temporal) {
349     //         return (Temporal) val;
350     //     }
351     //     return null;
352     // }
353 
354     // override
355     // LocalDate getLocalDate(int pos) {
356     //     Object val = get(pos);
357     //     if (val instanceof LocalDate) {
358     //         return (LocalDate) val;
359     //     }
360     //     return null;
361     // }
362 
363     // override
364     // LocalTime getLocalTime(int pos) {
365     //     Object val = get(pos);
366     //     if (val instanceof LocalTime) {
367     //         return (LocalTime) val;
368     //     }
369     //     return null;
370     // }
371 
372     // override
373     // LocalDateTime getLocalDateTime(int pos) {
374     //     Object val = get(pos);
375     //     if (val instanceof LocalDateTime) {
376     //         return (LocalDateTime) val;
377     //     }
378     //     return null;
379     // }
380 
381     // override
382     // OffsetTime getOffsetTime(int pos) {
383     //     Object val = get(pos);
384     //     if (val instanceof OffsetTime) {
385     //         return (OffsetTime) val;
386     //     }
387     //     return null;
388     // }
389 
390     // override
391     // OffsetDateTime getOffsetDateTime(int pos) {
392     //     Object val = get(pos);
393     //     if (val instanceof OffsetDateTime) {
394     //         return (OffsetDateTime) val;
395     //     }
396     //     return null;
397     // }
398 
399     // override
400     // UUID getUUID(int pos) {
401     //     Object val = get(pos);
402     //     if (val instanceof UUID) {
403     //         return (UUID) val;
404     //     }
405     //     return null;
406     // }
407 
408     // override
409     // Tuple addBoolean(Boolean value) {
410     //     add(value);
411     //     return this;
412     // }
413 
414     override
415     Tuple addValue(ref Variant value) {
416         add(value);
417         return this;
418     }
419 
420     // override
421     // Tuple addShort(Short value) {
422     //     add(value);
423     //     return this;
424     // }
425 
426     // override
427     // Tuple addInteger(Integer value) {
428     //     add(value);
429     //     return this;
430     // }
431 
432     // override
433     // Tuple addLong(Long value) {
434     //     add(value);
435     //     return this;
436     // }
437 
438     // override
439     // Tuple addFloat(Float value) {
440     //     add(value);
441     //     return this;
442     // }
443 
444     // override
445     // Tuple addDouble(Double value) {
446     //     add(value);
447     //     return this;
448     // }
449 
450     // override
451     // Tuple addString(String value) {
452     //     add(value);
453     //     return this;
454     // }
455 
456     // override
457     // Tuple addBuffer(Buffer value) {
458     //     add(value);
459     //     return this;
460     // }
461 
462     // override
463     // Tuple addTemporal(Temporal value) {
464     //     add(value);
465     //     return this;
466     // }
467 
468     // override
469     // Tuple addLocalDate(LocalDate value) {
470     //     add(value);
471     //     return this;
472     // }
473 
474     // override
475     // Tuple addLocalTime(LocalTime value) {
476     //     add(value);
477     //     return this;
478     // }
479 
480     // override
481     // Tuple addLocalDateTime(LocalDateTime value) {
482     //     add(value);
483     //     return this;
484     // }
485 
486     // override
487     // Tuple addOffsetTime(OffsetTime value) {
488     //     add(value);
489     //     return this;
490     // }
491 
492     // override
493     // Tuple addOffsetDateTime(OffsetDateTime value) {
494     //     add(value);
495     //     return this;
496     // }
497 
498     // override
499     // Tuple addUUID(UUID value) {
500     //     add(value);
501     //     return this;
502     // }
503 
504     // override
505     // Tuple addBigDecimal(BigDecimal value) {
506     //     add(value);
507     //     return this;
508     // }
509 
510     // override
511     // Tuple addIntegerArray(Integer[] value) {
512     //     add(value);
513     //     return this;
514     // }
515 
516     // override
517     // Tuple addBooleanArray(Boolean[] value) {
518     //     add(value);
519     //     return this;
520     // }
521 
522     // override
523     // Tuple addShortArray(Short[] value) {
524     //     add(value);
525     //     return this;
526     // }
527 
528     // override
529     // Tuple addLongArray(Long[] value) {
530     //     add(value);
531     //     return this;
532     // }
533 
534     // override
535     // Tuple addFloatArray(Float[] value) {
536     //     add(value);
537     //     return this;
538     // }
539 
540     // override
541     // Tuple addDoubleArray(Double[] value) {
542     //     add(value);
543     //     return this;
544     // }
545 
546     // override
547     // Tuple addStringArray(String[] value) {
548     //     add(value);
549     //     return this;
550     // }
551 
552     // override
553     // Tuple addLocalDateArray(LocalDate[] value) {
554     //     add(value);
555     //     return this;
556     // }
557 
558     // override
559     // Tuple addLocalTimeArray(LocalTime[] value) {
560     //     add(value);
561     //     return this;
562     // }
563 
564     // override
565     // Tuple addOffsetTimeArray(OffsetTime[] value) {
566     //     add(value);
567     //     return this;
568     // }
569 
570     // override
571     // Tuple addLocalDateTimeArray(LocalDateTime[] value) {
572     //     add(value);
573     //     return this;
574     // }
575 
576     // override
577     // Tuple addOffsetDateTimeArray(OffsetDateTime[] value) {
578     //     add(value);
579     //     return this;
580     // }
581 
582     // override
583     // Tuple addBufferArray(Buffer[] value) {
584     //     add(value);
585     //     return this;
586     // }
587 
588     // override
589     // Tuple addUUIDArray(UUID[] value) {
590     //     add(value);
591     //     return this;
592     // }
593 
594     // override
595     // <T> Tuple addValues(T[] value) {
596     //     add(value);
597     //     return this;
598     // }
599 }