flanncpp: fix C headers for pre-C++11 compilers

dm-jrae · dm-jrae · commit 07daf8e30898 · 2015-07-30T12:16:31.000+01:00
diff --git a/src/cpp/flann/flann.cpp b/src/cpp/flann/flann.cpp
@@ -313,29 +313,29 @@ template <typename T>
 int _flann_add_points(flann_index_t index_ptr, T* points, int rows, int columns,
                 float rebuild_threshold) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_add_points<L2<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<L2<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_add_points<L1<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<L1<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_add_points<MinkowskiDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<MinkowskiDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_add_points<HistIntersectionDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<HistIntersectionDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_add_points<HellingerDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<HellingerDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_add_points<ChiSquareDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<ChiSquareDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_add_points<KL_Divergence<T>>(index_ptr, points, rows, columns, rebuild_threshold);
+        return __flann_add_points<KL_Divergence<T> >(index_ptr, points, rows, columns, rebuild_threshold);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
-        return NULL;
+        return 0;
     }
 }
 
@@ -386,29 +386,29 @@ int __flann_remove_point(flann_index_t index_ptr, unsigned int point_id_uint) {
 template <typename T>
 int _flann_remove_point(flann_index_t index_ptr, unsigned int point_id) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_remove_point<L2<T>>(index_ptr, point_id);
+        return __flann_remove_point<L2<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_remove_point<L1<T>>(index_ptr, point_id);
+        return __flann_remove_point<L1<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_remove_point<MinkowskiDistance<T>>(index_ptr, point_id);
+        return __flann_remove_point<MinkowskiDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_remove_point<HistIntersectionDistance<T>>(index_ptr, point_id);
+        return __flann_remove_point<HistIntersectionDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_remove_point<HellingerDistance<T>>(index_ptr, point_id);
+        return __flann_remove_point<HellingerDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_remove_point<ChiSquareDistance<T>>(index_ptr, point_id);
+        return __flann_remove_point<ChiSquareDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_remove_point<KL_Divergence<T>>(index_ptr, point_id);
+        return __flann_remove_point<KL_Divergence<T> >(index_ptr, point_id);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
-        return NULL;
+        return 0;
     }
 }
 
@@ -458,25 +458,25 @@ typename Distance::ElementType* __flann_get_point(flann_index_t index_ptr,
 template <typename T>
 T* _flann_get_point(flann_index_t index_ptr, unsigned int point_id) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_get_point<L2<T>>(index_ptr, point_id);
+        return __flann_get_point<L2<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_get_point<L1<T>>(index_ptr, point_id);
+        return __flann_get_point<L1<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_get_point<MinkowskiDistance<T>>(index_ptr, point_id);
+        return __flann_get_point<MinkowskiDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_get_point<HistIntersectionDistance<T>>(index_ptr, point_id);
+        return __flann_get_point<HistIntersectionDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_get_point<HellingerDistance<T>>(index_ptr, point_id);
+        return __flann_get_point<HellingerDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_get_point<ChiSquareDistance<T>>(index_ptr, point_id);
+        return __flann_get_point<ChiSquareDistance<T> >(index_ptr, point_id);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_get_point<KL_Divergence<T>>(index_ptr, point_id);
+        return __flann_get_point<KL_Divergence<T> >(index_ptr, point_id);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
@@ -528,25 +528,25 @@ unsigned int __flann_veclen(flann_index_t index_ptr) {
 template <typename T>
 unsigned int _flann_veclen(flann_index_t index_ptr) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_veclen<L2<T>>(index_ptr);
+        return __flann_veclen<L2<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_veclen<L1<T>>(index_ptr);
+        return __flann_veclen<L1<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_veclen<MinkowskiDistance<T>>(index_ptr);
+        return __flann_veclen<MinkowskiDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_veclen<HistIntersectionDistance<T>>(index_ptr);
+        return __flann_veclen<HistIntersectionDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_veclen<HellingerDistance<T>>(index_ptr);
+        return __flann_veclen<HellingerDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_veclen<ChiSquareDistance<T>>(index_ptr);
+        return __flann_veclen<ChiSquareDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_veclen<KL_Divergence<T>>(index_ptr);
+        return __flann_veclen<KL_Divergence<T> >(index_ptr);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
@@ -598,25 +598,25 @@ unsigned int __flann_size(flann_index_t index_ptr) {
 template <typename T>
 unsigned int _flann_size(flann_index_t index_ptr) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_size<L2<T>>(index_ptr);
+        return __flann_size<L2<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_size<L1<T>>(index_ptr);
+        return __flann_size<L1<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_size<MinkowskiDistance<T>>(index_ptr);
+        return __flann_size<MinkowskiDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_size<HistIntersectionDistance<T>>(index_ptr);
+        return __flann_size<HistIntersectionDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_size<HellingerDistance<T>>(index_ptr);
+        return __flann_size<HellingerDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_size<ChiSquareDistance<T>>(index_ptr);
+        return __flann_size<ChiSquareDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_size<KL_Divergence<T>>(index_ptr);
+        return __flann_size<KL_Divergence<T> >(index_ptr);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
@@ -668,29 +668,29 @@ int __flann_used_memory(flann_index_t index_ptr) {
 template <typename T>
 int _flann_used_memory(flann_index_t index_ptr) {
     if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {
-        return __flann_used_memory<L2<T>>(index_ptr);
+        return __flann_used_memory<L2<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MANHATTAN) {
-        return __flann_used_memory<L1<T>>(index_ptr);
+        return __flann_used_memory<L1<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {
-        return __flann_used_memory<MinkowskiDistance<T>>(index_ptr);
+        return __flann_used_memory<MinkowskiDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {
-        return __flann_used_memory<HistIntersectionDistance<T>>(index_ptr);
+        return __flann_used_memory<HistIntersectionDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_HELLINGER) {
-        return __flann_used_memory<HellingerDistance<T>>(index_ptr);
+        return __flann_used_memory<HellingerDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {
-        return __flann_used_memory<ChiSquareDistance<T>>(index_ptr);
+        return __flann_used_memory<ChiSquareDistance<T> >(index_ptr);
     }
     else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {
-        return __flann_used_memory<KL_Divergence<T>>(index_ptr);
+        return __flann_used_memory<KL_Divergence<T> >(index_ptr);
     }
     else {
         Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");
-        return NULL;
+        return 0;
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -313,29 +313,29 @@ template <typename T>`
`313`	`313`	`int _flann_add_points(flann_index_t index_ptr, T* points, int rows, int columns,`
`314`	`314`	`float rebuild_threshold) {`
`315`	`315`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`316`		`- return __flann_add_points<L2<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`316`	`+ return __flann_add_points<L2<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`317`	`317`	`}`
`318`	`318`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`319`		`- return __flann_add_points<L1<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`319`	`+ return __flann_add_points<L1<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`320`	`320`	`}`
`321`	`321`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`322`		`- return __flann_add_points<MinkowskiDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`322`	`+ return __flann_add_points<MinkowskiDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`323`	`323`	`}`
`324`	`324`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`325`		`- return __flann_add_points<HistIntersectionDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`325`	`+ return __flann_add_points<HistIntersectionDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`326`	`326`	`}`
`327`	`327`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`328`		`- return __flann_add_points<HellingerDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`328`	`+ return __flann_add_points<HellingerDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`329`	`329`	`}`
`330`	`330`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`331`		`- return __flann_add_points<ChiSquareDistance<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`331`	`+ return __flann_add_points<ChiSquareDistance<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`332`	`332`	`}`
`333`	`333`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`334`		`- return __flann_add_points<KL_Divergence<T>>(index_ptr, points, rows, columns, rebuild_threshold);`
	`334`	`+ return __flann_add_points<KL_Divergence<T> >(index_ptr, points, rows, columns, rebuild_threshold);`
`335`	`335`	`}`
`336`	`336`	`else {`
`337`	`337`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`338`		`- return NULL;`
	`338`	`+ return 0;`
`339`	`339`	`}`
`340`	`340`	`}`
`341`	`341`
`@@ -386,29 +386,29 @@ int __flann_remove_point(flann_index_t index_ptr, unsigned int point_id_uint) {`
`386`	`386`	`template <typename T>`
`387`	`387`	`int _flann_remove_point(flann_index_t index_ptr, unsigned int point_id) {`
`388`	`388`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`389`		`- return __flann_remove_point<L2<T>>(index_ptr, point_id);`
	`389`	`+ return __flann_remove_point<L2<T> >(index_ptr, point_id);`
`390`	`390`	`}`
`391`	`391`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`392`		`- return __flann_remove_point<L1<T>>(index_ptr, point_id);`
	`392`	`+ return __flann_remove_point<L1<T> >(index_ptr, point_id);`
`393`	`393`	`}`
`394`	`394`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`395`		`- return __flann_remove_point<MinkowskiDistance<T>>(index_ptr, point_id);`
	`395`	`+ return __flann_remove_point<MinkowskiDistance<T> >(index_ptr, point_id);`
`396`	`396`	`}`
`397`	`397`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`398`		`- return __flann_remove_point<HistIntersectionDistance<T>>(index_ptr, point_id);`
	`398`	`+ return __flann_remove_point<HistIntersectionDistance<T> >(index_ptr, point_id);`
`399`	`399`	`}`
`400`	`400`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`401`		`- return __flann_remove_point<HellingerDistance<T>>(index_ptr, point_id);`
	`401`	`+ return __flann_remove_point<HellingerDistance<T> >(index_ptr, point_id);`
`402`	`402`	`}`
`403`	`403`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`404`		`- return __flann_remove_point<ChiSquareDistance<T>>(index_ptr, point_id);`
	`404`	`+ return __flann_remove_point<ChiSquareDistance<T> >(index_ptr, point_id);`
`405`	`405`	`}`
`406`	`406`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`407`		`- return __flann_remove_point<KL_Divergence<T>>(index_ptr, point_id);`
	`407`	`+ return __flann_remove_point<KL_Divergence<T> >(index_ptr, point_id);`
`408`	`408`	`}`
`409`	`409`	`else {`
`410`	`410`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`411`		`- return NULL;`
	`411`	`+ return 0;`
`412`	`412`	`}`
`413`	`413`	`}`
`414`	`414`
`@@ -458,25 +458,25 @@ typename Distance::ElementType* __flann_get_point(flann_index_t index_ptr,`
`458`	`458`	`template <typename T>`
`459`	`459`	`T* _flann_get_point(flann_index_t index_ptr, unsigned int point_id) {`
`460`	`460`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`461`		`- return __flann_get_point<L2<T>>(index_ptr, point_id);`
	`461`	`+ return __flann_get_point<L2<T> >(index_ptr, point_id);`
`462`	`462`	`}`
`463`	`463`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`464`		`- return __flann_get_point<L1<T>>(index_ptr, point_id);`
	`464`	`+ return __flann_get_point<L1<T> >(index_ptr, point_id);`
`465`	`465`	`}`
`466`	`466`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`467`		`- return __flann_get_point<MinkowskiDistance<T>>(index_ptr, point_id);`
	`467`	`+ return __flann_get_point<MinkowskiDistance<T> >(index_ptr, point_id);`
`468`	`468`	`}`
`469`	`469`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`470`		`- return __flann_get_point<HistIntersectionDistance<T>>(index_ptr, point_id);`
	`470`	`+ return __flann_get_point<HistIntersectionDistance<T> >(index_ptr, point_id);`
`471`	`471`	`}`
`472`	`472`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`473`		`- return __flann_get_point<HellingerDistance<T>>(index_ptr, point_id);`
	`473`	`+ return __flann_get_point<HellingerDistance<T> >(index_ptr, point_id);`
`474`	`474`	`}`
`475`	`475`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`476`		`- return __flann_get_point<ChiSquareDistance<T>>(index_ptr, point_id);`
	`476`	`+ return __flann_get_point<ChiSquareDistance<T> >(index_ptr, point_id);`
`477`	`477`	`}`
`478`	`478`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`479`		`- return __flann_get_point<KL_Divergence<T>>(index_ptr, point_id);`
	`479`	`+ return __flann_get_point<KL_Divergence<T> >(index_ptr, point_id);`
`480`	`480`	`}`
`481`	`481`	`else {`
`482`	`482`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`@@ -528,25 +528,25 @@ unsigned int __flann_veclen(flann_index_t index_ptr) {`
`528`	`528`	`template <typename T>`
`529`	`529`	`unsigned int _flann_veclen(flann_index_t index_ptr) {`
`530`	`530`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`531`		`- return __flann_veclen<L2<T>>(index_ptr);`
	`531`	`+ return __flann_veclen<L2<T> >(index_ptr);`
`532`	`532`	`}`
`533`	`533`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`534`		`- return __flann_veclen<L1<T>>(index_ptr);`
	`534`	`+ return __flann_veclen<L1<T> >(index_ptr);`
`535`	`535`	`}`
`536`	`536`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`537`		`- return __flann_veclen<MinkowskiDistance<T>>(index_ptr);`
	`537`	`+ return __flann_veclen<MinkowskiDistance<T> >(index_ptr);`
`538`	`538`	`}`
`539`	`539`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`540`		`- return __flann_veclen<HistIntersectionDistance<T>>(index_ptr);`
	`540`	`+ return __flann_veclen<HistIntersectionDistance<T> >(index_ptr);`
`541`	`541`	`}`
`542`	`542`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`543`		`- return __flann_veclen<HellingerDistance<T>>(index_ptr);`
	`543`	`+ return __flann_veclen<HellingerDistance<T> >(index_ptr);`
`544`	`544`	`}`
`545`	`545`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`546`		`- return __flann_veclen<ChiSquareDistance<T>>(index_ptr);`
	`546`	`+ return __flann_veclen<ChiSquareDistance<T> >(index_ptr);`
`547`	`547`	`}`
`548`	`548`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`549`		`- return __flann_veclen<KL_Divergence<T>>(index_ptr);`
	`549`	`+ return __flann_veclen<KL_Divergence<T> >(index_ptr);`
`550`	`550`	`}`
`551`	`551`	`else {`
`552`	`552`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`@@ -598,25 +598,25 @@ unsigned int __flann_size(flann_index_t index_ptr) {`
`598`	`598`	`template <typename T>`
`599`	`599`	`unsigned int _flann_size(flann_index_t index_ptr) {`
`600`	`600`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`601`		`- return __flann_size<L2<T>>(index_ptr);`
	`601`	`+ return __flann_size<L2<T> >(index_ptr);`
`602`	`602`	`}`
`603`	`603`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`604`		`- return __flann_size<L1<T>>(index_ptr);`
	`604`	`+ return __flann_size<L1<T> >(index_ptr);`
`605`	`605`	`}`
`606`	`606`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`607`		`- return __flann_size<MinkowskiDistance<T>>(index_ptr);`
	`607`	`+ return __flann_size<MinkowskiDistance<T> >(index_ptr);`
`608`	`608`	`}`
`609`	`609`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`610`		`- return __flann_size<HistIntersectionDistance<T>>(index_ptr);`
	`610`	`+ return __flann_size<HistIntersectionDistance<T> >(index_ptr);`
`611`	`611`	`}`
`612`	`612`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`613`		`- return __flann_size<HellingerDistance<T>>(index_ptr);`
	`613`	`+ return __flann_size<HellingerDistance<T> >(index_ptr);`
`614`	`614`	`}`
`615`	`615`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`616`		`- return __flann_size<ChiSquareDistance<T>>(index_ptr);`
	`616`	`+ return __flann_size<ChiSquareDistance<T> >(index_ptr);`
`617`	`617`	`}`
`618`	`618`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`619`		`- return __flann_size<KL_Divergence<T>>(index_ptr);`
	`619`	`+ return __flann_size<KL_Divergence<T> >(index_ptr);`
`620`	`620`	`}`
`621`	`621`	`else {`
`622`	`622`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`@@ -668,29 +668,29 @@ int __flann_used_memory(flann_index_t index_ptr) {`
`668`	`668`	`template <typename T>`
`669`	`669`	`int _flann_used_memory(flann_index_t index_ptr) {`
`670`	`670`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`671`		`- return __flann_used_memory<L2<T>>(index_ptr);`
	`671`	`+ return __flann_used_memory<L2<T> >(index_ptr);`
`672`	`672`	`}`
`673`	`673`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`674`		`- return __flann_used_memory<L1<T>>(index_ptr);`
	`674`	`+ return __flann_used_memory<L1<T> >(index_ptr);`
`675`	`675`	`}`
`676`	`676`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`677`		`- return __flann_used_memory<MinkowskiDistance<T>>(index_ptr);`
	`677`	`+ return __flann_used_memory<MinkowskiDistance<T> >(index_ptr);`
`678`	`678`	`}`
`679`	`679`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`680`		`- return __flann_used_memory<HistIntersectionDistance<T>>(index_ptr);`
	`680`	`+ return __flann_used_memory<HistIntersectionDistance<T> >(index_ptr);`
`681`	`681`	`}`
`682`	`682`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`683`		`- return __flann_used_memory<HellingerDistance<T>>(index_ptr);`
	`683`	`+ return __flann_used_memory<HellingerDistance<T> >(index_ptr);`
`684`	`684`	`}`
`685`	`685`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`686`		`- return __flann_used_memory<ChiSquareDistance<T>>(index_ptr);`
	`686`	`+ return __flann_used_memory<ChiSquareDistance<T> >(index_ptr);`
`687`	`687`	`}`
`688`	`688`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`689`		`- return __flann_used_memory<KL_Divergence<T>>(index_ptr);`
	`689`	`+ return __flann_used_memory<KL_Divergence<T> >(index_ptr);`
`690`	`690`	`}`
`691`	`691`	`else {`
`692`	`692`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`693`		`- return NULL;`
	`693`	`+ return 0;`
`694`	`694`	`}`
`695`	`695`	`}`
`696`	`696`