jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

scilab: add vector<enum> in li_std_sequence_container_typemaps test

Browse source
This commit is contained in:
Simon Marchetto 2014-02-27 17:26:16 +01:00
commit fb5f4b3b9a
2 changed files with 73 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

54
Examples/test-suite/li_std_sequence_container_typemaps.i
View file

@ -24,9 +24,12 @@ public:
typedef ClassA* ClassAPtr; typedef ClassA* ClassAPtr;
enum _Color { RED=1, GREEN=10, YELLOW=11, BLUE=100, MAGENTA=101, CYAN=111 };
typedef enum _Color Color;
namespace std { namespace std {
template<typename T> T binaryOperation(T x, T y) { template<typename T> T binaryOperation(T x, T y) {
return x + y; return static_cast<T>(x + y);
} }
template<> bool binaryOperation(bool x, bool y) { template<> bool binaryOperation(bool x, bool y) {
@ -42,8 +45,11 @@ namespace std {
struct sequence_container { struct sequence_container {
typedef typename SeqCont::value_type value_type; typedef typename SeqCont::value_type value_type;
static SeqCont ret_container(const int size, const value_type value) { static SeqCont ret_container(const value_type value1, const value_type value2) {
return SeqCont(size, value); SeqCont s;
s.push_back(value1);
s.push_back(value2);
return s;
} }
static value_type val_container(const SeqCont container) { static value_type val_container(const SeqCont container) {
@ -55,40 +61,32 @@ namespace std {
return std::accumulate(container.begin(), container.end(), container.front(), return std::accumulate(container.begin(), container.end(), container.front(),
binaryOperation<value_type>); binaryOperation<value_type>);
} }
/*SeqCont ret_val_containers(const SeqCont container,
const SeqCont other_container) {
SeqCont out_container(container);
out_container.insert(out_container.end(), other_container.begin(),
other_container.end());
return out_container;
}*/
}; };
template<typename T> template<typename T>
std::vector<T> ret_vector(const int size, const T value) { std::vector<T> ret_vector(const T value1, const T value2) {
return sequence_container<std::vector<T> >::ret_container(size, value); return sequence_container<std::vector<T> >::ret_container(value1, value2);
} }
template<typename T> template<typename T>
T val_vector(const std::vector<T> container) { T val_vector(const std::vector<T> container) {
return sequence_container<std::vector<T> >::val_container(container); return sequence_container<std::vector<T> >::val_container(container);
} }
template<typename T> template<typename T>
T ref_vector(const std::vector<T>& container) { T ref_vector(const std::vector<T>& container) {
return sequence_container<std::vector<T> >::ref_container(container); return sequence_container<std::vector<T> >::ref_container(container);
} }
template<typename T> template<typename T>
std::list<T> ret_list(const int size, const T value) { std::list<T> ret_list(const T value1, const T value2) {
return sequence_container<std::list<T> >::ret_container(size, value); return sequence_container<std::list<T> >::ret_container(value1, value2);
} }
template<typename T> template<typename T>
T val_list(const std::list<T> container) { T val_list(const std::list<T> container) {
return sequence_container<std::list<T> >::val_container(container); return sequence_container<std::list<T> >::val_container(container);
} }
template<typename T> template<typename T>
T ref_list(const std::list<T>& container) { T ref_list(const std::list<T>& container) {
return sequence_container<std::list<T> >::ref_container(container); return sequence_container<std::list<T> >::ref_container(container);
} }
} }
%} %}
@ -97,22 +95,32 @@ namespace std {
namespace std namespace std
{ {
%template(TYPE ## _vector) std::vector<TYPE>; %template(TYPE ## _vector) std::vector<TYPE>;
%template(TYPE ## _list) std::list<TYPE>;
}
%enddef
%define instantiate_containers_functions(TYPE...)
namespace std
{
%template(ret_ ## TYPE ## _vector) ret_vector<TYPE>; %template(ret_ ## TYPE ## _vector) ret_vector<TYPE>;
%template(val_ ## TYPE ## _vector) val_vector<TYPE>; %template(val_ ## TYPE ## _vector) val_vector<TYPE>;
%template(ref_ ## TYPE ## _vector) ref_vector<TYPE>; %template(ref_ ## TYPE ## _vector) ref_vector<TYPE>;
%template(TYPE ## _list) std::list<TYPE>;
%template(ret_ ## TYPE ## _list) ret_list<TYPE>; %template(ret_ ## TYPE ## _list) ret_list<TYPE>;
%template(val_ ## TYPE ## _list) val_list<TYPE>; %template(val_ ## TYPE ## _list) val_list<TYPE>;
%template(ref_ ## TYPE ## _list) ref_list<TYPE>; %template(ref_ ## TYPE ## _list) ref_list<TYPE>;
} }
%enddef %enddef
instantiate_containers_templates(int); instantiate_containers_templates(int);
instantiate_containers_templates(double); instantiate_containers_templates(double);
instantiate_containers_templates(bool); instantiate_containers_templates(bool);
instantiate_containers_templates(string); instantiate_containers_templates(string);
instantiate_containers_templates(Color);
instantiate_containers_templates(ClassAPtr); instantiate_containers_templates(ClassAPtr);
instantiate_containers_functions(int);
instantiate_containers_functions(double);
instantiate_containers_functions(bool);
instantiate_containers_functions(string);
instantiate_containers_functions(Color);
instantiate_containers_functions(ClassAPtr);

81
Examples/test-suite/scilab/li_std_sequence_container_typemaps_runme.sci
View file

@ -2,35 +2,37 @@
exec("swigtest.start", -1); exec("swigtest.start", -1);
// test sequence container of pointers returned from fonction (expected a list)
function [classAPtr_list, classAPtr1, classAPtr2] = testCreateSequenceContainerPtr(container, value1, value2)
classAPtr1 = new_ClassA(value1);
classAPtr2 = new_ClassA(value2);
cmd = msprintf("classAPtr_list = ret_ClassAPtr_%s(classAPtr1, classAPtr2);", container);
ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end
if ~exists('classAPtr_list') | (size(classAPtr_list) <> 2) then swigtesterror(); end
if (ClassA_a_get(classAPtr_list(1)) <> value1) | (ClassA_a_get(classAPtr_list(2)) <> value2) then swigtesterror(); end
endfunction
// test sequence containers of pointers // test sequence containers of pointers
// -container: type of container: "vector", "list"... // -container: type of container: "vector", "list"...
// -value, count: value to store count times in container // -value1, value2: values to store in container
// -expected_accumulate_value: expected value of an accumulation function // -expected_accumulate_value: expected value of an accumulation function
// computed on the container // computed on the container
function testSequenceContainerPtr(container, count, value, expected_accumulate_value) function testSequenceContainerPtr(container, value1, value2, expected_accumulate_value)
// test sequence container returned from fonction (expected a list) // test sequence container of pointers returned from fonction (expected a list)
classAPtr = new_ClassA(value); [classAPtr_list, classAPtr1, classAPtr2] = testCreateSequenceContainerPtr(container, value1, value2);
cmd = msprintf("l = ret_ClassAPtr_%s(count, classAPtr);", container);
ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end
if ~exists('l') | (size(l) <> count) | (ClassA_a_get(l(1)) <> value) then swigtesterror(); end
l2 = l;
// test sequence container passed as value of function // test sequence container passed as value of function
cmd = msprintf("classAPtr = val_ClassAPtr_%s(l);", container); cmd = msprintf("classAPtr = val_ClassAPtr_%s(classAPtr_list);", container);
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end if ierr <> 0 then swigtesterror(); end
if ClassA_a_get(classAPtr) <> expected_accumulate_value then swigtesterror(); end if ClassA_a_get(classAPtr1) <> expected_accumulate_value then swigtesterror(); end
// recreate a container // recreate a container
classAPtr = new_ClassA(value); [classAPtr_list, classAPtr1, classAPtr2] = testCreateSequenceContainerPtr(container, value1, value2);
cmd = msprintf("l = ret_ClassAPtr_%s(count, classAPtr);", container);
ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end
if ~exists('l') | (size(l) <> count) | (ClassA_a_get(l(1)) <> value) then swigtesterror(); end
// test sequence container passed as refererence of function // test sequence container passed as refererence of function
cmd = msprintf("classAPtr = ref_ClassAPtr_%s(l);", container); cmd = msprintf("classAPtr = ref_ClassAPtr_%s(classAPtr_list);", container);
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end if ierr <> 0 then swigtesterror(); end
if ClassA_a_get(classAPtr) <> expected_accumulate_value then swigtesterror(); end if ClassA_a_get(classAPtr) <> expected_accumulate_value then swigtesterror(); end
@ -39,21 +41,22 @@ endfunction
// test sequence containers of primitive type // test sequence containers of primitive type
// -container: type of container: "vector", "list"... // -container: type of container: "vector", "list"...
// -value_type: type of element stored in container: "int", ... // -value_type: type of element stored in container: "int", ...
// -value, count: value to store count times in container // -value1, value2: values to store in container
// -expected_accumulate_value: expected value of an accumulation function // -expected_accumulate_value: expected value of an accumulation function
// computed on the container // computed on the container
function testSequenceContainer(container, value_type, value, count, expected_accumulate_value) function testSequenceContainer(container, value_type, value1, value2, expected_accumulate_value)
// test sequence container returned from fonction (expect a row matrix) // test sequence container of basic type returned from fonction (expect a row matrix)
if value_type = "string" if value_type = "string" then
cmd = msprintf("c = ret_%s_%s(count, ''%s'');", value_type, container, value); cmd = msprintf("c = ret_%s_%s(''%s'', ''%s'');", value_type, container, value1, value2);
elseif value_type = "bool" then elseif value_type = "bool" then
cmd = msprintf("c = ret_%s_%s(count, %s);", value_type, container, "%"+string(value)); cmd = msprintf("c = ret_%s_%s(%s, %s);", value_type, container, "%"+string(value1), "%"+string(value2));
else else
cmd = msprintf("c = ret_%s_%s(count, %d);", value_type, container, value); cmd = msprintf("c = ret_%s_%s(%d, %d);", value_type, container, value1, value2);
end end
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then swigtesterror(); end if ierr <> 0 then swigtesterror(); end
if ~isdef('c') | c <> repmat(value, 1, count) then swigtesterror(); end if ~isdef('c') | c <> [value1, value2] then swigtesterror(); end
// test sequence container passed as value of function // test sequence container passed as value of function
cmd = msprintf("s = val_%s_%s(c);", value_type, container); cmd = msprintf("s = val_%s_%s(c);", value_type, container);
@ -62,8 +65,7 @@ function testSequenceContainer(container, value_type, value, count, expected_acc
if s <> expected_accumulate_value then swigtesterror(); end if s <> expected_accumulate_value then swigtesterror(); end
// test sequence container passed as matrix as value of function // test sequence container passed as matrix as value of function
//m = repmat(value, 1, count); //cmd = msprintf("s = val_%s_%s([value1, value2]);", value_type, container);
//cmd = msprintf("s = val_%s_%s(m);", value_type, container);
//ierr = execstr(cmd, "errcatch"); //ierr = execstr(cmd, "errcatch");
//if ierr <> 0 then swigtesterror(); end //if ierr <> 0 then swigtesterror(); end
//if s <> expected_accumulate_value then swigtesterror(); end //if s <> expected_accumulate_value then swigtesterror(); end
@ -75,26 +77,27 @@ function testSequenceContainer(container, value_type, value, count, expected_acc
if s <> expected_accumulate_value then swigtesterror(); end if s <> expected_accumulate_value then swigtesterror(); end
// test sequence container passed as matrix as reference of function // test sequence container passed as matrix as reference of function
//m = repmat(value, 1, count); //cmd = msprintf("s = val_%s_%s([value1, value2]);", value_type, container);
//cmd = msprintf("s = val_%s_%s(m);", value_type, container);
//ierr = execstr(cmd, "errcatch"); //ierr = execstr(cmd, "errcatch");
//if ierr <> 0 then swigtesterror(); end //if ierr <> 0 then swigtesterror(); end
//if s <> expected_accumulate_value then swigtesterror(); end //if s <> expected_accumulate_value then swigtesterror(); end
endfunction endfunction
// test vector // test vector
testSequenceContainer("vector", "int", 2, 4, 10); testSequenceContainer("vector", "int", 1, 2, 4);
testSequenceContainer("vector", "double", 2., 3., 8.); testSequenceContainer("vector", "double", 2., 3., 7.);
testSequenceContainer("vector", "string", "a", 4, "aaaaa"); testSequenceContainer("vector", "string", "a", "b", "aab");
testSequenceContainer("vector", "bool", %T, 2, %T); testSequenceContainer("vector", "bool", %T, %F, %T);
testSequenceContainerPtr("vector", 1, 3, 6.0); testSequenceContainer("vector", "Color", RED_get(), BLUE_get(), MAGENTA_get());
testSequenceContainerPtr("vector", 1, 3, 5);
// test list // test list
testSequenceContainer("list", "int", 2, 3, 8); testSequenceContainer("list", "int", 1, 2, 4);
testSequenceContainer("list", "double", 2., 4., 10.); testSequenceContainer("list", "double", 2., 3., 7.);
testSequenceContainer("list", "string", "a", 4, "aaaaa"); testSequenceContainer("list", "string", "a", "b", "aab");
testSequenceContainer("list", "bool", %T, 2, %T); testSequenceContainer("list", "bool", %T, %F, %T);
testSequenceContainerPtr("list", 1, 3, 6.0); testSequenceContainer("list", "Color", RED_get(), BLUE_get(), MAGENTA_get());
testSequenceContainerPtr("list", 1, 3, 5);
exec("swigtest.quit", -1); exec("swigtest.quit", -1);