diff --git a/Examples/test-suite/li_std_sequence_container_typemaps.i b/Examples/test-suite/li_std_sequence_container_typemaps.i index 295fcd8eb..b3d1b47dd 100644 --- a/Examples/test-suite/li_std_sequence_container_typemaps.i +++ b/Examples/test-suite/li_std_sequence_container_typemaps.i @@ -24,9 +24,12 @@ public: typedef ClassA* ClassAPtr; +enum _Color { RED=1, GREEN=10, YELLOW=11, BLUE=100, MAGENTA=101, CYAN=111 }; +typedef enum _Color Color; + namespace std { template T binaryOperation(T x, T y) { - return x + y; + return static_cast(x + y); } template<> bool binaryOperation(bool x, bool y) { @@ -42,8 +45,11 @@ namespace std { struct sequence_container { typedef typename SeqCont::value_type value_type; - static SeqCont ret_container(const int size, const value_type value) { - return SeqCont(size, value); + static SeqCont ret_container(const value_type value1, const value_type value2) { + SeqCont s; + s.push_back(value1); + s.push_back(value2); + return s; } static value_type val_container(const SeqCont container) { @@ -55,40 +61,32 @@ namespace std { return std::accumulate(container.begin(), container.end(), container.front(), binaryOperation); } - - /*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 - std::vector ret_vector(const int size, const T value) { - return sequence_container >::ret_container(size, value); + std::vector ret_vector(const T value1, const T value2) { + return sequence_container >::ret_container(value1, value2); } template T val_vector(const std::vector container) { - return sequence_container >::val_container(container); + return sequence_container >::val_container(container); } template T ref_vector(const std::vector& container) { - return sequence_container >::ref_container(container); + return sequence_container >::ref_container(container); } template - std::list ret_list(const int size, const T value) { - return sequence_container >::ret_container(size, value); + std::list ret_list(const T value1, const T value2) { + return sequence_container >::ret_container(value1, value2); } template T val_list(const std::list container) { - return sequence_container >::val_container(container); + return sequence_container >::val_container(container); } template T ref_list(const std::list& container) { - return sequence_container >::ref_container(container); + return sequence_container >::ref_container(container); } } %} @@ -97,22 +95,32 @@ namespace std { namespace std { %template(TYPE ## _vector) std::vector; + %template(TYPE ## _list) std::list; +} +%enddef + +%define instantiate_containers_functions(TYPE...) +namespace std +{ %template(ret_ ## TYPE ## _vector) ret_vector; %template(val_ ## TYPE ## _vector) val_vector; %template(ref_ ## TYPE ## _vector) ref_vector; - - %template(TYPE ## _list) std::list; %template(ret_ ## TYPE ## _list) ret_list; %template(val_ ## TYPE ## _list) val_list; %template(ref_ ## TYPE ## _list) ref_list; } %enddef - instantiate_containers_templates(int); instantiate_containers_templates(double); instantiate_containers_templates(bool); instantiate_containers_templates(string); +instantiate_containers_templates(Color); 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); diff --git a/Examples/test-suite/scilab/li_std_sequence_container_typemaps_runme.sci b/Examples/test-suite/scilab/li_std_sequence_container_typemaps_runme.sci index 33f27403d..6570741f2 100644 --- a/Examples/test-suite/scilab/li_std_sequence_container_typemaps_runme.sci +++ b/Examples/test-suite/scilab/li_std_sequence_container_typemaps_runme.sci @@ -2,35 +2,37 @@ 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 // -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 // computed on the container -function testSequenceContainerPtr(container, count, value, expected_accumulate_value) - // test sequence container returned from fonction (expected a list) - classAPtr = new_ClassA(value); - 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; +function testSequenceContainerPtr(container, value1, value2, expected_accumulate_value) + // test sequence container of pointers returned from fonction (expected a list) + [classAPtr_list, classAPtr1, classAPtr2] = testCreateSequenceContainerPtr(container, value1, value2); // 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"); 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 - classAPtr = new_ClassA(value); - 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 + [classAPtr_list, classAPtr1, classAPtr2] = testCreateSequenceContainerPtr(container, value1, value2); // 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"); if ierr <> 0 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 // -container: type of container: "vector", "list"... // -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 // computed on the container -function testSequenceContainer(container, value_type, value, count, expected_accumulate_value) - // test sequence container returned from fonction (expect a row matrix) - if value_type = "string" - cmd = msprintf("c = ret_%s_%s(count, ''%s'');", value_type, container, value); +function testSequenceContainer(container, value_type, value1, value2, expected_accumulate_value) + // test sequence container of basic type returned from fonction (expect a row matrix) + if value_type = "string" then + cmd = msprintf("c = ret_%s_%s(''%s'', ''%s'');", value_type, container, value1, value2); 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 - 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 ierr = execstr(cmd, "errcatch"); + 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 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 // test sequence container passed as matrix as value of function - //m = repmat(value, 1, count); - //cmd = msprintf("s = val_%s_%s(m);", value_type, container); + //cmd = msprintf("s = val_%s_%s([value1, value2]);", value_type, container); //ierr = execstr(cmd, "errcatch"); //if ierr <> 0 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 // test sequence container passed as matrix as reference of function - //m = repmat(value, 1, count); - //cmd = msprintf("s = val_%s_%s(m);", value_type, container); + //cmd = msprintf("s = val_%s_%s([value1, value2]);", value_type, container); //ierr = execstr(cmd, "errcatch"); //if ierr <> 0 then swigtesterror(); end //if s <> expected_accumulate_value then swigtesterror(); end endfunction // test vector -testSequenceContainer("vector", "int", 2, 4, 10); -testSequenceContainer("vector", "double", 2., 3., 8.); -testSequenceContainer("vector", "string", "a", 4, "aaaaa"); -testSequenceContainer("vector", "bool", %T, 2, %T); -testSequenceContainerPtr("vector", 1, 3, 6.0); +testSequenceContainer("vector", "int", 1, 2, 4); +testSequenceContainer("vector", "double", 2., 3., 7.); +testSequenceContainer("vector", "string", "a", "b", "aab"); +testSequenceContainer("vector", "bool", %T, %F, %T); +testSequenceContainer("vector", "Color", RED_get(), BLUE_get(), MAGENTA_get()); +testSequenceContainerPtr("vector", 1, 3, 5); // test list -testSequenceContainer("list", "int", 2, 3, 8); -testSequenceContainer("list", "double", 2., 4., 10.); -testSequenceContainer("list", "string", "a", 4, "aaaaa"); -testSequenceContainer("list", "bool", %T, 2, %T); -testSequenceContainerPtr("list", 1, 3, 6.0); +testSequenceContainer("list", "int", 1, 2, 4); +testSequenceContainer("list", "double", 2., 3., 7.); +testSequenceContainer("list", "string", "a", "b", "aab"); +testSequenceContainer("list", "bool", %T, %F, %T); +testSequenceContainer("list", "Color", RED_get(), BLUE_get(), MAGENTA_get()); +testSequenceContainerPtr("list", 1, 3, 5); exec("swigtest.quit", -1);