Text file
src/oneml/alpr/oneml_alprGO_wrap.cxx
1/* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 4.0.2
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11// source: /builds/sertiscorp/mle/edge/oneml/build/bindings/go/alpr/oneml_alpr.i
12
13#define SWIGMODULE alprAPI
14
15#ifdef __cplusplus
16/* SwigValueWrapper is described in swig.swg */
17template<typename T> class SwigValueWrapper {
18 struct SwigMovePointer {
19 T *ptr;
20 SwigMovePointer(T *p) : ptr(p) { }
21 ~SwigMovePointer() { delete ptr; }
22 SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
23 } pointer;
24 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
25 SwigValueWrapper(const SwigValueWrapper<T>& rhs);
26public:
27 SwigValueWrapper() : pointer(0) { }
28 SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
29 operator T&() const { return *pointer.ptr; }
30 T *operator&() { return pointer.ptr; }
31};
32
33template <typename T> T SwigValueInit() {
34 return T();
35}
36#endif
37
38/* -----------------------------------------------------------------------------
39 * This section contains generic SWIG labels for method/variable
40 * declarations/attributes, and other compiler dependent labels.
41 * ----------------------------------------------------------------------------- */
42
43/* template workaround for compilers that cannot correctly implement the C++ standard */
44#ifndef SWIGTEMPLATEDISAMBIGUATOR
45# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
46# define SWIGTEMPLATEDISAMBIGUATOR template
47# elif defined(__HP_aCC)
48/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
49/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
50# define SWIGTEMPLATEDISAMBIGUATOR template
51# else
52# define SWIGTEMPLATEDISAMBIGUATOR
53# endif
54#endif
55
56/* inline attribute */
57#ifndef SWIGINLINE
58# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
59# define SWIGINLINE inline
60# else
61# define SWIGINLINE
62# endif
63#endif
64
65/* attribute recognised by some compilers to avoid 'unused' warnings */
66#ifndef SWIGUNUSED
67# if defined(__GNUC__)
68# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
69# define SWIGUNUSED __attribute__ ((__unused__))
70# else
71# define SWIGUNUSED
72# endif
73# elif defined(__ICC)
74# define SWIGUNUSED __attribute__ ((__unused__))
75# else
76# define SWIGUNUSED
77# endif
78#endif
79
80#ifndef SWIG_MSC_UNSUPPRESS_4505
81# if defined(_MSC_VER)
82# pragma warning(disable : 4505) /* unreferenced local function has been removed */
83# endif
84#endif
85
86#ifndef SWIGUNUSEDPARM
87# ifdef __cplusplus
88# define SWIGUNUSEDPARM(p)
89# else
90# define SWIGUNUSEDPARM(p) p SWIGUNUSED
91# endif
92#endif
93
94/* internal SWIG method */
95#ifndef SWIGINTERN
96# define SWIGINTERN static SWIGUNUSED
97#endif
98
99/* internal inline SWIG method */
100#ifndef SWIGINTERNINLINE
101# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
102#endif
103
104/* exporting methods */
105#if defined(__GNUC__)
106# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
107# ifndef GCC_HASCLASSVISIBILITY
108# define GCC_HASCLASSVISIBILITY
109# endif
110# endif
111#endif
112
113#ifndef SWIGEXPORT
114# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
115# if defined(STATIC_LINKED)
116# define SWIGEXPORT
117# else
118# define SWIGEXPORT __declspec(dllexport)
119# endif
120# else
121# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
122# define SWIGEXPORT __attribute__ ((visibility("default")))
123# else
124# define SWIGEXPORT
125# endif
126# endif
127#endif
128
129/* calling conventions for Windows */
130#ifndef SWIGSTDCALL
131# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
132# define SWIGSTDCALL __stdcall
133# else
134# define SWIGSTDCALL
135# endif
136#endif
137
138/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
139#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
140# define _CRT_SECURE_NO_DEPRECATE
141#endif
142
143/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
144#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
145# define _SCL_SECURE_NO_DEPRECATE
146#endif
147
148/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
149#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
150# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
151#endif
152
153/* Intel's compiler complains if a variable which was never initialised is
154 * cast to void, which is a common idiom which we use to indicate that we
155 * are aware a variable isn't used. So we just silence that warning.
156 * See: https://github.com/swig/swig/issues/192 for more discussion.
157 */
158#ifdef __INTEL_COMPILER
159# pragma warning disable 592
160#endif
161
162
163#include <stddef.h>
164#include <stdio.h>
165#include <stdlib.h>
166#include <string.h>
167#include <sys/types.h>
168
169
170
171typedef long long intgo;
172typedef unsigned long long uintgo;
173
174
175# if !defined(__clang__) && (defined(__i386__) || defined(__x86_64__))
176# define SWIGSTRUCTPACKED __attribute__((__packed__, __gcc_struct__))
177# else
178# define SWIGSTRUCTPACKED __attribute__((__packed__))
179# endif
180
181
182
183typedef struct { char *p; intgo n; } _gostring_;
184typedef struct { void* array; intgo len; intgo cap; } _goslice_;
185
186
187
188
189#define swiggo_size_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1];
190#define swiggo_size_assert(t, n) swiggo_size_assert_eq(sizeof(t), n, swiggo_sizeof_##t##_is_not_##n)
191
192swiggo_size_assert(char, 1)
193swiggo_size_assert(short, 2)
194swiggo_size_assert(int, 4)
195typedef long long swiggo_long_long;
196swiggo_size_assert(swiggo_long_long, 8)
197swiggo_size_assert(float, 4)
198swiggo_size_assert(double, 8)
199
200#ifdef __cplusplus
201extern "C" {
202#endif
203extern void crosscall2(void (*fn)(void *, int), void *, int);
204extern char* _cgo_topofstack(void) __attribute__ ((weak));
205extern void _cgo_allocate(void *, int);
206extern void _cgo_panic(void *, int);
207#ifdef __cplusplus
208}
209#endif
210
211static char *_swig_topofstack() {
212 if (_cgo_topofstack) {
213 return _cgo_topofstack();
214 } else {
215 return 0;
216 }
217}
218
219static void _swig_gopanic(const char *p) {
220 struct {
221 const char *p;
222 } SWIGSTRUCTPACKED a;
223 a.p = p;
224 crosscall2(_cgo_panic, &a, (int) sizeof a);
225}
226
227
228
229
230#define SWIG_contract_assert(expr, msg) \
231 if (!(expr)) { _swig_gopanic(msg); } else
232
233
234#define SWIG_exception(code, msg) _swig_gopanic(msg)
235
236
237static _gostring_ Swig_AllocateString(const char *p, size_t l) {
238 _gostring_ ret;
239 ret.p = (char*)malloc(l);
240 memcpy(ret.p, p, l);
241 ret.n = l;
242 return ret;
243}
244
245
246static void Swig_free(void* p) {
247 free(p);
248}
249
250static void* Swig_malloc(int c) {
251 return malloc(c);
252}
253
254
255#define SWIG_FILE_WITH_INIT
256#include "oneml/public/oneml_structs.h"
257
258
259#include <vector>
260#include <stdexcept>
261
262
263#include <stdint.h> // Use the C99 official header
264
265
266#include <string>
267
268
269#include <typeinfo>
270#include <stdexcept>
271
272
273#include <utility>
274
275SWIGINTERN std::vector< oneML::Image >::const_reference std_vector_Sl_oneML_Image_Sg__get(std::vector< oneML::Image > *self,int i){
276 int size = int(self->size());
277 if (i>=0 && i<size)
278 return (*self)[i];
279 else
280 throw std::out_of_range("vector index out of range");
281 }
282SWIGINTERN void std_vector_Sl_oneML_Image_Sg__set(std::vector< oneML::Image > *self,int i,std::vector< oneML::Image >::value_type const &val){
283 int size = int(self->size());
284 if (i>=0 && i<size)
285 (*self)[i] = val;
286 else
287 throw std::out_of_range("vector index out of range");
288 }
289SWIGINTERN oneML::Image *new_oneML_Image__SWIG_1(int w,int h,int d,unsigned char *data){
290 oneML::Image* img = new oneML::Image();
291 int size = w*h*d/8;
292 auto ptr = new unsigned char[size];
293 memcpy(ptr, data, size);
294 img->set_width(w);
295 img->set_height(h);
296 img->set_depth(d);
297 img->set_data(reinterpret_cast<uint8_t*>(ptr));
298
299 return img;
300 }
301SWIGINTERN void oneML_Image_go_set_data(oneML::Image *self,unsigned char *data){
302 self->set_data(reinterpret_cast<uint8_t*>(data));
303 }
304SWIGINTERN uint8_t *oneML_Image_go_get_data(oneML::Image *self){
305 return self->get_data().get();
306 }
307
308#include "oneml/public/oneml_vehicle_detector_API.h"
309
310SWIGINTERN std::vector< float >::const_reference std_vector_Sl_float_Sg__get(std::vector< float > *self,int i){
311 int size = int(self->size());
312 if (i>=0 && i<size)
313 return (*self)[i];
314 else
315 throw std::out_of_range("vector index out of range");
316 }
317SWIGINTERN void std_vector_Sl_float_Sg__set(std::vector< float > *self,int i,std::vector< float >::value_type const &val){
318 int size = int(self->size());
319 if (i>=0 && i<size)
320 (*self)[i] = val;
321 else
322 throw std::out_of_range("vector index out of range");
323 }
324SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
325 int size = int(self->size());
326 if (i>=0 && i<size)
327 return (*self)[i];
328 else
329 throw std::out_of_range("vector index out of range");
330 }
331SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
332 int size = int(self->size());
333 if (i>=0 && i<size)
334 (*self)[i] = val;
335 else
336 throw std::out_of_range("vector index out of range");
337 }
338SWIGINTERN std::vector< oneML::BBox >::const_reference std_vector_Sl_oneML_BBox_Sg__get(std::vector< oneML::BBox > *self,int i){
339 int size = int(self->size());
340 if (i>=0 && i<size)
341 return (*self)[i];
342 else
343 throw std::out_of_range("vector index out of range");
344 }
345SWIGINTERN void std_vector_Sl_oneML_BBox_Sg__set(std::vector< oneML::BBox > *self,int i,std::vector< oneML::BBox >::value_type const &val){
346 int size = int(self->size());
347 if (i>=0 && i<size)
348 (*self)[i] = val;
349 else
350 throw std::out_of_range("vector index out of range");
351 }
352SWIGINTERN std::vector< oneML::alpr::VehicleDetectorResult >::const_reference std_vector_Sl_oneML_alpr_VehicleDetectorResult_Sg__get(std::vector< oneML::alpr::VehicleDetectorResult > *self,int i){
353 int size = int(self->size());
354 if (i>=0 && i<size)
355 return (*self)[i];
356 else
357 throw std::out_of_range("vector index out of range");
358 }
359SWIGINTERN void std_vector_Sl_oneML_alpr_VehicleDetectorResult_Sg__set(std::vector< oneML::alpr::VehicleDetectorResult > *self,int i,std::vector< oneML::alpr::VehicleDetectorResult >::value_type const &val){
360 int size = int(self->size());
361 if (i>=0 && i<size)
362 (*self)[i] = val;
363 else
364 throw std::out_of_range("vector index out of range");
365 }
366SWIGINTERN std::vector< float > oneML_alpr_VehicleDetectorResult_go_get_scores(oneML::alpr::VehicleDetectorResult *self){
367 std::vector<float> scores;
368 self->get_scores(scores);
369 return scores;
370 }
371SWIGINTERN std::vector< oneML::BBox > oneML_alpr_VehicleDetectorResult_go_get_bboxes(oneML::alpr::VehicleDetectorResult *self){
372 std::vector<oneML::BBox> bboxes;
373 self->get_bboxes(bboxes);
374 return bboxes;
375 }
376SWIGINTERN std::vector< int > oneML_alpr_VehicleDetectorResult_go_get_return_status(oneML::alpr::VehicleDetectorResult *self){
377 std::vector<oneML::alpr::VehicleDetectorStatus> v = self->get_return_status();
378
379 std::vector<int> statuses;
380 statuses.reserve(v.size());
381 for (auto & status : v) {
382 statuses.emplace_back(static_cast<int>(status));
383 }
384 return statuses;
385 }
386SWIGINTERN oneML::alpr::VehicleDetectorResult oneML_alpr_VehicleDetector_go_detect(oneML::alpr::VehicleDetector *self,oneML::Image const &img){
387 oneML::alpr::VehicleDetectorResult result;
388 self->detect(img, result);
389 return result;
390 }
391SWIGINTERN std::vector< oneML::alpr::VehicleDetectorResult > oneML_alpr_VehicleDetector_go_detect_batch(oneML::alpr::VehicleDetector *self,std::vector< oneML::Image > const &imgs){
392 std::vector<oneML::alpr::VehicleDetectorResult> results;
393 self->detect(imgs, results);
394 return results;
395 }
396
397#include "oneml/public/oneml_utils_API.h"
398
399SWIGINTERN oneML::Image oneML_Utils__read_image_cv(oneML::Utils *self,std::string const &img_path){
400 oneML::Image image;
401 self->read_image_cv(img_path, image);
402
403 return image;
404 }
405
406#include "oneml/license/oneml_license_manager.h"
407
408#ifdef __cplusplus
409extern "C" {
410#endif
411
412void _wrap_Swig_free_alpr_7074c9342a7bdf4a(void *_swig_go_0) {
413 void *arg1 = (void *) 0 ;
414
415 arg1 = *(void **)&_swig_go_0;
416
417 Swig_free(arg1);
418
419}
420
421
422void *_wrap_Swig_malloc_alpr_7074c9342a7bdf4a(intgo _swig_go_0) {
423 int arg1 ;
424 void *result = 0 ;
425 void *_swig_go_result;
426
427 arg1 = (int)_swig_go_0;
428
429 result = (void *)Swig_malloc(arg1);
430 *(void **)&_swig_go_result = (void *)result;
431 return _swig_go_result;
432}
433
434
435std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_0_alpr_7074c9342a7bdf4a() {
436 std::vector< oneML::Image > *result = 0 ;
437 std::vector< oneML::Image > *_swig_go_result;
438
439
440 {
441 try
442 {
443 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >();
444 }
445 catch (const std::invalid_argument& e)
446 {
447 SWIG_exception(SWIG_ValueError, e.what());
448 }
449 catch (const std::out_of_range& e)
450 {
451 SWIG_exception(SWIG_IndexError, e.what());
452 }
453 catch(const std::exception& e)
454 {
455 SWIG_exception(SWIG_RuntimeError, e.what());
456 }
457 }
458 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
459 return _swig_go_result;
460}
461
462
463std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_1_alpr_7074c9342a7bdf4a(long long _swig_go_0) {
464 std::vector< oneML::Image >::size_type arg1 ;
465 std::vector< oneML::Image > *result = 0 ;
466 std::vector< oneML::Image > *_swig_go_result;
467
468 arg1 = (size_t)_swig_go_0;
469
470 {
471 try
472 {
473 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >(arg1);
474 }
475 catch (const std::invalid_argument& e)
476 {
477 SWIG_exception(SWIG_ValueError, e.what());
478 }
479 catch (const std::out_of_range& e)
480 {
481 SWIG_exception(SWIG_IndexError, e.what());
482 }
483 catch(const std::exception& e)
484 {
485 SWIG_exception(SWIG_RuntimeError, e.what());
486 }
487 }
488 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
489 return _swig_go_result;
490}
491
492
493std::vector< oneML::Image > *_wrap_new_MultiImage__SWIG_2_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
494 std::vector< oneML::Image > *arg1 = 0 ;
495 std::vector< oneML::Image > *result = 0 ;
496 std::vector< oneML::Image > *_swig_go_result;
497
498 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
499
500 {
501 try
502 {
503 result = (std::vector< oneML::Image > *)new std::vector< oneML::Image >((std::vector< oneML::Image > const &)*arg1);
504 }
505 catch (const std::invalid_argument& e)
506 {
507 SWIG_exception(SWIG_ValueError, e.what());
508 }
509 catch (const std::out_of_range& e)
510 {
511 SWIG_exception(SWIG_IndexError, e.what());
512 }
513 catch(const std::exception& e)
514 {
515 SWIG_exception(SWIG_RuntimeError, e.what());
516 }
517 }
518 *(std::vector< oneML::Image > **)&_swig_go_result = (std::vector< oneML::Image > *)result;
519 return _swig_go_result;
520}
521
522
523long long _wrap_MultiImage_size_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
524 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
525 std::vector< oneML::Image >::size_type result;
526 long long _swig_go_result;
527
528 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
529
530 {
531 try
532 {
533 result = ((std::vector< oneML::Image > const *)arg1)->size();
534 }
535 catch (const std::invalid_argument& e)
536 {
537 SWIG_exception(SWIG_ValueError, e.what());
538 }
539 catch (const std::out_of_range& e)
540 {
541 SWIG_exception(SWIG_IndexError, e.what());
542 }
543 catch(const std::exception& e)
544 {
545 SWIG_exception(SWIG_RuntimeError, e.what());
546 }
547 }
548 _swig_go_result = result;
549 return _swig_go_result;
550}
551
552
553long long _wrap_MultiImage_capacity_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
554 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
555 std::vector< oneML::Image >::size_type result;
556 long long _swig_go_result;
557
558 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
559
560 {
561 try
562 {
563 result = ((std::vector< oneML::Image > const *)arg1)->capacity();
564 }
565 catch (const std::invalid_argument& e)
566 {
567 SWIG_exception(SWIG_ValueError, e.what());
568 }
569 catch (const std::out_of_range& e)
570 {
571 SWIG_exception(SWIG_IndexError, e.what());
572 }
573 catch(const std::exception& e)
574 {
575 SWIG_exception(SWIG_RuntimeError, e.what());
576 }
577 }
578 _swig_go_result = result;
579 return _swig_go_result;
580}
581
582
583void _wrap_MultiImage_reserve_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0, long long _swig_go_1) {
584 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
585 std::vector< oneML::Image >::size_type arg2 ;
586
587 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
588 arg2 = (size_t)_swig_go_1;
589
590 {
591 try
592 {
593 (arg1)->reserve(arg2);
594 }
595 catch (const std::invalid_argument& e)
596 {
597 SWIG_exception(SWIG_ValueError, e.what());
598 }
599 catch (const std::out_of_range& e)
600 {
601 SWIG_exception(SWIG_IndexError, e.what());
602 }
603 catch(const std::exception& e)
604 {
605 SWIG_exception(SWIG_RuntimeError, e.what());
606 }
607 }
608
609}
610
611
612bool _wrap_MultiImage_isEmpty_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
613 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
614 bool result;
615 bool _swig_go_result;
616
617 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
618
619 {
620 try
621 {
622 result = (bool)((std::vector< oneML::Image > const *)arg1)->empty();
623 }
624 catch (const std::invalid_argument& e)
625 {
626 SWIG_exception(SWIG_ValueError, e.what());
627 }
628 catch (const std::out_of_range& e)
629 {
630 SWIG_exception(SWIG_IndexError, e.what());
631 }
632 catch(const std::exception& e)
633 {
634 SWIG_exception(SWIG_RuntimeError, e.what());
635 }
636 }
637 _swig_go_result = result;
638 return _swig_go_result;
639}
640
641
642void _wrap_MultiImage_clear_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
643 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
644
645 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
646
647 {
648 try
649 {
650 (arg1)->clear();
651 }
652 catch (const std::invalid_argument& e)
653 {
654 SWIG_exception(SWIG_ValueError, e.what());
655 }
656 catch (const std::out_of_range& e)
657 {
658 SWIG_exception(SWIG_IndexError, e.what());
659 }
660 catch(const std::exception& e)
661 {
662 SWIG_exception(SWIG_RuntimeError, e.what());
663 }
664 }
665
666}
667
668
669void _wrap_MultiImage_add_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0, oneML::Image *_swig_go_1) {
670 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
671 std::vector< oneML::Image >::value_type *arg2 = 0 ;
672
673 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
674 arg2 = *(std::vector< oneML::Image >::value_type **)&_swig_go_1;
675
676 {
677 try
678 {
679 (arg1)->push_back((std::vector< oneML::Image >::value_type const &)*arg2);
680 }
681 catch (const std::invalid_argument& e)
682 {
683 SWIG_exception(SWIG_ValueError, e.what());
684 }
685 catch (const std::out_of_range& e)
686 {
687 SWIG_exception(SWIG_IndexError, e.what());
688 }
689 catch(const std::exception& e)
690 {
691 SWIG_exception(SWIG_RuntimeError, e.what());
692 }
693 }
694
695}
696
697
698oneML::Image *_wrap_MultiImage_get_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0, intgo _swig_go_1) {
699 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
700 int arg2 ;
701 std::vector< oneML::Image >::value_type *result = 0 ;
702 oneML::Image *_swig_go_result;
703
704 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
705 arg2 = (int)_swig_go_1;
706
707 {
708 try
709 {
710 try {
711 result = (std::vector< oneML::Image >::value_type *) &std_vector_Sl_oneML_Image_Sg__get(arg1,arg2);
712 } catch(std::out_of_range &_e) {
713 _swig_gopanic((&_e)->what());
714 }
715 }
716 catch (const std::invalid_argument& e)
717 {
718 SWIG_exception(SWIG_ValueError, e.what());
719 }
720 catch (const std::out_of_range& e)
721 {
722 SWIG_exception(SWIG_IndexError, e.what());
723 }
724 catch(const std::exception& e)
725 {
726 SWIG_exception(SWIG_RuntimeError, e.what());
727 }
728 }
729 *(std::vector< oneML::Image >::value_type **)&_swig_go_result = result;
730 return _swig_go_result;
731}
732
733
734void _wrap_MultiImage_set_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0, intgo _swig_go_1, oneML::Image *_swig_go_2) {
735 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
736 int arg2 ;
737 std::vector< oneML::Image >::value_type *arg3 = 0 ;
738
739 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
740 arg2 = (int)_swig_go_1;
741 arg3 = *(std::vector< oneML::Image >::value_type **)&_swig_go_2;
742
743 {
744 try
745 {
746 try {
747 std_vector_Sl_oneML_Image_Sg__set(arg1,arg2,(oneML::Image const &)*arg3);
748 } catch(std::out_of_range &_e) {
749 _swig_gopanic((&_e)->what());
750 }
751 }
752 catch (const std::invalid_argument& e)
753 {
754 SWIG_exception(SWIG_ValueError, e.what());
755 }
756 catch (const std::out_of_range& e)
757 {
758 SWIG_exception(SWIG_IndexError, e.what());
759 }
760 catch(const std::exception& e)
761 {
762 SWIG_exception(SWIG_RuntimeError, e.what());
763 }
764 }
765
766}
767
768
769void _wrap_delete_MultiImage_alpr_7074c9342a7bdf4a(std::vector< oneML::Image > *_swig_go_0) {
770 std::vector< oneML::Image > *arg1 = (std::vector< oneML::Image > *) 0 ;
771
772 arg1 = *(std::vector< oneML::Image > **)&_swig_go_0;
773
774 {
775 try
776 {
777 delete arg1;
778 }
779 catch (const std::invalid_argument& e)
780 {
781 SWIG_exception(SWIG_ValueError, e.what());
782 }
783 catch (const std::out_of_range& e)
784 {
785 SWIG_exception(SWIG_IndexError, e.what());
786 }
787 catch(const std::exception& e)
788 {
789 SWIG_exception(SWIG_RuntimeError, e.what());
790 }
791 }
792
793}
794
795
796oneML::Image *_wrap_new_Image__SWIG_0_alpr_7074c9342a7bdf4a() {
797 oneML::Image *result = 0 ;
798 oneML::Image *_swig_go_result;
799
800
801 {
802 try
803 {
804 result = (oneML::Image *)new oneML::Image();
805 }
806 catch (const std::invalid_argument& e)
807 {
808 SWIG_exception(SWIG_ValueError, e.what());
809 }
810 catch (const std::out_of_range& e)
811 {
812 SWIG_exception(SWIG_IndexError, e.what());
813 }
814 catch(const std::exception& e)
815 {
816 SWIG_exception(SWIG_RuntimeError, e.what());
817 }
818 }
819 *(oneML::Image **)&_swig_go_result = (oneML::Image *)result;
820 return _swig_go_result;
821}
822
823
824long long _wrap_Image_size_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
825 oneML::Image *arg1 = (oneML::Image *) 0 ;
826 size_t result;
827 long long _swig_go_result;
828
829 arg1 = *(oneML::Image **)&_swig_go_0;
830
831 {
832 try
833 {
834 result = ((oneML::Image const *)arg1)->size();
835 }
836 catch (const std::invalid_argument& e)
837 {
838 SWIG_exception(SWIG_ValueError, e.what());
839 }
840 catch (const std::out_of_range& e)
841 {
842 SWIG_exception(SWIG_IndexError, e.what());
843 }
844 catch(const std::exception& e)
845 {
846 SWIG_exception(SWIG_RuntimeError, e.what());
847 }
848 }
849 _swig_go_result = result;
850 return _swig_go_result;
851}
852
853
854void _wrap_Image_SetWidth_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0, short _swig_go_1) {
855 oneML::Image *arg1 = (oneML::Image *) 0 ;
856 uint16_t arg2 ;
857
858 arg1 = *(oneML::Image **)&_swig_go_0;
859 arg2 = (uint16_t)_swig_go_1;
860
861 {
862 try
863 {
864 (arg1)->set_width(arg2);
865 }
866 catch (const std::invalid_argument& e)
867 {
868 SWIG_exception(SWIG_ValueError, e.what());
869 }
870 catch (const std::out_of_range& e)
871 {
872 SWIG_exception(SWIG_IndexError, e.what());
873 }
874 catch(const std::exception& e)
875 {
876 SWIG_exception(SWIG_RuntimeError, e.what());
877 }
878 }
879
880}
881
882
883void _wrap_Image_SetHeight_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0, short _swig_go_1) {
884 oneML::Image *arg1 = (oneML::Image *) 0 ;
885 uint16_t arg2 ;
886
887 arg1 = *(oneML::Image **)&_swig_go_0;
888 arg2 = (uint16_t)_swig_go_1;
889
890 {
891 try
892 {
893 (arg1)->set_height(arg2);
894 }
895 catch (const std::invalid_argument& e)
896 {
897 SWIG_exception(SWIG_ValueError, e.what());
898 }
899 catch (const std::out_of_range& e)
900 {
901 SWIG_exception(SWIG_IndexError, e.what());
902 }
903 catch(const std::exception& e)
904 {
905 SWIG_exception(SWIG_RuntimeError, e.what());
906 }
907 }
908
909}
910
911
912void _wrap_Image_SetDepth_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0, short _swig_go_1) {
913 oneML::Image *arg1 = (oneML::Image *) 0 ;
914 uint16_t arg2 ;
915
916 arg1 = *(oneML::Image **)&_swig_go_0;
917 arg2 = (uint16_t)_swig_go_1;
918
919 {
920 try
921 {
922 (arg1)->set_depth(arg2);
923 }
924 catch (const std::invalid_argument& e)
925 {
926 SWIG_exception(SWIG_ValueError, e.what());
927 }
928 catch (const std::out_of_range& e)
929 {
930 SWIG_exception(SWIG_IndexError, e.what());
931 }
932 catch(const std::exception& e)
933 {
934 SWIG_exception(SWIG_RuntimeError, e.what());
935 }
936 }
937
938}
939
940
941short _wrap_Image_GetWidth_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
942 oneML::Image *arg1 = (oneML::Image *) 0 ;
943 uint16_t result;
944 short _swig_go_result;
945
946 arg1 = *(oneML::Image **)&_swig_go_0;
947
948 {
949 try
950 {
951 result = (uint16_t)((oneML::Image const *)arg1)->get_width();
952 }
953 catch (const std::invalid_argument& e)
954 {
955 SWIG_exception(SWIG_ValueError, e.what());
956 }
957 catch (const std::out_of_range& e)
958 {
959 SWIG_exception(SWIG_IndexError, e.what());
960 }
961 catch(const std::exception& e)
962 {
963 SWIG_exception(SWIG_RuntimeError, e.what());
964 }
965 }
966 _swig_go_result = result;
967 return _swig_go_result;
968}
969
970
971short _wrap_Image_GetHeight_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
972 oneML::Image *arg1 = (oneML::Image *) 0 ;
973 uint16_t result;
974 short _swig_go_result;
975
976 arg1 = *(oneML::Image **)&_swig_go_0;
977
978 {
979 try
980 {
981 result = (uint16_t)((oneML::Image const *)arg1)->get_height();
982 }
983 catch (const std::invalid_argument& e)
984 {
985 SWIG_exception(SWIG_ValueError, e.what());
986 }
987 catch (const std::out_of_range& e)
988 {
989 SWIG_exception(SWIG_IndexError, e.what());
990 }
991 catch(const std::exception& e)
992 {
993 SWIG_exception(SWIG_RuntimeError, e.what());
994 }
995 }
996 _swig_go_result = result;
997 return _swig_go_result;
998}
999
1000
1001short _wrap_Image_GetDepth_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
1002 oneML::Image *arg1 = (oneML::Image *) 0 ;
1003 uint16_t result;
1004 short _swig_go_result;
1005
1006 arg1 = *(oneML::Image **)&_swig_go_0;
1007
1008 {
1009 try
1010 {
1011 result = (uint16_t)((oneML::Image const *)arg1)->get_depth();
1012 }
1013 catch (const std::invalid_argument& e)
1014 {
1015 SWIG_exception(SWIG_ValueError, e.what());
1016 }
1017 catch (const std::out_of_range& e)
1018 {
1019 SWIG_exception(SWIG_IndexError, e.what());
1020 }
1021 catch(const std::exception& e)
1022 {
1023 SWIG_exception(SWIG_RuntimeError, e.what());
1024 }
1025 }
1026 _swig_go_result = result;
1027 return _swig_go_result;
1028}
1029
1030
1031oneML::Image *_wrap_new_Image__SWIG_1_alpr_7074c9342a7bdf4a(intgo _swig_go_0, intgo _swig_go_1, intgo _swig_go_2, _goslice_ _swig_go_3) {
1032 int arg1 ;
1033 int arg2 ;
1034 int arg3 ;
1035 unsigned char *arg4 = (unsigned char *) 0 ;
1036 oneML::Image *result = 0 ;
1037 oneML::Image *_swig_go_result;
1038
1039 arg1 = (int)_swig_go_0;
1040 arg2 = (int)_swig_go_1;
1041 arg3 = (int)_swig_go_2;
1042 {
1043 if (_swig_go_3.len == 0) {
1044 _swig_gopanic("array must contain at least 1 element");
1045 }
1046 arg4 = (unsigned char *) _swig_go_3.array;
1047 }
1048
1049 {
1050 try
1051 {
1052 result = (oneML::Image *)new_oneML_Image__SWIG_1(arg1,arg2,arg3,arg4);
1053 }
1054 catch (const std::invalid_argument& e)
1055 {
1056 SWIG_exception(SWIG_ValueError, e.what());
1057 }
1058 catch (const std::out_of_range& e)
1059 {
1060 SWIG_exception(SWIG_IndexError, e.what());
1061 }
1062 catch(const std::exception& e)
1063 {
1064 SWIG_exception(SWIG_RuntimeError, e.what());
1065 }
1066 }
1067 *(oneML::Image **)&_swig_go_result = (oneML::Image *)result;
1068
1069
1070 return _swig_go_result;
1071}
1072
1073
1074void _wrap_Image_SetData_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0, _goslice_ _swig_go_1) {
1075 oneML::Image *arg1 = (oneML::Image *) 0 ;
1076 unsigned char *arg2 = (unsigned char *) 0 ;
1077
1078 arg1 = *(oneML::Image **)&_swig_go_0;
1079 {
1080 if (_swig_go_1.len == 0) {
1081 _swig_gopanic("array must contain at least 1 element");
1082 }
1083 arg2 = (unsigned char *) _swig_go_1.array;
1084 }
1085
1086 {
1087 try
1088 {
1089 oneML_Image_go_set_data(arg1,arg2);
1090 }
1091 catch (const std::invalid_argument& e)
1092 {
1093 SWIG_exception(SWIG_ValueError, e.what());
1094 }
1095 catch (const std::out_of_range& e)
1096 {
1097 SWIG_exception(SWIG_IndexError, e.what());
1098 }
1099 catch(const std::exception& e)
1100 {
1101 SWIG_exception(SWIG_RuntimeError, e.what());
1102 }
1103 }
1104
1105
1106
1107}
1108
1109
1110char *_wrap_Image_GetData_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
1111 oneML::Image *arg1 = (oneML::Image *) 0 ;
1112 uint8_t *result = 0 ;
1113 char *_swig_go_result;
1114
1115 arg1 = *(oneML::Image **)&_swig_go_0;
1116
1117 {
1118 try
1119 {
1120 result = (uint8_t *)oneML_Image_go_get_data(arg1);
1121 }
1122 catch (const std::invalid_argument& e)
1123 {
1124 SWIG_exception(SWIG_ValueError, e.what());
1125 }
1126 catch (const std::out_of_range& e)
1127 {
1128 SWIG_exception(SWIG_IndexError, e.what());
1129 }
1130 catch(const std::exception& e)
1131 {
1132 SWIG_exception(SWIG_RuntimeError, e.what());
1133 }
1134 }
1135 *(uint8_t **)&_swig_go_result = (uint8_t *)result;
1136 return _swig_go_result;
1137}
1138
1139
1140void _wrap_delete_Image_alpr_7074c9342a7bdf4a(oneML::Image *_swig_go_0) {
1141 oneML::Image *arg1 = (oneML::Image *) 0 ;
1142
1143 arg1 = *(oneML::Image **)&_swig_go_0;
1144
1145 {
1146 try
1147 {
1148 delete arg1;
1149 }
1150 catch (const std::invalid_argument& e)
1151 {
1152 SWIG_exception(SWIG_ValueError, e.what());
1153 }
1154 catch (const std::out_of_range& e)
1155 {
1156 SWIG_exception(SWIG_IndexError, e.what());
1157 }
1158 catch(const std::exception& e)
1159 {
1160 SWIG_exception(SWIG_RuntimeError, e.what());
1161 }
1162 }
1163
1164}
1165
1166
1167void _wrap_BBox_top_set_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0, float _swig_go_1) {
1168 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1169 float arg2 ;
1170
1171 arg1 = *(oneML::BBox **)&_swig_go_0;
1172 arg2 = (float)_swig_go_1;
1173
1174 if (arg1) (arg1)->top = arg2;
1175
1176}
1177
1178
1179float _wrap_BBox_top_get_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0) {
1180 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1181 float result;
1182 float _swig_go_result;
1183
1184 arg1 = *(oneML::BBox **)&_swig_go_0;
1185
1186 result = (float) ((arg1)->top);
1187 _swig_go_result = result;
1188 return _swig_go_result;
1189}
1190
1191
1192void _wrap_BBox_left_set_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0, float _swig_go_1) {
1193 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1194 float arg2 ;
1195
1196 arg1 = *(oneML::BBox **)&_swig_go_0;
1197 arg2 = (float)_swig_go_1;
1198
1199 if (arg1) (arg1)->left = arg2;
1200
1201}
1202
1203
1204float _wrap_BBox_left_get_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0) {
1205 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1206 float result;
1207 float _swig_go_result;
1208
1209 arg1 = *(oneML::BBox **)&_swig_go_0;
1210
1211 result = (float) ((arg1)->left);
1212 _swig_go_result = result;
1213 return _swig_go_result;
1214}
1215
1216
1217void _wrap_BBox_bottom_set_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0, float _swig_go_1) {
1218 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1219 float arg2 ;
1220
1221 arg1 = *(oneML::BBox **)&_swig_go_0;
1222 arg2 = (float)_swig_go_1;
1223
1224 if (arg1) (arg1)->bottom = arg2;
1225
1226}
1227
1228
1229float _wrap_BBox_bottom_get_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0) {
1230 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1231 float result;
1232 float _swig_go_result;
1233
1234 arg1 = *(oneML::BBox **)&_swig_go_0;
1235
1236 result = (float) ((arg1)->bottom);
1237 _swig_go_result = result;
1238 return _swig_go_result;
1239}
1240
1241
1242void _wrap_BBox_right_set_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0, float _swig_go_1) {
1243 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1244 float arg2 ;
1245
1246 arg1 = *(oneML::BBox **)&_swig_go_0;
1247 arg2 = (float)_swig_go_1;
1248
1249 if (arg1) (arg1)->right = arg2;
1250
1251}
1252
1253
1254float _wrap_BBox_right_get_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0) {
1255 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1256 float result;
1257 float _swig_go_result;
1258
1259 arg1 = *(oneML::BBox **)&_swig_go_0;
1260
1261 result = (float) ((arg1)->right);
1262 _swig_go_result = result;
1263 return _swig_go_result;
1264}
1265
1266
1267oneML::BBox *_wrap_new_BBox_alpr_7074c9342a7bdf4a() {
1268 oneML::BBox *result = 0 ;
1269 oneML::BBox *_swig_go_result;
1270
1271
1272 {
1273 try
1274 {
1275 result = (oneML::BBox *)new oneML::BBox();
1276 }
1277 catch (const std::invalid_argument& e)
1278 {
1279 SWIG_exception(SWIG_ValueError, e.what());
1280 }
1281 catch (const std::out_of_range& e)
1282 {
1283 SWIG_exception(SWIG_IndexError, e.what());
1284 }
1285 catch(const std::exception& e)
1286 {
1287 SWIG_exception(SWIG_RuntimeError, e.what());
1288 }
1289 }
1290 *(oneML::BBox **)&_swig_go_result = (oneML::BBox *)result;
1291 return _swig_go_result;
1292}
1293
1294
1295void _wrap_delete_BBox_alpr_7074c9342a7bdf4a(oneML::BBox *_swig_go_0) {
1296 oneML::BBox *arg1 = (oneML::BBox *) 0 ;
1297
1298 arg1 = *(oneML::BBox **)&_swig_go_0;
1299
1300 {
1301 try
1302 {
1303 delete arg1;
1304 }
1305 catch (const std::invalid_argument& e)
1306 {
1307 SWIG_exception(SWIG_ValueError, e.what());
1308 }
1309 catch (const std::out_of_range& e)
1310 {
1311 SWIG_exception(SWIG_IndexError, e.what());
1312 }
1313 catch(const std::exception& e)
1314 {
1315 SWIG_exception(SWIG_RuntimeError, e.what());
1316 }
1317 }
1318
1319}
1320
1321
1322std::vector< float > *_wrap_new_FloatVector__SWIG_0_alpr_7074c9342a7bdf4a() {
1323 std::vector< float > *result = 0 ;
1324 std::vector< float > *_swig_go_result;
1325
1326
1327 {
1328 try
1329 {
1330 result = (std::vector< float > *)new std::vector< float >();
1331 }
1332 catch (const std::invalid_argument& e)
1333 {
1334 SWIG_exception(SWIG_ValueError, e.what());
1335 }
1336 catch (const std::out_of_range& e)
1337 {
1338 SWIG_exception(SWIG_IndexError, e.what());
1339 }
1340 catch(const std::exception& e)
1341 {
1342 SWIG_exception(SWIG_RuntimeError, e.what());
1343 }
1344 }
1345 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1346 return _swig_go_result;
1347}
1348
1349
1350std::vector< float > *_wrap_new_FloatVector__SWIG_1_alpr_7074c9342a7bdf4a(long long _swig_go_0) {
1351 std::vector< float >::size_type arg1 ;
1352 std::vector< float > *result = 0 ;
1353 std::vector< float > *_swig_go_result;
1354
1355 arg1 = (size_t)_swig_go_0;
1356
1357 {
1358 try
1359 {
1360 result = (std::vector< float > *)new std::vector< float >(arg1);
1361 }
1362 catch (const std::invalid_argument& e)
1363 {
1364 SWIG_exception(SWIG_ValueError, e.what());
1365 }
1366 catch (const std::out_of_range& e)
1367 {
1368 SWIG_exception(SWIG_IndexError, e.what());
1369 }
1370 catch(const std::exception& e)
1371 {
1372 SWIG_exception(SWIG_RuntimeError, e.what());
1373 }
1374 }
1375 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1376 return _swig_go_result;
1377}
1378
1379
1380std::vector< float > *_wrap_new_FloatVector__SWIG_2_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1381 std::vector< float > *arg1 = 0 ;
1382 std::vector< float > *result = 0 ;
1383 std::vector< float > *_swig_go_result;
1384
1385 arg1 = *(std::vector< float > **)&_swig_go_0;
1386
1387 {
1388 try
1389 {
1390 result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1);
1391 }
1392 catch (const std::invalid_argument& e)
1393 {
1394 SWIG_exception(SWIG_ValueError, e.what());
1395 }
1396 catch (const std::out_of_range& e)
1397 {
1398 SWIG_exception(SWIG_IndexError, e.what());
1399 }
1400 catch(const std::exception& e)
1401 {
1402 SWIG_exception(SWIG_RuntimeError, e.what());
1403 }
1404 }
1405 *(std::vector< float > **)&_swig_go_result = (std::vector< float > *)result;
1406 return _swig_go_result;
1407}
1408
1409
1410long long _wrap_FloatVector_size_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1411 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1412 std::vector< float >::size_type result;
1413 long long _swig_go_result;
1414
1415 arg1 = *(std::vector< float > **)&_swig_go_0;
1416
1417 {
1418 try
1419 {
1420 result = ((std::vector< float > const *)arg1)->size();
1421 }
1422 catch (const std::invalid_argument& e)
1423 {
1424 SWIG_exception(SWIG_ValueError, e.what());
1425 }
1426 catch (const std::out_of_range& e)
1427 {
1428 SWIG_exception(SWIG_IndexError, e.what());
1429 }
1430 catch(const std::exception& e)
1431 {
1432 SWIG_exception(SWIG_RuntimeError, e.what());
1433 }
1434 }
1435 _swig_go_result = result;
1436 return _swig_go_result;
1437}
1438
1439
1440long long _wrap_FloatVector_capacity_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1441 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1442 std::vector< float >::size_type result;
1443 long long _swig_go_result;
1444
1445 arg1 = *(std::vector< float > **)&_swig_go_0;
1446
1447 {
1448 try
1449 {
1450 result = ((std::vector< float > const *)arg1)->capacity();
1451 }
1452 catch (const std::invalid_argument& e)
1453 {
1454 SWIG_exception(SWIG_ValueError, e.what());
1455 }
1456 catch (const std::out_of_range& e)
1457 {
1458 SWIG_exception(SWIG_IndexError, e.what());
1459 }
1460 catch(const std::exception& e)
1461 {
1462 SWIG_exception(SWIG_RuntimeError, e.what());
1463 }
1464 }
1465 _swig_go_result = result;
1466 return _swig_go_result;
1467}
1468
1469
1470void _wrap_FloatVector_reserve_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0, long long _swig_go_1) {
1471 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1472 std::vector< float >::size_type arg2 ;
1473
1474 arg1 = *(std::vector< float > **)&_swig_go_0;
1475 arg2 = (size_t)_swig_go_1;
1476
1477 {
1478 try
1479 {
1480 (arg1)->reserve(arg2);
1481 }
1482 catch (const std::invalid_argument& e)
1483 {
1484 SWIG_exception(SWIG_ValueError, e.what());
1485 }
1486 catch (const std::out_of_range& e)
1487 {
1488 SWIG_exception(SWIG_IndexError, e.what());
1489 }
1490 catch(const std::exception& e)
1491 {
1492 SWIG_exception(SWIG_RuntimeError, e.what());
1493 }
1494 }
1495
1496}
1497
1498
1499bool _wrap_FloatVector_isEmpty_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1500 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1501 bool result;
1502 bool _swig_go_result;
1503
1504 arg1 = *(std::vector< float > **)&_swig_go_0;
1505
1506 {
1507 try
1508 {
1509 result = (bool)((std::vector< float > const *)arg1)->empty();
1510 }
1511 catch (const std::invalid_argument& e)
1512 {
1513 SWIG_exception(SWIG_ValueError, e.what());
1514 }
1515 catch (const std::out_of_range& e)
1516 {
1517 SWIG_exception(SWIG_IndexError, e.what());
1518 }
1519 catch(const std::exception& e)
1520 {
1521 SWIG_exception(SWIG_RuntimeError, e.what());
1522 }
1523 }
1524 _swig_go_result = result;
1525 return _swig_go_result;
1526}
1527
1528
1529void _wrap_FloatVector_clear_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1530 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1531
1532 arg1 = *(std::vector< float > **)&_swig_go_0;
1533
1534 {
1535 try
1536 {
1537 (arg1)->clear();
1538 }
1539 catch (const std::invalid_argument& e)
1540 {
1541 SWIG_exception(SWIG_ValueError, e.what());
1542 }
1543 catch (const std::out_of_range& e)
1544 {
1545 SWIG_exception(SWIG_IndexError, e.what());
1546 }
1547 catch(const std::exception& e)
1548 {
1549 SWIG_exception(SWIG_RuntimeError, e.what());
1550 }
1551 }
1552
1553}
1554
1555
1556void _wrap_FloatVector_add_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0, float _swig_go_1) {
1557 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1558 std::vector< float >::value_type *arg2 = 0 ;
1559
1560 arg1 = *(std::vector< float > **)&_swig_go_0;
1561 arg2 = (std::vector< float >::value_type *)&_swig_go_1;
1562
1563 {
1564 try
1565 {
1566 (arg1)->push_back((std::vector< float >::value_type const &)*arg2);
1567 }
1568 catch (const std::invalid_argument& e)
1569 {
1570 SWIG_exception(SWIG_ValueError, e.what());
1571 }
1572 catch (const std::out_of_range& e)
1573 {
1574 SWIG_exception(SWIG_IndexError, e.what());
1575 }
1576 catch(const std::exception& e)
1577 {
1578 SWIG_exception(SWIG_RuntimeError, e.what());
1579 }
1580 }
1581
1582}
1583
1584
1585float _wrap_FloatVector_get_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0, intgo _swig_go_1) {
1586 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1587 int arg2 ;
1588 std::vector< float >::value_type *result = 0 ;
1589 float _swig_go_result;
1590
1591 arg1 = *(std::vector< float > **)&_swig_go_0;
1592 arg2 = (int)_swig_go_1;
1593
1594 {
1595 try
1596 {
1597 try {
1598 result = (std::vector< float >::value_type *) &std_vector_Sl_float_Sg__get(arg1,arg2);
1599 } catch(std::out_of_range &_e) {
1600 _swig_gopanic((&_e)->what());
1601 }
1602 }
1603 catch (const std::invalid_argument& e)
1604 {
1605 SWIG_exception(SWIG_ValueError, e.what());
1606 }
1607 catch (const std::out_of_range& e)
1608 {
1609 SWIG_exception(SWIG_IndexError, e.what());
1610 }
1611 catch(const std::exception& e)
1612 {
1613 SWIG_exception(SWIG_RuntimeError, e.what());
1614 }
1615 }
1616 _swig_go_result = (float)*result;
1617 return _swig_go_result;
1618}
1619
1620
1621void _wrap_FloatVector_set_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0, intgo _swig_go_1, float _swig_go_2) {
1622 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1623 int arg2 ;
1624 std::vector< float >::value_type *arg3 = 0 ;
1625
1626 arg1 = *(std::vector< float > **)&_swig_go_0;
1627 arg2 = (int)_swig_go_1;
1628 arg3 = (std::vector< float >::value_type *)&_swig_go_2;
1629
1630 {
1631 try
1632 {
1633 try {
1634 std_vector_Sl_float_Sg__set(arg1,arg2,(float const &)*arg3);
1635 } catch(std::out_of_range &_e) {
1636 _swig_gopanic((&_e)->what());
1637 }
1638 }
1639 catch (const std::invalid_argument& e)
1640 {
1641 SWIG_exception(SWIG_ValueError, e.what());
1642 }
1643 catch (const std::out_of_range& e)
1644 {
1645 SWIG_exception(SWIG_IndexError, e.what());
1646 }
1647 catch(const std::exception& e)
1648 {
1649 SWIG_exception(SWIG_RuntimeError, e.what());
1650 }
1651 }
1652
1653}
1654
1655
1656void _wrap_delete_FloatVector_alpr_7074c9342a7bdf4a(std::vector< float > *_swig_go_0) {
1657 std::vector< float > *arg1 = (std::vector< float > *) 0 ;
1658
1659 arg1 = *(std::vector< float > **)&_swig_go_0;
1660
1661 {
1662 try
1663 {
1664 delete arg1;
1665 }
1666 catch (const std::invalid_argument& e)
1667 {
1668 SWIG_exception(SWIG_ValueError, e.what());
1669 }
1670 catch (const std::out_of_range& e)
1671 {
1672 SWIG_exception(SWIG_IndexError, e.what());
1673 }
1674 catch(const std::exception& e)
1675 {
1676 SWIG_exception(SWIG_RuntimeError, e.what());
1677 }
1678 }
1679
1680}
1681
1682
1683std::vector< int > *_wrap_new_IntVector__SWIG_0_alpr_7074c9342a7bdf4a() {
1684 std::vector< int > *result = 0 ;
1685 std::vector< int > *_swig_go_result;
1686
1687
1688 {
1689 try
1690 {
1691 result = (std::vector< int > *)new std::vector< int >();
1692 }
1693 catch (const std::invalid_argument& e)
1694 {
1695 SWIG_exception(SWIG_ValueError, e.what());
1696 }
1697 catch (const std::out_of_range& e)
1698 {
1699 SWIG_exception(SWIG_IndexError, e.what());
1700 }
1701 catch(const std::exception& e)
1702 {
1703 SWIG_exception(SWIG_RuntimeError, e.what());
1704 }
1705 }
1706 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
1707 return _swig_go_result;
1708}
1709
1710
1711std::vector< int > *_wrap_new_IntVector__SWIG_1_alpr_7074c9342a7bdf4a(long long _swig_go_0) {
1712 std::vector< int >::size_type arg1 ;
1713 std::vector< int > *result = 0 ;
1714 std::vector< int > *_swig_go_result;
1715
1716 arg1 = (size_t)_swig_go_0;
1717
1718 {
1719 try
1720 {
1721 result = (std::vector< int > *)new std::vector< int >(arg1);
1722 }
1723 catch (const std::invalid_argument& e)
1724 {
1725 SWIG_exception(SWIG_ValueError, e.what());
1726 }
1727 catch (const std::out_of_range& e)
1728 {
1729 SWIG_exception(SWIG_IndexError, e.what());
1730 }
1731 catch(const std::exception& e)
1732 {
1733 SWIG_exception(SWIG_RuntimeError, e.what());
1734 }
1735 }
1736 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
1737 return _swig_go_result;
1738}
1739
1740
1741std::vector< int > *_wrap_new_IntVector__SWIG_2_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
1742 std::vector< int > *arg1 = 0 ;
1743 std::vector< int > *result = 0 ;
1744 std::vector< int > *_swig_go_result;
1745
1746 arg1 = *(std::vector< int > **)&_swig_go_0;
1747
1748 {
1749 try
1750 {
1751 result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
1752 }
1753 catch (const std::invalid_argument& e)
1754 {
1755 SWIG_exception(SWIG_ValueError, e.what());
1756 }
1757 catch (const std::out_of_range& e)
1758 {
1759 SWIG_exception(SWIG_IndexError, e.what());
1760 }
1761 catch(const std::exception& e)
1762 {
1763 SWIG_exception(SWIG_RuntimeError, e.what());
1764 }
1765 }
1766 *(std::vector< int > **)&_swig_go_result = (std::vector< int > *)result;
1767 return _swig_go_result;
1768}
1769
1770
1771long long _wrap_IntVector_size_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
1772 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1773 std::vector< int >::size_type result;
1774 long long _swig_go_result;
1775
1776 arg1 = *(std::vector< int > **)&_swig_go_0;
1777
1778 {
1779 try
1780 {
1781 result = ((std::vector< int > const *)arg1)->size();
1782 }
1783 catch (const std::invalid_argument& e)
1784 {
1785 SWIG_exception(SWIG_ValueError, e.what());
1786 }
1787 catch (const std::out_of_range& e)
1788 {
1789 SWIG_exception(SWIG_IndexError, e.what());
1790 }
1791 catch(const std::exception& e)
1792 {
1793 SWIG_exception(SWIG_RuntimeError, e.what());
1794 }
1795 }
1796 _swig_go_result = result;
1797 return _swig_go_result;
1798}
1799
1800
1801long long _wrap_IntVector_capacity_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
1802 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1803 std::vector< int >::size_type result;
1804 long long _swig_go_result;
1805
1806 arg1 = *(std::vector< int > **)&_swig_go_0;
1807
1808 {
1809 try
1810 {
1811 result = ((std::vector< int > const *)arg1)->capacity();
1812 }
1813 catch (const std::invalid_argument& e)
1814 {
1815 SWIG_exception(SWIG_ValueError, e.what());
1816 }
1817 catch (const std::out_of_range& e)
1818 {
1819 SWIG_exception(SWIG_IndexError, e.what());
1820 }
1821 catch(const std::exception& e)
1822 {
1823 SWIG_exception(SWIG_RuntimeError, e.what());
1824 }
1825 }
1826 _swig_go_result = result;
1827 return _swig_go_result;
1828}
1829
1830
1831void _wrap_IntVector_reserve_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0, long long _swig_go_1) {
1832 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1833 std::vector< int >::size_type arg2 ;
1834
1835 arg1 = *(std::vector< int > **)&_swig_go_0;
1836 arg2 = (size_t)_swig_go_1;
1837
1838 {
1839 try
1840 {
1841 (arg1)->reserve(arg2);
1842 }
1843 catch (const std::invalid_argument& e)
1844 {
1845 SWIG_exception(SWIG_ValueError, e.what());
1846 }
1847 catch (const std::out_of_range& e)
1848 {
1849 SWIG_exception(SWIG_IndexError, e.what());
1850 }
1851 catch(const std::exception& e)
1852 {
1853 SWIG_exception(SWIG_RuntimeError, e.what());
1854 }
1855 }
1856
1857}
1858
1859
1860bool _wrap_IntVector_isEmpty_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
1861 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1862 bool result;
1863 bool _swig_go_result;
1864
1865 arg1 = *(std::vector< int > **)&_swig_go_0;
1866
1867 {
1868 try
1869 {
1870 result = (bool)((std::vector< int > const *)arg1)->empty();
1871 }
1872 catch (const std::invalid_argument& e)
1873 {
1874 SWIG_exception(SWIG_ValueError, e.what());
1875 }
1876 catch (const std::out_of_range& e)
1877 {
1878 SWIG_exception(SWIG_IndexError, e.what());
1879 }
1880 catch(const std::exception& e)
1881 {
1882 SWIG_exception(SWIG_RuntimeError, e.what());
1883 }
1884 }
1885 _swig_go_result = result;
1886 return _swig_go_result;
1887}
1888
1889
1890void _wrap_IntVector_clear_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
1891 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1892
1893 arg1 = *(std::vector< int > **)&_swig_go_0;
1894
1895 {
1896 try
1897 {
1898 (arg1)->clear();
1899 }
1900 catch (const std::invalid_argument& e)
1901 {
1902 SWIG_exception(SWIG_ValueError, e.what());
1903 }
1904 catch (const std::out_of_range& e)
1905 {
1906 SWIG_exception(SWIG_IndexError, e.what());
1907 }
1908 catch(const std::exception& e)
1909 {
1910 SWIG_exception(SWIG_RuntimeError, e.what());
1911 }
1912 }
1913
1914}
1915
1916
1917void _wrap_IntVector_add_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0, intgo _swig_go_1) {
1918 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1919 std::vector< int >::value_type *arg2 = 0 ;
1920
1921 arg1 = *(std::vector< int > **)&_swig_go_0;
1922 arg2 = (std::vector< int >::value_type *)&_swig_go_1;
1923
1924 {
1925 try
1926 {
1927 (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
1928 }
1929 catch (const std::invalid_argument& e)
1930 {
1931 SWIG_exception(SWIG_ValueError, e.what());
1932 }
1933 catch (const std::out_of_range& e)
1934 {
1935 SWIG_exception(SWIG_IndexError, e.what());
1936 }
1937 catch(const std::exception& e)
1938 {
1939 SWIG_exception(SWIG_RuntimeError, e.what());
1940 }
1941 }
1942
1943}
1944
1945
1946intgo _wrap_IntVector_get_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0, intgo _swig_go_1) {
1947 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1948 int arg2 ;
1949 std::vector< int >::value_type *result = 0 ;
1950 intgo _swig_go_result;
1951
1952 arg1 = *(std::vector< int > **)&_swig_go_0;
1953 arg2 = (int)_swig_go_1;
1954
1955 {
1956 try
1957 {
1958 try {
1959 result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__get(arg1,arg2);
1960 } catch(std::out_of_range &_e) {
1961 _swig_gopanic((&_e)->what());
1962 }
1963 }
1964 catch (const std::invalid_argument& e)
1965 {
1966 SWIG_exception(SWIG_ValueError, e.what());
1967 }
1968 catch (const std::out_of_range& e)
1969 {
1970 SWIG_exception(SWIG_IndexError, e.what());
1971 }
1972 catch(const std::exception& e)
1973 {
1974 SWIG_exception(SWIG_RuntimeError, e.what());
1975 }
1976 }
1977 _swig_go_result = (int)*result;
1978 return _swig_go_result;
1979}
1980
1981
1982void _wrap_IntVector_set_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0, intgo _swig_go_1, intgo _swig_go_2) {
1983 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
1984 int arg2 ;
1985 std::vector< int >::value_type *arg3 = 0 ;
1986
1987 arg1 = *(std::vector< int > **)&_swig_go_0;
1988 arg2 = (int)_swig_go_1;
1989 arg3 = (std::vector< int >::value_type *)&_swig_go_2;
1990
1991 {
1992 try
1993 {
1994 try {
1995 std_vector_Sl_int_Sg__set(arg1,arg2,(int const &)*arg3);
1996 } catch(std::out_of_range &_e) {
1997 _swig_gopanic((&_e)->what());
1998 }
1999 }
2000 catch (const std::invalid_argument& e)
2001 {
2002 SWIG_exception(SWIG_ValueError, e.what());
2003 }
2004 catch (const std::out_of_range& e)
2005 {
2006 SWIG_exception(SWIG_IndexError, e.what());
2007 }
2008 catch(const std::exception& e)
2009 {
2010 SWIG_exception(SWIG_RuntimeError, e.what());
2011 }
2012 }
2013
2014}
2015
2016
2017void _wrap_delete_IntVector_alpr_7074c9342a7bdf4a(std::vector< int > *_swig_go_0) {
2018 std::vector< int > *arg1 = (std::vector< int > *) 0 ;
2019
2020 arg1 = *(std::vector< int > **)&_swig_go_0;
2021
2022 {
2023 try
2024 {
2025 delete arg1;
2026 }
2027 catch (const std::invalid_argument& e)
2028 {
2029 SWIG_exception(SWIG_ValueError, e.what());
2030 }
2031 catch (const std::out_of_range& e)
2032 {
2033 SWIG_exception(SWIG_IndexError, e.what());
2034 }
2035 catch(const std::exception& e)
2036 {
2037 SWIG_exception(SWIG_RuntimeError, e.what());
2038 }
2039 }
2040
2041}
2042
2043
2044std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_0_alpr_7074c9342a7bdf4a() {
2045 std::vector< oneML::BBox > *result = 0 ;
2046 std::vector< oneML::BBox > *_swig_go_result;
2047
2048
2049 {
2050 try
2051 {
2052 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >();
2053 }
2054 catch (const std::invalid_argument& e)
2055 {
2056 SWIG_exception(SWIG_ValueError, e.what());
2057 }
2058 catch (const std::out_of_range& e)
2059 {
2060 SWIG_exception(SWIG_IndexError, e.what());
2061 }
2062 catch(const std::exception& e)
2063 {
2064 SWIG_exception(SWIG_RuntimeError, e.what());
2065 }
2066 }
2067 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2068 return _swig_go_result;
2069}
2070
2071
2072std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_1_alpr_7074c9342a7bdf4a(long long _swig_go_0) {
2073 std::vector< oneML::BBox >::size_type arg1 ;
2074 std::vector< oneML::BBox > *result = 0 ;
2075 std::vector< oneML::BBox > *_swig_go_result;
2076
2077 arg1 = (size_t)_swig_go_0;
2078
2079 {
2080 try
2081 {
2082 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >(arg1);
2083 }
2084 catch (const std::invalid_argument& e)
2085 {
2086 SWIG_exception(SWIG_ValueError, e.what());
2087 }
2088 catch (const std::out_of_range& e)
2089 {
2090 SWIG_exception(SWIG_IndexError, e.what());
2091 }
2092 catch(const std::exception& e)
2093 {
2094 SWIG_exception(SWIG_RuntimeError, e.what());
2095 }
2096 }
2097 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2098 return _swig_go_result;
2099}
2100
2101
2102std::vector< oneML::BBox > *_wrap_new_BBoxVector__SWIG_2_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2103 std::vector< oneML::BBox > *arg1 = 0 ;
2104 std::vector< oneML::BBox > *result = 0 ;
2105 std::vector< oneML::BBox > *_swig_go_result;
2106
2107 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2108
2109 {
2110 try
2111 {
2112 result = (std::vector< oneML::BBox > *)new std::vector< oneML::BBox >((std::vector< oneML::BBox > const &)*arg1);
2113 }
2114 catch (const std::invalid_argument& e)
2115 {
2116 SWIG_exception(SWIG_ValueError, e.what());
2117 }
2118 catch (const std::out_of_range& e)
2119 {
2120 SWIG_exception(SWIG_IndexError, e.what());
2121 }
2122 catch(const std::exception& e)
2123 {
2124 SWIG_exception(SWIG_RuntimeError, e.what());
2125 }
2126 }
2127 *(std::vector< oneML::BBox > **)&_swig_go_result = (std::vector< oneML::BBox > *)result;
2128 return _swig_go_result;
2129}
2130
2131
2132long long _wrap_BBoxVector_size_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2133 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2134 std::vector< oneML::BBox >::size_type result;
2135 long long _swig_go_result;
2136
2137 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2138
2139 {
2140 try
2141 {
2142 result = ((std::vector< oneML::BBox > const *)arg1)->size();
2143 }
2144 catch (const std::invalid_argument& e)
2145 {
2146 SWIG_exception(SWIG_ValueError, e.what());
2147 }
2148 catch (const std::out_of_range& e)
2149 {
2150 SWIG_exception(SWIG_IndexError, e.what());
2151 }
2152 catch(const std::exception& e)
2153 {
2154 SWIG_exception(SWIG_RuntimeError, e.what());
2155 }
2156 }
2157 _swig_go_result = result;
2158 return _swig_go_result;
2159}
2160
2161
2162long long _wrap_BBoxVector_capacity_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2163 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2164 std::vector< oneML::BBox >::size_type result;
2165 long long _swig_go_result;
2166
2167 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2168
2169 {
2170 try
2171 {
2172 result = ((std::vector< oneML::BBox > const *)arg1)->capacity();
2173 }
2174 catch (const std::invalid_argument& e)
2175 {
2176 SWIG_exception(SWIG_ValueError, e.what());
2177 }
2178 catch (const std::out_of_range& e)
2179 {
2180 SWIG_exception(SWIG_IndexError, e.what());
2181 }
2182 catch(const std::exception& e)
2183 {
2184 SWIG_exception(SWIG_RuntimeError, e.what());
2185 }
2186 }
2187 _swig_go_result = result;
2188 return _swig_go_result;
2189}
2190
2191
2192void _wrap_BBoxVector_reserve_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0, long long _swig_go_1) {
2193 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2194 std::vector< oneML::BBox >::size_type arg2 ;
2195
2196 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2197 arg2 = (size_t)_swig_go_1;
2198
2199 {
2200 try
2201 {
2202 (arg1)->reserve(arg2);
2203 }
2204 catch (const std::invalid_argument& e)
2205 {
2206 SWIG_exception(SWIG_ValueError, e.what());
2207 }
2208 catch (const std::out_of_range& e)
2209 {
2210 SWIG_exception(SWIG_IndexError, e.what());
2211 }
2212 catch(const std::exception& e)
2213 {
2214 SWIG_exception(SWIG_RuntimeError, e.what());
2215 }
2216 }
2217
2218}
2219
2220
2221bool _wrap_BBoxVector_isEmpty_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2222 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2223 bool result;
2224 bool _swig_go_result;
2225
2226 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2227
2228 {
2229 try
2230 {
2231 result = (bool)((std::vector< oneML::BBox > const *)arg1)->empty();
2232 }
2233 catch (const std::invalid_argument& e)
2234 {
2235 SWIG_exception(SWIG_ValueError, e.what());
2236 }
2237 catch (const std::out_of_range& e)
2238 {
2239 SWIG_exception(SWIG_IndexError, e.what());
2240 }
2241 catch(const std::exception& e)
2242 {
2243 SWIG_exception(SWIG_RuntimeError, e.what());
2244 }
2245 }
2246 _swig_go_result = result;
2247 return _swig_go_result;
2248}
2249
2250
2251void _wrap_BBoxVector_clear_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2252 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2253
2254 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2255
2256 {
2257 try
2258 {
2259 (arg1)->clear();
2260 }
2261 catch (const std::invalid_argument& e)
2262 {
2263 SWIG_exception(SWIG_ValueError, e.what());
2264 }
2265 catch (const std::out_of_range& e)
2266 {
2267 SWIG_exception(SWIG_IndexError, e.what());
2268 }
2269 catch(const std::exception& e)
2270 {
2271 SWIG_exception(SWIG_RuntimeError, e.what());
2272 }
2273 }
2274
2275}
2276
2277
2278void _wrap_BBoxVector_add_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0, oneML::BBox *_swig_go_1) {
2279 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2280 std::vector< oneML::BBox >::value_type *arg2 = 0 ;
2281
2282 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2283 arg2 = *(std::vector< oneML::BBox >::value_type **)&_swig_go_1;
2284
2285 {
2286 try
2287 {
2288 (arg1)->push_back((std::vector< oneML::BBox >::value_type const &)*arg2);
2289 }
2290 catch (const std::invalid_argument& e)
2291 {
2292 SWIG_exception(SWIG_ValueError, e.what());
2293 }
2294 catch (const std::out_of_range& e)
2295 {
2296 SWIG_exception(SWIG_IndexError, e.what());
2297 }
2298 catch(const std::exception& e)
2299 {
2300 SWIG_exception(SWIG_RuntimeError, e.what());
2301 }
2302 }
2303
2304}
2305
2306
2307oneML::BBox *_wrap_BBoxVector_get_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0, intgo _swig_go_1) {
2308 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2309 int arg2 ;
2310 std::vector< oneML::BBox >::value_type *result = 0 ;
2311 oneML::BBox *_swig_go_result;
2312
2313 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2314 arg2 = (int)_swig_go_1;
2315
2316 {
2317 try
2318 {
2319 try {
2320 result = (std::vector< oneML::BBox >::value_type *) &std_vector_Sl_oneML_BBox_Sg__get(arg1,arg2);
2321 } catch(std::out_of_range &_e) {
2322 _swig_gopanic((&_e)->what());
2323 }
2324 }
2325 catch (const std::invalid_argument& e)
2326 {
2327 SWIG_exception(SWIG_ValueError, e.what());
2328 }
2329 catch (const std::out_of_range& e)
2330 {
2331 SWIG_exception(SWIG_IndexError, e.what());
2332 }
2333 catch(const std::exception& e)
2334 {
2335 SWIG_exception(SWIG_RuntimeError, e.what());
2336 }
2337 }
2338 *(std::vector< oneML::BBox >::value_type **)&_swig_go_result = result;
2339 return _swig_go_result;
2340}
2341
2342
2343void _wrap_BBoxVector_set_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0, intgo _swig_go_1, oneML::BBox *_swig_go_2) {
2344 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2345 int arg2 ;
2346 std::vector< oneML::BBox >::value_type *arg3 = 0 ;
2347
2348 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2349 arg2 = (int)_swig_go_1;
2350 arg3 = *(std::vector< oneML::BBox >::value_type **)&_swig_go_2;
2351
2352 {
2353 try
2354 {
2355 try {
2356 std_vector_Sl_oneML_BBox_Sg__set(arg1,arg2,(oneML::BBox const &)*arg3);
2357 } catch(std::out_of_range &_e) {
2358 _swig_gopanic((&_e)->what());
2359 }
2360 }
2361 catch (const std::invalid_argument& e)
2362 {
2363 SWIG_exception(SWIG_ValueError, e.what());
2364 }
2365 catch (const std::out_of_range& e)
2366 {
2367 SWIG_exception(SWIG_IndexError, e.what());
2368 }
2369 catch(const std::exception& e)
2370 {
2371 SWIG_exception(SWIG_RuntimeError, e.what());
2372 }
2373 }
2374
2375}
2376
2377
2378void _wrap_delete_BBoxVector_alpr_7074c9342a7bdf4a(std::vector< oneML::BBox > *_swig_go_0) {
2379 std::vector< oneML::BBox > *arg1 = (std::vector< oneML::BBox > *) 0 ;
2380
2381 arg1 = *(std::vector< oneML::BBox > **)&_swig_go_0;
2382
2383 {
2384 try
2385 {
2386 delete arg1;
2387 }
2388 catch (const std::invalid_argument& e)
2389 {
2390 SWIG_exception(SWIG_ValueError, e.what());
2391 }
2392 catch (const std::out_of_range& e)
2393 {
2394 SWIG_exception(SWIG_IndexError, e.what());
2395 }
2396 catch(const std::exception& e)
2397 {
2398 SWIG_exception(SWIG_RuntimeError, e.what());
2399 }
2400 }
2401
2402}
2403
2404
2405std::vector< oneML::alpr::VehicleDetectorResult > *_wrap_new_VehicleDetectorResultVector__SWIG_0_alpr_7074c9342a7bdf4a() {
2406 std::vector< oneML::alpr::VehicleDetectorResult > *result = 0 ;
2407 std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_result;
2408
2409
2410 {
2411 try
2412 {
2413 result = (std::vector< oneML::alpr::VehicleDetectorResult > *)new std::vector< oneML::alpr::VehicleDetectorResult >();
2414 }
2415 catch (const std::invalid_argument& e)
2416 {
2417 SWIG_exception(SWIG_ValueError, e.what());
2418 }
2419 catch (const std::out_of_range& e)
2420 {
2421 SWIG_exception(SWIG_IndexError, e.what());
2422 }
2423 catch(const std::exception& e)
2424 {
2425 SWIG_exception(SWIG_RuntimeError, e.what());
2426 }
2427 }
2428 *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_result = (std::vector< oneML::alpr::VehicleDetectorResult > *)result;
2429 return _swig_go_result;
2430}
2431
2432
2433std::vector< oneML::alpr::VehicleDetectorResult > *_wrap_new_VehicleDetectorResultVector__SWIG_1_alpr_7074c9342a7bdf4a(long long _swig_go_0) {
2434 std::vector< oneML::alpr::VehicleDetectorResult >::size_type arg1 ;
2435 std::vector< oneML::alpr::VehicleDetectorResult > *result = 0 ;
2436 std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_result;
2437
2438 arg1 = (size_t)_swig_go_0;
2439
2440 {
2441 try
2442 {
2443 result = (std::vector< oneML::alpr::VehicleDetectorResult > *)new std::vector< oneML::alpr::VehicleDetectorResult >(arg1);
2444 }
2445 catch (const std::invalid_argument& e)
2446 {
2447 SWIG_exception(SWIG_ValueError, e.what());
2448 }
2449 catch (const std::out_of_range& e)
2450 {
2451 SWIG_exception(SWIG_IndexError, e.what());
2452 }
2453 catch(const std::exception& e)
2454 {
2455 SWIG_exception(SWIG_RuntimeError, e.what());
2456 }
2457 }
2458 *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_result = (std::vector< oneML::alpr::VehicleDetectorResult > *)result;
2459 return _swig_go_result;
2460}
2461
2462
2463std::vector< oneML::alpr::VehicleDetectorResult > *_wrap_new_VehicleDetectorResultVector__SWIG_2_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2464 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = 0 ;
2465 std::vector< oneML::alpr::VehicleDetectorResult > *result = 0 ;
2466 std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_result;
2467
2468 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2469
2470 {
2471 try
2472 {
2473 result = (std::vector< oneML::alpr::VehicleDetectorResult > *)new std::vector< oneML::alpr::VehicleDetectorResult >((std::vector< oneML::alpr::VehicleDetectorResult > const &)*arg1);
2474 }
2475 catch (const std::invalid_argument& e)
2476 {
2477 SWIG_exception(SWIG_ValueError, e.what());
2478 }
2479 catch (const std::out_of_range& e)
2480 {
2481 SWIG_exception(SWIG_IndexError, e.what());
2482 }
2483 catch(const std::exception& e)
2484 {
2485 SWIG_exception(SWIG_RuntimeError, e.what());
2486 }
2487 }
2488 *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_result = (std::vector< oneML::alpr::VehicleDetectorResult > *)result;
2489 return _swig_go_result;
2490}
2491
2492
2493long long _wrap_VehicleDetectorResultVector_size_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2494 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2495 std::vector< oneML::alpr::VehicleDetectorResult >::size_type result;
2496 long long _swig_go_result;
2497
2498 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2499
2500 {
2501 try
2502 {
2503 result = ((std::vector< oneML::alpr::VehicleDetectorResult > const *)arg1)->size();
2504 }
2505 catch (const std::invalid_argument& e)
2506 {
2507 SWIG_exception(SWIG_ValueError, e.what());
2508 }
2509 catch (const std::out_of_range& e)
2510 {
2511 SWIG_exception(SWIG_IndexError, e.what());
2512 }
2513 catch(const std::exception& e)
2514 {
2515 SWIG_exception(SWIG_RuntimeError, e.what());
2516 }
2517 }
2518 _swig_go_result = result;
2519 return _swig_go_result;
2520}
2521
2522
2523long long _wrap_VehicleDetectorResultVector_capacity_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2524 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2525 std::vector< oneML::alpr::VehicleDetectorResult >::size_type result;
2526 long long _swig_go_result;
2527
2528 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2529
2530 {
2531 try
2532 {
2533 result = ((std::vector< oneML::alpr::VehicleDetectorResult > const *)arg1)->capacity();
2534 }
2535 catch (const std::invalid_argument& e)
2536 {
2537 SWIG_exception(SWIG_ValueError, e.what());
2538 }
2539 catch (const std::out_of_range& e)
2540 {
2541 SWIG_exception(SWIG_IndexError, e.what());
2542 }
2543 catch(const std::exception& e)
2544 {
2545 SWIG_exception(SWIG_RuntimeError, e.what());
2546 }
2547 }
2548 _swig_go_result = result;
2549 return _swig_go_result;
2550}
2551
2552
2553void _wrap_VehicleDetectorResultVector_reserve_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0, long long _swig_go_1) {
2554 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2555 std::vector< oneML::alpr::VehicleDetectorResult >::size_type arg2 ;
2556
2557 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2558 arg2 = (size_t)_swig_go_1;
2559
2560 {
2561 try
2562 {
2563 (arg1)->reserve(arg2);
2564 }
2565 catch (const std::invalid_argument& e)
2566 {
2567 SWIG_exception(SWIG_ValueError, e.what());
2568 }
2569 catch (const std::out_of_range& e)
2570 {
2571 SWIG_exception(SWIG_IndexError, e.what());
2572 }
2573 catch(const std::exception& e)
2574 {
2575 SWIG_exception(SWIG_RuntimeError, e.what());
2576 }
2577 }
2578
2579}
2580
2581
2582bool _wrap_VehicleDetectorResultVector_isEmpty_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2583 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2584 bool result;
2585 bool _swig_go_result;
2586
2587 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2588
2589 {
2590 try
2591 {
2592 result = (bool)((std::vector< oneML::alpr::VehicleDetectorResult > const *)arg1)->empty();
2593 }
2594 catch (const std::invalid_argument& e)
2595 {
2596 SWIG_exception(SWIG_ValueError, e.what());
2597 }
2598 catch (const std::out_of_range& e)
2599 {
2600 SWIG_exception(SWIG_IndexError, e.what());
2601 }
2602 catch(const std::exception& e)
2603 {
2604 SWIG_exception(SWIG_RuntimeError, e.what());
2605 }
2606 }
2607 _swig_go_result = result;
2608 return _swig_go_result;
2609}
2610
2611
2612void _wrap_VehicleDetectorResultVector_clear_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2613 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2614
2615 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2616
2617 {
2618 try
2619 {
2620 (arg1)->clear();
2621 }
2622 catch (const std::invalid_argument& e)
2623 {
2624 SWIG_exception(SWIG_ValueError, e.what());
2625 }
2626 catch (const std::out_of_range& e)
2627 {
2628 SWIG_exception(SWIG_IndexError, e.what());
2629 }
2630 catch(const std::exception& e)
2631 {
2632 SWIG_exception(SWIG_RuntimeError, e.what());
2633 }
2634 }
2635
2636}
2637
2638
2639void _wrap_VehicleDetectorResultVector_add_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0, oneML::alpr::VehicleDetectorResult *_swig_go_1) {
2640 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2641 std::vector< oneML::alpr::VehicleDetectorResult >::value_type *arg2 = 0 ;
2642
2643 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2644 arg2 = *(std::vector< oneML::alpr::VehicleDetectorResult >::value_type **)&_swig_go_1;
2645
2646 {
2647 try
2648 {
2649 (arg1)->push_back((std::vector< oneML::alpr::VehicleDetectorResult >::value_type const &)*arg2);
2650 }
2651 catch (const std::invalid_argument& e)
2652 {
2653 SWIG_exception(SWIG_ValueError, e.what());
2654 }
2655 catch (const std::out_of_range& e)
2656 {
2657 SWIG_exception(SWIG_IndexError, e.what());
2658 }
2659 catch(const std::exception& e)
2660 {
2661 SWIG_exception(SWIG_RuntimeError, e.what());
2662 }
2663 }
2664
2665}
2666
2667
2668oneML::alpr::VehicleDetectorResult *_wrap_VehicleDetectorResultVector_get_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0, intgo _swig_go_1) {
2669 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2670 int arg2 ;
2671 std::vector< oneML::alpr::VehicleDetectorResult >::value_type *result = 0 ;
2672 oneML::alpr::VehicleDetectorResult *_swig_go_result;
2673
2674 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2675 arg2 = (int)_swig_go_1;
2676
2677 {
2678 try
2679 {
2680 try {
2681 result = (std::vector< oneML::alpr::VehicleDetectorResult >::value_type *) &std_vector_Sl_oneML_alpr_VehicleDetectorResult_Sg__get(arg1,arg2);
2682 } catch(std::out_of_range &_e) {
2683 _swig_gopanic((&_e)->what());
2684 }
2685 }
2686 catch (const std::invalid_argument& e)
2687 {
2688 SWIG_exception(SWIG_ValueError, e.what());
2689 }
2690 catch (const std::out_of_range& e)
2691 {
2692 SWIG_exception(SWIG_IndexError, e.what());
2693 }
2694 catch(const std::exception& e)
2695 {
2696 SWIG_exception(SWIG_RuntimeError, e.what());
2697 }
2698 }
2699 *(std::vector< oneML::alpr::VehicleDetectorResult >::value_type **)&_swig_go_result = result;
2700 return _swig_go_result;
2701}
2702
2703
2704void _wrap_VehicleDetectorResultVector_set_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0, intgo _swig_go_1, oneML::alpr::VehicleDetectorResult *_swig_go_2) {
2705 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2706 int arg2 ;
2707 std::vector< oneML::alpr::VehicleDetectorResult >::value_type *arg3 = 0 ;
2708
2709 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2710 arg2 = (int)_swig_go_1;
2711 arg3 = *(std::vector< oneML::alpr::VehicleDetectorResult >::value_type **)&_swig_go_2;
2712
2713 {
2714 try
2715 {
2716 try {
2717 std_vector_Sl_oneML_alpr_VehicleDetectorResult_Sg__set(arg1,arg2,(oneML::alpr::VehicleDetectorResult const &)*arg3);
2718 } catch(std::out_of_range &_e) {
2719 _swig_gopanic((&_e)->what());
2720 }
2721 }
2722 catch (const std::invalid_argument& e)
2723 {
2724 SWIG_exception(SWIG_ValueError, e.what());
2725 }
2726 catch (const std::out_of_range& e)
2727 {
2728 SWIG_exception(SWIG_IndexError, e.what());
2729 }
2730 catch(const std::exception& e)
2731 {
2732 SWIG_exception(SWIG_RuntimeError, e.what());
2733 }
2734 }
2735
2736}
2737
2738
2739void _wrap_delete_VehicleDetectorResultVector_alpr_7074c9342a7bdf4a(std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_0) {
2740 std::vector< oneML::alpr::VehicleDetectorResult > *arg1 = (std::vector< oneML::alpr::VehicleDetectorResult > *) 0 ;
2741
2742 arg1 = *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_0;
2743
2744 {
2745 try
2746 {
2747 delete arg1;
2748 }
2749 catch (const std::invalid_argument& e)
2750 {
2751 SWIG_exception(SWIG_ValueError, e.what());
2752 }
2753 catch (const std::out_of_range& e)
2754 {
2755 SWIG_exception(SWIG_IndexError, e.what());
2756 }
2757 catch(const std::exception& e)
2758 {
2759 SWIG_exception(SWIG_RuntimeError, e.what());
2760 }
2761 }
2762
2763}
2764
2765
2766oneML::alpr::VehicleDetectorResult *_wrap_new_VehicleDetectorResult_alpr_7074c9342a7bdf4a() {
2767 oneML::alpr::VehicleDetectorResult *result = 0 ;
2768 oneML::alpr::VehicleDetectorResult *_swig_go_result;
2769
2770
2771 {
2772 try
2773 {
2774 result = (oneML::alpr::VehicleDetectorResult *)new oneML::alpr::VehicleDetectorResult();
2775 }
2776 catch (const std::invalid_argument& e)
2777 {
2778 SWIG_exception(SWIG_ValueError, e.what());
2779 }
2780 catch (const std::out_of_range& e)
2781 {
2782 SWIG_exception(SWIG_IndexError, e.what());
2783 }
2784 catch(const std::exception& e)
2785 {
2786 SWIG_exception(SWIG_RuntimeError, e.what());
2787 }
2788 }
2789 *(oneML::alpr::VehicleDetectorResult **)&_swig_go_result = (oneML::alpr::VehicleDetectorResult *)result;
2790 return _swig_go_result;
2791}
2792
2793
2794intgo _wrap_VehicleDetectorResult_GetSize_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetectorResult *_swig_go_0) {
2795 oneML::alpr::VehicleDetectorResult *arg1 = (oneML::alpr::VehicleDetectorResult *) 0 ;
2796 int result;
2797 intgo _swig_go_result;
2798
2799 arg1 = *(oneML::alpr::VehicleDetectorResult **)&_swig_go_0;
2800
2801 {
2802 try
2803 {
2804 result = (int)((oneML::alpr::VehicleDetectorResult const *)arg1)->get_size();
2805 }
2806 catch (const std::invalid_argument& e)
2807 {
2808 SWIG_exception(SWIG_ValueError, e.what());
2809 }
2810 catch (const std::out_of_range& e)
2811 {
2812 SWIG_exception(SWIG_IndexError, e.what());
2813 }
2814 catch(const std::exception& e)
2815 {
2816 SWIG_exception(SWIG_RuntimeError, e.what());
2817 }
2818 }
2819 _swig_go_result = result;
2820 return _swig_go_result;
2821}
2822
2823
2824std::vector< float > *_wrap_VehicleDetectorResult_GetScores_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetectorResult *_swig_go_0) {
2825 oneML::alpr::VehicleDetectorResult *arg1 = (oneML::alpr::VehicleDetectorResult *) 0 ;
2826 std::vector< float > result;
2827 std::vector< float > *_swig_go_result;
2828
2829 arg1 = *(oneML::alpr::VehicleDetectorResult **)&_swig_go_0;
2830
2831 {
2832 try
2833 {
2834 result = oneML_alpr_VehicleDetectorResult_go_get_scores(arg1);
2835 }
2836 catch (const std::invalid_argument& e)
2837 {
2838 SWIG_exception(SWIG_ValueError, e.what());
2839 }
2840 catch (const std::out_of_range& e)
2841 {
2842 SWIG_exception(SWIG_IndexError, e.what());
2843 }
2844 catch(const std::exception& e)
2845 {
2846 SWIG_exception(SWIG_RuntimeError, e.what());
2847 }
2848 }
2849 *(std::vector< float > **)&_swig_go_result = new std::vector< float >(result);
2850 return _swig_go_result;
2851}
2852
2853
2854std::vector< oneML::BBox > *_wrap_VehicleDetectorResult_GetBboxes_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetectorResult *_swig_go_0) {
2855 oneML::alpr::VehicleDetectorResult *arg1 = (oneML::alpr::VehicleDetectorResult *) 0 ;
2856 std::vector< oneML::BBox > result;
2857 std::vector< oneML::BBox > *_swig_go_result;
2858
2859 arg1 = *(oneML::alpr::VehicleDetectorResult **)&_swig_go_0;
2860
2861 {
2862 try
2863 {
2864 result = oneML_alpr_VehicleDetectorResult_go_get_bboxes(arg1);
2865 }
2866 catch (const std::invalid_argument& e)
2867 {
2868 SWIG_exception(SWIG_ValueError, e.what());
2869 }
2870 catch (const std::out_of_range& e)
2871 {
2872 SWIG_exception(SWIG_IndexError, e.what());
2873 }
2874 catch(const std::exception& e)
2875 {
2876 SWIG_exception(SWIG_RuntimeError, e.what());
2877 }
2878 }
2879 *(std::vector< oneML::BBox > **)&_swig_go_result = new std::vector< oneML::BBox >(result);
2880 return _swig_go_result;
2881}
2882
2883
2884std::vector< int > *_wrap_VehicleDetectorResult_GetReturnStatus_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetectorResult *_swig_go_0) {
2885 oneML::alpr::VehicleDetectorResult *arg1 = (oneML::alpr::VehicleDetectorResult *) 0 ;
2886 std::vector< int > result;
2887 std::vector< int > *_swig_go_result;
2888
2889 arg1 = *(oneML::alpr::VehicleDetectorResult **)&_swig_go_0;
2890
2891 {
2892 try
2893 {
2894 result = oneML_alpr_VehicleDetectorResult_go_get_return_status(arg1);
2895 }
2896 catch (const std::invalid_argument& e)
2897 {
2898 SWIG_exception(SWIG_ValueError, e.what());
2899 }
2900 catch (const std::out_of_range& e)
2901 {
2902 SWIG_exception(SWIG_IndexError, e.what());
2903 }
2904 catch(const std::exception& e)
2905 {
2906 SWIG_exception(SWIG_RuntimeError, e.what());
2907 }
2908 }
2909 *(std::vector< int > **)&_swig_go_result = new std::vector< int >(result);
2910 return _swig_go_result;
2911}
2912
2913
2914void _wrap_delete_VehicleDetectorResult_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetectorResult *_swig_go_0) {
2915 oneML::alpr::VehicleDetectorResult *arg1 = (oneML::alpr::VehicleDetectorResult *) 0 ;
2916
2917 arg1 = *(oneML::alpr::VehicleDetectorResult **)&_swig_go_0;
2918
2919 {
2920 try
2921 {
2922 delete arg1;
2923 }
2924 catch (const std::invalid_argument& e)
2925 {
2926 SWIG_exception(SWIG_ValueError, e.what());
2927 }
2928 catch (const std::out_of_range& e)
2929 {
2930 SWIG_exception(SWIG_IndexError, e.what());
2931 }
2932 catch(const std::exception& e)
2933 {
2934 SWIG_exception(SWIG_RuntimeError, e.what());
2935 }
2936 }
2937
2938}
2939
2940
2941oneML::alpr::VehicleDetector *_wrap_new_VehicleDetector_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
2942 oneML::LicenseManager *arg1 = 0 ;
2943 oneML::alpr::VehicleDetector *result = 0 ;
2944 oneML::alpr::VehicleDetector *_swig_go_result;
2945
2946 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
2947
2948 {
2949 try
2950 {
2951 result = (oneML::alpr::VehicleDetector *)new oneML::alpr::VehicleDetector(*arg1);
2952 }
2953 catch (const std::invalid_argument& e)
2954 {
2955 SWIG_exception(SWIG_ValueError, e.what());
2956 }
2957 catch (const std::out_of_range& e)
2958 {
2959 SWIG_exception(SWIG_IndexError, e.what());
2960 }
2961 catch(const std::exception& e)
2962 {
2963 SWIG_exception(SWIG_RuntimeError, e.what());
2964 }
2965 }
2966 *(oneML::alpr::VehicleDetector **)&_swig_go_result = (oneML::alpr::VehicleDetector *)result;
2967 return _swig_go_result;
2968}
2969
2970
2971oneML::alpr::VehicleDetectorResult *_wrap_VehicleDetector_Detect_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetector *_swig_go_0, oneML::Image *_swig_go_1) {
2972 oneML::alpr::VehicleDetector *arg1 = (oneML::alpr::VehicleDetector *) 0 ;
2973 oneML::Image *arg2 = 0 ;
2974 oneML::alpr::VehicleDetectorResult result;
2975 oneML::alpr::VehicleDetectorResult *_swig_go_result;
2976
2977 arg1 = *(oneML::alpr::VehicleDetector **)&_swig_go_0;
2978 arg2 = *(oneML::Image **)&_swig_go_1;
2979
2980 {
2981 try
2982 {
2983 result = oneML_alpr_VehicleDetector_go_detect(arg1,(oneML::Image const &)*arg2);
2984 }
2985 catch (const std::invalid_argument& e)
2986 {
2987 SWIG_exception(SWIG_ValueError, e.what());
2988 }
2989 catch (const std::out_of_range& e)
2990 {
2991 SWIG_exception(SWIG_IndexError, e.what());
2992 }
2993 catch(const std::exception& e)
2994 {
2995 SWIG_exception(SWIG_RuntimeError, e.what());
2996 }
2997 }
2998 *(oneML::alpr::VehicleDetectorResult **)&_swig_go_result = new oneML::alpr::VehicleDetectorResult(result);
2999 return _swig_go_result;
3000}
3001
3002
3003std::vector< oneML::alpr::VehicleDetectorResult > *_wrap_VehicleDetector_DetectBatch_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetector *_swig_go_0, std::vector< oneML::Image > *_swig_go_1) {
3004 oneML::alpr::VehicleDetector *arg1 = (oneML::alpr::VehicleDetector *) 0 ;
3005 std::vector< oneML::Image > *arg2 = 0 ;
3006 std::vector< oneML::alpr::VehicleDetectorResult > result;
3007 std::vector< oneML::alpr::VehicleDetectorResult > *_swig_go_result;
3008
3009 arg1 = *(oneML::alpr::VehicleDetector **)&_swig_go_0;
3010 arg2 = *(std::vector< oneML::Image > **)&_swig_go_1;
3011
3012 {
3013 try
3014 {
3015 result = oneML_alpr_VehicleDetector_go_detect_batch(arg1,(std::vector< oneML::Image > const &)*arg2);
3016 }
3017 catch (const std::invalid_argument& e)
3018 {
3019 SWIG_exception(SWIG_ValueError, e.what());
3020 }
3021 catch (const std::out_of_range& e)
3022 {
3023 SWIG_exception(SWIG_IndexError, e.what());
3024 }
3025 catch(const std::exception& e)
3026 {
3027 SWIG_exception(SWIG_RuntimeError, e.what());
3028 }
3029 }
3030 *(std::vector< oneML::alpr::VehicleDetectorResult > **)&_swig_go_result = new std::vector< oneML::alpr::VehicleDetectorResult >(result);
3031 return _swig_go_result;
3032}
3033
3034
3035void _wrap_delete_VehicleDetector_alpr_7074c9342a7bdf4a(oneML::alpr::VehicleDetector *_swig_go_0) {
3036 oneML::alpr::VehicleDetector *arg1 = (oneML::alpr::VehicleDetector *) 0 ;
3037
3038 arg1 = *(oneML::alpr::VehicleDetector **)&_swig_go_0;
3039
3040 {
3041 try
3042 {
3043 delete arg1;
3044 }
3045 catch (const std::invalid_argument& e)
3046 {
3047 SWIG_exception(SWIG_ValueError, e.what());
3048 }
3049 catch (const std::out_of_range& e)
3050 {
3051 SWIG_exception(SWIG_IndexError, e.what());
3052 }
3053 catch(const std::exception& e)
3054 {
3055 SWIG_exception(SWIG_RuntimeError, e.what());
3056 }
3057 }
3058
3059}
3060
3061
3062intgo _wrap_VehicleDetectorStatus_Empty_alpr_7074c9342a7bdf4a() {
3063 oneML::alpr::VehicleDetectorStatus result;
3064 intgo _swig_go_result;
3065
3066
3067 {
3068 try
3069 {
3070 result = oneML::alpr::VehicleDetectorStatus::Empty;
3071
3072 }
3073 catch (const std::invalid_argument& e)
3074 {
3075 SWIG_exception(SWIG_ValueError, e.what());
3076 }
3077 catch (const std::out_of_range& e)
3078 {
3079 SWIG_exception(SWIG_IndexError, e.what());
3080 }
3081 catch(const std::exception& e)
3082 {
3083 SWIG_exception(SWIG_RuntimeError, e.what());
3084 }
3085 }
3086 _swig_go_result = (intgo)result;
3087 return _swig_go_result;
3088}
3089
3090
3091intgo _wrap_VehicleDetectorStatus_Success_alpr_7074c9342a7bdf4a() {
3092 oneML::alpr::VehicleDetectorStatus result;
3093 intgo _swig_go_result;
3094
3095
3096 {
3097 try
3098 {
3099 result = oneML::alpr::VehicleDetectorStatus::Success;
3100
3101 }
3102 catch (const std::invalid_argument& e)
3103 {
3104 SWIG_exception(SWIG_ValueError, e.what());
3105 }
3106 catch (const std::out_of_range& e)
3107 {
3108 SWIG_exception(SWIG_IndexError, e.what());
3109 }
3110 catch(const std::exception& e)
3111 {
3112 SWIG_exception(SWIG_RuntimeError, e.what());
3113 }
3114 }
3115 _swig_go_result = (intgo)result;
3116 return _swig_go_result;
3117}
3118
3119
3120intgo _wrap_VehicleDetectorStatus_Fail_alpr_7074c9342a7bdf4a() {
3121 oneML::alpr::VehicleDetectorStatus result;
3122 intgo _swig_go_result;
3123
3124
3125 {
3126 try
3127 {
3128 result = oneML::alpr::VehicleDetectorStatus::Fail;
3129
3130 }
3131 catch (const std::invalid_argument& e)
3132 {
3133 SWIG_exception(SWIG_ValueError, e.what());
3134 }
3135 catch (const std::out_of_range& e)
3136 {
3137 SWIG_exception(SWIG_IndexError, e.what());
3138 }
3139 catch(const std::exception& e)
3140 {
3141 SWIG_exception(SWIG_RuntimeError, e.what());
3142 }
3143 }
3144 _swig_go_result = (intgo)result;
3145 return _swig_go_result;
3146}
3147
3148
3149oneML::Utils *_wrap_new_Utils_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3150 oneML::LicenseManager *arg1 = 0 ;
3151 oneML::Utils *result = 0 ;
3152 oneML::Utils *_swig_go_result;
3153
3154 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3155
3156 {
3157 try
3158 {
3159 result = (oneML::Utils *)new oneML::Utils(*arg1);
3160 }
3161 catch (const std::invalid_argument& e)
3162 {
3163 SWIG_exception(SWIG_ValueError, e.what());
3164 }
3165 catch (const std::out_of_range& e)
3166 {
3167 SWIG_exception(SWIG_IndexError, e.what());
3168 }
3169 catch(const std::exception& e)
3170 {
3171 SWIG_exception(SWIG_RuntimeError, e.what());
3172 }
3173 }
3174 *(oneML::Utils **)&_swig_go_result = (oneML::Utils *)result;
3175 return _swig_go_result;
3176}
3177
3178
3179oneML::Image *_wrap_Utils_ReadImageCV_alpr_7074c9342a7bdf4a(oneML::Utils *_swig_go_0, _gostring_ _swig_go_1) {
3180 oneML::Utils *arg1 = (oneML::Utils *) 0 ;
3181 std::string *arg2 = 0 ;
3182 oneML::Image result;
3183 oneML::Image *_swig_go_result;
3184
3185 arg1 = *(oneML::Utils **)&_swig_go_0;
3186
3187 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
3188 arg2 = &arg2_str;
3189
3190
3191 {
3192 try
3193 {
3194 result = oneML_Utils__read_image_cv(arg1,(std::string const &)*arg2);
3195 }
3196 catch (const std::invalid_argument& e)
3197 {
3198 SWIG_exception(SWIG_ValueError, e.what());
3199 }
3200 catch (const std::out_of_range& e)
3201 {
3202 SWIG_exception(SWIG_IndexError, e.what());
3203 }
3204 catch(const std::exception& e)
3205 {
3206 SWIG_exception(SWIG_RuntimeError, e.what());
3207 }
3208 }
3209 *(oneML::Image **)&_swig_go_result = new oneML::Image(result);
3210 return _swig_go_result;
3211}
3212
3213
3214void _wrap_delete_Utils_alpr_7074c9342a7bdf4a(oneML::Utils *_swig_go_0) {
3215 oneML::Utils *arg1 = (oneML::Utils *) 0 ;
3216
3217 arg1 = *(oneML::Utils **)&_swig_go_0;
3218
3219 {
3220 try
3221 {
3222 delete arg1;
3223 }
3224 catch (const std::invalid_argument& e)
3225 {
3226 SWIG_exception(SWIG_ValueError, e.what());
3227 }
3228 catch (const std::out_of_range& e)
3229 {
3230 SWIG_exception(SWIG_IndexError, e.what());
3231 }
3232 catch(const std::exception& e)
3233 {
3234 SWIG_exception(SWIG_RuntimeError, e.what());
3235 }
3236 }
3237
3238}
3239
3240
3241intgo _wrap_LicenseActivationType_NotFound_alpr_7074c9342a7bdf4a() {
3242 oneML::LicenseActivationType result;
3243 intgo _swig_go_result;
3244
3245
3246 {
3247 try
3248 {
3249 result = oneML::LicenseActivationType::NotFound;
3250
3251 }
3252 catch (const std::invalid_argument& e)
3253 {
3254 SWIG_exception(SWIG_ValueError, e.what());
3255 }
3256 catch (const std::out_of_range& e)
3257 {
3258 SWIG_exception(SWIG_IndexError, e.what());
3259 }
3260 catch(const std::exception& e)
3261 {
3262 SWIG_exception(SWIG_RuntimeError, e.what());
3263 }
3264 }
3265 _swig_go_result = (intgo)result;
3266 return _swig_go_result;
3267}
3268
3269
3270intgo _wrap_LicenseActivationType_KeyOnline_alpr_7074c9342a7bdf4a() {
3271 oneML::LicenseActivationType result;
3272 intgo _swig_go_result;
3273
3274
3275 {
3276 try
3277 {
3278 result = oneML::LicenseActivationType::KeyOnline;
3279
3280 }
3281 catch (const std::invalid_argument& e)
3282 {
3283 SWIG_exception(SWIG_ValueError, e.what());
3284 }
3285 catch (const std::out_of_range& e)
3286 {
3287 SWIG_exception(SWIG_IndexError, e.what());
3288 }
3289 catch(const std::exception& e)
3290 {
3291 SWIG_exception(SWIG_RuntimeError, e.what());
3292 }
3293 }
3294 _swig_go_result = (intgo)result;
3295 return _swig_go_result;
3296}
3297
3298
3299intgo _wrap_LicenseActivationType_TrialOnline_alpr_7074c9342a7bdf4a() {
3300 oneML::LicenseActivationType result;
3301 intgo _swig_go_result;
3302
3303
3304 {
3305 try
3306 {
3307 result = oneML::LicenseActivationType::TrialOnline;
3308
3309 }
3310 catch (const std::invalid_argument& e)
3311 {
3312 SWIG_exception(SWIG_ValueError, e.what());
3313 }
3314 catch (const std::out_of_range& e)
3315 {
3316 SWIG_exception(SWIG_IndexError, e.what());
3317 }
3318 catch(const std::exception& e)
3319 {
3320 SWIG_exception(SWIG_RuntimeError, e.what());
3321 }
3322 }
3323 _swig_go_result = (intgo)result;
3324 return _swig_go_result;
3325}
3326
3327
3328intgo _wrap_LicenseStatus_Ok_alpr_7074c9342a7bdf4a() {
3329 oneML::LicenseStatus result;
3330 intgo _swig_go_result;
3331
3332
3333 {
3334 try
3335 {
3336 result = oneML::LicenseStatus::Ok;
3337
3338 }
3339 catch (const std::invalid_argument& e)
3340 {
3341 SWIG_exception(SWIG_ValueError, e.what());
3342 }
3343 catch (const std::out_of_range& e)
3344 {
3345 SWIG_exception(SWIG_IndexError, e.what());
3346 }
3347 catch(const std::exception& e)
3348 {
3349 SWIG_exception(SWIG_RuntimeError, e.what());
3350 }
3351 }
3352 _swig_go_result = (intgo)result;
3353 return _swig_go_result;
3354}
3355
3356
3357intgo _wrap_LicenseStatus_Error_alpr_7074c9342a7bdf4a() {
3358 oneML::LicenseStatus result;
3359 intgo _swig_go_result;
3360
3361
3362 {
3363 try
3364 {
3365 result = oneML::LicenseStatus::Error;
3366
3367 }
3368 catch (const std::invalid_argument& e)
3369 {
3370 SWIG_exception(SWIG_ValueError, e.what());
3371 }
3372 catch (const std::out_of_range& e)
3373 {
3374 SWIG_exception(SWIG_IndexError, e.what());
3375 }
3376 catch(const std::exception& e)
3377 {
3378 SWIG_exception(SWIG_RuntimeError, e.what());
3379 }
3380 }
3381 _swig_go_result = (intgo)result;
3382 return _swig_go_result;
3383}
3384
3385
3386intgo _wrap_LicenseStatus_Expired_alpr_7074c9342a7bdf4a() {
3387 oneML::LicenseStatus result;
3388 intgo _swig_go_result;
3389
3390
3391 {
3392 try
3393 {
3394 result = oneML::LicenseStatus::Expired;
3395
3396 }
3397 catch (const std::invalid_argument& e)
3398 {
3399 SWIG_exception(SWIG_ValueError, e.what());
3400 }
3401 catch (const std::out_of_range& e)
3402 {
3403 SWIG_exception(SWIG_IndexError, e.what());
3404 }
3405 catch(const std::exception& e)
3406 {
3407 SWIG_exception(SWIG_RuntimeError, e.what());
3408 }
3409 }
3410 _swig_go_result = (intgo)result;
3411 return _swig_go_result;
3412}
3413
3414
3415intgo _wrap_LicenseStatus_Suspended_alpr_7074c9342a7bdf4a() {
3416 oneML::LicenseStatus result;
3417 intgo _swig_go_result;
3418
3419
3420 {
3421 try
3422 {
3423 result = oneML::LicenseStatus::Suspended;
3424
3425 }
3426 catch (const std::invalid_argument& e)
3427 {
3428 SWIG_exception(SWIG_ValueError, e.what());
3429 }
3430 catch (const std::out_of_range& e)
3431 {
3432 SWIG_exception(SWIG_IndexError, e.what());
3433 }
3434 catch(const std::exception& e)
3435 {
3436 SWIG_exception(SWIG_RuntimeError, e.what());
3437 }
3438 }
3439 _swig_go_result = (intgo)result;
3440 return _swig_go_result;
3441}
3442
3443
3444oneML::LicenseManager *_wrap_new_LicenseManager__SWIG_0_alpr_7074c9342a7bdf4a() {
3445 oneML::LicenseManager *result = 0 ;
3446 oneML::LicenseManager *_swig_go_result;
3447
3448
3449 {
3450 try
3451 {
3452 result = (oneML::LicenseManager *)new oneML::LicenseManager();
3453 }
3454 catch (const std::invalid_argument& e)
3455 {
3456 SWIG_exception(SWIG_ValueError, e.what());
3457 }
3458 catch (const std::out_of_range& e)
3459 {
3460 SWIG_exception(SWIG_IndexError, e.what());
3461 }
3462 catch(const std::exception& e)
3463 {
3464 SWIG_exception(SWIG_RuntimeError, e.what());
3465 }
3466 }
3467 *(oneML::LicenseManager **)&_swig_go_result = (oneML::LicenseManager *)result;
3468 return _swig_go_result;
3469}
3470
3471
3472void _wrap_delete_LicenseManager_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3473 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3474
3475 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3476
3477 {
3478 try
3479 {
3480 delete arg1;
3481 }
3482 catch (const std::invalid_argument& e)
3483 {
3484 SWIG_exception(SWIG_ValueError, e.what());
3485 }
3486 catch (const std::out_of_range& e)
3487 {
3488 SWIG_exception(SWIG_IndexError, e.what());
3489 }
3490 catch(const std::exception& e)
3491 {
3492 SWIG_exception(SWIG_RuntimeError, e.what());
3493 }
3494 }
3495
3496}
3497
3498
3499oneML::LicenseManager *_wrap_new_LicenseManager__SWIG_1_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3500 oneML::LicenseManager *arg1 = 0 ;
3501 oneML::LicenseManager *result = 0 ;
3502 oneML::LicenseManager *_swig_go_result;
3503
3504 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3505
3506 {
3507 try
3508 {
3509 result = (oneML::LicenseManager *)new oneML::LicenseManager((oneML::LicenseManager const &)*arg1);
3510 }
3511 catch (const std::invalid_argument& e)
3512 {
3513 SWIG_exception(SWIG_ValueError, e.what());
3514 }
3515 catch (const std::out_of_range& e)
3516 {
3517 SWIG_exception(SWIG_IndexError, e.what());
3518 }
3519 catch(const std::exception& e)
3520 {
3521 SWIG_exception(SWIG_RuntimeError, e.what());
3522 }
3523 }
3524 *(oneML::LicenseManager **)&_swig_go_result = (oneML::LicenseManager *)result;
3525 return _swig_go_result;
3526}
3527
3528
3529void _wrap_LicenseManager_SetKey_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0, _gostring_ _swig_go_1) {
3530 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3531 std::string *arg2 = 0 ;
3532
3533 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3534
3535 std::string arg2_str(_swig_go_1.p, _swig_go_1.n);
3536 arg2 = &arg2_str;
3537
3538
3539 {
3540 try
3541 {
3542 (arg1)->set_key((std::string const &)*arg2);
3543 }
3544 catch (const std::invalid_argument& e)
3545 {
3546 SWIG_exception(SWIG_ValueError, e.what());
3547 }
3548 catch (const std::out_of_range& e)
3549 {
3550 SWIG_exception(SWIG_IndexError, e.what());
3551 }
3552 catch(const std::exception& e)
3553 {
3554 SWIG_exception(SWIG_RuntimeError, e.what());
3555 }
3556 }
3557
3558}
3559
3560
3561_gostring_ _wrap_LicenseManager_GetKey_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3562 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3563 std::string result;
3564 _gostring_ _swig_go_result;
3565
3566 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3567
3568 {
3569 try
3570 {
3571 result = ((oneML::LicenseManager const *)arg1)->get_key();
3572 }
3573 catch (const std::invalid_argument& e)
3574 {
3575 SWIG_exception(SWIG_ValueError, e.what());
3576 }
3577 catch (const std::out_of_range& e)
3578 {
3579 SWIG_exception(SWIG_IndexError, e.what());
3580 }
3581 catch(const std::exception& e)
3582 {
3583 SWIG_exception(SWIG_RuntimeError, e.what());
3584 }
3585 }
3586 _swig_go_result = Swig_AllocateString((&result)->data(), (&result)->length());
3587 return _swig_go_result;
3588}
3589
3590
3591intgo _wrap_LicenseManager_ActivateKey_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3592 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3593 oneML::LicenseStatus result;
3594 intgo _swig_go_result;
3595
3596 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3597
3598 {
3599 try
3600 {
3601 result = (oneML::LicenseStatus)(arg1)->activate_key();
3602 }
3603 catch (const std::invalid_argument& e)
3604 {
3605 SWIG_exception(SWIG_ValueError, e.what());
3606 }
3607 catch (const std::out_of_range& e)
3608 {
3609 SWIG_exception(SWIG_IndexError, e.what());
3610 }
3611 catch(const std::exception& e)
3612 {
3613 SWIG_exception(SWIG_RuntimeError, e.what());
3614 }
3615 }
3616 _swig_go_result = (intgo)result;
3617 return _swig_go_result;
3618}
3619
3620
3621intgo _wrap_LicenseManager_ActivateTrial_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3622 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3623 oneML::LicenseStatus result;
3624 intgo _swig_go_result;
3625
3626 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3627
3628 {
3629 try
3630 {
3631 result = (oneML::LicenseStatus)(arg1)->activate_trial();
3632 }
3633 catch (const std::invalid_argument& e)
3634 {
3635 SWIG_exception(SWIG_ValueError, e.what());
3636 }
3637 catch (const std::out_of_range& e)
3638 {
3639 SWIG_exception(SWIG_IndexError, e.what());
3640 }
3641 catch(const std::exception& e)
3642 {
3643 SWIG_exception(SWIG_RuntimeError, e.what());
3644 }
3645 }
3646 _swig_go_result = (intgo)result;
3647 return _swig_go_result;
3648}
3649
3650
3651_gostring_ _wrap_LicenseManager_GetMachineCode_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3652 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3653 std::string result;
3654 _gostring_ _swig_go_result;
3655
3656 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3657
3658 {
3659 try
3660 {
3661 result = ((oneML::LicenseManager const *)arg1)->get_machine_code();
3662 }
3663 catch (const std::invalid_argument& e)
3664 {
3665 SWIG_exception(SWIG_ValueError, e.what());
3666 }
3667 catch (const std::out_of_range& e)
3668 {
3669 SWIG_exception(SWIG_IndexError, e.what());
3670 }
3671 catch(const std::exception& e)
3672 {
3673 SWIG_exception(SWIG_RuntimeError, e.what());
3674 }
3675 }
3676 _swig_go_result = Swig_AllocateString((&result)->data(), (&result)->length());
3677 return _swig_go_result;
3678}
3679
3680
3681bool _wrap_LicenseManager_IsTrial_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3682 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3683 bool result;
3684 bool _swig_go_result;
3685
3686 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3687
3688 {
3689 try
3690 {
3691 result = (bool)((oneML::LicenseManager const *)arg1)->is_trial();
3692 }
3693 catch (const std::invalid_argument& e)
3694 {
3695 SWIG_exception(SWIG_ValueError, e.what());
3696 }
3697 catch (const std::out_of_range& e)
3698 {
3699 SWIG_exception(SWIG_IndexError, e.what());
3700 }
3701 catch(const std::exception& e)
3702 {
3703 SWIG_exception(SWIG_RuntimeError, e.what());
3704 }
3705 }
3706 _swig_go_result = result;
3707 return _swig_go_result;
3708}
3709
3710
3711intgo _wrap_LicenseManager_ValidateActivation_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3712 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3713 oneML::LicenseStatus result;
3714 intgo _swig_go_result;
3715
3716 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3717
3718 {
3719 try
3720 {
3721 result = (oneML::LicenseStatus)((oneML::LicenseManager const *)arg1)->validate_activation();
3722 }
3723 catch (const std::invalid_argument& e)
3724 {
3725 SWIG_exception(SWIG_ValueError, e.what());
3726 }
3727 catch (const std::out_of_range& e)
3728 {
3729 SWIG_exception(SWIG_IndexError, e.what());
3730 }
3731 catch(const std::exception& e)
3732 {
3733 SWIG_exception(SWIG_RuntimeError, e.what());
3734 }
3735 }
3736 _swig_go_result = (intgo)result;
3737 return _swig_go_result;
3738}
3739
3740
3741intgo _wrap_LicenseManager_GetActivationType_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3742 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3743 oneML::LicenseActivationType result;
3744 intgo _swig_go_result;
3745
3746 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3747
3748 {
3749 try
3750 {
3751 result = (oneML::LicenseActivationType)((oneML::LicenseManager const *)arg1)->get_activation_type();
3752 }
3753 catch (const std::invalid_argument& e)
3754 {
3755 SWIG_exception(SWIG_ValueError, e.what());
3756 }
3757 catch (const std::out_of_range& e)
3758 {
3759 SWIG_exception(SWIG_IndexError, e.what());
3760 }
3761 catch(const std::exception& e)
3762 {
3763 SWIG_exception(SWIG_RuntimeError, e.what());
3764 }
3765 }
3766 _swig_go_result = (intgo)result;
3767 return _swig_go_result;
3768}
3769
3770
3771long long _wrap_LicenseManager_GetActivationExpiryDate_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3772 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3773 uint64_t result;
3774 long long _swig_go_result;
3775
3776 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3777
3778 {
3779 try
3780 {
3781 result = (uint64_t)((oneML::LicenseManager const *)arg1)->get_activation_expiry_date();
3782 }
3783 catch (const std::invalid_argument& e)
3784 {
3785 SWIG_exception(SWIG_ValueError, e.what());
3786 }
3787 catch (const std::out_of_range& e)
3788 {
3789 SWIG_exception(SWIG_IndexError, e.what());
3790 }
3791 catch(const std::exception& e)
3792 {
3793 SWIG_exception(SWIG_RuntimeError, e.what());
3794 }
3795 }
3796 _swig_go_result = result;
3797 return _swig_go_result;
3798}
3799
3800
3801long long _wrap_LicenseManager_GetActivationSuspendedDate_alpr_7074c9342a7bdf4a(oneML::LicenseManager *_swig_go_0) {
3802 oneML::LicenseManager *arg1 = (oneML::LicenseManager *) 0 ;
3803 uint64_t result;
3804 long long _swig_go_result;
3805
3806 arg1 = *(oneML::LicenseManager **)&_swig_go_0;
3807
3808 {
3809 try
3810 {
3811 result = (uint64_t)((oneML::LicenseManager const *)arg1)->get_activation_suspended_date();
3812 }
3813 catch (const std::invalid_argument& e)
3814 {
3815 SWIG_exception(SWIG_ValueError, e.what());
3816 }
3817 catch (const std::out_of_range& e)
3818 {
3819 SWIG_exception(SWIG_IndexError, e.what());
3820 }
3821 catch(const std::exception& e)
3822 {
3823 SWIG_exception(SWIG_RuntimeError, e.what());
3824 }
3825 }
3826 _swig_go_result = result;
3827 return _swig_go_result;
3828}
3829
3830
3831#ifdef __cplusplus
3832}
3833#endif
3834
View as plain text