coco
5163 lines
212 KiB
C++
5163 lines
212 KiB
C++
// Copyright (C) 2012 Massachusetts Institute of Technology, Lincoln Laboratory
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
// Authors: Davis E. King (davis@dlib.net)
|
|
/*
|
|
READ THIS FIRST
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
\############/
|
|
\##########/
|
|
\########/
|
|
\######/
|
|
\####/
|
|
\##/
|
|
\/
|
|
|
|
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
See example_mex_function.cpp for a discussion of how to use the mex wrapper.
|
|
|
|
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
|
|
/\
|
|
/##\
|
|
/####\
|
|
/######\
|
|
/########\
|
|
/##########\
|
|
/############\
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
######
|
|
READ THIS FIRST
|
|
*/
|
|
|
|
// Copyright (C) 2012 Massachusetts Institute of Technology, Lincoln Laboratory
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
// Authors: Davis E. King (davis@dlib.net)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
// BEGIN IMPLEMENTATION DETAILS
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
#include "../matrix.h"
|
|
#include "../array2d.h"
|
|
#include "../array.h"
|
|
#include "../image_transforms.h"
|
|
#include "../is_kind.h"
|
|
#include "../string.h"
|
|
#include "../any.h" // for sig_traits
|
|
#include "../hash.h"
|
|
#include <tuple>
|
|
#include <map>
|
|
|
|
#if defined(_MSC_VER)
|
|
#define DLL_EXPORT_SYM __declspec(dllexport)
|
|
#endif
|
|
#include "mex.h"
|
|
#include <sstream>
|
|
#include "call_matlab.h"
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
#ifdef ARG_1_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_1 else A1 = ARG_1_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_1
|
|
#endif
|
|
|
|
#ifdef ARG_2_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_2 else A2 = ARG_2_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_2
|
|
#endif
|
|
|
|
#ifdef ARG_3_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_3 else A3 = ARG_3_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_3
|
|
#endif
|
|
|
|
#ifdef ARG_4_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_4 else A4 = ARG_4_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_4
|
|
#endif
|
|
|
|
#ifdef ARG_5_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_5 else A5 = ARG_5_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_5
|
|
#endif
|
|
|
|
#ifdef ARG_6_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_6 else A6 = ARG_6_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_6
|
|
#endif
|
|
|
|
#ifdef ARG_7_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_7 else A7 = ARG_7_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_7
|
|
#endif
|
|
|
|
#ifdef ARG_8_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_8 else A8 = ARG_8_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_8
|
|
#endif
|
|
|
|
#ifdef ARG_9_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_9 else A9 = ARG_9_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_9
|
|
#endif
|
|
|
|
#ifdef ARG_10_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_10 else A10 = ARG_10_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_10
|
|
#endif
|
|
|
|
#ifdef ARG_11_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_11 else A11 = ARG_11_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_11
|
|
#endif
|
|
|
|
#ifdef ARG_12_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_12 else A12 = ARG_12_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_12
|
|
#endif
|
|
|
|
#ifdef ARG_13_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_13 else A13 = ARG_13_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_13
|
|
#endif
|
|
|
|
#ifdef ARG_14_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_14 else A14 = ARG_14_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_14
|
|
#endif
|
|
|
|
#ifdef ARG_15_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_15 else A15 = ARG_15_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_15
|
|
#endif
|
|
|
|
#ifdef ARG_16_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_16 else A16 = ARG_16_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_16
|
|
#endif
|
|
|
|
#ifdef ARG_17_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_17 else A17 = ARG_17_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_17
|
|
#endif
|
|
|
|
#ifdef ARG_18_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_18 else A18 = ARG_18_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_18
|
|
#endif
|
|
|
|
#ifdef ARG_19_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_19 else A19 = ARG_19_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_19
|
|
#endif
|
|
|
|
#ifdef ARG_20_DEFAULT
|
|
#define ELSE_ASSIGN_ARG_20 else A20 = ARG_20_DEFAULT;
|
|
#else
|
|
#define ELSE_ASSIGN_ARG_20
|
|
#endif
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
namespace mex_binding
|
|
{
|
|
using namespace dlib;
|
|
|
|
template <typename T>
|
|
struct is_input_type
|
|
{
|
|
const static unsigned long value = (!is_same_type<void,T>::value && (!is_reference_type<T>::value || is_const_type<T>::value )) ? 1 : 0;
|
|
};
|
|
template <typename T>
|
|
struct is_output_type
|
|
{
|
|
const static unsigned long value = (!is_same_type<void,T>::value && is_reference_type<T>::value && !is_const_type<T>::value) ? 1 : 0;
|
|
};
|
|
|
|
|
|
template <typename funct>
|
|
struct funct_traits
|
|
{
|
|
const static unsigned long num_inputs = is_input_type<typename sig_traits<funct>::arg1_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg2_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg3_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg4_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg5_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg6_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg7_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg8_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg9_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg10_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg11_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg12_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg13_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg14_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg15_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg16_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg17_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg18_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg19_type>::value +
|
|
is_input_type<typename sig_traits<funct>::arg20_type>::value;
|
|
|
|
const static unsigned long num_outputs= is_output_type<typename sig_traits<funct>::arg1_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg2_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg3_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg4_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg5_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg6_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg7_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg8_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg9_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg10_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg11_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg12_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg13_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg14_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg15_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg16_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg17_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg18_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg19_type>::value +
|
|
is_output_type<typename sig_traits<funct>::arg20_type>::value;
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
struct is_array_type
|
|
{
|
|
// true if T is std::vector or dlib::array
|
|
const static bool value = is_std_vector<T>::value || dlib::is_array<T>::value;
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename T,
|
|
typename enabled = void
|
|
>
|
|
struct inner_type
|
|
{
|
|
typedef T type;
|
|
};
|
|
|
|
template < typename T>
|
|
struct inner_type<T, typename dlib::enable_if_c<is_matrix<T>::value || is_array2d<T>::value || dlib::is_array<T>::value >::type>
|
|
{
|
|
typedef typename T::type type;
|
|
};
|
|
|
|
template < typename T>
|
|
struct inner_type<T, typename dlib::enable_if<is_std_vector<T> >::type>
|
|
{
|
|
typedef typename T::value_type type;
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
struct user_hit_ctrl_c {};
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void validate_and_populate_arg (
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
T& arg
|
|
);
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
matlab_struct& arg
|
|
);
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
matlab_object& arg
|
|
);
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
std::string& arg
|
|
);
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <typename T>
|
|
struct is_column_major_matrix : public default_is_kind_value {};
|
|
|
|
template <
|
|
typename T,
|
|
long num_rows,
|
|
long num_cols,
|
|
typename mem_manager
|
|
>
|
|
struct is_column_major_matrix<matrix<T,num_rows,num_cols,mem_manager,column_major_layout> >
|
|
{ static const bool value = true; };
|
|
|
|
// -------------------------------------------------------
|
|
|
|
string escape_percent(const string& str)
|
|
{
|
|
string temp;
|
|
for(auto c : str)
|
|
{
|
|
if (c != '%')
|
|
{
|
|
temp += c;
|
|
}
|
|
else
|
|
{
|
|
temp += c;
|
|
temp += c;
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
string escape_percent(const std::ostringstream& sout)
|
|
{
|
|
return escape_percent(sout.str());
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <
|
|
typename matrix_type
|
|
>
|
|
typename dlib::enable_if_c<is_matrix<matrix_type>::value || is_array2d<matrix_type>::value >::type
|
|
clear_mat (
|
|
matrix_type& m
|
|
)
|
|
{
|
|
m.set_size(0,0);
|
|
}
|
|
|
|
template <
|
|
typename matrix_type
|
|
>
|
|
typename dlib::disable_if_c<is_matrix<matrix_type>::value || is_array2d<matrix_type>::value >::type
|
|
clear_mat (
|
|
matrix_type&
|
|
)
|
|
{
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <
|
|
typename matrix_type,
|
|
typename EXP
|
|
>
|
|
typename dlib::enable_if_c<is_matrix<matrix_type>::value && is_same_type<typename inner_type<matrix_type>::type,typename EXP::type>::value >::type
|
|
assign_mat (
|
|
const long arg_idx,
|
|
matrix_type& m,
|
|
const matrix_exp<EXP>& src
|
|
)
|
|
{
|
|
if (matrix_type::NR != 0 && matrix_type::NR != src.nc())
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Argument " << arg_idx+1 << " expects a matrix with " << matrix_type::NR << " rows but got one with " << src.nc();
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
if (matrix_type::NC != 0 && matrix_type::NC != src.nr())
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Argument " << arg_idx+1 << " expects a matrix with " << matrix_type::NC << " columns but got one with " << src.nr();
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
|
|
m = trans(src);
|
|
}
|
|
|
|
template <
|
|
typename matrix_type,
|
|
typename EXP
|
|
>
|
|
typename dlib::enable_if_c<is_array2d<matrix_type>::value && is_same_type<typename inner_type<matrix_type>::type,typename EXP::type>::value >::type
|
|
assign_mat (
|
|
const long arg_idx,
|
|
matrix_type& m,
|
|
const matrix_exp<EXP>& src
|
|
)
|
|
{
|
|
assign_image(m , trans(src));
|
|
}
|
|
|
|
template <
|
|
typename matrix_type,
|
|
typename EXP
|
|
>
|
|
typename disable_if_c<(is_array2d<matrix_type>::value || is_matrix<matrix_type>::value) &&
|
|
is_same_type<typename inner_type<matrix_type>::type,typename EXP::type>::value >::type
|
|
assign_mat (
|
|
const long arg_idx,
|
|
matrix_type& ,
|
|
const matrix_exp<EXP>&
|
|
)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "mex_function has some bug in it related to processing input argument " << arg_idx+1;
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <
|
|
typename T,
|
|
typename U
|
|
>
|
|
typename dlib::enable_if_c<is_built_in_scalar_type<T>::value || is_same_type<T,bool>::value >::type
|
|
assign_scalar (
|
|
const long arg_idx,
|
|
T& dest,
|
|
const U& src
|
|
)
|
|
{
|
|
if (is_signed_type<U>::value && src < 0 && is_unsigned_type<T>::value)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Error, input argument " << arg_idx+1 << " must be a non-negative number.";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
else
|
|
{
|
|
dest = src;
|
|
}
|
|
}
|
|
|
|
template <
|
|
typename T,
|
|
typename U
|
|
>
|
|
typename dlib::disable_if_c<is_built_in_scalar_type<T>::value || is_same_type<T,bool>::value >::type
|
|
assign_scalar (
|
|
const long arg_idx,
|
|
T& ,
|
|
const U&
|
|
)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "mex_function has some bug in it related to processing input argument " << arg_idx+1;
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
void assign_function_handle (
|
|
const long arg_idx,
|
|
function_handle& dest,
|
|
const mxArray* src
|
|
)
|
|
{
|
|
const_cast<void*&>(dest.h) = (void*)src;
|
|
}
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
void assign_function_handle (
|
|
const long arg_idx,
|
|
T& ,
|
|
const mxArray*
|
|
)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "mex_function has some bug in it related to processing input argument " << arg_idx+1;
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
typename dlib::enable_if<is_array_type<T> >::type
|
|
assign_std_vector (
|
|
const long arg_idx,
|
|
T& dest,
|
|
const mxArray* src
|
|
)
|
|
{
|
|
const long nr = mxGetM(src);
|
|
const long nc = mxGetN(src);
|
|
|
|
typedef typename inner_type<T>::type type;
|
|
|
|
if (!mxIsCell(src))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a cell array";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
if (nr != 1 && nc != 1)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a cell array with exactly 1 row or 1 column (i.e. a row or column vector)";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
const long size = nr*nc;
|
|
dest.resize(size);
|
|
|
|
for (unsigned long i = 0; i < dest.size(); ++i)
|
|
{
|
|
try
|
|
{
|
|
validate_and_populate_arg(i, mxGetCell(src, i), dest[i]);
|
|
}
|
|
catch (invalid_args_exception& e)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Error in argument " << arg_idx+1 << ": element " << i+1 << " of cell array not the expected type.\n";
|
|
sout << "\t" << e.what();
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
template <
|
|
typename T
|
|
>
|
|
typename disable_if<is_array_type<T> >::type
|
|
assign_std_vector (
|
|
const long arg_idx,
|
|
T& ,
|
|
const mxArray*
|
|
)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "mex_function has some bug in it related to processing input argument " << arg_idx+1;
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void assign_image (
|
|
const long arg_idx,
|
|
T&,
|
|
const dlib::uint8* data,
|
|
long nr,
|
|
long nc
|
|
)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "mex_function has some bug in it related to processing input argument " << arg_idx+1;
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
template <typename MM>
|
|
void assign_image(
|
|
const long ,
|
|
array2d<dlib::rgb_pixel,MM>& img,
|
|
const dlib::uint8* data,
|
|
long nr,
|
|
long nc
|
|
)
|
|
{
|
|
img.set_size(nr, nc);
|
|
for (long c = 0; c < img.nc(); ++c)
|
|
for (long r = 0; r < img.nr(); ++r)
|
|
img[r][c].red = *data++;
|
|
for (long c = 0; c < img.nc(); ++c)
|
|
for (long r = 0; r < img.nr(); ++r)
|
|
img[r][c].green = *data++;
|
|
for (long c = 0; c < img.nc(); ++c)
|
|
for (long r = 0; r < img.nr(); ++r)
|
|
img[r][c].blue = *data++;
|
|
}
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void call_private_set_mxArray(T&, mxArray*) {}
|
|
void call_private_set_mxArray(matrix_colmajor& item, mxArray* m) { item._private_set_mxArray(m); }
|
|
void call_private_set_mxArray(fmatrix_colmajor& item, mxArray* m) { item._private_set_mxArray(m); }
|
|
|
|
// -------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void validate_and_populate_arg (
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
T& arg
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
if (is_built_in_scalar_type<T>::value || is_same_type<T,bool>::value)
|
|
{
|
|
if( !(mxIsDouble(prhs) || mxIsSingle(prhs) || mxIsLogical(prhs) ) ||
|
|
mxIsComplex(prhs) ||
|
|
mxGetNumberOfElements(prhs)!=1 )
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a scalar";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_scalar(arg_idx, arg , mxGetScalar(prhs));
|
|
}
|
|
else if (is_matrix<T>::value || is_array2d<T>::value)
|
|
{
|
|
if (prhs == NULL)
|
|
{
|
|
clear_mat(arg);
|
|
return;
|
|
}
|
|
|
|
typedef typename inner_type<T>::type type;
|
|
|
|
const int num_dims = mxGetNumberOfDimensions(prhs);
|
|
const long nr = mxGetM(prhs);
|
|
const long nc = mxGetN(prhs);
|
|
|
|
if (is_same_type<type,dlib::rgb_pixel>::value)
|
|
{
|
|
if (!(num_dims == 3 && mxGetDimensions(prhs)[2] == 3 && mxIsUint8(prhs)))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a 3-D NxMx3 image matrix of uint8";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
const long rows = mxGetDimensions(prhs)[0];
|
|
const long cols = mxGetDimensions(prhs)[1];
|
|
assign_image(arg_idx, arg , (const dlib::uint8*)mxGetData(prhs), rows, cols);
|
|
return;
|
|
}
|
|
|
|
if (num_dims != 2)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a 2-D matrix (got a " << num_dims << "-D matrix)";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
|
|
if (is_same_type<type,double>::value)
|
|
{
|
|
if (!mxIsDouble(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of doubles";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
if (is_column_major_matrix<T>::value)
|
|
call_private_set_mxArray(arg, (mxArray*)prhs);
|
|
else
|
|
assign_mat(arg_idx, arg , pointer_to_matrix(mxGetPr(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, float>::value)
|
|
{
|
|
if (!mxIsSingle(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of single/float";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
if (is_column_major_matrix<T>::value)
|
|
call_private_set_mxArray(arg,(mxArray*)prhs);
|
|
else
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const float*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, bool>::value)
|
|
{
|
|
if (!mxIsLogical(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of logical elements.";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
DLIB_CASSERT(sizeof(mxLogical) == sizeof(bool),"logical matrices are not supported by the mex wrapper when mxLogical isn't a bool.");
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const bool*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::uint8>::value)
|
|
{
|
|
if (!mxIsUint8(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of uint8";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const dlib::uint8*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::int8>::value)
|
|
{
|
|
if (!mxIsInt8(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of int8";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const dlib::int8*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::int16>::value ||
|
|
(is_same_type<type, short>::value && sizeof(short) == sizeof(dlib::int16)))
|
|
{
|
|
if (!mxIsInt16(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of int16";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::uint16>::value ||
|
|
(is_same_type<type, unsigned short>::value && sizeof(unsigned short) == sizeof(dlib::uint16)))
|
|
{
|
|
if (!mxIsUint16(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of uint16";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::int32>::value ||
|
|
(is_same_type<type, int>::value && sizeof(int) == sizeof(dlib::int32)) ||
|
|
(is_same_type<type, long>::value && sizeof(long) == sizeof(dlib::int32)))
|
|
{
|
|
if (!mxIsInt32(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of int32";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::uint32>::value ||
|
|
(is_same_type<type, unsigned int>::value && sizeof(unsigned int) == sizeof(dlib::uint32)) ||
|
|
(is_same_type<type, unsigned long>::value && sizeof(unsigned long) == sizeof(dlib::uint32)))
|
|
{
|
|
if (!mxIsUint32(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of uint32";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::uint64>::value ||
|
|
(is_same_type<type, unsigned int>::value && sizeof(unsigned int) == sizeof(dlib::uint64)) ||
|
|
(is_same_type<type, unsigned long>::value && sizeof(unsigned long) == sizeof(dlib::uint64)))
|
|
{
|
|
if (!mxIsUint64(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of uint64";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else if (is_same_type<type, dlib::int64>::value ||
|
|
(is_same_type<type, int>::value && sizeof(int) == sizeof(dlib::int64)) ||
|
|
(is_same_type<type, long>::value && sizeof(long) == sizeof(dlib::int64)))
|
|
{
|
|
if (!mxIsInt64(prhs) || mxIsComplex(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a matrix of int64";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
assign_mat(arg_idx, arg , pointer_to_matrix((const type*)mxGetData(prhs), nc, nr));
|
|
}
|
|
else
|
|
{
|
|
throw invalid_args_exception("mex_function uses unsupported matrix type");
|
|
}
|
|
}
|
|
else if (is_array_type<T>::value)
|
|
{
|
|
assign_std_vector(arg_idx, arg, prhs);
|
|
|
|
}
|
|
else if (is_same_type<T,function_handle>::value)
|
|
{
|
|
if (!mxIsClass(prhs, "function_handle"))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a function handle.";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
assign_function_handle(arg_idx, arg, prhs);
|
|
}
|
|
else
|
|
{
|
|
throw invalid_args_exception("mex_function uses unsupported input argument type");
|
|
}
|
|
}
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
matlab_struct& arg
|
|
)
|
|
{
|
|
if (!mxIsStruct(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a struct";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
arg.set_struct_handle(arg_idx, prhs);
|
|
}
|
|
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
matlab_object& arg
|
|
)
|
|
{
|
|
arg.set_object_handle(arg_idx, prhs);
|
|
}
|
|
|
|
|
|
void validate_and_populate_arg(
|
|
long arg_idx,
|
|
const mxArray *prhs,
|
|
std::string& arg
|
|
)
|
|
{
|
|
if (!mxIsChar(prhs))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " must be a char string";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
|
|
const long nr = mxGetM(prhs);
|
|
const long nc = mxGetN(prhs);
|
|
const long size = nr*nc;
|
|
arg.resize(size+1);
|
|
if (mxGetString(prhs, &arg[0], arg.size()))
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Input argument " << arg_idx+1 << " encountered an error while calling mxGetString()";
|
|
throw invalid_args_exception(sout);
|
|
}
|
|
arg.resize(size);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename EXP>
|
|
typename dlib::enable_if<is_same_type<dlib::rgb_pixel,typename EXP::type> >::type assign_image_to_matlab (
|
|
dlib::uint8* mat,
|
|
const matrix_exp<EXP>& item
|
|
)
|
|
{
|
|
for (long c = 0; c < item.nc(); ++c)
|
|
for (long r = 0; r < item.nr(); ++r)
|
|
*mat++ = item(r,c).red;
|
|
for (long c = 0; c < item.nc(); ++c)
|
|
for (long r = 0; r < item.nr(); ++r)
|
|
*mat++ = item(r,c).green;
|
|
for (long c = 0; c < item.nc(); ++c)
|
|
for (long r = 0; r < item.nr(); ++r)
|
|
*mat++ = item(r,c).blue;
|
|
}
|
|
|
|
template <typename T, typename EXP>
|
|
typename disable_if<is_same_type<dlib::rgb_pixel,typename EXP::type> >::type assign_image_to_matlab (
|
|
T* mat,
|
|
const matrix_exp<EXP>&
|
|
)
|
|
{
|
|
mexErrMsgIdAndTxt("mex_function:validate_and_populate_arg",
|
|
"mex_function uses unsupported output image argument type");
|
|
}
|
|
|
|
template <typename T>
|
|
typename dlib::enable_if<is_matrix<T> >::type assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const T& item
|
|
)
|
|
{
|
|
typedef typename T::type type;
|
|
|
|
type* mat = 0;
|
|
|
|
if (is_same_type<double, type>::value)
|
|
{
|
|
plhs = mxCreateDoubleMatrix(item.nr(),
|
|
item.nc(),
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetPr(plhs);
|
|
}
|
|
else if (is_same_type<float, type>::value )
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxSINGLE_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<bool, type>::value )
|
|
{
|
|
plhs = mxCreateLogicalMatrix(item.nr(),
|
|
item.nc());
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::uint8, type>::value )
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxUINT8_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::int8, type>::value )
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxINT8_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::int16, type>::value ||
|
|
(is_same_type<short,type>::value && sizeof(short) == sizeof(dlib::int16)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxINT16_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::uint16, type>::value ||
|
|
(is_same_type<unsigned short,type>::value && sizeof(unsigned short) == sizeof(dlib::uint16)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxUINT16_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::int32, type>::value ||
|
|
(is_same_type<long,type>::value && sizeof(long) == sizeof(dlib::int32)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxINT32_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::uint32, type>::value ||
|
|
(is_same_type<unsigned long,type>::value && sizeof(unsigned long) == sizeof(dlib::uint32)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxUINT32_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::uint64, type>::value ||
|
|
(is_same_type<unsigned long,type>::value && sizeof(unsigned long) == sizeof(dlib::uint64)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxUINT64_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::int64, type>::value ||
|
|
(is_same_type<long,type>::value && sizeof(long) == sizeof(dlib::int64)))
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxINT64_CLASS,
|
|
mxREAL);
|
|
|
|
mat = (type*)mxGetData(plhs);
|
|
}
|
|
else if (is_same_type<dlib::rgb_pixel, type>::value)
|
|
{
|
|
mwSize dims[3] = {(mwSize)item.nr(), (mwSize)item.nc(), 3};
|
|
plhs = mxCreateNumericArray(3, dims, mxUINT8_CLASS, mxREAL);
|
|
|
|
assign_image_to_matlab((dlib::uint8*)mxGetData(plhs), item);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
mexErrMsgIdAndTxt("mex_function:validate_and_populate_arg",
|
|
"mex_function uses unsupported output argument type");
|
|
}
|
|
|
|
|
|
const_temp_matrix<T> m(item);
|
|
|
|
for (long c = 0; c < m.nc(); ++c)
|
|
{
|
|
for ( long r = 0; r < m.nr(); ++r)
|
|
{
|
|
*mat++ = m(r,c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
matrix_colmajor& item
|
|
)
|
|
{
|
|
if(item._private_is_owned_by_matlab())
|
|
{
|
|
// Don't need to do a copy if it's this kind of matrix since we can just
|
|
// pull the underlying mxArray out directly and thus avoid a copy.
|
|
plhs = item._private_release_mxArray();
|
|
// If there isn't anything there because the matrix is empty then set it to an
|
|
// empty matrix.
|
|
if (!plhs)
|
|
plhs = mxCreateDoubleMatrix(item.nr(),
|
|
item.nc(),
|
|
mxREAL);
|
|
}
|
|
else
|
|
{
|
|
plhs = mxCreateDoubleMatrix(item.nr(),
|
|
item.nc(),
|
|
mxREAL);
|
|
if (item.size() != 0)
|
|
memcpy(mxGetPr(plhs), &item(0,0), item.size()*sizeof(double));
|
|
}
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
fmatrix_colmajor& item
|
|
)
|
|
{
|
|
if(item._private_is_owned_by_matlab())
|
|
{
|
|
// Don't need to do a copy if it's this kind of matrix since we can just
|
|
// pull the underlying mxArray out directly and thus avoid a copy.
|
|
plhs = item._private_release_mxArray();
|
|
// If there isn't anything there because the matrix is empty then set it to an
|
|
// empty matrix.
|
|
if (!plhs)
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxSINGLE_CLASS,
|
|
mxREAL);
|
|
}
|
|
else
|
|
{
|
|
plhs = mxCreateNumericMatrix(item.nr(),
|
|
item.nc(),
|
|
mxSINGLE_CLASS,
|
|
mxREAL);
|
|
if (item.size() != 0)
|
|
memcpy(mxGetPr(plhs), &item(0,0), item.size()*sizeof(float));
|
|
}
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
matlab_struct& item
|
|
)
|
|
{
|
|
plhs = (mxArray*)item.release_struct_to_matlab();
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
matlab_object& item
|
|
)
|
|
{
|
|
plhs = (mxArray*)item.release_object_to_matlab();
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const std::string& item
|
|
)
|
|
{
|
|
plhs = mxCreateString(item.c_str());
|
|
}
|
|
|
|
template <typename T, typename MM>
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const array2d<T,MM>& item
|
|
)
|
|
{
|
|
assign_to_matlab(plhs,array_to_matrix(item));
|
|
}
|
|
|
|
template <typename T>
|
|
typename dlib::disable_if_c<is_matrix<T>::value || is_array_type<T>::value ||
|
|
is_same_type<T,function_handle>::value>::type assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const T& item
|
|
)
|
|
{
|
|
plhs = mxCreateDoubleScalar(item);
|
|
}
|
|
|
|
|
|
void assign_to_matlab (
|
|
mxArray*& plhs,
|
|
const char* str
|
|
)
|
|
{
|
|
assign_to_matlab(plhs, std::string(str));
|
|
}
|
|
|
|
void assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const function_handle& h
|
|
)
|
|
{
|
|
}
|
|
|
|
template <typename T>
|
|
typename dlib::enable_if<is_array_type<T> >::type assign_to_matlab(
|
|
mxArray*& plhs,
|
|
const T& item
|
|
)
|
|
{
|
|
mwSize dims[1] = {item.size()};
|
|
plhs = mxCreateCellArray(1,dims);
|
|
for (unsigned long i = 0; i < item.size(); ++i)
|
|
{
|
|
mxArray* next = 0;
|
|
assign_to_matlab(next, item[i]);
|
|
mxSetCell(plhs, i, next);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void mark_owned_by_matlab (const T&){}
|
|
|
|
void mark_owned_by_matlab(matrix_colmajor& item) { item._private_mark_owned_by_matlab(); }
|
|
void mark_owned_by_matlab(fmatrix_colmajor& item) { item._private_mark_owned_by_matlab(); }
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
unsigned long num_args
|
|
>
|
|
struct call_mex_function_helper;
|
|
|
|
template <>
|
|
struct call_mex_function_helper<0>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int , mxArray **,
|
|
int , const mxArray **
|
|
) const
|
|
{
|
|
f();
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<1>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
|
|
f(A1);
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<2>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
|
|
f(A1,A2);
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<3>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
|
|
f(A1,A2,A3);
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<4>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
|
|
f(A1,A2,A3,A4);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<5>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
|
|
f(A1,A2,A3,A4,A5);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
}
|
|
};
|
|
|
|
|
|
template <>
|
|
struct call_mex_function_helper<6>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
|
|
f(A1,A2,A3,A4,A5,A6);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
}
|
|
};
|
|
|
|
|
|
template <>
|
|
struct call_mex_function_helper<7>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
}
|
|
};
|
|
|
|
|
|
template <>
|
|
struct call_mex_function_helper<8>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
}
|
|
};
|
|
|
|
|
|
template <>
|
|
struct call_mex_function_helper<9>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
}
|
|
};
|
|
|
|
|
|
|
|
template <>
|
|
struct call_mex_function_helper<10>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<11>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<12>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<13>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<14>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<15>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<16>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
typedef typename sig_traits<funct>::arg16_type arg16_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
typename basic_type<arg16_type>::type A16;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
mark_owned_by_matlab(A16);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
if (i < nrhs && is_input_type<arg16_type>::value) {validate_and_populate_arg(i,prhs[i],A16); ++i;} ELSE_ASSIGN_ARG_16;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
if (is_output_type<arg16_type>::value) {assign_to_matlab(plhs[i],A16); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<17>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
typedef typename sig_traits<funct>::arg16_type arg16_type;
|
|
typedef typename sig_traits<funct>::arg17_type arg17_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
typename basic_type<arg16_type>::type A16;
|
|
typename basic_type<arg17_type>::type A17;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
mark_owned_by_matlab(A16);
|
|
mark_owned_by_matlab(A17);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
if (i < nrhs && is_input_type<arg16_type>::value) {validate_and_populate_arg(i,prhs[i],A16); ++i;} ELSE_ASSIGN_ARG_16;
|
|
if (i < nrhs && is_input_type<arg17_type>::value) {validate_and_populate_arg(i,prhs[i],A17); ++i;} ELSE_ASSIGN_ARG_17;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
if (is_output_type<arg16_type>::value) {assign_to_matlab(plhs[i],A16); ++i;}
|
|
if (is_output_type<arg17_type>::value) {assign_to_matlab(plhs[i],A17); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<18>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
typedef typename sig_traits<funct>::arg16_type arg16_type;
|
|
typedef typename sig_traits<funct>::arg17_type arg17_type;
|
|
typedef typename sig_traits<funct>::arg18_type arg18_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
typename basic_type<arg16_type>::type A16;
|
|
typename basic_type<arg17_type>::type A17;
|
|
typename basic_type<arg18_type>::type A18;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
mark_owned_by_matlab(A16);
|
|
mark_owned_by_matlab(A17);
|
|
mark_owned_by_matlab(A18);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
if (i < nrhs && is_input_type<arg16_type>::value) {validate_and_populate_arg(i,prhs[i],A16); ++i;} ELSE_ASSIGN_ARG_16;
|
|
if (i < nrhs && is_input_type<arg17_type>::value) {validate_and_populate_arg(i,prhs[i],A17); ++i;} ELSE_ASSIGN_ARG_17;
|
|
if (i < nrhs && is_input_type<arg18_type>::value) {validate_and_populate_arg(i,prhs[i],A18); ++i;} ELSE_ASSIGN_ARG_18;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
if (is_output_type<arg16_type>::value) {assign_to_matlab(plhs[i],A16); ++i;}
|
|
if (is_output_type<arg17_type>::value) {assign_to_matlab(plhs[i],A17); ++i;}
|
|
if (is_output_type<arg18_type>::value) {assign_to_matlab(plhs[i],A18); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<19>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
typedef typename sig_traits<funct>::arg16_type arg16_type;
|
|
typedef typename sig_traits<funct>::arg17_type arg17_type;
|
|
typedef typename sig_traits<funct>::arg18_type arg18_type;
|
|
typedef typename sig_traits<funct>::arg19_type arg19_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
typename basic_type<arg16_type>::type A16;
|
|
typename basic_type<arg17_type>::type A17;
|
|
typename basic_type<arg18_type>::type A18;
|
|
typename basic_type<arg19_type>::type A19;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
mark_owned_by_matlab(A16);
|
|
mark_owned_by_matlab(A17);
|
|
mark_owned_by_matlab(A18);
|
|
mark_owned_by_matlab(A19);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
if (i < nrhs && is_input_type<arg16_type>::value) {validate_and_populate_arg(i,prhs[i],A16); ++i;} ELSE_ASSIGN_ARG_16;
|
|
if (i < nrhs && is_input_type<arg17_type>::value) {validate_and_populate_arg(i,prhs[i],A17); ++i;} ELSE_ASSIGN_ARG_17;
|
|
if (i < nrhs && is_input_type<arg18_type>::value) {validate_and_populate_arg(i,prhs[i],A18); ++i;} ELSE_ASSIGN_ARG_18;
|
|
if (i < nrhs && is_input_type<arg19_type>::value) {validate_and_populate_arg(i,prhs[i],A19); ++i;} ELSE_ASSIGN_ARG_19;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
if (is_output_type<arg16_type>::value) {assign_to_matlab(plhs[i],A16); ++i;}
|
|
if (is_output_type<arg17_type>::value) {assign_to_matlab(plhs[i],A17); ++i;}
|
|
if (is_output_type<arg18_type>::value) {assign_to_matlab(plhs[i],A18); ++i;}
|
|
if (is_output_type<arg19_type>::value) {assign_to_matlab(plhs[i],A19); ++i;}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct call_mex_function_helper<20>
|
|
{
|
|
template <typename funct>
|
|
void callit(
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
) const
|
|
{
|
|
typedef typename sig_traits<funct>::arg1_type arg1_type;
|
|
typedef typename sig_traits<funct>::arg2_type arg2_type;
|
|
typedef typename sig_traits<funct>::arg3_type arg3_type;
|
|
typedef typename sig_traits<funct>::arg4_type arg4_type;
|
|
typedef typename sig_traits<funct>::arg5_type arg5_type;
|
|
typedef typename sig_traits<funct>::arg6_type arg6_type;
|
|
typedef typename sig_traits<funct>::arg7_type arg7_type;
|
|
typedef typename sig_traits<funct>::arg8_type arg8_type;
|
|
typedef typename sig_traits<funct>::arg9_type arg9_type;
|
|
typedef typename sig_traits<funct>::arg10_type arg10_type;
|
|
typedef typename sig_traits<funct>::arg11_type arg11_type;
|
|
typedef typename sig_traits<funct>::arg12_type arg12_type;
|
|
typedef typename sig_traits<funct>::arg13_type arg13_type;
|
|
typedef typename sig_traits<funct>::arg14_type arg14_type;
|
|
typedef typename sig_traits<funct>::arg15_type arg15_type;
|
|
typedef typename sig_traits<funct>::arg16_type arg16_type;
|
|
typedef typename sig_traits<funct>::arg17_type arg17_type;
|
|
typedef typename sig_traits<funct>::arg18_type arg18_type;
|
|
typedef typename sig_traits<funct>::arg19_type arg19_type;
|
|
typedef typename sig_traits<funct>::arg20_type arg20_type;
|
|
|
|
typename basic_type<arg1_type>::type A1;
|
|
typename basic_type<arg2_type>::type A2;
|
|
typename basic_type<arg3_type>::type A3;
|
|
typename basic_type<arg4_type>::type A4;
|
|
typename basic_type<arg5_type>::type A5;
|
|
typename basic_type<arg6_type>::type A6;
|
|
typename basic_type<arg7_type>::type A7;
|
|
typename basic_type<arg8_type>::type A8;
|
|
typename basic_type<arg9_type>::type A9;
|
|
typename basic_type<arg10_type>::type A10;
|
|
typename basic_type<arg11_type>::type A11;
|
|
typename basic_type<arg12_type>::type A12;
|
|
typename basic_type<arg13_type>::type A13;
|
|
typename basic_type<arg14_type>::type A14;
|
|
typename basic_type<arg15_type>::type A15;
|
|
typename basic_type<arg16_type>::type A16;
|
|
typename basic_type<arg17_type>::type A17;
|
|
typename basic_type<arg18_type>::type A18;
|
|
typename basic_type<arg19_type>::type A19;
|
|
typename basic_type<arg20_type>::type A20;
|
|
|
|
mark_owned_by_matlab(A1);
|
|
mark_owned_by_matlab(A2);
|
|
mark_owned_by_matlab(A3);
|
|
mark_owned_by_matlab(A4);
|
|
mark_owned_by_matlab(A5);
|
|
mark_owned_by_matlab(A6);
|
|
mark_owned_by_matlab(A7);
|
|
mark_owned_by_matlab(A8);
|
|
mark_owned_by_matlab(A9);
|
|
mark_owned_by_matlab(A10);
|
|
mark_owned_by_matlab(A11);
|
|
mark_owned_by_matlab(A12);
|
|
mark_owned_by_matlab(A13);
|
|
mark_owned_by_matlab(A14);
|
|
mark_owned_by_matlab(A15);
|
|
mark_owned_by_matlab(A16);
|
|
mark_owned_by_matlab(A17);
|
|
mark_owned_by_matlab(A18);
|
|
mark_owned_by_matlab(A19);
|
|
mark_owned_by_matlab(A20);
|
|
|
|
int i = 0;
|
|
if (i < nrhs && is_input_type<arg1_type>::value) {validate_and_populate_arg(i,prhs[i],A1); ++i;} ELSE_ASSIGN_ARG_1;
|
|
if (i < nrhs && is_input_type<arg2_type>::value) {validate_and_populate_arg(i,prhs[i],A2); ++i;} ELSE_ASSIGN_ARG_2;
|
|
if (i < nrhs && is_input_type<arg3_type>::value) {validate_and_populate_arg(i,prhs[i],A3); ++i;} ELSE_ASSIGN_ARG_3;
|
|
if (i < nrhs && is_input_type<arg4_type>::value) {validate_and_populate_arg(i,prhs[i],A4); ++i;} ELSE_ASSIGN_ARG_4;
|
|
if (i < nrhs && is_input_type<arg5_type>::value) {validate_and_populate_arg(i,prhs[i],A5); ++i;} ELSE_ASSIGN_ARG_5;
|
|
if (i < nrhs && is_input_type<arg6_type>::value) {validate_and_populate_arg(i,prhs[i],A6); ++i;} ELSE_ASSIGN_ARG_6;
|
|
if (i < nrhs && is_input_type<arg7_type>::value) {validate_and_populate_arg(i,prhs[i],A7); ++i;} ELSE_ASSIGN_ARG_7;
|
|
if (i < nrhs && is_input_type<arg8_type>::value) {validate_and_populate_arg(i,prhs[i],A8); ++i;} ELSE_ASSIGN_ARG_8;
|
|
if (i < nrhs && is_input_type<arg9_type>::value) {validate_and_populate_arg(i,prhs[i],A9); ++i;} ELSE_ASSIGN_ARG_9;
|
|
if (i < nrhs && is_input_type<arg10_type>::value) {validate_and_populate_arg(i,prhs[i],A10); ++i;} ELSE_ASSIGN_ARG_10;
|
|
if (i < nrhs && is_input_type<arg11_type>::value) {validate_and_populate_arg(i,prhs[i],A11); ++i;} ELSE_ASSIGN_ARG_11;
|
|
if (i < nrhs && is_input_type<arg12_type>::value) {validate_and_populate_arg(i,prhs[i],A12); ++i;} ELSE_ASSIGN_ARG_12;
|
|
if (i < nrhs && is_input_type<arg13_type>::value) {validate_and_populate_arg(i,prhs[i],A13); ++i;} ELSE_ASSIGN_ARG_13;
|
|
if (i < nrhs && is_input_type<arg14_type>::value) {validate_and_populate_arg(i,prhs[i],A14); ++i;} ELSE_ASSIGN_ARG_14;
|
|
if (i < nrhs && is_input_type<arg15_type>::value) {validate_and_populate_arg(i,prhs[i],A15); ++i;} ELSE_ASSIGN_ARG_15;
|
|
if (i < nrhs && is_input_type<arg16_type>::value) {validate_and_populate_arg(i,prhs[i],A16); ++i;} ELSE_ASSIGN_ARG_16;
|
|
if (i < nrhs && is_input_type<arg17_type>::value) {validate_and_populate_arg(i,prhs[i],A17); ++i;} ELSE_ASSIGN_ARG_17;
|
|
if (i < nrhs && is_input_type<arg18_type>::value) {validate_and_populate_arg(i,prhs[i],A18); ++i;} ELSE_ASSIGN_ARG_18;
|
|
if (i < nrhs && is_input_type<arg19_type>::value) {validate_and_populate_arg(i,prhs[i],A19); ++i;} ELSE_ASSIGN_ARG_19;
|
|
if (i < nrhs && is_input_type<arg20_type>::value) {validate_and_populate_arg(i,prhs[i],A20); ++i;} ELSE_ASSIGN_ARG_20;
|
|
|
|
f(A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20);
|
|
|
|
|
|
i = 0;
|
|
if (is_output_type<arg1_type>::value) {assign_to_matlab(plhs[i],A1); ++i;}
|
|
if (is_output_type<arg2_type>::value) {assign_to_matlab(plhs[i],A2); ++i;}
|
|
if (is_output_type<arg3_type>::value) {assign_to_matlab(plhs[i],A3); ++i;}
|
|
if (is_output_type<arg4_type>::value) {assign_to_matlab(plhs[i],A4); ++i;}
|
|
if (is_output_type<arg5_type>::value) {assign_to_matlab(plhs[i],A5); ++i;}
|
|
if (is_output_type<arg6_type>::value) {assign_to_matlab(plhs[i],A6); ++i;}
|
|
if (is_output_type<arg7_type>::value) {assign_to_matlab(plhs[i],A7); ++i;}
|
|
if (is_output_type<arg8_type>::value) {assign_to_matlab(plhs[i],A8); ++i;}
|
|
if (is_output_type<arg9_type>::value) {assign_to_matlab(plhs[i],A9); ++i;}
|
|
if (is_output_type<arg10_type>::value) {assign_to_matlab(plhs[i],A10); ++i;}
|
|
if (is_output_type<arg11_type>::value) {assign_to_matlab(plhs[i],A11); ++i;}
|
|
if (is_output_type<arg12_type>::value) {assign_to_matlab(plhs[i],A12); ++i;}
|
|
if (is_output_type<arg13_type>::value) {assign_to_matlab(plhs[i],A13); ++i;}
|
|
if (is_output_type<arg14_type>::value) {assign_to_matlab(plhs[i],A14); ++i;}
|
|
if (is_output_type<arg15_type>::value) {assign_to_matlab(plhs[i],A15); ++i;}
|
|
if (is_output_type<arg16_type>::value) {assign_to_matlab(plhs[i],A16); ++i;}
|
|
if (is_output_type<arg17_type>::value) {assign_to_matlab(plhs[i],A17); ++i;}
|
|
if (is_output_type<arg18_type>::value) {assign_to_matlab(plhs[i],A18); ++i;}
|
|
if (is_output_type<arg19_type>::value) {assign_to_matlab(plhs[i],A19); ++i;}
|
|
if (is_output_type<arg20_type>::value) {assign_to_matlab(plhs[i],A20); ++i;}
|
|
}
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T> struct is_matlab_object { const static bool value = false; };
|
|
template <> struct is_matlab_object <matlab_object> { const static bool value = true; };
|
|
template <> struct is_matlab_object <const matlab_object> { const static bool value = true; };
|
|
template <> struct is_matlab_object <matlab_object&> { const static bool value = true; };
|
|
template <> struct is_matlab_object <const matlab_object&> { const static bool value = true; };
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <
|
|
typename funct
|
|
>
|
|
void call_mex_function (
|
|
const funct& f,
|
|
int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[]
|
|
)
|
|
{
|
|
const long expected_nrhs = funct_traits<funct>::num_inputs;
|
|
const long expected_nlhs = funct_traits<funct>::num_outputs;
|
|
const long expected_args = expected_nrhs + expected_nlhs;
|
|
|
|
long defaulted_args = 0;
|
|
|
|
#ifdef ARG_1_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg1_type>::value);
|
|
#ifndef ARG_2_DEFAULT
|
|
// You can't define a default for argument 1 if you don't define one for argument 2 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 2);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(1 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_2_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg2_type>::value);
|
|
#ifndef ARG_3_DEFAULT
|
|
// You can't define a default for argument 2 if you don't define one for argument 3 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 3);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(2 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_3_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg3_type>::value);
|
|
#ifndef ARG_4_DEFAULT
|
|
// You can't define a default for argument 3 if you don't define one for argument 4 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 4);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(3 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_4_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg4_type>::value);
|
|
#ifndef ARG_5_DEFAULT
|
|
// You can't define a default for argument 4 if you don't define one for argument 5 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 5);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(4 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_5_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg5_type>::value);
|
|
#ifndef ARG_6_DEFAULT
|
|
// You can't define a default for argument 5 if you don't define one for argument 6 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 6);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(5 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_6_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg6_type>::value);
|
|
#ifndef ARG_7_DEFAULT
|
|
// You can't define a default for argument 6 if you don't define one for argument 7 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 7);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(6 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_7_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg7_type>::value);
|
|
#ifndef ARG_8_DEFAULT
|
|
// You can't define a default for argument 7 if you don't define one for argument 8 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 8);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(7 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_8_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg8_type>::value);
|
|
#ifndef ARG_9_DEFAULT
|
|
// You can't define a default for argument 8 if you don't define one for argument 9 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 9);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(8 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_9_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg9_type>::value);
|
|
#ifndef ARG_10_DEFAULT
|
|
// You can't define a default for argument 9 if you don't define one for argument 10 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 10);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(9 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_10_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg10_type>::value);
|
|
#ifndef ARG_11_DEFAULT
|
|
// You can't define a default for argument 10 if you don't define one for argument 11 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 11);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(10 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_11_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg11_type>::value);
|
|
#ifndef ARG_12_DEFAULT
|
|
// You can't define a default for argument 11 if you don't define one for argument 12 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 12);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(11 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_12_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg12_type>::value);
|
|
#ifndef ARG_13_DEFAULT
|
|
// You can't define a default for argument 12 if you don't define one for argument 13 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 13);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(12 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_13_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg13_type>::value);
|
|
#ifndef ARG_14_DEFAULT
|
|
// You can't define a default for argument 13 if you don't define one for argument 14 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 14);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(13 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_14_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg14_type>::value);
|
|
#ifndef ARG_15_DEFAULT
|
|
// You can't define a default for argument 14 if you don't define one for argument 15 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 15);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(14 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_15_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg15_type>::value);
|
|
#ifndef ARG_16_DEFAULT
|
|
// You can't define a default for argument 15 if you don't define one for argument 16 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 16);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(15 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_16_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg16_type>::value);
|
|
#ifndef ARG_17_DEFAULT
|
|
// You can't define a default for argument 16 if you don't define one for argument 17 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 17);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(16 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_17_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg17_type>::value);
|
|
#ifndef ARG_18_DEFAULT
|
|
// You can't define a default for argument 17 if you don't define one for argument 18 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 18);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(17 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_18_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg18_type>::value);
|
|
#ifndef ARG_19_DEFAULT
|
|
// You can't define a default for argument 18 if you don't define one for argument 19 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 19);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(18 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_19_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg19_type>::value);
|
|
#ifndef ARG_20_DEFAULT
|
|
// You can't define a default for argument 19 if you don't define one for argument 20 also.
|
|
COMPILE_TIME_ASSERT(expected_args < 20);
|
|
#endif
|
|
COMPILE_TIME_ASSERT(19 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
#ifdef ARG_20_DEFAULT
|
|
++defaulted_args;
|
|
// You can only set an argument's default value if it is an input argument.
|
|
COMPILE_TIME_ASSERT(is_input_type<typename sig_traits<funct>::arg20_type>::value);
|
|
COMPILE_TIME_ASSERT(20 <= expected_args); // You can't define a default for an argument that doesn't exist.
|
|
#endif
|
|
|
|
|
|
// Arguments with type matlab_object are optional in both input and output.
|
|
int num_optional_inputs = 0;
|
|
int num_optional_outputs = 0;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg20_type>::value) if (is_input_type<typename sig_traits<funct>::arg20_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg19_type>::value) if (is_input_type<typename sig_traits<funct>::arg19_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg18_type>::value) if (is_input_type<typename sig_traits<funct>::arg18_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg17_type>::value) if (is_input_type<typename sig_traits<funct>::arg17_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg16_type>::value) if (is_input_type<typename sig_traits<funct>::arg16_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg15_type>::value) if (is_input_type<typename sig_traits<funct>::arg15_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg14_type>::value) if (is_input_type<typename sig_traits<funct>::arg14_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg13_type>::value) if (is_input_type<typename sig_traits<funct>::arg13_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg12_type>::value) if (is_input_type<typename sig_traits<funct>::arg12_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg11_type>::value) if (is_input_type<typename sig_traits<funct>::arg11_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg10_type>::value) if (is_input_type<typename sig_traits<funct>::arg10_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg9_type>::value) if (is_input_type<typename sig_traits<funct>::arg9_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg8_type>::value) if (is_input_type<typename sig_traits<funct>::arg8_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg7_type>::value) if (is_input_type<typename sig_traits<funct>::arg7_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg6_type>::value) if (is_input_type<typename sig_traits<funct>::arg6_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg5_type>::value) if (is_input_type<typename sig_traits<funct>::arg5_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg4_type>::value) if (is_input_type<typename sig_traits<funct>::arg4_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg3_type>::value) if (is_input_type<typename sig_traits<funct>::arg3_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg2_type>::value) if (is_input_type<typename sig_traits<funct>::arg2_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
if (is_matlab_object<typename sig_traits<funct>::arg1_type>::value) if (is_input_type<typename sig_traits<funct>::arg1_type>::value) ++num_optional_inputs; else ++num_optional_outputs;
|
|
|
|
|
|
/* check for proper number of arguments */
|
|
if(nrhs > expected_nrhs || nrhs < expected_nrhs - defaulted_args - num_optional_inputs)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Expected between " << expected_nrhs-defaulted_args - num_optional_inputs
|
|
<< " and " << expected_nrhs << " input arguments, got " << nrhs << ".";
|
|
|
|
mexErrMsgIdAndTxt("mex_function:nrhs",
|
|
escape_percent(sout).c_str());
|
|
}
|
|
|
|
if (nlhs > expected_nlhs)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Expected at most " << expected_nlhs << " output arguments, got " << nlhs << ".";
|
|
|
|
mexErrMsgIdAndTxt("mex_function:nlhs",
|
|
escape_percent(sout).c_str());
|
|
}
|
|
|
|
call_mex_function_helper<sig_traits<funct>::num_args> helper;
|
|
helper.callit(f, nlhs, plhs, nrhs, prhs);
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
class mex_streambuf : public std::streambuf
|
|
{
|
|
|
|
public:
|
|
mex_streambuf (
|
|
)
|
|
{
|
|
buf.resize(1000);
|
|
setp(&buf[0], &buf[0] + buf.size()-2);
|
|
|
|
// make cout send data to mex_streambuf
|
|
oldbuf = std::cout.rdbuf(this);
|
|
}
|
|
|
|
~mex_streambuf()
|
|
{
|
|
// put cout back to the way we found it before running our mex function.
|
|
std::cout.rdbuf(oldbuf);
|
|
}
|
|
|
|
|
|
protected:
|
|
|
|
|
|
int sync (
|
|
)
|
|
{
|
|
int num = static_cast<int>(pptr()-pbase());
|
|
if (num != 0)
|
|
{
|
|
check_for_matlab_ctrl_c();
|
|
|
|
buf[num] = 0; // null terminate the string
|
|
mexPrintf("%s",&buf[0]);
|
|
mexEvalString("drawnow"); // flush print to screen
|
|
pbump(-num);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int_type overflow (
|
|
int_type c
|
|
)
|
|
{
|
|
if (c != EOF)
|
|
{
|
|
*pptr() = c;
|
|
pbump(1);
|
|
}
|
|
sync();
|
|
return c;
|
|
}
|
|
|
|
private:
|
|
std::vector<char> buf;
|
|
std::streambuf* oldbuf;
|
|
|
|
};
|
|
|
|
class mex_warn_streambuf : public std::streambuf
|
|
{
|
|
|
|
public:
|
|
mex_warn_streambuf (
|
|
)
|
|
{
|
|
buf.resize(1000);
|
|
setp(&buf[0], &buf[0] + buf.size()-2);
|
|
|
|
// make cout send data to mex_warn_streambuf
|
|
oldbuf = std::cerr.rdbuf(this);
|
|
}
|
|
|
|
~mex_warn_streambuf()
|
|
{
|
|
// put cerr back to the way we found it before running our mex function.
|
|
std::cerr.rdbuf(oldbuf);
|
|
}
|
|
|
|
protected:
|
|
|
|
|
|
int sync (
|
|
)
|
|
{
|
|
int num = static_cast<int>(pptr()-pbase());
|
|
if (num != 0)
|
|
{
|
|
check_for_matlab_ctrl_c();
|
|
|
|
buf[num] = 0; // null terminate the string
|
|
mexWarnMsgTxt(&buf[0]);
|
|
mexEvalString("drawnow"); // flush print to screen
|
|
pbump(-num);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int_type overflow (
|
|
int_type c
|
|
)
|
|
{
|
|
if (c != EOF)
|
|
{
|
|
*pptr() = c;
|
|
pbump(1);
|
|
}
|
|
sync();
|
|
return c;
|
|
}
|
|
|
|
private:
|
|
std::vector<char> buf;
|
|
std::streambuf* oldbuf;
|
|
|
|
};
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
void setup_input_args (
|
|
mxArray*& array,
|
|
const T& item,
|
|
int& nrhs
|
|
)
|
|
{
|
|
assign_to_matlab(array, item);
|
|
++nrhs;
|
|
}
|
|
|
|
void setup_input_args (
|
|
mxArray*& array,
|
|
const function_handle& item,
|
|
int& nrhs
|
|
)
|
|
{
|
|
array = static_cast<mxArray*>(item.h);
|
|
++nrhs;
|
|
}
|
|
|
|
template <typename T>
|
|
void setup_input_args (
|
|
mxArray*& array,
|
|
const output_decorator<T>& item,
|
|
int& nrhs
|
|
)
|
|
{
|
|
}
|
|
|
|
template <typename T>
|
|
void setup_output_args (
|
|
const std::string& function_name,
|
|
mxArray* array,
|
|
const T& item,
|
|
int& nrhs
|
|
)
|
|
{
|
|
}
|
|
|
|
template <typename T>
|
|
void setup_output_args (
|
|
const std::string& function_name,
|
|
mxArray* array,
|
|
const output_decorator<T>& item,
|
|
int& i
|
|
)
|
|
{
|
|
try
|
|
{
|
|
validate_and_populate_arg(i,array,const_cast<T&>(item.item));
|
|
++i;
|
|
}
|
|
catch (invalid_args_exception& e)
|
|
{
|
|
throw dlib::error("Error occurred calling MATLAB function '" + function_name + "' from mex file. \n"
|
|
"The MATLAB function didn't return what we expected it to. \nIn particular, return" + string(e.what()));
|
|
}
|
|
}
|
|
|
|
void call_matlab_for_real (
|
|
int nlhs,
|
|
mxArray* plhs[],
|
|
int nrhs,
|
|
mxArray* prhs[],
|
|
const std::string& function_name
|
|
)
|
|
{
|
|
int status = mexCallMATLAB(nlhs, plhs, nrhs, prhs, function_name.c_str());
|
|
if (status)
|
|
{
|
|
throw dlib::error("Error, an exception was thrown when we tried to call the MATLAB function '" + function_name + "'.");
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
namespace dlib
|
|
{
|
|
void call_matlab (
|
|
const std::string& function_name
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
|
|
call_matlab_for_real(0,NULL,0,NULL, function_name);
|
|
}
|
|
|
|
template <typename T1>
|
|
void free_callback_resources (
|
|
int nlhs,
|
|
mxArray* plhs[],
|
|
int nrhs,
|
|
mxArray* prhs[]
|
|
)
|
|
{
|
|
// free resources
|
|
for (int i = 0; i < nlhs; ++i)
|
|
mxDestroyArray(plhs[i]);
|
|
|
|
for (int i = 0; i < nrhs; ++i)
|
|
{
|
|
// don't call mxDestroyArray() on function handles (which should only ever be in prhs[0])
|
|
if (i == 0 && dlib::is_same_type<T1,function_handle>::value)
|
|
continue;
|
|
mxDestroyArray(prhs[i]);
|
|
}
|
|
}
|
|
|
|
template <
|
|
typename T1
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 1;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 2;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 3;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 4;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 5;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 6;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 7;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 8;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 9;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 10;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 11;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 12;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12,
|
|
typename T13
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12,
|
|
const T13& A13
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 13;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12,
|
|
typename T13,
|
|
typename T14
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12,
|
|
const T13& A13,
|
|
const T14& A14
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 14;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12,
|
|
typename T13,
|
|
typename T14,
|
|
typename T15
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12,
|
|
const T13& A13,
|
|
const T14& A14,
|
|
const T15& A15
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 15;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12,
|
|
typename T13,
|
|
typename T14,
|
|
typename T15,
|
|
typename T16
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12,
|
|
const T13& A13,
|
|
const T14& A14,
|
|
const T15& A15,
|
|
const T16& A16
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 16;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
setup_input_args(prhs[nrhs], A16, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
setup_output_args(function_name, plhs[i], A16, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10,
|
|
typename T11,
|
|
typename T12,
|
|
typename T13,
|
|
typename T14,
|
|
typename T15,
|
|
typename T16,
|
|
typename T17
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1,
|
|
const T2& A2,
|
|
const T3& A3,
|
|
const T4& A4,
|
|
const T5& A5,
|
|
const T6& A6,
|
|
const T7& A7,
|
|
const T8& A8,
|
|
const T9& A9,
|
|
const T10& A10,
|
|
const T11& A11,
|
|
const T12& A12,
|
|
const T13& A13,
|
|
const T14& A14,
|
|
const T15& A15,
|
|
const T16& A16,
|
|
const T17& A17
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 17;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
setup_input_args(prhs[nrhs], A16, nrhs);
|
|
setup_input_args(prhs[nrhs], A17, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
setup_output_args(function_name, plhs[i], A16, i);
|
|
setup_output_args(function_name, plhs[i], A17, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
|
|
typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
|
|
typename T13, typename T14, typename T15, typename T16, typename T17, typename T18
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
|
|
const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const
|
|
T12& A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const
|
|
T17& A17, const T18& A18
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 18;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
setup_input_args(prhs[nrhs], A16, nrhs);
|
|
setup_input_args(prhs[nrhs], A17, nrhs);
|
|
setup_input_args(prhs[nrhs], A18, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
setup_output_args(function_name, plhs[i], A16, i);
|
|
setup_output_args(function_name, plhs[i], A17, i);
|
|
setup_output_args(function_name, plhs[i], A18, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
|
|
typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
|
|
typename T13, typename T14, typename T15, typename T16, typename T17, typename T18,
|
|
typename T19
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
|
|
const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const
|
|
T12& A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const
|
|
T17& A17, const T18& A18, const T19& A19
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 19;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
setup_input_args(prhs[nrhs], A16, nrhs);
|
|
setup_input_args(prhs[nrhs], A17, nrhs);
|
|
setup_input_args(prhs[nrhs], A18, nrhs);
|
|
setup_input_args(prhs[nrhs], A19, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
setup_output_args(function_name, plhs[i], A16, i);
|
|
setup_output_args(function_name, plhs[i], A17, i);
|
|
setup_output_args(function_name, plhs[i], A18, i);
|
|
setup_output_args(function_name, plhs[i], A19, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
template <
|
|
typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
|
|
typename T7, typename T8, typename T9, typename T10, typename T11, typename T12,
|
|
typename T13, typename T14, typename T15, typename T16, typename T17, typename T18,
|
|
typename T19, typename T20
|
|
>
|
|
void call_matlab (
|
|
const std::string& function_name,
|
|
const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
|
|
const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const
|
|
T12& A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const
|
|
T17& A17, const T18& A18, const T19& A19, const T20& A20
|
|
)
|
|
{
|
|
using namespace mex_binding;
|
|
const int num_args = 20;
|
|
mxArray* plhs[num_args] = {0};
|
|
mxArray* prhs[num_args] = {0};
|
|
|
|
int nrhs = 0;
|
|
setup_input_args(prhs[nrhs], A1, nrhs);
|
|
setup_input_args(prhs[nrhs], A2, nrhs);
|
|
setup_input_args(prhs[nrhs], A3, nrhs);
|
|
setup_input_args(prhs[nrhs], A4, nrhs);
|
|
setup_input_args(prhs[nrhs], A5, nrhs);
|
|
setup_input_args(prhs[nrhs], A6, nrhs);
|
|
setup_input_args(prhs[nrhs], A7, nrhs);
|
|
setup_input_args(prhs[nrhs], A8, nrhs);
|
|
setup_input_args(prhs[nrhs], A9, nrhs);
|
|
setup_input_args(prhs[nrhs], A10, nrhs);
|
|
setup_input_args(prhs[nrhs], A11, nrhs);
|
|
setup_input_args(prhs[nrhs], A12, nrhs);
|
|
setup_input_args(prhs[nrhs], A13, nrhs);
|
|
setup_input_args(prhs[nrhs], A14, nrhs);
|
|
setup_input_args(prhs[nrhs], A15, nrhs);
|
|
setup_input_args(prhs[nrhs], A16, nrhs);
|
|
setup_input_args(prhs[nrhs], A17, nrhs);
|
|
setup_input_args(prhs[nrhs], A18, nrhs);
|
|
setup_input_args(prhs[nrhs], A19, nrhs);
|
|
setup_input_args(prhs[nrhs], A20, nrhs);
|
|
|
|
const int nlhs = num_args - nrhs;
|
|
call_matlab_for_real(nlhs,plhs,nrhs,prhs, function_name);
|
|
|
|
int i = 0;
|
|
setup_output_args(function_name, plhs[i], A1, i);
|
|
setup_output_args(function_name, plhs[i], A2, i);
|
|
setup_output_args(function_name, plhs[i], A3, i);
|
|
setup_output_args(function_name, plhs[i], A4, i);
|
|
setup_output_args(function_name, plhs[i], A5, i);
|
|
setup_output_args(function_name, plhs[i], A6, i);
|
|
setup_output_args(function_name, plhs[i], A7, i);
|
|
setup_output_args(function_name, plhs[i], A8, i);
|
|
setup_output_args(function_name, plhs[i], A9, i);
|
|
setup_output_args(function_name, plhs[i], A10, i);
|
|
setup_output_args(function_name, plhs[i], A11, i);
|
|
setup_output_args(function_name, plhs[i], A12, i);
|
|
setup_output_args(function_name, plhs[i], A13, i);
|
|
setup_output_args(function_name, plhs[i], A14, i);
|
|
setup_output_args(function_name, plhs[i], A15, i);
|
|
setup_output_args(function_name, plhs[i], A16, i);
|
|
setup_output_args(function_name, plhs[i], A17, i);
|
|
setup_output_args(function_name, plhs[i], A18, i);
|
|
setup_output_args(function_name, plhs[i], A19, i);
|
|
setup_output_args(function_name, plhs[i], A20, i);
|
|
|
|
free_callback_resources<T1>(nlhs,plhs,nrhs,prhs);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
matlab_object::~matlab_object(
|
|
)
|
|
{
|
|
if (handle && should_free)
|
|
{
|
|
mxDestroyArray((mxArray*)handle);
|
|
handle = 0;
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
matlab_object::
|
|
operator T(
|
|
) const
|
|
{
|
|
T item;
|
|
get(item);
|
|
return item;
|
|
}
|
|
|
|
template <typename T>
|
|
void matlab_object::
|
|
get(
|
|
T& item
|
|
) const
|
|
{
|
|
if (handle == 0)
|
|
throw dlib::invalid_args_exception("An attempt was made to access an empty matlab_object.");
|
|
|
|
mex_binding::validate_and_populate_arg(arg_idx,(mxArray*)handle,item);
|
|
}
|
|
|
|
template <typename T>
|
|
matlab_object& matlab_object::
|
|
operator= (
|
|
const T& new_val
|
|
)
|
|
{
|
|
mxArray* item;
|
|
mex_binding::assign_to_matlab(item, new_val);
|
|
handle = item;
|
|
should_free = true;
|
|
return *this;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
template <typename T>
|
|
matlab_struct::sub::operator T() const
|
|
{
|
|
T item;
|
|
get(item);
|
|
return item;
|
|
}
|
|
|
|
template <typename T>
|
|
void matlab_struct::sub::get(T& item) const
|
|
{
|
|
if (struct_handle == 0)
|
|
throw dlib::error("Attempt to access data in an empty struct.");
|
|
|
|
mxArray* temp = mxGetFieldByNumber((const mxArray*)struct_handle, 0, field_idx);
|
|
if (temp == 0)
|
|
throw dlib::error("Attempt to access data in an empty struct.");
|
|
|
|
try
|
|
{
|
|
mex_binding::validate_and_populate_arg(0,temp,item);
|
|
}
|
|
catch(mex_binding::invalid_args_exception& e)
|
|
{
|
|
std::ostringstream sout;
|
|
sout << "Struct field '" << mxGetFieldNameByNumber((const mxArray*)struct_handle, field_idx) << "' can't be interpreted as the requested type."
|
|
<< endl << e.what();
|
|
throw dlib::error(sout.str());
|
|
}
|
|
}
|
|
|
|
const matlab_struct::sub matlab_struct::
|
|
operator[] (const std::string& name) const
|
|
{
|
|
if (struct_handle == 0)
|
|
throw dlib::error("Struct does not have a field named '" + name + "'.");
|
|
|
|
matlab_struct::sub temp;
|
|
temp.struct_handle = struct_handle;
|
|
temp.field_idx = mxGetFieldNumber((const mxArray*)struct_handle, name.c_str());
|
|
if (temp.field_idx == -1 )
|
|
throw dlib::error("Struct does not have a field named '" + name + "'.");
|
|
return temp;
|
|
}
|
|
|
|
matlab_struct::sub matlab_struct::
|
|
operator[] (const std::string& name)
|
|
{
|
|
if (struct_handle == 0)
|
|
{
|
|
// We make a struct from scratch and mark that we will free it unless it gets
|
|
// written back to matlab by assign_to_matlab().
|
|
mwSize dims[1] = {1};
|
|
const char* name_str = name.c_str();
|
|
struct_handle = mxCreateStructArray(1, dims, 1, &name_str);
|
|
should_free = true;
|
|
if (struct_handle == 0)
|
|
throw dlib::error("Error creating struct from within mex function.");
|
|
}
|
|
|
|
|
|
matlab_struct::sub temp;
|
|
temp.struct_handle = struct_handle;
|
|
if ((temp.field_idx=mxGetFieldNumber((mxArray*)struct_handle, name.c_str())) == -1)
|
|
{
|
|
if ((temp.field_idx=mxAddField((mxArray*)struct_handle, name.c_str())) == -1)
|
|
{
|
|
throw dlib::error("Unable to add field '"+name + "' to struct.");
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
const matlab_struct::sub matlab_struct::sub::
|
|
operator[] (const std::string& name) const
|
|
{
|
|
if (struct_handle == 0)
|
|
throw dlib::error("Struct does not have a field named '" + name + "'.");
|
|
|
|
matlab_struct::sub temp;
|
|
temp.struct_handle = mxGetFieldByNumber((const mxArray*)struct_handle, 0, field_idx);
|
|
if (temp.struct_handle == 0)
|
|
throw dlib::error("Failure to get struct field while calling mxGetFieldByNumber()");
|
|
|
|
if (!mxIsStruct((const mxArray*)temp.struct_handle))
|
|
throw dlib::error("Struct sub-field element '"+name+"' is not another struct.");
|
|
|
|
temp.field_idx = mxGetFieldNumber((const mxArray*)temp.struct_handle, name.c_str());
|
|
if (temp.field_idx == -1 )
|
|
throw dlib::error("Struct does not have a field named '" + name + "'.");
|
|
return temp;
|
|
}
|
|
|
|
matlab_struct::sub matlab_struct::sub::
|
|
operator[] (const std::string& name)
|
|
{
|
|
if (struct_handle == 0)
|
|
throw dlib::error("Struct does not have a field named '" + name + "'.");
|
|
|
|
matlab_struct::sub temp;
|
|
temp.struct_handle = mxGetFieldByNumber((const mxArray*)struct_handle, 0, field_idx);
|
|
// We are replacing this field with a struct if it exists and isn't already a struct
|
|
if (temp.struct_handle != 0 && !mxIsStruct((const mxArray*)temp.struct_handle))
|
|
{
|
|
mxDestroyArray((mxArray*)temp.struct_handle);
|
|
temp.struct_handle = 0;
|
|
}
|
|
if (temp.struct_handle == 0)
|
|
{
|
|
mwSize dims[1] = {1};
|
|
temp.struct_handle = mxCreateStructArray(1, dims, 0, 0);
|
|
if (temp.struct_handle == 0)
|
|
throw dlib::error("Failure to create new sub-struct field");
|
|
mxSetFieldByNumber((mxArray*)struct_handle, 0, field_idx, (mxArray*)temp.struct_handle);
|
|
}
|
|
|
|
|
|
if ((temp.field_idx=mxGetFieldNumber((mxArray*)temp.struct_handle, name.c_str())) == -1)
|
|
{
|
|
if ((temp.field_idx=mxAddField((mxArray*)temp.struct_handle, name.c_str())) == -1)
|
|
{
|
|
throw dlib::error("Unable to add field '"+name + "' to struct.");
|
|
}
|
|
}
|
|
return temp;
|
|
}
|
|
|
|
bool matlab_struct::has_field (
|
|
const std::string& name
|
|
) const
|
|
{
|
|
if (struct_handle == 0)
|
|
return false;
|
|
return mxGetFieldNumber((const mxArray*)struct_handle, name.c_str()) != -1;
|
|
}
|
|
|
|
bool matlab_struct::sub::has_field (
|
|
const std::string& name
|
|
) const
|
|
{
|
|
if (struct_handle == 0)
|
|
return false;
|
|
mxArray* temp = mxGetFieldByNumber((const mxArray*)struct_handle, 0, field_idx);
|
|
if (temp == 0 || !mxIsStruct(temp))
|
|
return false;
|
|
return mxGetFieldNumber(temp, name.c_str()) != -1;
|
|
}
|
|
|
|
template <typename T>
|
|
matlab_struct::sub& matlab_struct::sub::operator= (
|
|
const T& new_val
|
|
)
|
|
{
|
|
// Delete anything in the field before we overwrite it
|
|
mxArray* item = mxGetFieldByNumber((mxArray*)struct_handle, 0, field_idx);
|
|
if (item != 0)
|
|
{
|
|
mxDestroyArray((mxArray*)item);
|
|
item = 0;
|
|
}
|
|
|
|
// Now set the field
|
|
mex_binding::assign_to_matlab(item, new_val);
|
|
mxSetFieldByNumber((mxArray*)struct_handle, 0, field_idx, item);
|
|
|
|
return *this;
|
|
}
|
|
|
|
matlab_struct::
|
|
~matlab_struct (
|
|
)
|
|
{
|
|
if (struct_handle && should_free)
|
|
{
|
|
mxDestroyArray((mxArray*)struct_handle);
|
|
struct_handle = 0;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
void call_matlab (
|
|
const function_handle& funct
|
|
)
|
|
{
|
|
call_matlab("feval", funct);
|
|
}
|
|
|
|
extern "C" bool utIsInterruptPending();
|
|
void check_for_matlab_ctrl_c(
|
|
)
|
|
{
|
|
if (utIsInterruptPending())
|
|
throw mex_binding::user_hit_ctrl_c();
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
#ifdef MEX_CLASS_NAME
|
|
template <typename T, typename mfp_type>
|
|
class mex_class_wrapper
|
|
{
|
|
public:
|
|
mex_class_wrapper(T& obj_, mfp_type mfp_) : obj(obj_), mfp(mfp_) {}
|
|
|
|
template <typename... Args>
|
|
void operator()(Args&&... args) const
|
|
{
|
|
(obj.*mfp)(std::forward<Args>(args)...);
|
|
}
|
|
|
|
mfp_type mfp;
|
|
T& obj;
|
|
};
|
|
|
|
template <typename T, typename mfp_type>
|
|
mex_class_wrapper<T,mfp_type> wrap_mex_class(T& obj, mfp_type mfp) { return mex_class_wrapper<T,mfp_type>(obj, mfp); }
|
|
|
|
namespace dlib
|
|
{
|
|
template <typename T, typename mfp_type>
|
|
struct sig_traits<mex_class_wrapper<T,mfp_type>>
|
|
: public sig_traits<mfp_type>
|
|
{};
|
|
|
|
template <size_t i, typename T, bool is_good = i < std::tuple_size<T>::value>
|
|
struct tuple_element_default_void
|
|
{
|
|
typedef void type;
|
|
};
|
|
|
|
template <size_t i, typename T>
|
|
struct tuple_element_default_void<i,T,true>
|
|
{
|
|
typedef typename std::tuple_element<i,T>::type type;
|
|
};
|
|
|
|
template <typename class_type, typename return_type, typename... Args>
|
|
struct sig_traits<return_type(class_type::*)(Args...) >
|
|
{
|
|
enum { num_args = sizeof...(Args) };
|
|
|
|
typedef return_type result_type;
|
|
|
|
template <size_t i>
|
|
struct arg
|
|
{
|
|
typedef typename tuple_element_default_void<i-1, std::tuple<Args...>>::type type;
|
|
};
|
|
|
|
// These are here because that's how things are defined in sig_traits (since it is
|
|
// older than C++11, along with most of the other code in this file)
|
|
typedef typename arg<1>::type arg1_type;
|
|
typedef typename arg<2>::type arg2_type;
|
|
typedef typename arg<3>::type arg3_type;
|
|
typedef typename arg<4>::type arg4_type;
|
|
typedef typename arg<5>::type arg5_type;
|
|
typedef typename arg<6>::type arg6_type;
|
|
typedef typename arg<7>::type arg7_type;
|
|
typedef typename arg<8>::type arg8_type;
|
|
typedef typename arg<9>::type arg9_type;
|
|
typedef typename arg<10>::type arg10_type;
|
|
typedef typename arg<11>::type arg11_type;
|
|
typedef typename arg<12>::type arg12_type;
|
|
typedef typename arg<13>::type arg13_type;
|
|
typedef typename arg<14>::type arg14_type;
|
|
typedef typename arg<15>::type arg15_type;
|
|
typedef typename arg<16>::type arg16_type;
|
|
typedef typename arg<17>::type arg17_type;
|
|
typedef typename arg<18>::type arg18_type;
|
|
typedef typename arg<19>::type arg19_type;
|
|
typedef typename arg<20>::type arg20_type;
|
|
};
|
|
|
|
template <typename class_type, typename return_type, typename... Args>
|
|
struct sig_traits<return_type(class_type::*)(Args...) const>
|
|
{
|
|
enum { num_args = sizeof...(Args) };
|
|
|
|
typedef return_type result_type;
|
|
|
|
template <size_t i>
|
|
struct arg
|
|
{
|
|
typedef typename tuple_element_default_void<i-1, std::tuple<Args...>>::type type;
|
|
};
|
|
|
|
// These are here because that's how things are defined in sig_traits (since it is
|
|
// older than C++11, along with most of the other code in this file)
|
|
typedef typename arg<1>::type arg1_type;
|
|
typedef typename arg<2>::type arg2_type;
|
|
typedef typename arg<3>::type arg3_type;
|
|
typedef typename arg<4>::type arg4_type;
|
|
typedef typename arg<5>::type arg5_type;
|
|
typedef typename arg<6>::type arg6_type;
|
|
typedef typename arg<7>::type arg7_type;
|
|
typedef typename arg<8>::type arg8_type;
|
|
typedef typename arg<9>::type arg9_type;
|
|
typedef typename arg<10>::type arg10_type;
|
|
typedef typename arg<11>::type arg11_type;
|
|
typedef typename arg<12>::type arg12_type;
|
|
typedef typename arg<13>::type arg13_type;
|
|
typedef typename arg<14>::type arg14_type;
|
|
typedef typename arg<15>::type arg15_type;
|
|
typedef typename arg<16>::type arg16_type;
|
|
typedef typename arg<17>::type arg17_type;
|
|
typedef typename arg<18>::type arg18_type;
|
|
typedef typename arg<19>::type arg19_type;
|
|
typedef typename arg<20>::type arg20_type;
|
|
};
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
|
|
template <size_t I>
|
|
struct visit_impl
|
|
{
|
|
template <typename T, typename F>
|
|
static void visit(T& tup, size_t idx, F fun)
|
|
{
|
|
if (idx == I - 1) fun(std::get<I - 1>(tup));
|
|
else visit_impl<I - 1>::visit(tup, idx, fun);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct visit_impl<0>
|
|
{
|
|
template <typename T, typename F>
|
|
static void visit(T& tup, size_t idx, F fun) { DLIB_CASSERT(false,"this should never happen"); }
|
|
};
|
|
|
|
template <typename F, typename... Ts>
|
|
void visit_at(std::tuple<Ts...> const& tup, size_t idx, F fun)
|
|
{
|
|
visit_impl<sizeof...(Ts)>::visit(tup, idx, fun);
|
|
}
|
|
|
|
template <typename F, typename... Ts>
|
|
void visit_at(std::tuple<Ts...>& tup, size_t idx, F fun)
|
|
{
|
|
visit_impl<sizeof...(Ts)>::visit(tup, idx, fun);
|
|
}
|
|
|
|
class mex_class_dispatch
|
|
{
|
|
public:
|
|
mex_class_dispatch(
|
|
MEX_CLASS_NAME* ptr_,
|
|
int nlhs_,
|
|
mxArray** plhs_,
|
|
int nrhs_,
|
|
const mxArray** prhs_
|
|
) :
|
|
ptr(ptr_),
|
|
nlhs(nlhs_),
|
|
plhs(plhs_),
|
|
nrhs(nrhs_),
|
|
prhs(prhs_)
|
|
{}
|
|
|
|
template <typename funct>
|
|
void operator() (const funct& mfp)
|
|
{
|
|
mex_binding::call_mex_function(wrap_mex_class(*ptr,mfp), nlhs, plhs, nrhs, prhs);
|
|
}
|
|
|
|
private:
|
|
MEX_CLASS_NAME* ptr;
|
|
int nlhs;
|
|
mxArray** plhs;
|
|
int nrhs;
|
|
const mxArray** prhs;
|
|
};
|
|
|
|
class class_factory_type : dlib::noncopyable
|
|
{
|
|
/*!
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This is a container class for all the MEX_CLASS_NAME objects we create. It allows
|
|
us to track what we have created and make sure the MATLAB user doesn't do any
|
|
double frees or use any stale pointers.
|
|
|
|
It also helps us deal with the problem that would otherwise arise when a mex file
|
|
is unloaded from MATLAB when there are still active pointers to MEX_CLASS_NAME objects
|
|
in MATLAB, since we will be able to detect stale pointers.
|
|
!*/
|
|
public:
|
|
|
|
class_factory_type()
|
|
{
|
|
seed = (uint64)time(0);
|
|
}
|
|
|
|
~class_factory_type()
|
|
{
|
|
for (auto i : object_table)
|
|
delete i.second;
|
|
}
|
|
|
|
template <typename ...T>
|
|
uint64 create(T&& ...args)
|
|
{
|
|
MEX_CLASS_NAME* item = new MEX_CLASS_NAME(std::forward<T>(args)...);
|
|
uint64 id = (uint64)item;
|
|
// Now generate a unique id that incorporates our seed value. The point of doing
|
|
// this is to avoid any chance that a mex file will get unloaded and then reloaded
|
|
// and start constructing objects with the same addresses, while old stale objects
|
|
// at those addresses are still stored in matlab, which would then call into the
|
|
// mex file and make things go crazy. So here we try to generate ID numbers that
|
|
// are globally unique.
|
|
uint64 i = 0;
|
|
id = murmur_hash3_128bit_3(id, seed, ++i).first;
|
|
// very unlikely but make sure there aren't any hash collisions.
|
|
while(object_table.count(id) != 0)
|
|
id = murmur_hash3_128bit_3(id, seed, ++i).first;
|
|
|
|
object_table[id] = item;
|
|
return id;
|
|
}
|
|
|
|
void free(uint64 item)
|
|
{
|
|
if (object_table.count(item) == 0)
|
|
{
|
|
throw dlib::error("An attempt to deallocate a mex class object with an invalid pointer was detected.");
|
|
}
|
|
|
|
delete object_table[item];
|
|
object_table.erase(item);
|
|
}
|
|
|
|
MEX_CLASS_NAME* access(uint64 item) // convert numeric ID to pointer to object that can be used.
|
|
{
|
|
if (object_table.count(item) == 0)
|
|
{
|
|
throw dlib::error("An attempt to access a mex class object with an invalid pointer was detected.");
|
|
}
|
|
|
|
return object_table[item];
|
|
}
|
|
|
|
private:
|
|
|
|
std::map<uint64, MEX_CLASS_NAME*> object_table;
|
|
uint64 seed;
|
|
} class_factory;
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
// Make a FOREACH macro
|
|
#define FE_1(WHAT, X) WHAT(X)
|
|
#define FE_2(WHAT, X, ...) WHAT(X),FE_1(WHAT, __VA_ARGS__)
|
|
#define FE_3(WHAT, X, ...) WHAT(X),FE_2(WHAT, __VA_ARGS__)
|
|
#define FE_4(WHAT, X, ...) WHAT(X),FE_3(WHAT, __VA_ARGS__)
|
|
#define FE_5(WHAT, X, ...) WHAT(X),FE_4(WHAT, __VA_ARGS__)
|
|
#define FE_6(WHAT, X, ...) WHAT(X),FE_5(WHAT, __VA_ARGS__)
|
|
#define FE_7(WHAT, X, ...) WHAT(X),FE_6(WHAT, __VA_ARGS__)
|
|
#define FE_8(WHAT, X, ...) WHAT(X),FE_7(WHAT, __VA_ARGS__)
|
|
#define FE_9(WHAT, X, ...) WHAT(X),FE_8(WHAT, __VA_ARGS__)
|
|
#define FE_10(WHAT, X, ...) WHAT(X),FE_9(WHAT, __VA_ARGS__)
|
|
#define FE_11(WHAT, X, ...) WHAT(X),FE_10(WHAT, __VA_ARGS__)
|
|
#define FE_12(WHAT, X, ...) WHAT(X),FE_11(WHAT, __VA_ARGS__)
|
|
#define FE_13(WHAT, X, ...) WHAT(X),FE_12(WHAT, __VA_ARGS__)
|
|
#define FE_14(WHAT, X, ...) WHAT(X),FE_13(WHAT, __VA_ARGS__)
|
|
#define FE_15(WHAT, X, ...) WHAT(X),FE_14(WHAT, __VA_ARGS__)
|
|
#define FE_16(WHAT, X, ...) WHAT(X),FE_15(WHAT, __VA_ARGS__)
|
|
#define FE_17(WHAT, X, ...) WHAT(X),FE_16(WHAT, __VA_ARGS__)
|
|
#define FE_18(WHAT, X, ...) WHAT(X),FE_17(WHAT, __VA_ARGS__)
|
|
#define FE_19(WHAT, X, ...) WHAT(X),FE_18(WHAT, __VA_ARGS__)
|
|
#define FE_20(WHAT, X, ...) WHAT(X),FE_19(WHAT, __VA_ARGS__)
|
|
//... repeat as needed
|
|
#define GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,NAME,...) NAME
|
|
#define FOR_EACH(action,...) GET_MACRO(__VA_ARGS__,FE_20,FE_19,FE_18,FE_17,FE_16,FE_15,FE_14,FE_13,FE_12,FE_11,FE_10,FE_9,FE_8,FE_7,FE_6,FE_5,FE_4,FE_3,FE_2,FE_1)(action,__VA_ARGS__)
|
|
#define MEX_CLASS_ANNOTATE(x) &MEX_CLASS_NAME::x
|
|
|
|
// Now make a tuple containing all the member function pointers to our MEX_CLASS_NAME
|
|
auto mex_class_methods = std::make_tuple(FOR_EACH(MEX_CLASS_ANNOTATE, MEX_CLASS_METHODS));
|
|
|
|
|
|
#endif // MEX_CLASS_NAME
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
bool is_string(const mxArray* arr, const char* str)
|
|
{
|
|
if (mxIsChar(arr))
|
|
{
|
|
char ch[20];
|
|
DLIB_CASSERT(mxGetString(arr, ch, sizeof(ch))==0, "Unable to retrieve string");
|
|
ch[sizeof(ch)-1] = 0;// ensure NULL termination regardless of what MATLAB does.
|
|
return strcmp(str,ch)==0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|
|
/* The gateway function called by MATLAB*/
|
|
void mexFunction( int nlhs, mxArray *plhs[],
|
|
int nrhs, const mxArray *prhs[])
|
|
{
|
|
// Only remap cout and cerr if we aren't using octave since octave already does this.
|
|
#if !defined(OCTAVE_IMPORT) && !defined(OCTAVE_API)
|
|
// make it so cout prints to mexPrintf()
|
|
mex_binding::mex_streambuf sb;
|
|
// make it so cerr prints to mexWarnMsgTxt()
|
|
mex_binding::mex_warn_streambuf wsb;
|
|
#endif
|
|
|
|
try
|
|
{
|
|
#ifdef MEX_CLASS_NAME
|
|
if (nrhs == 0)
|
|
{
|
|
#define DEF2STR(x) DEF2STR2((x))
|
|
#define DEF2STR2(x) #x
|
|
|
|
string classname = trim(string(DEF2STR(MEX_CLASS_NAME)), " \t()");
|
|
std::vector<string> methods = split(trim(string(DEF2STR(MEX_CLASS_METHODS)), " \t()"), " \t,");
|
|
|
|
string mex_filename = trim(string(DEF2STR(MEX_FILENAME))," \t()");
|
|
bool has_load_obj = false;
|
|
size_t load_obj_idx = 0;
|
|
|
|
cout << "classdef " << classname << " < handle\n"
|
|
<< " properties (Access = private)\n"
|
|
<< " cpp_ptr\n"
|
|
<< " end\n"
|
|
<< "\n"
|
|
<< " methods\n"
|
|
<< " function this = "<<classname<<"()\n"
|
|
<< " this.cpp_ptr = "<<mex_filename<<"('construct');\n"
|
|
<< " end\n"
|
|
<< "\n"
|
|
<< " function copied_obj = clone(this)\n"
|
|
<< " %Returns a new independent object that is a copy of this.\n"
|
|
<< " copied_obj = "<<classname<<"();\n"
|
|
<< " copied_obj.cpp_ptr = "<<mex_filename<<"(this.cpp_ptr,'clone');\n"
|
|
<< " end\n"
|
|
<< "\n";
|
|
for (size_t i = 0; i < methods.size(); ++i)
|
|
{
|
|
if (methods[i] == "load_obj")
|
|
{
|
|
has_load_obj = true;
|
|
load_obj_idx = i;
|
|
}
|
|
else
|
|
{
|
|
cout << " function varargout = "<<methods[i]<<"(this, varargin) \n"
|
|
<< " [varargout{1:nargout}] = "<<mex_filename<<"(this.cpp_ptr, "<<i+1<<", varargin{:}); \n"
|
|
<< " end \n\n";
|
|
}
|
|
}
|
|
cout << " end\n\n";
|
|
|
|
cout << " methods(Access=private) \n"
|
|
<< " function delete(this) \n"
|
|
<< " "<<mex_filename<<"(this.cpp_ptr); \n"
|
|
<< " end \n";
|
|
if (has_load_obj)
|
|
{
|
|
cout << " function varargout = load_obj(this, varargin) \n"
|
|
<< " [varargout{1:nargout}] = "<<mex_filename<<"(this.cpp_ptr, "<<load_obj_idx+1<<", varargin{:}); \n"
|
|
<< " end \n";
|
|
}
|
|
cout << " end \n\n";
|
|
|
|
if (has_load_obj)
|
|
{
|
|
cout << " methods(Static) \n"
|
|
<< " function this = loadobj(in) \n"
|
|
<< " this = "<<classname<<"(); \n"
|
|
<< " this.load_obj(in); \n"
|
|
<< " end \n"
|
|
<< " end \n";
|
|
}
|
|
cout << "end \n";
|
|
}
|
|
else if (nrhs == 1)
|
|
{
|
|
// this is a constructor call
|
|
if (is_string(prhs[0],"construct"))
|
|
{
|
|
DLIB_CASSERT(nlhs == 1, "If you want to construct a new object then you must assign the pointer to something.");
|
|
plhs[0] = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
|
|
uint64* ptr_int = (uint64*)mxGetData(plhs[0]);
|
|
*ptr_int = class_factory.create();
|
|
}
|
|
else // destructor call
|
|
{
|
|
DLIB_CASSERT(mxIsUint64(prhs[0]) && mxGetNumberOfElements(prhs[0])==1, "When calling a class destructor the first argument must be a pointer (a UINT64 in matlab)");
|
|
const uint64 ptr_int = *((uint64*)mxGetData(prhs[0]));
|
|
class_factory.free(ptr_int);
|
|
}
|
|
}
|
|
else // a regular function call
|
|
{
|
|
DLIB_CASSERT(mxIsUint64(prhs[0]) && mxGetNumberOfElements(prhs[0])==1, "When calling a class member function the first argument must be a pointer (a UINT64 in matlab)");
|
|
if (is_string(prhs[1], "clone"))
|
|
{
|
|
DLIB_CASSERT(nlhs == 1, "If you want to construct a new object then you must assign the pointer to something.");
|
|
const uint64 ptr_int = *((uint64*)mxGetData(prhs[0]));
|
|
|
|
MEX_CLASS_NAME* ptr = class_factory.access(ptr_int);
|
|
|
|
plhs[0] = mxCreateNumericMatrix(1, 1, mxUINT64_CLASS, mxREAL);
|
|
uint64* ptr_int2 = (uint64*)mxGetData(plhs[0]);
|
|
// copy construct a new object
|
|
*ptr_int2 = class_factory.create(*ptr);
|
|
}
|
|
else
|
|
{
|
|
DLIB_CASSERT(mxIsDouble(prhs[1]) && mxGetNumberOfElements(prhs[1])==1, "When calling a class member function the second argument must be a number indicating which member function");
|
|
const uint64 ptr_int = *((uint64*)mxGetData(prhs[0]));
|
|
const int funct_idx = *(mxGetPr(prhs[1]));
|
|
|
|
auto num_registered_functions = std::tuple_size<decltype(mex_class_methods)>::value;
|
|
DLIB_CASSERT(1 <= funct_idx && funct_idx <= num_registered_functions, "Invalid function index provided.");
|
|
|
|
MEX_CLASS_NAME* ptr = class_factory.access(ptr_int);
|
|
|
|
// we used the first two arguments to decide what function to call. So adjust nrhs
|
|
// and prhs so the member function never sees them.
|
|
mex_class_dispatch dispatch(ptr, nlhs, plhs, nrhs-2, prhs+2);
|
|
// now invoke the member function, subtract 1 to convert to 0 indexing.
|
|
visit_at(mex_class_methods, funct_idx-1, dispatch);
|
|
}
|
|
}
|
|
#else
|
|
mex_binding::call_mex_function(mex_function, nlhs, plhs, nrhs, prhs);
|
|
#endif
|
|
}
|
|
catch (mex_binding::invalid_args_exception& e)
|
|
{
|
|
mexErrMsgIdAndTxt("mex_function:validate_and_populate_arg",
|
|
mex_binding::escape_percent(e.what()).c_str());
|
|
}
|
|
catch (mex_binding::user_hit_ctrl_c& )
|
|
{
|
|
// do nothing, just return to matlab
|
|
}
|
|
catch (std::exception& e)
|
|
{
|
|
mexErrMsgIdAndTxt("mex_function:error",
|
|
mex_binding::escape_percent(e.what()).c_str());
|
|
}
|
|
|
|
cout << flush;
|
|
cerr << flush;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------
|
|
|