Merge pull request #81 from asobolev/tmp2

refactoring to array_to_nix step 1

Author: mpsonntag

src/utils/arguments.h

@@ -62,28 +62,22 @@ class extractor : public argument_helper<const mxArray> {
     extractor(const mxArray **arr, int n) : argument_helper(arr, n) { }
 
     std::string str(size_t pos) const {
-		check_arg_type(pos, nix::DataType::String);
-
-        char *tmp = mxArrayToString(array[pos]);
-        std::string the_string(tmp);
-        mxFree(tmp);
-        return the_string;
+        return mx_array_to_str(array[pos]);
     }
 
-	template<typename T>
-	T num(size_t pos) const {
-		nix::DataType dtype = nix::to_data_type<T>::value;
-		check_arg_type(pos, dtype);
-		
-		if (mxGetNumberOfElements(array[pos]) < 1) {
-			throw std::runtime_error("array empty");
-		}
+    template<typename T>
+    T num(size_t pos) const {
+        check_arg_type(pos, nix::to_data_type<T>::value);
 
-		const void *data = mxGetData(array[pos]);
-		T res;
-		memcpy(&res, data, sizeof(T));
-		return res;
-	}
+        if (mxGetNumberOfElements(array[pos]) < 1) {
+            throw std::runtime_error("array empty");
+        }
+
+        const void *data = mxGetData(array[pos]);
+        T res;
+        memcpy(&res, data, sizeof(T));
+        return res;
+    }
 
     template<typename T>
     std::vector<T> vec(size_t pos) const {
@@ -131,6 +125,21 @@ class extractor : public argument_helper<const mxArray> {
         return res;
     }
 
+    std::vector<nix::Value> vec(size_t pos) const {
+        mwSize size = mxGetNumberOfElements(array[pos]);
+
+        mwIndex index;
+        std::vector<nix::Value> vals;
+        const mxArray *cell_element_ptr;
+
+        for (index = 0; index < size; index++)  {
+            cell_element_ptr = mxGetCell(array[pos], index);
+            vals.push_back(mx_array_to_value(cell_element_ptr));
+        }
+
+        return vals;
+    }
+
     nix::NDSize ndsize(size_t pos) const {
         return mx_array_to_ndsize(array[pos]);
     }

src/utils/nix2mx.cc

@@ -9,8 +9,15 @@
 #include "handle.h"
 #include "arguments.h"
 #include "struct.h"
+#include "datatypes.h"
 
 
+void check_arg_type(const mxArray *arr, nix::DataType dtype) {
+    if (dtype_mex2nix(arr) != dtype) {
+        throw std::invalid_argument("wrong type");
+    }
+}
+
 mxArray *nmCreateScalar(uint32_t val) {
     mxArray *arr = mxCreateNumericMatrix(1, 1, mxUINT32_CLASS, mxREAL);
     void *data = mxGetData(arr);
@@ -72,3 +79,55 @@ nix::NDSize mx_array_to_ndsize(const mxArray *arr) {
     return size;
 }
 
+std::string mx_array_to_str(const mxArray *arr) {
+    check_arg_type(arr, nix::DataType::String);
+
+    std::string the_string = mxArrayToString(arr);
+    return the_string;
+}
+
+template<typename T>
+T mx_array_to_num(const mxArray *arr) {
+    check_arg_type(arr, nix::to_data_type<T>::value);
+
+    if (mxGetNumberOfElements(arr) < 1) {
+        throw std::runtime_error("array empty");
+    }
+
+    const void *data = mxGetData(arr);
+    T res;
+    memcpy(&res, data, sizeof(T));
+    return res;
+}
+
+bool mx_array_to_bool(const mxArray *arr) {
+    check_arg_type(arr, nix::DataType::Bool);
+
+    const mxLogical *l = mxGetLogicals(arr);
+    return l[0];
+}
+
+nix::Value mx_array_to_value(const mxArray *arr) {
+    nix::Value val;
+
+    switch (mxGetClassID(arr)) {
+    case mxLOGICAL_CLASS: val.set(mx_array_to_bool(arr)); break;
+    case mxCHAR_CLASS: val.set(mx_array_to_str(arr)); break;
+    case mxDOUBLE_CLASS: val.set(mx_array_to_num<double>(arr)); break;
+    case mxUINT32_CLASS: val.set(mx_array_to_num<uint32_t>(arr)); break;
+    case mxINT32_CLASS:  val.set(mx_array_to_num<int32_t>(arr)); break;
+    case mxUINT64_CLASS: val.set(mx_array_to_num<uint64_t>(arr)); break;
+    case mxINT64_CLASS:  val.set(mx_array_to_num<int64_t>(arr)); break;
+
+    case mxSINGLE_CLASS: throw std::invalid_argument("Element type is not supported");
+    case mxUINT8_CLASS:  throw std::invalid_argument("Element type is not supported");
+    case mxINT8_CLASS:   throw std::invalid_argument("Element type is not supported");
+    case mxUINT16_CLASS: throw std::invalid_argument("Element type is not supported");
+    case mxINT16_CLASS:  throw std::invalid_argument("Element type is not supported");
+
+    default: throw std::invalid_argument("Element type is not recognized");
+    }
+
+    return val;
+}
+

src/utils/nix2mx.h

@@ -3,9 +3,21 @@
 
 #include "mex.h"
 #include <nix.hpp>
+#include "datatypes.h"
+
+void check_arg_type(const mxArray *arr, nix::DataType dtype);
 
 nix::NDSize mx_array_to_ndsize(const mxArray *arr);
 
+std::string mx_array_to_str(const mxArray *arr);
+
+template<typename T>
+T mx_array_to_num(const mxArray *arr);
+
+bool mx_array_to_bool(const mxArray *arr);
+
+nix::Value mx_array_to_value(const mxArray *arr);
+
 mxArray *nmCreateScalar(uint32_t val);
 
 mxArray *dim_to_struct(nix::SetDimension dim);