Merge pull request flann-lib#261 from dm-jrae/master

mariusmuja · mariusmuja · commit 9a01507d2231 · 2015-07-30T08:28:37.000-07:00
C wrapper fix for C++99
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;
     }
 }
 
@@ -366,7 +366,6 @@ int flann_add_points_int(flann_index_t index_ptr, int* points, int rows, int col
 
 template <typename Distance>
 int __flann_remove_point(flann_index_t index_ptr, unsigned int point_id_uint) {
-    typedef typename Distance::ElementType ElementType;
     size_t point_id(point_id_uint);
     try {
         if (index_ptr==NULL) {
@@ -386,29 +385,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;
     }
 }
 
@@ -440,7 +439,6 @@ int flann_remove_point_int(flann_index_t index_ptr, unsigned int point_id)
 template <typename Distance>
 typename Distance::ElementType* __flann_get_point(flann_index_t index_ptr,
                                          unsigned int point_id_uint) {
-    typedef typename Distance::ElementType ElementType;
     size_t point_id(point_id_uint);
     try {
         if (index_ptr==NULL) {
@@ -458,25 +456,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");
@@ -511,7 +509,6 @@ int* flann_get_point_int(flann_index_t index_ptr, unsigned int point_id)
 
 template <typename Distance>
 unsigned int __flann_veclen(flann_index_t index_ptr) {
-    typedef typename Distance::ElementType ElementType;
     try {
         if (index_ptr==NULL) {
             throw FLANNException("Invalid index");
@@ -528,29 +525,29 @@ 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");
-        return NULL;
+        return 0;
     }
 }
 
@@ -581,7 +578,6 @@ unsigned int flann_veclen_int(flann_index_t index_ptr)
 
 template <typename Distance>
 unsigned int __flann_size(flann_index_t index_ptr) {
-    typedef typename Distance::ElementType ElementType;
     try {
         if (index_ptr==NULL) {
             throw FLANNException("Invalid index");
@@ -598,29 +594,29 @@ 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");
-        return NULL;
+        return 0;
     }
 }
 
@@ -651,7 +647,6 @@ unsigned int flann_size_int(flann_index_t index_ptr)
 
 template <typename Distance>
 int __flann_used_memory(flann_index_t index_ptr) {
-    typedef typename Distance::ElementType ElementType;
     try {
         if (index_ptr==NULL) {
             throw FLANNException("Invalid index");
@@ -668,29 +663,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`
`@@ -366,7 +366,6 @@ int flann_add_points_int(flann_index_t index_ptr, int* points, int rows, int col`
`366`	`366`
`367`	`367`	`template <typename Distance>`
`368`	`368`	`int __flann_remove_point(flann_index_t index_ptr, unsigned int point_id_uint) {`
`369`		`- typedef typename Distance::ElementType ElementType;`
`370`	`369`	`size_t point_id(point_id_uint);`
`371`	`370`	`try {`
`372`	`371`	`if (index_ptr==NULL) {`
`@@ -386,29 +385,29 @@ int __flann_remove_point(flann_index_t index_ptr, unsigned int point_id_uint) {`
`386`	`385`	`template <typename T>`
`387`	`386`	`int _flann_remove_point(flann_index_t index_ptr, unsigned int point_id) {`
`388`	`387`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`389`		`- return __flann_remove_point<L2<T>>(index_ptr, point_id);`
	`388`	`+ return __flann_remove_point<L2<T> >(index_ptr, point_id);`
`390`	`389`	`}`
`391`	`390`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`392`		`- return __flann_remove_point<L1<T>>(index_ptr, point_id);`
	`391`	`+ return __flann_remove_point<L1<T> >(index_ptr, point_id);`
`393`	`392`	`}`
`394`	`393`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`395`		`- return __flann_remove_point<MinkowskiDistance<T>>(index_ptr, point_id);`
	`394`	`+ return __flann_remove_point<MinkowskiDistance<T> >(index_ptr, point_id);`
`396`	`395`	`}`
`397`	`396`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`398`		`- return __flann_remove_point<HistIntersectionDistance<T>>(index_ptr, point_id);`
	`397`	`+ return __flann_remove_point<HistIntersectionDistance<T> >(index_ptr, point_id);`
`399`	`398`	`}`
`400`	`399`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`401`		`- return __flann_remove_point<HellingerDistance<T>>(index_ptr, point_id);`
	`400`	`+ return __flann_remove_point<HellingerDistance<T> >(index_ptr, point_id);`
`402`	`401`	`}`
`403`	`402`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`404`		`- return __flann_remove_point<ChiSquareDistance<T>>(index_ptr, point_id);`
	`403`	`+ return __flann_remove_point<ChiSquareDistance<T> >(index_ptr, point_id);`
`405`	`404`	`}`
`406`	`405`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`407`		`- return __flann_remove_point<KL_Divergence<T>>(index_ptr, point_id);`
	`406`	`+ return __flann_remove_point<KL_Divergence<T> >(index_ptr, point_id);`
`408`	`407`	`}`
`409`	`408`	`else {`
`410`	`409`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`411`		`- return NULL;`
	`410`	`+ return 0;`
`412`	`411`	`}`
`413`	`412`	`}`
`414`	`413`
`@@ -440,7 +439,6 @@ int flann_remove_point_int(flann_index_t index_ptr, unsigned int point_id)`
`440`	`439`	`template <typename Distance>`
`441`	`440`	`typename Distance::ElementType* __flann_get_point(flann_index_t index_ptr,`
`442`	`441`	`unsigned int point_id_uint) {`
`443`		`- typedef typename Distance::ElementType ElementType;`
`444`	`442`	`size_t point_id(point_id_uint);`
`445`	`443`	`try {`
`446`	`444`	`if (index_ptr==NULL) {`
`@@ -458,25 +456,25 @@ typename Distance::ElementType* __flann_get_point(flann_index_t index_ptr,`
`458`	`456`	`template <typename T>`
`459`	`457`	`T* _flann_get_point(flann_index_t index_ptr, unsigned int point_id) {`
`460`	`458`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`461`		`- return __flann_get_point<L2<T>>(index_ptr, point_id);`
	`459`	`+ return __flann_get_point<L2<T> >(index_ptr, point_id);`
`462`	`460`	`}`
`463`	`461`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`464`		`- return __flann_get_point<L1<T>>(index_ptr, point_id);`
	`462`	`+ return __flann_get_point<L1<T> >(index_ptr, point_id);`
`465`	`463`	`}`
`466`	`464`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`467`		`- return __flann_get_point<MinkowskiDistance<T>>(index_ptr, point_id);`
	`465`	`+ return __flann_get_point<MinkowskiDistance<T> >(index_ptr, point_id);`
`468`	`466`	`}`
`469`	`467`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`470`		`- return __flann_get_point<HistIntersectionDistance<T>>(index_ptr, point_id);`
	`468`	`+ return __flann_get_point<HistIntersectionDistance<T> >(index_ptr, point_id);`
`471`	`469`	`}`
`472`	`470`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`473`		`- return __flann_get_point<HellingerDistance<T>>(index_ptr, point_id);`
	`471`	`+ return __flann_get_point<HellingerDistance<T> >(index_ptr, point_id);`
`474`	`472`	`}`
`475`	`473`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`476`		`- return __flann_get_point<ChiSquareDistance<T>>(index_ptr, point_id);`
	`474`	`+ return __flann_get_point<ChiSquareDistance<T> >(index_ptr, point_id);`
`477`	`475`	`}`
`478`	`476`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`479`		`- return __flann_get_point<KL_Divergence<T>>(index_ptr, point_id);`
	`477`	`+ return __flann_get_point<KL_Divergence<T> >(index_ptr, point_id);`
`480`	`478`	`}`
`481`	`479`	`else {`
`482`	`480`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`@@ -511,7 +509,6 @@ int* flann_get_point_int(flann_index_t index_ptr, unsigned int point_id)`
`511`	`509`
`512`	`510`	`template <typename Distance>`
`513`	`511`	`unsigned int __flann_veclen(flann_index_t index_ptr) {`
`514`		`- typedef typename Distance::ElementType ElementType;`
`515`	`512`	`try {`
`516`	`513`	`if (index_ptr==NULL) {`
`517`	`514`	`throw FLANNException("Invalid index");`
`@@ -528,29 +525,29 @@ unsigned int __flann_veclen(flann_index_t index_ptr) {`
`528`	`525`	`template <typename T>`
`529`	`526`	`unsigned int _flann_veclen(flann_index_t index_ptr) {`
`530`	`527`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`531`		`- return __flann_veclen<L2<T>>(index_ptr);`
	`528`	`+ return __flann_veclen<L2<T> >(index_ptr);`
`532`	`529`	`}`
`533`	`530`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`534`		`- return __flann_veclen<L1<T>>(index_ptr);`
	`531`	`+ return __flann_veclen<L1<T> >(index_ptr);`
`535`	`532`	`}`
`536`	`533`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`537`		`- return __flann_veclen<MinkowskiDistance<T>>(index_ptr);`
	`534`	`+ return __flann_veclen<MinkowskiDistance<T> >(index_ptr);`
`538`	`535`	`}`
`539`	`536`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`540`		`- return __flann_veclen<HistIntersectionDistance<T>>(index_ptr);`
	`537`	`+ return __flann_veclen<HistIntersectionDistance<T> >(index_ptr);`
`541`	`538`	`}`
`542`	`539`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`543`		`- return __flann_veclen<HellingerDistance<T>>(index_ptr);`
	`540`	`+ return __flann_veclen<HellingerDistance<T> >(index_ptr);`
`544`	`541`	`}`
`545`	`542`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`546`		`- return __flann_veclen<ChiSquareDistance<T>>(index_ptr);`
	`543`	`+ return __flann_veclen<ChiSquareDistance<T> >(index_ptr);`
`547`	`544`	`}`
`548`	`545`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`549`		`- return __flann_veclen<KL_Divergence<T>>(index_ptr);`
	`546`	`+ return __flann_veclen<KL_Divergence<T> >(index_ptr);`
`550`	`547`	`}`
`551`	`548`	`else {`
`552`	`549`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`553`		`- return NULL;`
	`550`	`+ return 0;`
`554`	`551`	`}`
`555`	`552`	`}`
`556`	`553`
`@@ -581,7 +578,6 @@ unsigned int flann_veclen_int(flann_index_t index_ptr)`
`581`	`578`
`582`	`579`	`template <typename Distance>`
`583`	`580`	`unsigned int __flann_size(flann_index_t index_ptr) {`
`584`		`- typedef typename Distance::ElementType ElementType;`
`585`	`581`	`try {`
`586`	`582`	`if (index_ptr==NULL) {`
`587`	`583`	`throw FLANNException("Invalid index");`
`@@ -598,29 +594,29 @@ unsigned int __flann_size(flann_index_t index_ptr) {`
`598`	`594`	`template <typename T>`
`599`	`595`	`unsigned int _flann_size(flann_index_t index_ptr) {`
`600`	`596`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`601`		`- return __flann_size<L2<T>>(index_ptr);`
	`597`	`+ return __flann_size<L2<T> >(index_ptr);`
`602`	`598`	`}`
`603`	`599`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`604`		`- return __flann_size<L1<T>>(index_ptr);`
	`600`	`+ return __flann_size<L1<T> >(index_ptr);`
`605`	`601`	`}`
`606`	`602`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`607`		`- return __flann_size<MinkowskiDistance<T>>(index_ptr);`
	`603`	`+ return __flann_size<MinkowskiDistance<T> >(index_ptr);`
`608`	`604`	`}`
`609`	`605`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`610`		`- return __flann_size<HistIntersectionDistance<T>>(index_ptr);`
	`606`	`+ return __flann_size<HistIntersectionDistance<T> >(index_ptr);`
`611`	`607`	`}`
`612`	`608`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`613`		`- return __flann_size<HellingerDistance<T>>(index_ptr);`
	`609`	`+ return __flann_size<HellingerDistance<T> >(index_ptr);`
`614`	`610`	`}`
`615`	`611`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`616`		`- return __flann_size<ChiSquareDistance<T>>(index_ptr);`
	`612`	`+ return __flann_size<ChiSquareDistance<T> >(index_ptr);`
`617`	`613`	`}`
`618`	`614`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`619`		`- return __flann_size<KL_Divergence<T>>(index_ptr);`
	`615`	`+ return __flann_size<KL_Divergence<T> >(index_ptr);`
`620`	`616`	`}`
`621`	`617`	`else {`
`622`	`618`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`623`		`- return NULL;`
	`619`	`+ return 0;`
`624`	`620`	`}`
`625`	`621`	`}`
`626`	`622`
`@@ -651,7 +647,6 @@ unsigned int flann_size_int(flann_index_t index_ptr)`
`651`	`647`
`652`	`648`	`template <typename Distance>`
`653`	`649`	`int __flann_used_memory(flann_index_t index_ptr) {`
`654`		`- typedef typename Distance::ElementType ElementType;`
`655`	`650`	`try {`
`656`	`651`	`if (index_ptr==NULL) {`
`657`	`652`	`throw FLANNException("Invalid index");`
`@@ -668,29 +663,29 @@ int __flann_used_memory(flann_index_t index_ptr) {`
`668`	`663`	`template <typename T>`
`669`	`664`	`int _flann_used_memory(flann_index_t index_ptr) {`
`670`	`665`	`if (flann_distance_type==FLANN_DIST_EUCLIDEAN) {`
`671`		`- return __flann_used_memory<L2<T>>(index_ptr);`
	`666`	`+ return __flann_used_memory<L2<T> >(index_ptr);`
`672`	`667`	`}`
`673`	`668`	`else if (flann_distance_type==FLANN_DIST_MANHATTAN) {`
`674`		`- return __flann_used_memory<L1<T>>(index_ptr);`
	`669`	`+ return __flann_used_memory<L1<T> >(index_ptr);`
`675`	`670`	`}`
`676`	`671`	`else if (flann_distance_type==FLANN_DIST_MINKOWSKI) {`
`677`		`- return __flann_used_memory<MinkowskiDistance<T>>(index_ptr);`
	`672`	`+ return __flann_used_memory<MinkowskiDistance<T> >(index_ptr);`
`678`	`673`	`}`
`679`	`674`	`else if (flann_distance_type==FLANN_DIST_HIST_INTERSECT) {`
`680`		`- return __flann_used_memory<HistIntersectionDistance<T>>(index_ptr);`
	`675`	`+ return __flann_used_memory<HistIntersectionDistance<T> >(index_ptr);`
`681`	`676`	`}`
`682`	`677`	`else if (flann_distance_type==FLANN_DIST_HELLINGER) {`
`683`		`- return __flann_used_memory<HellingerDistance<T>>(index_ptr);`
	`678`	`+ return __flann_used_memory<HellingerDistance<T> >(index_ptr);`
`684`	`679`	`}`
`685`	`680`	`else if (flann_distance_type==FLANN_DIST_CHI_SQUARE) {`
`686`		`- return __flann_used_memory<ChiSquareDistance<T>>(index_ptr);`
	`681`	`+ return __flann_used_memory<ChiSquareDistance<T> >(index_ptr);`
`687`	`682`	`}`
`688`	`683`	`else if (flann_distance_type==FLANN_DIST_KULLBACK_LEIBLER) {`
`689`		`- return __flann_used_memory<KL_Divergence<T>>(index_ptr);`
	`684`	`+ return __flann_used_memory<KL_Divergence<T> >(index_ptr);`
`690`	`685`	`}`
`691`	`686`	`else {`
`692`	`687`	`Logger::error( "Distance type unsupported in the C bindings, use the C++ bindings instead\n");`
`693`		`- return NULL;`
	`688`	`+ return 0;`
`694`	`689`	`}`
`695`	`690`	`}`
`696`	`691`