Examples/test-suite/duplicate_class_name_in_ns.i


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

%module duplicate_class_name_in_ns

%rename(XA) A::X;
%rename(XB) B::X;

%inline %{

namespace A
{
    class X
    {
    public:
        X(){};
    };

    template<typename T>
    class Foo
    {
    public:
        Foo(){};
    };

    class Bar
    {
    public:
        Bar(){};
    };

    template<typename T>
    class Baz
    {
    public:
        Baz(){};
    };
}

namespace B
{
    // non-template derived from non-template
    class X : public A::X
    {
    public:
        X(){};
        A::X do_x(){return A::X();}
    };

    // template derived from template with different template args
    template<typename T, typename U>
    class Foo : public A::Foo<U>
    {
    public:
        Foo(){};
        A::Foo<U> do_foo(){return A::Foo<U>();}
    };

    // template derived from non-template
    template<typename T, typename U>
    class Bar : public A::Bar
    {
    public:
        Bar(){};
        A::Bar do_bar(){return A::Bar();}
    };

    // template derived from template with same template args
    template<typename T>
    class Baz : public A::Baz<T>
    {
    public:
        Baz(){};
        A::Baz<T> do_baz(){return A::Baz<T>();}
    };
}

%}

%template(AFoo) A::Foo<double>;
%template(ABaz) A::Baz<double>;
%template(BFoo) B::Foo<int, double>;
%template(BBar) B::Bar<int, double>;
%template(BBaz) B::Baz<double>;

%inline %{
    A::X get_a_x() {B::X x; return x.do_x();}
    A::Foo<double> get_a_foo() {B::Foo<int, double> x; return x.do_foo();}
    A::Bar get_a_bar() {B::Bar<int, double> x; return x.do_bar();}
    A::Baz<double> get_a_baz() {B::Baz<double> x; return x.do_baz();}
%}