ljio

Author: StephenNneji

cpp/RAT2/callCppFunction.cpp

@@ -42,19 +42,19 @@ namespace RAT
     int i;
     int loop_ub;
     int loop_ub_tmp;
-    char tmp_data[10001];
+    char b_pointer_data[10000];
 
     //  Calls a Cpp custom function stored at the given pointer address.
     //
     //  data = callCppFunction(pointer, xdata, params)
     //  [output, subRough] = callCppFunction(pointer, params, bulkIn ,bulkOut, contrast, domains);
-    loop_ub_tmp = pointer_size[1];
-    if (loop_ub_tmp - 1 >= 0) {
-      std::copy(&pointer_data[0], &pointer_data[loop_ub_tmp], &tmp_data[0]);
+    loop_ub = pointer_size[1];
+    if (loop_ub - 1 >= 0) {
+      std::copy(&pointer_data[0], &pointer_data[loop_ub], &b_pointer_data[0]);
     }
 
-    tmp_data[pointer_size[1]] = '\x00';
-    callbackHandle = convertString2HandlePtr<CallbackInterface>(&tmp_data[0]);
+    callbackHandle = convertString2HandlePtr<CallbackInterface>(&b_pointer_data
+      [0], static_cast<double>(pointer_size[1]));
     callback = std::mem_fn(&ClassHandle<CallbackInterface>::ptr)(callbackHandle);
     outArray = { };
 
@@ -153,19 +153,19 @@ namespace RAT
     int i;
     int loop_ub;
     int loop_ub_tmp;
-    char tmp_data[10001];
+    char b_pointer_data[10000];
 
     //  Calls a Cpp custom function stored at the given pointer address.
     //
     //  data = callCppFunction(pointer, xdata, params)
     //  [output, subRough] = callCppFunction(pointer, params, bulkIn ,bulkOut, contrast, domains);
-    loop_ub_tmp = pointer_size[1];
-    if (loop_ub_tmp - 1 >= 0) {
-      std::copy(&pointer_data[0], &pointer_data[loop_ub_tmp], &tmp_data[0]);
+    loop_ub = pointer_size[1];
+    if (loop_ub - 1 >= 0) {
+      std::copy(&pointer_data[0], &pointer_data[loop_ub], &b_pointer_data[0]);
     }
 
-    tmp_data[pointer_size[1]] = '\x00';
-    callbackHandle = convertString2HandlePtr<CallbackInterface>(&tmp_data[0]);
+    callbackHandle = convertString2HandlePtr<CallbackInterface>(&b_pointer_data
+      [0], static_cast<double>(pointer_size[1]));
     callback = std::mem_fn(&ClassHandle<CallbackInterface>::ptr)(callbackHandle);
     outArray = { };
 
@@ -264,19 +264,19 @@ namespace RAT
     int i;
     int loop_ub;
     int loop_ub_tmp;
-    char tmp_data[10001];
+    char b_pointer_data[10000];
 
     //  Calls a Cpp custom function stored at the given pointer address.
     //
     //  data = callCppFunction(pointer, xdata, params)
     //  [output, subRough] = callCppFunction(pointer, params, bulkIn ,bulkOut, contrast, domains);
-    loop_ub_tmp = pointer_size[1];
-    if (loop_ub_tmp - 1 >= 0) {
-      std::copy(&pointer_data[0], &pointer_data[loop_ub_tmp], &tmp_data[0]);
+    loop_ub = pointer_size[1];
+    if (loop_ub - 1 >= 0) {
+      std::copy(&pointer_data[0], &pointer_data[loop_ub], &b_pointer_data[0]);
     }
 
-    tmp_data[pointer_size[1]] = '\x00';
-    callbackHandle = convertString2HandlePtr<CallbackInterface>(&tmp_data[0]);
+    callbackHandle = convertString2HandlePtr<CallbackInterface>(&b_pointer_data
+      [0], static_cast<double>(pointer_size[1]));
     callback = std::mem_fn(&ClassHandle<CallbackInterface>::ptr)(callbackHandle);
     outArray = { };
 
@@ -369,33 +369,32 @@ namespace RAT
     ::coder::array<double, 1U> xdata;
     double params_data[5];
     double actualSize;
-    int loop_ub_tmp;
-    char tmp_data[10001];
+    int loop_ub;
+    char b_pointer_data[10000];
 
     //  Calls a Cpp custom function stored at the given pointer address.
     //
     //  data = callCppFunction(pointer, xdata, params)
     //  [output, subRough] = callCppFunction(pointer, params, bulkIn ,bulkOut, contrast, domains);
-    loop_ub_tmp = pointer_size[1];
-    if (loop_ub_tmp - 1 >= 0) {
-      std::copy(&pointer_data[0], &pointer_data[loop_ub_tmp], &tmp_data[0]);
+    loop_ub = pointer_size[1];
+    if (loop_ub - 1 >= 0) {
+      std::copy(&pointer_data[0], &pointer_data[loop_ub], &b_pointer_data[0]);
     }
 
-    tmp_data[pointer_size[1]] = '\x00';
-    callbackHandle = convertString2HandlePtr<CallbackInterface>(&tmp_data[0]);
+    callbackHandle = convertString2HandlePtr<CallbackInterface>(&b_pointer_data
+      [0], static_cast<double>(pointer_size[1]));
     callback = std::mem_fn(&ClassHandle<CallbackInterface>::ptr)(callbackHandle);
     outArray = { };
 
-    loop_ub_tmp = varargin_1.size(0);
+    loop_ub = varargin_1.size(0);
     xdata.set_size(varargin_1.size(0));
-    for (int i{0}; i < loop_ub_tmp; i++) {
+    for (int i{0}; i < loop_ub; i++) {
       xdata[i] = varargin_1[i];
     }
 
-    loop_ub_tmp = varargin_2_size[1];
-    if (loop_ub_tmp - 1 >= 0) {
-      std::copy(&varargin_2_data[0], &varargin_2_data[loop_ub_tmp],
-                &params_data[0]);
+    loop_ub = varargin_2_size[1];
+    if (loop_ub - 1 >= 0) {
+      std::copy(&varargin_2_data[0], &varargin_2_data[loop_ub], &params_data[0]);
     }
 
     dataArray = convertPtr2Vector(&(xdata.data())[0], static_cast<double>
@@ -406,9 +405,9 @@ namespace RAT
                      double>&)>(&CallbackInterface::invoke)(callback, dataArray,
       paramsArray, outArray);
     actualSize = getVectorSize(outArray);
-    loop_ub_tmp = static_cast<int>(actualSize);
+    loop_ub = static_cast<int>(actualSize);
     output.set_size(static_cast<int>(actualSize));
-    for (int i{0}; i < loop_ub_tmp; i++) {
+    for (int i{0}; i < loop_ub; i++) {
       output[i] = 0.0;
     }
 

cpp/RAT2/classHandle.hpp

@@ -60,9 +60,9 @@ template<class base> inline std::string convertPtr2String(base *ptr)
     return std::to_string(handle);
 }
 
-template<class base> inline ClassHandle<base> *convertString2HandlePtr(const char* in)
+template<class base> inline ClassHandle<base> *convertString2HandlePtr(const char* in, int size)
 {
-    uint64_t value = stoull(std::string(in));
+    uint64_t value = stoull(std::string(in).substr(0, size));
     ClassHandle<base> *ptr = reinterpret_cast<ClassHandle<base> *>(value);
     if (!ptr->isValid())
        throw std::invalid_argument("callback handle is not valid");