bug 4230: add support for enumerations as dictionary keys in PHP

9 files changed, 129 insertions, 0 deletions

diff --git a/cpp/src/slice2php/Main.cpp b/cpp/src/slice2php/Main.cpp
index a51a7e17ef6..de7997f0339 100644
--- a/cpp/src/slice2php/Main.cpp
+++ b/cpp/src/slice2php/Main.cpp
@@ -863,6 +863,39 @@ CodeVisitor::visitSequence(const SequencePtr& p)
 void
 CodeVisitor::visitDictionary(const DictionaryPtr& p)
 {
+    TypePtr keyType = p->keyType();
+    BuiltinPtr b = BuiltinPtr::dynamicCast(keyType);
+    if(b)
+    {
+        switch(b->kind())
+        {
+        case Slice::Builtin::KindBool:
+        case Slice::Builtin::KindByte:
+        case Slice::Builtin::KindShort:
+        case Slice::Builtin::KindInt:
+        case Slice::Builtin::KindLong:
+        case Slice::Builtin::KindString:
+            //
+            // These types are acceptable as dictionary keys.
+            //
+            break;
+
+        case Slice::Builtin::KindFloat:
+        case Slice::Builtin::KindDouble:
+            emitWarning(p->file(), p->line(), "dictionary key type not supported in PHP");
+            break;
+
+        case Slice::Builtin::KindObject:
+        case Slice::Builtin::KindObjectProxy:
+        case Slice::Builtin::KindLocalObject:
+            assert(false);
+        }
+    }
+    else if(!EnumPtr::dynamicCast(keyType))
+    {
+        emitWarning(p->file(), p->line(), "dictionary key type not supported in PHP");
+    }
+
     string type = getTypeVar(p);
 
     startNamespace(p);
diff --git a/cpp/test/Ice/operations/Test.ice b/cpp/test/Ice/operations/Test.ice
index ea771c12ff3..95068160441 100644
--- a/cpp/test/Ice/operations/Test.ice
+++ b/cpp/test/Ice/operations/Test.ice
@@ -71,6 +71,7 @@ dictionary<short, int> ShortIntD;
 dictionary<long, float> LongFloatD;
 dictionary<string, string> StringStringD;
 dictionary<string, MyEnum> StringMyEnumD;
+dictionary<MyEnum, string> MyEnumStringD;
 dictionary<MyStruct, MyEnum> MyStructMyEnumD;
 
 ["ami"] class MyClass
@@ -150,6 +151,9 @@ dictionary<MyStruct, MyEnum> MyStructMyEnumD;
     StringMyEnumD opStringMyEnumD(StringMyEnumD p1, StringMyEnumD p2,
                                   out StringMyEnumD p3);
 
+    MyEnumStringD opMyEnumStringD(MyEnumStringD p1, MyEnumStringD p2,
+                                  out MyEnumStringD p3);
+
     MyStructMyEnumD opMyStructMyEnumD(MyStructMyEnumD p1, MyStructMyEnumD p2,
                                       out MyStructMyEnumD p3);
 
diff --git a/cpp/test/Ice/operations/TestAMD.ice b/cpp/test/Ice/operations/TestAMD.ice
index a44c923e1fa..6e5e70b237f 100644
--- a/cpp/test/Ice/operations/TestAMD.ice
+++ b/cpp/test/Ice/operations/TestAMD.ice
@@ -71,6 +71,7 @@ dictionary<short, int> ShortIntD;
 dictionary<long, float> LongFloatD;
 dictionary<string, string> StringStringD;
 dictionary<string, MyEnum> StringMyEnumD;
+dictionary<MyEnum, string> MyEnumStringD;
 dictionary<MyStruct, MyEnum> MyStructMyEnumD;
 
 ["ami", "amd"] class MyClass
@@ -150,6 +151,9 @@ dictionary<MyStruct, MyEnum> MyStructMyEnumD;
     StringMyEnumD opStringMyEnumD(StringMyEnumD p1, StringMyEnumD p2,
                                   out StringMyEnumD p3);
 
+    MyEnumStringD opMyEnumStringD(MyEnumStringD p1, MyEnumStringD p2,
+                                  out MyEnumStringD p3);
+
     MyStructMyEnumD opMyStructMyEnumD(MyStructMyEnumD p1, MyStructMyEnumD p2,
                                       out MyStructMyEnumD p3);
 
diff --git a/cpp/test/Ice/operations/TestAMDI.cpp b/cpp/test/Ice/operations/TestAMDI.cpp
index fd56b7f596a..000f1c33d27 100644
--- a/cpp/test/Ice/operations/TestAMDI.cpp
+++ b/cpp/test/Ice/operations/TestAMDI.cpp
@@ -361,6 +361,18 @@ MyDerivedClassI::opStringMyEnumD_async(const Test::AMD_MyClass_opStringMyEnumDPt
 }
 
 void
+MyDerivedClassI::opMyEnumStringD_async(const Test::AMD_MyClass_opMyEnumStringDPtr& cb,
+                                       const Test::MyEnumStringD& p1,
+                                       const Test::MyEnumStringD& p2,
+                                       const Ice::Current&)
+{
+    Test::MyEnumStringD p3 = p1;
+    Test::MyEnumStringD r = p1;
+    std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+    cb->ice_response(r, p3);
+}
+
+void
 MyDerivedClassI::opMyStructMyEnumD_async(const Test::AMD_MyClass_opMyStructMyEnumDPtr& cb,
                                        const Test::MyStructMyEnumD& p1,
                                        const Test::MyStructMyEnumD& p2,
diff --git a/cpp/test/Ice/operations/TestAMDI.h b/cpp/test/Ice/operations/TestAMDI.h
index efbcf319e7e..74dfeb6ddce 100644
--- a/cpp/test/Ice/operations/TestAMDI.h
+++ b/cpp/test/Ice/operations/TestAMDI.h
@@ -119,6 +119,10 @@ public:
                                        const Test::StringMyEnumD&, const Test::StringMyEnumD&,
                                        const Ice::Current&);
 
+    virtual void opMyEnumStringD_async(const Test::AMD_MyClass_opMyEnumStringDPtr&,
+                                       const Test::MyEnumStringD&, const Test::MyEnumStringD&,
+                                       const Ice::Current&);
+
     virtual void opMyStructMyEnumD_async(const Test::AMD_MyClass_opMyStructMyEnumDPtr&,
                                          const Test::MyStructMyEnumD&, const Test::MyStructMyEnumD&,
                                          const Ice::Current&);
diff --git a/cpp/test/Ice/operations/TestI.cpp b/cpp/test/Ice/operations/TestI.cpp
index 09c9ab409c1..1ef347a9243 100644
--- a/cpp/test/Ice/operations/TestI.cpp
+++ b/cpp/test/Ice/operations/TestI.cpp
@@ -336,6 +336,18 @@ MyDerivedClassI::opStringMyEnumD(const Test::StringMyEnumD& p1,
     return r;
 }
 
+Test::MyEnumStringD
+MyDerivedClassI::opMyEnumStringD(const Test::MyEnumStringD& p1,
+                                 const Test::MyEnumStringD& p2,
+                                 Test::MyEnumStringD& p3,
+                                 const Ice::Current&)
+{
+    p3 = p1;
+    Test::MyEnumStringD r = p1;
+    std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+    return r;
+}
+
 Test::MyStructMyEnumD
 MyDerivedClassI::opMyStructMyEnumD(const Test::MyStructMyEnumD& p1,
                                    const Test::MyStructMyEnumD& p2,
diff --git a/cpp/test/Ice/operations/TestI.h b/cpp/test/Ice/operations/TestI.h
index fc374a02c17..8bdefefd402 100644
--- a/cpp/test/Ice/operations/TestI.h
+++ b/cpp/test/Ice/operations/TestI.h
@@ -144,6 +144,10 @@ public:
                                                 Test::StringMyEnumD&,
                                                 const Ice::Current&);
 
+    virtual Test::MyEnumStringD opMyEnumStringD(const Test::MyEnumStringD&, const Test::MyEnumStringD&,
+                                                Test::MyEnumStringD&,
+                                                const Ice::Current&);
+
     virtual Test::MyStructMyEnumD opMyStructMyEnumD(const Test::MyStructMyEnumD&, const Test::MyStructMyEnumD&,
                                                     Test::MyStructMyEnumD&,
                                                     const Ice::Current&);
diff --git a/cpp/test/Ice/operations/Twoways.cpp b/cpp/test/Ice/operations/Twoways.cpp
index 6c79d5a3706..3cc97b68408 100644
--- a/cpp/test/Ice/operations/Twoways.cpp
+++ b/cpp/test/Ice/operations/Twoways.cpp
@@ -627,6 +627,23 @@ twoways(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
     }
 
     {
+        Test::MyEnumStringD di1;
+        di1[Test::enum1] = "abc";
+        Test::MyEnumStringD di2;
+        di2[Test::enum2] = "Hello!!";
+        di2[Test::enum3] = "qwerty";
+
+        Test::MyEnumStringD _do;
+        Test::MyEnumStringD ro = p->opMyEnumStringD(di1, di2, _do);
+
+        test(_do == di1);
+        test(ro.size() == 3);
+        test(ro[Test::enum1] == "abc");
+        test(ro[Test::enum2] == "Hello!!");
+        test(ro[Test::enum3] == "qwerty");
+    }
+
+    {
         Test::MyStruct s11 = { 1, 1 };
         Test::MyStruct s12 = { 1, 2 };
         Test::MyStructMyEnumD di1;
diff --git a/cpp/test/Ice/operations/TwowaysAMI.cpp b/cpp/test/Ice/operations/TwowaysAMI.cpp
index 87477254af6..7dd38532f0e 100644
--- a/cpp/test/Ice/operations/TwowaysAMI.cpp
+++ b/cpp/test/Ice/operations/TwowaysAMI.cpp
@@ -753,6 +753,33 @@ public:
 
 typedef IceUtil::Handle<AMI_MyClass_opStringMyEnumDI> AMI_MyClass_opStringMyEnumDIPtr;
 
+class AMI_MyClass_opMyEnumStringDI : public Test::AMI_MyClass_opMyEnumStringD, public CallbackBase
+{
+public:
+
+    virtual void ice_response(const ::Test::MyEnumStringD& ro, const ::Test::MyEnumStringD& _do)
+    {
+        Test::MyEnumStringD di1;
+        di1[Test::enum1] = "abc";
+        test(_do == di1);
+        test(ro.size() == 3);
+        test(ro.find(Test::enum1) != ro.end());
+        test(ro.find(Test::enum1)->second == "abc");
+        test(ro.find(Test::enum2) != ro.end());
+        test(ro.find(Test::enum2)->second == "Hello!!");
+        test(ro.find(Test::enum3) != ro.end());
+        test(ro.find(Test::enum3)->second == "qwerty");
+        called();
+    }
+
+    virtual void ice_exception(const ::Ice::Exception&)
+    {
+        test(false);
+    }
+};
+
+typedef IceUtil::Handle<AMI_MyClass_opMyEnumStringDI> AMI_MyClass_opMyEnumStringDIPtr;
+
 class AMI_MyClass_opMyStructMyEnumDI : public Test::AMI_MyClass_opMyStructMyEnumD, public CallbackBase
 {
 public:
@@ -1241,6 +1268,18 @@ twowaysAMI(const Ice::CommunicatorPtr& communicator, const Test::MyClassPrx& p)
     }
 
     {
+        Test::MyEnumStringD di1;
+        di1[Test::enum1] = "abc";
+        Test::MyEnumStringD di2;
+        di2[Test::enum2] = "Hello!!";
+        di2[Test::enum3] = "qwerty";
+
+        AMI_MyClass_opMyEnumStringDIPtr cb = new AMI_MyClass_opMyEnumStringDI;
+        p->opMyEnumStringD_async(cb, di1, di2);
+        cb->check();
+    }
+
+    {
         Test::MyStruct s11 = { 1, 1 };
         Test::MyStruct s12 = { 1, 2 };
         Test::MyStructMyEnumD di1;