renamed PolymorphicData class to OverloadData, this should represent correctly

the class' function; other relative renamings were also performed

12 files changed, 122 insertions, 123 deletions

diff --git a/tests/libsample/derived.cpp b/tests/libsample/derived.cpp
index 4aeafd5e5..5a27a6c2f 100644
--- a/tests/libsample/derived.cpp
+++ b/tests/libsample/derived.cpp
@@ -84,31 +84,31 @@ Derived::defaultValue(int n)
     return ((double) n) + 0.1;
 }
 
-PolymorphicFuncEnum
-Derived::polymorphic(int i, int d)
+OverloadedFuncEnum
+Derived::overloaded(int i, int d)
 {
     //cout << __PRETTY_FUNCTION__ << "[i = 0, d = 0]" << endl;
-    return PolymorphicFunc_ii;
+    return OverloadedFunc_ii;
 }
 
-PolymorphicFuncEnum
-Derived::polymorphic(double n)
+OverloadedFuncEnum
+Derived::overloaded(double n)
 {
     //cout << __PRETTY_FUNCTION__ << endl;
-    return PolymorphicFunc_d;
+    return OverloadedFunc_d;
 }
 
-Derived::OtherPolymorphicFuncEnum
-Derived::otherPolymorphic(int a, int b, bool c, double d)
+Derived::OtherOverloadedFuncEnum
+Derived::otherOverloaded(int a, int b, bool c, double d)
 {
     //cout << __PRETTY_FUNCTION__ << endl;
-    return OtherPolymorphicFunc_iibd;
+    return OtherOverloadedFunc_iibd;
 }
 
-Derived::OtherPolymorphicFuncEnum
-Derived::otherPolymorphic(int a, double b)
+Derived::OtherOverloadedFuncEnum
+Derived::otherOverloaded(int a, double b)
 {
     //cout << __PRETTY_FUNCTION__ << endl;
-    return OtherPolymorphicFunc_id;
+    return OtherOverloadedFunc_id;
 }
 
diff --git a/tests/libsample/derived.h b/tests/libsample/derived.h
index 624c66051..e12042f90 100644
--- a/tests/libsample/derived.h
+++ b/tests/libsample/derived.h
@@ -37,17 +37,17 @@
 
 #include "abstract.h"
 
-enum PolymorphicFuncEnum {
-    PolymorphicFunc_ii,
-    PolymorphicFunc_d
+enum OverloadedFuncEnum {
+    OverloadedFunc_ii,
+    OverloadedFunc_d
 };
 
 class Derived : public Abstract
 {
 public:
-    enum OtherPolymorphicFuncEnum {
-        OtherPolymorphicFunc_iibd,
-        OtherPolymorphicFunc_id
+    enum OtherOverloadedFuncEnum {
+        OtherOverloadedFunc_iibd,
+        OtherOverloadedFunc_id
     };
 
     Derived(int id = -1);
@@ -65,12 +65,12 @@ public:
     double defaultValue(int n = 0);
 
     // overloads
-    PolymorphicFuncEnum polymorphic(int i = 0, int d = 0);
-    PolymorphicFuncEnum polymorphic(double n);
+    OverloadedFuncEnum overloaded(int i = 0, int d = 0);
+    OverloadedFuncEnum overloaded(double n);
 
     // more overloads
-    OtherPolymorphicFuncEnum otherPolymorphic(int a, int b, bool c, double d);
-    OtherPolymorphicFuncEnum otherPolymorphic(int a, double b);
+    OtherOverloadedFuncEnum otherOverloaded(int a, int b, bool c, double d);
+    OtherOverloadedFuncEnum otherOverloaded(int a, double b);
 
 protected:
     const char* getClassName() { return className(); }
diff --git a/tests/libsample/functions.cpp b/tests/libsample/functions.cpp
index d8f27cf66..e1d909046 100644
--- a/tests/libsample/functions.cpp
+++ b/tests/libsample/functions.cpp
@@ -105,15 +105,15 @@ returnCString()
     return __PRETTY_FUNCTION__;
 }
 
-GlobalPolyFuncEnum
-polymorphicFunc(int val)
+GlobalOverloadFuncEnum
+overloadedFunc(int val)
 {
-    return GlobalPolyFunc_i;
+    return GlobalOverloadFunc_i;
 }
 
-GlobalPolyFuncEnum
-polymorphicFunc(double val)
+GlobalOverloadFuncEnum
+overloadedFunc(double val)
 {
-    return GlobalPolyFunc_d;
+    return GlobalOverloadFunc_d;
 }
 
diff --git a/tests/libsample/functions.h b/tests/libsample/functions.h
index fcb8bda8e..05753da3e 100644
--- a/tests/libsample/functions.h
+++ b/tests/libsample/functions.h
@@ -46,9 +46,9 @@ enum GlobalEnum {
     ThirdThing
 };
 
-enum GlobalPolyFuncEnum {
-    GlobalPolyFunc_i,
-    GlobalPolyFunc_d
+enum GlobalOverloadFuncEnum {
+    GlobalOverloadFunc_i,
+    GlobalOverloadFunc_d
 };
 
 void printSomething();
@@ -62,9 +62,9 @@ int countCharacters(const char* text);
 char* makeCString();
 const char* returnCString();
 
-// Tests polymorphism on functions (!methods)
-GlobalPolyFuncEnum polymorphicFunc(int val);
-GlobalPolyFuncEnum polymorphicFunc(double val);
+// Tests overloading on functions (!methods)
+GlobalOverloadFuncEnum overloadedFunc(int val);
+GlobalOverloadFuncEnum overloadedFunc(double val);
 
 #endif // FUNCTIONS_H
 
diff --git a/tests/libsample/implicitconv.cpp b/tests/libsample/implicitconv.cpp
index 3baf8ccd2..8e0d3f463 100644
--- a/tests/libsample/implicitconv.cpp
+++ b/tests/libsample/implicitconv.cpp
@@ -46,27 +46,27 @@ ImplicitConv::implicitConvDefault(ImplicitConv implicit)
     return implicit;
 }
 
-ImplicitConv::ICPolymorphicFuncEnum
-ImplicitConv::implicitConvPolymorphism(ImplicitConv implicit, int dummyArg)
+ImplicitConv::ICOverloadedFuncEnum
+ImplicitConv::implicitConvOverloading(ImplicitConv implicit, int dummyArg)
 {
-    return ImplicitConv::PolyFunc_Ii;
+    return ImplicitConv::OverFunc_Ii;
 }
 
-ImplicitConv::ICPolymorphicFuncEnum
-ImplicitConv::implicitConvPolymorphism(ImplicitConv implicit, bool dummyArg)
+ImplicitConv::ICOverloadedFuncEnum
+ImplicitConv::implicitConvOverloading(ImplicitConv implicit, bool dummyArg)
 {
-    return ImplicitConv::PolyFunc_Ib;
+    return ImplicitConv::OverFunc_Ib;
 }
 
-ImplicitConv::ICPolymorphicFuncEnum
-ImplicitConv::implicitConvPolymorphism(int dummyArg)
+ImplicitConv::ICOverloadedFuncEnum
+ImplicitConv::implicitConvOverloading(int dummyArg)
 {
-    return ImplicitConv::PolyFunc_i;
+    return ImplicitConv::OverFunc_i;
 }
 
-ImplicitConv::ICPolymorphicFuncEnum
-ImplicitConv::implicitConvPolymorphism(CtorEnum dummyArg)
+ImplicitConv::ICOverloadedFuncEnum
+ImplicitConv::implicitConvOverloading(CtorEnum dummyArg)
 {
-    return ImplicitConv::PolyFunc_C;
+    return ImplicitConv::OverFunc_C;
 }
 
diff --git a/tests/libsample/implicitconv.h b/tests/libsample/implicitconv.h
index 57566f89d..7d537fb13 100644
--- a/tests/libsample/implicitconv.h
+++ b/tests/libsample/implicitconv.h
@@ -45,11 +45,11 @@ public:
         CtorThree
     };
 
-    enum ICPolymorphicFuncEnum {
-        PolyFunc_Ii,
-        PolyFunc_Ib,
-        PolyFunc_i,
-        PolyFunc_C
+    enum ICOverloadedFuncEnum {
+        OverFunc_Ii,
+        OverFunc_Ib,
+        OverFunc_i,
+        OverFunc_C
     };
 
     ImplicitConv() : m_ctorEnum(CtorNone), m_objId(-1) {}
@@ -64,10 +64,10 @@ public:
 
     static ImplicitConv implicitConvDefault(ImplicitConv implicit = CtorTwo);
 
-    static ICPolymorphicFuncEnum implicitConvPolymorphism(ImplicitConv implicit, int dummyArg);
-    static ICPolymorphicFuncEnum implicitConvPolymorphism(ImplicitConv implicit, bool dummyArg);
-    static ICPolymorphicFuncEnum implicitConvPolymorphism(int dummyArg);
-    static ICPolymorphicFuncEnum implicitConvPolymorphism(CtorEnum dummyArg);
+    static ICOverloadedFuncEnum implicitConvOverloading(ImplicitConv implicit, int dummyArg);
+    static ICOverloadedFuncEnum implicitConvOverloading(ImplicitConv implicit, bool dummyArg);
+    static ICOverloadedFuncEnum implicitConvOverloading(int dummyArg);
+    static ICOverloadedFuncEnum implicitConvOverloading(CtorEnum dummyArg);
 
 private:
     CtorEnum m_ctorEnum;
diff --git a/tests/libsample/modifications.h b/tests/libsample/modifications.h
index d6bca2d6d..87405f361 100644
--- a/tests/libsample/modifications.h
+++ b/tests/libsample/modifications.h
@@ -44,22 +44,22 @@ public:
     Modifications() {}
     ~Modifications() {}
 
-    enum PolymorphicModFunc {
-        PolymorphicNone,
-        Polymorphic_ibid,
-        Polymorphic_ibib,
-        Polymorphic_ibiP,
-        Polymorphic_ibii,
-        Polymorphic_ibPP
+    enum OverloadedModFunc {
+        OverloadedNone,
+        Overloaded_ibid,
+        Overloaded_ibib,
+        Overloaded_ibiP,
+        Overloaded_ibii,
+        Overloaded_ibPP
     };
 
-    // those polymorphic methods should be heavily modified
+    // those overloaded methods should be heavily modified
     // to push the overload decisor to its limits
-    PolymorphicModFunc polymorphic(int a0, bool b0, int c0, double d0) { return Polymorphic_ibid; }
-    PolymorphicModFunc polymorphic(int a1, bool b1, int c1, bool d1) { return Polymorphic_ibib; }
-    PolymorphicModFunc polymorphic(int a2, bool b2, int c2, Point d2) { return Polymorphic_ibiP; }
-    PolymorphicModFunc polymorphic(int a3, bool b3, int c3 = 123, int d3 = 456) { return Polymorphic_ibii; }
-    PolymorphicModFunc polymorphic(int a4, bool b4, Point c4, Point d4) { return Polymorphic_ibPP; }
+    OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0) { return Overloaded_ibid; }
+    OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1) { return Overloaded_ibib; }
+    OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2) { return Overloaded_ibiP; }
+    OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456) { return Overloaded_ibii; }
+    OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4) { return Overloaded_ibPP; }
 
     // 'ok' must be removed and the return value will be changed
     // to a tuple (PyObject*) containing the expected result plus
diff --git a/tests/samplebinding/derived_test.py b/tests/samplebinding/derived_test.py
index 22d49470f..f9ed1320f 100755
--- a/tests/samplebinding/derived_test.py
+++ b/tests/samplebinding/derived_test.py
@@ -6,7 +6,7 @@ import sys
 import unittest
 
 import sample
-from sample import Abstract, Derived, PolymorphicFuncEnum
+from sample import Abstract, Derived, OverloadedFuncEnum
 
 class Deviant(Derived):
     def __init__(self):
@@ -32,45 +32,45 @@ class DerivedTest(unittest.TestCase):
                                  'id_', 'pureVirtual', 'unpureVirtual'])
         self.assert_(inherited_methods.issubset(dir(Derived)))
 
-    def testPolymorphicMethodCall(self):
-        '''Test if the correct polymorphic method is being called.'''
+    def testOverloadedMethodCall(self):
+        '''Test if the correct overloaded method is being called.'''
         derived = Derived()
 
-        result = derived.polymorphic(1, 2)
-        self.assertEqual(type(result), PolymorphicFuncEnum)
-        self.assertEqual(result, sample.PolymorphicFunc_ii)
+        result = derived.overloaded(1, 2)
+        self.assertEqual(type(result), OverloadedFuncEnum)
+        self.assertEqual(result, sample.OverloadedFunc_ii)
 
-        result = derived.polymorphic(3)
-        self.assertEqual(type(result), PolymorphicFuncEnum)
-        self.assertEqual(result, sample.PolymorphicFunc_ii)
+        result = derived.overloaded(3)
+        self.assertEqual(type(result), OverloadedFuncEnum)
+        self.assertEqual(result, sample.OverloadedFunc_ii)
 
-        result = derived.polymorphic(4.4)
-        self.assertEqual(type(result), PolymorphicFuncEnum)
-        self.assertEqual(result, sample.PolymorphicFunc_d)
+        result = derived.overloaded(4.4)
+        self.assertEqual(type(result), OverloadedFuncEnum)
+        self.assertEqual(result, sample.OverloadedFunc_d)
 
-    def testOtherPolymorphicMethodCall(self):
-        '''Another test to check polymorphic method calling, just to double check.'''
+    def testOtherOverloadedMethodCall(self):
+        '''Another test to check overloaded method calling, just to double check.'''
         derived = Derived()
 
-        result = derived.otherPolymorphic(1, 2, True, 3.3)
-        self.assertEqual(type(result), Derived.OtherPolymorphicFuncEnum)
-        self.assertEqual(result, sample.Derived.OtherPolymorphicFunc_iibd)
+        result = derived.otherOverloaded(1, 2, True, 3.3)
+        self.assertEqual(type(result), Derived.OtherOverloadedFuncEnum)
+        self.assertEqual(result, sample.Derived.OtherOverloadedFunc_iibd)
 
-        result = derived.otherPolymorphic(1, 2.2)
-        self.assertEqual(type(result), Derived.OtherPolymorphicFuncEnum)
-        self.assertEqual(result, Derived.OtherPolymorphicFunc_id)
+        result = derived.otherOverloaded(1, 2.2)
+        self.assertEqual(type(result), Derived.OtherOverloadedFuncEnum)
+        self.assertEqual(result, Derived.OtherOverloadedFunc_id)
 
-    def testPolymorphicMethodCallWithDifferentNumericTypes(self):
-        '''Test if the correct polymorphic method accepts a different numeric type as argument.'''
+    def testOverloadedMethodCallWithDifferentNumericTypes(self):
+        '''Test if the correct overloaded method accepts a different numeric type as argument.'''
         derived = Derived()
-        result = derived.polymorphic(1.1, 2.2)
-        self.assertEqual(type(result), PolymorphicFuncEnum)
-        self.assertEqual(result, sample.PolymorphicFunc_ii)
+        result = derived.overloaded(1.1, 2.2)
+        self.assertEqual(type(result), OverloadedFuncEnum)
+        self.assertEqual(result, sample.OverloadedFunc_ii)
 
-    def testPolymorphicMethodCallWithWrongNumberOfArguments(self):
-        '''Test if a call to a polymorphic method with the wrong number of arguments raises an exception.'''
+    def testOverloadedMethodCallWithWrongNumberOfArguments(self):
+        '''Test if a call to an overloaded method with the wrong number of arguments raises an exception.'''
         derived = Derived()
-        self.assertRaises(TypeError, lambda : derived.otherPolymorphic(1, 2, True))
+        self.assertRaises(TypeError, lambda : derived.otherOverloaded(1, 2, True))
 
     def testReimplementedPureVirtualMethodCall(self):
         '''Test if a Python override of a implemented pure virtual method is correctly called from C++.'''
diff --git a/tests/samplebinding/implicitconv_test.py b/tests/samplebinding/implicitconv_test.py
index 30dd870e3..f3da5dcfb 100755
--- a/tests/samplebinding/implicitconv_test.py
+++ b/tests/samplebinding/implicitconv_test.py
@@ -11,7 +11,7 @@ class ImplicitConvTest(unittest.TestCase):
     '''Test case for implicit conversions'''
 
     def testImplicitConversions(self):
-        '''Test if polymorphic function call decisor takes implicit conversions into account.'''
+        '''Test if overloaded function call decisor takes implicit conversions into account.'''
         ic = ImplicitConv.implicitConvCommon(ImplicitConv())
         self.assertEqual(ic.ctorEnum(), ImplicitConv.CtorNone)
 
diff --git a/tests/samplebinding/modifications_test.py b/tests/samplebinding/modifications_test.py
index 33d420f37..1bd3003ed 100755
--- a/tests/samplebinding/modifications_test.py
+++ b/tests/samplebinding/modifications_test.py
@@ -26,12 +26,12 @@ class ModificationsTest(unittest.TestCase):
 
     def testClassMembersAvailability(self):
         '''Test if Modified class really have the expected members.'''
-        expected_members = set(['PolymorphicModFunc', 'PolymorphicNone',
-                                'Polymorphic_ibiP', 'Polymorphic_ibib',
-                                'Polymorphic_ibid', 'Polymorphic_ibii',
+        expected_members = set(['OverloadedModFunc', 'OverloadedNone',
+                                'Overloaded_ibiP', 'Overloaded_ibib',
+                                'Overloaded_ibid', 'Overloaded_ibii',
                                 'calculateArea', 'doublePlus', 'increment',
                                 'multiplyPointCoordsPlusValue', 'name',
-                                'pointToPair', 'polymorphic', 'power',
+                                'pointToPair', 'overloaded', 'power',
                                 'timesTen'])
         self.assert_(expected_members.issubset(dir(Modifications)))
 
@@ -98,17 +98,17 @@ class ModificationsTest(unittest.TestCase):
         self.assertEqual(type(result), float)
         self.assertEqual(result, 14.1)
 
-    def testPolymorphicMethodModifications(self):
-        '''Tests modifications to a polymorphic method'''
-        # polymorphic(int, bool[removed], int, double)
-        self.assertEqual(self.mods.polymorphic(1, 2, 3.1), Modifications.Polymorphic_ibid)
-        # polymorphic(int, bool, int[removed,default=321], int)
-        self.assertEqual(self.mods.polymorphic(1, True, 2), Modifications.Polymorphic_ibii)
+    def testOverloadedMethodModifications(self):
+        '''Tests modifications to an overloaded method'''
+        # overloaded(int, bool[removed], int, double)
+        self.assertEqual(self.mods.overloaded(1, 2, 3.1), Modifications.Overloaded_ibid)
+        # overloaded(int, bool, int[removed,default=321], int)
+        self.assertEqual(self.mods.overloaded(1, True, 2), Modifications.Overloaded_ibii)
         # the others weren't modified
-        self.assertEqual(self.mods.polymorphic(1, True, 2, False), Modifications.Polymorphic_ibib)
-        self.assertEqual(self.mods.polymorphic(1, False, 2, Point(3, 4)), Modifications.Polymorphic_ibiP)
-        self.assertRaises(TypeError, lambda : self.mods.polymorphic(1, True, Point(2, 3), Point(4, 5)))
-        self.assertEqual(self.mods.poly(1, True, Point(2, 3), Point(4, 5)), Modifications.Polymorphic_ibPP)
+        self.assertEqual(self.mods.overloaded(1, True, 2, False), Modifications.Overloaded_ibib)
+        self.assertEqual(self.mods.overloaded(1, False, 2, Point(3, 4)), Modifications.Overloaded_ibiP)
+        self.assertRaises(TypeError, lambda : self.mods.overloaded(1, True, Point(2, 3), Point(4, 5)))
+        self.assertEqual(self.mods.over(1, True, Point(2, 3), Point(4, 5)), Modifications.Overloaded_ibPP)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/samplebinding/nondefaultctor_test.py b/tests/samplebinding/nondefaultctor_test.py
index 58a6442d8..dbb184eb3 100755
--- a/tests/samplebinding/nondefaultctor_test.py
+++ b/tests/samplebinding/nondefaultctor_test.py
@@ -16,7 +16,6 @@ class DerivedNonDefaultCtor (NonDefaultCtor):
 class NonDefaultCtorTest(unittest.TestCase):
 
     def testNonDefaultCtor(self):
-        '''Test if polymorphic function call decisor takes implicit conversions into account.'''
         c = NonDefaultCtor(2)
         # these functions returns NonDefaultCtor by value, so a PyObjecy  is created every time
         self.assertNotEqual(c.returnMyself(), c)
diff --git a/tests/samplebinding/typesystem_sample.xml b/tests/samplebinding/typesystem_sample.xml
index b2378aaae..dc0d64d77 100644
--- a/tests/samplebinding/typesystem_sample.xml
+++ b/tests/samplebinding/typesystem_sample.xml
@@ -29,21 +29,21 @@
     </container-type>
 
     <enum-type name="Abstract::PrintFormat"/>
-    <enum-type name="PolymorphicFuncEnum"/>
-    <enum-type name="Derived::OtherPolymorphicFuncEnum"/>
-    <enum-type name="Modifications::PolymorphicModFunc"/>
+    <enum-type name="OverloadedFuncEnum"/>
+    <enum-type name="Derived::OtherOverloadedFuncEnum"/>
+    <enum-type name="Modifications::OverloadedModFunc"/>
     <enum-type name="ImplicitConv::CtorEnum"/>
     <!-- BUG:
-    renaming the ICPolymorphicFuncEnum to the same name
+    renaming the ICOverloadedFuncEnum to the same name
     of a global enum causes the generator to confuse the
     two types.
     -->
-    <enum-type name="ImplicitConv::ICPolymorphicFuncEnum"/>
+    <enum-type name="ImplicitConv::ICOverloadedFuncEnum"/>
     <enum-type name="SampleNamespace::Option" extensible="yes"/>
     <enum-type name="SampleNamespace::InValue"/>
     <enum-type name="SampleNamespace::OutValue"/>
     <enum-type name="GlobalEnum"/>
-    <enum-type name="GlobalPolyFuncEnum"/>
+    <enum-type name="GlobalOverloadFuncEnum"/>
 
     <namespace-type name="SampleNamespace"/>
 
@@ -80,7 +80,7 @@
 
     <object-type name="Modifications">
 
-        <modify-function signature="polymorphic(int, bool, int, double)">
+        <modify-function signature="overloaded(int, bool, int, double)">
             <modify-argument index="2">
                 <remove-argument/>
             </modify-argument>
@@ -92,7 +92,7 @@
             </inject-code>
         </modify-function>
 
-        <modify-function signature="polymorphic(int, bool, int, int)">
+        <modify-function signature="overloaded(int, bool, int, int)">
             <modify-argument index="3">
                 <remove-argument/>
                 <replace-default-expression with="321"/>
@@ -109,7 +109,7 @@
         compile time error on the binding
         -->
         <!--
-        <modify-function signature="polymorphic(int, bool, Point, Point)">
+        <modify-function signature="overloaded(int, bool, Point, Point)">
             <modify-argument index="3">
                 <remove-argument/>
             </modify-argument>
@@ -118,9 +118,9 @@
 
         <!--
         renaming this signature should remove it from the other
-        polymorphic methods decision tree
+        overloaded methods decision tree
         -->
-        <modify-function signature="polymorphic(int, bool, Point, Point)" rename="poly"/>
+        <modify-function signature="overloaded(int, bool, Point, Point)" rename="over"/>
 
         <!--
         'ok' must be removed and the return value will be changed