summaryrefslogtreecommitdiff
path: root/cpp/test/Ice/operations/TestAMDI.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'cpp/test/Ice/operations/TestAMDI.cpp')
-rw-r--r--cpp/test/Ice/operations/TestAMDI.cpp1015
1 files changed, 986 insertions, 29 deletions
diff --git a/cpp/test/Ice/operations/TestAMDI.cpp b/cpp/test/Ice/operations/TestAMDI.cpp
index 419320fdcc4..68c05fae57b 100644
--- a/cpp/test/Ice/operations/TestAMDI.cpp
+++ b/cpp/test/Ice/operations/TestAMDI.cpp
@@ -13,60 +13,1015 @@
#include <functional>
#include <iterator>
+using namespace Ice;
+using namespace Test;
+
using namespace std;
+MyDerivedClassI::MyDerivedClassI() : _opByteSOnewayCallCount(0)
+{
+}
+
+bool
+MyDerivedClassI::ice_isA(ICE_IN(string) id, const Ice::Current& current) const
+{
+ test(current.mode == ICE_ENUM(OperationMode, Nonmutating));
+#ifdef ICE_CPP11_MAPPING
+ return Test::MyDerivedClassDisp::ice_isA(move(id), current);
+#else
+ return Test::MyDerivedClass::ice_isA(id, current);
+#endif
+}
+
+void
+MyDerivedClassI::ice_ping(const Ice::Current& current) const
+{
+ test(current.mode == ICE_ENUM(OperationMode, Nonmutating));
+#ifdef ICE_CPP11_MAPPING
+ Test::MyDerivedClassDisp::ice_ping(current);
+#else
+ Test::MyDerivedClass::ice_ping(current);
+#endif
+}
+
+std::vector<std::string>
+MyDerivedClassI::ice_ids(const Ice::Current& current) const
+{
+ test(current.mode == ICE_ENUM(OperationMode, Nonmutating));
+#ifdef ICE_CPP11_MAPPING
+ return Test::MyDerivedClassDisp::ice_ids(current);
+#else
+ return Test::MyDerivedClass::ice_ids(current);
+#endif
+}
+
+const std::string&
+MyDerivedClassI::ice_id(const Ice::Current& current) const
+{
+ test(current.mode == ICE_ENUM(OperationMode, Nonmutating));
+#ifdef ICE_CPP11_MAPPING
+ return Test::MyDerivedClassDisp::ice_id(current);
+#else
+ return Test::MyDerivedClass::ice_id(current);
+#endif
+}
+
+#ifdef ICE_CPP11_MAPPING
+
class Thread_opVoid : public IceUtil::Thread
{
public:
- Thread_opVoid(const Test::AMD_MyClass_opVoidPtr& cb) :
- _cb(cb)
+ Thread_opVoid(function<void ()> response) :
+ _response(move(response))
{
}
virtual void run()
{
- _cb->ice_response();
+ _response();
}
private:
- const Test::AMD_MyClass_opVoidPtr _cb;
+ function<void ()> _response;
};
-MyDerivedClassI::MyDerivedClassI() : _opByteSOnewayCallCount(0)
+void
+MyDerivedClassI::shutdown_async(function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
{
+ {
+ IceUtil::Mutex::Lock sync(_opVoidMutex);
+ if(_opVoidThread)
+ {
+ _opVoidThread->getThreadControl().join();
+ _opVoidThread = 0;
+ }
+ }
+
+ current.adapter->getCommunicator()->shutdown();
+ response();
}
-bool
-MyDerivedClassI::ice_isA(const std::string& id, const Ice::Current& current) const
+void
+MyDerivedClassI::delay_async(Ice::Int ms, function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
{
- test(current.mode == Ice::Nonmutating);
- return Test::MyDerivedClass::ice_isA(id, current);
+ IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(ms));
+ response();
}
void
-MyDerivedClassI::ice_ping(const Ice::Current& current) const
+MyDerivedClassI::opVoid_async(function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
{
- test(current.mode == Ice::Nonmutating);
- Test::MyDerivedClass::ice_ping(current);
+ test(current.mode == OperationMode::Normal);
+
+ IceUtil::Mutex::Lock sync(_opVoidMutex);
+ if(_opVoidThread)
+ {
+ _opVoidThread->getThreadControl().join();
+ _opVoidThread = 0;
+ }
+
+ _opVoidThread = new Thread_opVoid(response);
+ _opVoidThread->start();
}
-std::vector<std::string>
-MyDerivedClassI::ice_ids(const Ice::Current& current) const
+
+void
+MyDerivedClassI::opByte_async(Ice::Byte p1,
+ Ice::Byte p2,
+ function<void (Ice::Byte, Ice::Byte)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
{
- test(current.mode == Ice::Nonmutating);
- return Test::MyDerivedClass::ice_ids(current);
+ response(p1, p1 ^ p2);
}
-const std::string&
-MyDerivedClassI::ice_id(const Ice::Current& current) const
+void
+MyDerivedClassI::opBool_async(bool p1,
+ bool p2,
+ function<void (bool, bool)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
{
- test(current.mode == Ice::Nonmutating);
- return Test::MyDerivedClass::ice_id(current);
+ response(p2, p1);
+}
+
+
+void
+MyDerivedClassI::opShortIntLong_async(short p1,
+ int p2,
+ long long int p3,
+ function<void (long long int, short, int, long long int)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(p3, p1, p2, p3);
+}
+
+
+void
+MyDerivedClassI::opFloatDouble_async(float p1,
+ double p2,
+ function<void (double, float, double)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(p2, p1, p2);
+}
+
+void
+MyDerivedClassI::opString_async(string p1,
+ string p2,
+ function<void (const string&, const string&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(p1 + " " + p2, p2 + " " + p1);
+}
+
+
+void
+MyDerivedClassI::opMyEnum_async(Test::MyEnum p1,
+ function<void (Test::MyEnum, Test::MyEnum)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(MyEnum::enum3, p1);
+}
+
+void
+MyDerivedClassI::opMyClass_async(shared_ptr<Test::MyClassPrx> p1,
+ function<void (const shared_ptr<Test::MyClassPrx>&,
+ const shared_ptr<Test::MyClassPrx>&,
+ const shared_ptr<Test::MyClassPrx>&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
+{
+ auto p2 = p1;
+ auto p3 = uncheckedCast<Test::MyClassPrx>(current.adapter->createProxy(
+ current.adapter->getCommunicator()->stringToIdentity("noSuchIdentity")));
+ response(uncheckedCast<Test::MyClassPrx>(current.adapter->createProxy(current.id)), p2, p3);
+}
+
+void
+MyDerivedClassI::opStruct_async(Test::Structure p1,
+ Test::Structure p2,
+ function<void (const Test::Structure&, const Test::Structure&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::Structure p3 = p1;
+ p3.s.s = "a new string";
+ response(p2, p3);
+}
+
+void
+MyDerivedClassI::opByteS_async(Test::ByteS p1,
+ Test::ByteS p2,
+ function<void (const Test::ByteS&, const Test::ByteS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ByteS p3;
+ p3.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), p3.begin());
+ Test::ByteS r = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(r));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opBoolS_async(Test::BoolS p1,
+ Test::BoolS p2,
+ function<void (const Test::BoolS&, const Test::BoolS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::BoolS p3 = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
+ Test::BoolS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opShortIntLongS_async(Test::ShortS p1,
+ Test::IntS p2,
+ Test::LongS p3,
+ function<void (const Test::LongS&,
+ const Test::ShortS&,
+ const Test::IntS&,
+ const Test::LongS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ShortS p4 = p1;
+ Test::IntS p5;
+ p5.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), p5.begin());
+ Test::LongS p6 = p3;
+ std::copy(p3.begin(), p3.end(), std::back_inserter(p6));
+ response(p3, p4, p5, p6);
+}
+
+void
+MyDerivedClassI::opFloatDoubleS_async(Test::FloatS p1,
+ Test::DoubleS p2,
+ function<void (const Test::DoubleS&,
+ const Test::FloatS&,
+ const Test::DoubleS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::FloatS p3 = p1;
+ Test::DoubleS p4;
+ p4.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), p4.begin());
+ Test::DoubleS r = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(r));
+ response(r, p3, p4);
+}
+
+void
+MyDerivedClassI::opStringS_async(Test::StringS p1,
+ Test::StringS p2,
+ function<void (const Test::StringS&, const Test::StringS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringS p3 = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
+ Test::StringS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
}
void
+MyDerivedClassI::opByteSS_async(Test::ByteSS p1,
+ Test::ByteSS p2,
+ function<void (const Test::ByteSS&, const Test::ByteSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ByteSS p3;
+ p3.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), p3.begin());
+ Test::ByteSS r = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(r));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opBoolSS_async(Test::BoolSS p1,
+ Test::BoolSS p2,
+ function<void (const Test::BoolSS&, const Test::BoolSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ auto p3 = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
+ Test::BoolSS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opShortIntLongSS_async(Test::ShortSS p1,
+ Test::IntSS p2,
+ Test::LongSS p3,
+ function<void (const Test::LongSS&,
+ const Test::ShortSS&,
+ const Test::IntSS&,
+ const Test::LongSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ auto p4 = p1;
+ Test::IntSS p5;
+ p5.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), p5.begin());
+ auto p6 = p3;
+ std::copy(p3.begin(), p3.end(), std::back_inserter(p6));
+ response(p3, p4, p5, p6);
+}
+
+void
+MyDerivedClassI::opFloatDoubleSS_async(Test::FloatSS p1,
+ Test::DoubleSS p2,
+ function<void (const Test::DoubleSS&,
+ const Test::FloatSS&,
+ const Test::DoubleSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::FloatSS p3 = p1;
+ Test::DoubleSS p4;
+ p4.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), p4.begin());
+ Test::DoubleSS r = p2;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(r));
+ response(r, p3, p4);
+}
+
+void
+MyDerivedClassI::opStringSS_async(Test::StringSS p1,
+ Test::StringSS p2,
+ function<void (const Test::StringSS&, const Test::StringSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringSS p3 = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
+ Test::StringSS r;
+ r.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringSSS_async(Test::StringSSS p1, Test::StringSSS p2,
+ function<void (const Test::StringSSS&, const Test::StringSSS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringSSS p3 = p1;
+ std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
+ Test::StringSSS r;
+ r.resize(p2.size());
+ std::reverse_copy(p2.begin(), p2.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opByteBoolD_async(Test::ByteBoolD p1, Test::ByteBoolD p2,
+ function<void (const Test::ByteBoolD&, const Test::ByteBoolD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ByteBoolD p3 = p1;
+ Test::ByteBoolD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opShortIntD_async(Test::ShortIntD p1, Test::ShortIntD p2,
+ function<void (const Test::ShortIntD&, const Test::ShortIntD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ShortIntD p3 = p1;
+ Test::ShortIntD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opLongFloatD_async(Test::LongFloatD p1, Test::LongFloatD p2,
+ function<void (const Test::LongFloatD&, const Test::LongFloatD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::LongFloatD p3 = p1;
+ Test::LongFloatD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringStringD_async(Test::StringStringD p1, Test::StringStringD p2,
+ function<void (const Test::StringStringD&, const Test::StringStringD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringStringD p3 = p1;
+ Test::StringStringD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringMyEnumD_async(Test::StringMyEnumD p1, Test::StringMyEnumD p2,
+ function<void (const Test::StringMyEnumD&, const Test::StringMyEnumD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringMyEnumD p3 = p1;
+ Test::StringMyEnumD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opMyEnumStringD_async(Test::MyEnumStringD p1, Test::MyEnumStringD p2,
+ function<void (const Test::MyEnumStringD&, const Test::MyEnumStringD&)> response,
+ function<void (exception_ptr)>,
+ 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()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opMyStructMyEnumD_async(Test::MyStructMyEnumD p1, Test::MyStructMyEnumD p2,
+ function<void (const Test::MyStructMyEnumD&,
+ const Test::MyStructMyEnumD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::MyStructMyEnumD p3 = p1;
+ Test::MyStructMyEnumD r = p1;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opByteBoolDS_async(Test::ByteBoolDS p1,
+ Test::ByteBoolDS p2,
+ function<void (const Test::ByteBoolDS&, const Test::ByteBoolDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ByteBoolDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::ByteBoolDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opShortIntDS_async(Test::ShortIntDS p1,
+ Test::ShortIntDS p2,
+ function<void (const Test::ShortIntDS&, const Test::ShortIntDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ShortIntDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::ShortIntDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opLongFloatDS_async(Test::LongFloatDS p1,
+ Test::LongFloatDS p2,
+ function<void (const Test::LongFloatDS&, const Test::LongFloatDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::LongFloatDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::LongFloatDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringStringDS_async(Test::StringStringDS p1,
+ Test::StringStringDS p2,
+ function<void (const Test::StringStringDS&, const Test::StringStringDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringStringDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::StringStringDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringMyEnumDS_async(Test::StringMyEnumDS p1,
+ Test::StringMyEnumDS p2,
+ function<void (const Test::StringMyEnumDS&, const Test::StringMyEnumDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringMyEnumDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::StringMyEnumDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opMyEnumStringDS_async(Test::MyEnumStringDS p1,
+ Test::MyEnumStringDS p2,
+ function<void (const Test::MyEnumStringDS&, const Test::MyEnumStringDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::MyEnumStringDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::MyEnumStringDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opMyStructMyEnumDS_async(Test::MyStructMyEnumDS p1,
+ Test::MyStructMyEnumDS p2,
+ function<void (const Test::MyStructMyEnumDS&,
+ const Test::MyStructMyEnumDS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::MyStructMyEnumDS p3 = p2;
+ std::copy(p1.begin(), p1.end(), std::back_inserter(p3));
+ Test::MyStructMyEnumDS r;
+ r.resize(p1.size());
+ std::reverse_copy(p1.begin(), p1.end(), r.begin());
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opByteByteSD_async(Test::ByteByteSD p1,
+ Test::ByteByteSD p2,
+ function<void (const Test::ByteByteSD&, const Test::ByteByteSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ByteByteSD p3 = p2;
+ Test::ByteByteSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opBoolBoolSD_async(Test::BoolBoolSD p1,
+ Test::BoolBoolSD p2,
+ function<void (const Test::BoolBoolSD&, const Test::BoolBoolSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::BoolBoolSD p3 = p2;
+ Test::BoolBoolSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opShortShortSD_async(Test::ShortShortSD p1,
+ Test::ShortShortSD p2,
+ function<void (const Test::ShortShortSD&, const Test::ShortShortSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::ShortShortSD p3 = p2;
+ Test::ShortShortSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opIntIntSD_async(Test::IntIntSD p1,
+ Test::IntIntSD p2,
+ function<void (const Test::IntIntSD&, const Test::IntIntSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::IntIntSD p3 = p2;
+ Test::IntIntSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opLongLongSD_async(Test::LongLongSD p1,
+ Test::LongLongSD p2,
+ function<void (const Test::LongLongSD&, const Test::LongLongSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::LongLongSD p3 = p2;
+ Test::LongLongSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringFloatSD_async(Test::StringFloatSD p1,
+ Test::StringFloatSD p2,
+ function<void (const Test::StringFloatSD&, const Test::StringFloatSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringFloatSD p3 = p2;
+ Test::StringFloatSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringDoubleSD_async(Test::StringDoubleSD p1,
+ Test::StringDoubleSD p2,
+ function<void (const Test::StringDoubleSD&,
+ const Test::StringDoubleSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringDoubleSD p3 = p2;
+ Test::StringDoubleSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opStringStringSD_async(Test::StringStringSD p1,
+ Test::StringStringSD p2,
+ function<void (const Test::StringStringSD&,
+ const Test::StringStringSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringStringSD p3 = p2;
+ Test::StringStringSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opMyEnumMyEnumSD_async(Test::MyEnumMyEnumSD p1,
+ Test::MyEnumMyEnumSD p2,
+ function<void (const Test::MyEnumMyEnumSD&,
+ const Test::MyEnumMyEnumSD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::MyEnumMyEnumSD p3 = p2;
+ Test::MyEnumMyEnumSD r;
+ std::set_union(p1.begin(), p1.end(), p2.begin(), p2.end(), std::inserter(r, r.end()));
+ response(r, p3);
+}
+
+void
+MyDerivedClassI::opIntS_async(Test::IntS s,
+ function<void (const Test::IntS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::IntS r;
+ std::transform(s.begin(), s.end(), std::back_inserter(r), std::negate<int>());
+ response(r);
+}
+
+void
+MyDerivedClassI::opByteSOneway_async(Test::ByteS,
+ function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ IceUtil::Mutex::Lock sync(_mutex);
+ ++_opByteSOnewayCallCount;
+ response();
+}
+
+void
+MyDerivedClassI::opByteSOnewayCallCount_async(function<void (int)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ IceUtil::Mutex::Lock sync(_mutex);
+ response(_opByteSOnewayCallCount);
+ _opByteSOnewayCallCount = 0;
+}
+
+void
+MyDerivedClassI::opContext_async(function<void (const Ice::Context&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
+{
+ Test::StringStringD r = current.ctx;
+ response(r);
+}
+
+void
+MyDerivedClassI::opDoubleMarshaling_async(Ice::Double p1,
+ Test::DoubleS p2,
+ function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Ice::Double d = 1278312346.0 / 13.0;
+ test(p1 == d);
+ for(unsigned int i = 0; i < p2.size(); ++i)
+ {
+ test(p2[i] == d);
+ }
+ response();
+}
+
+void
+MyDerivedClassI::opIdempotent_async(function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
+{
+ test(current.mode == OperationMode::Idempotent);
+ response();
+}
+
+void
+MyDerivedClassI::opNonmutating_async(function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current& current)
+{
+ test(current.mode == OperationMode::Nonmutating);
+ response();
+}
+
+void
+MyDerivedClassI::opDerived_async(function<void ()> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response();
+}
+
+void
+MyDerivedClassI::opByte1_async(Ice::Byte b,
+ function<void (Ice::Byte)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(b);
+}
+
+void
+MyDerivedClassI::opShort1_async(Ice::Short s,
+ function<void (Ice::Short)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(s);
+}
+
+void
+MyDerivedClassI::opInt1_async(Ice::Int i,
+ function<void (Ice::Int)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(i);
+}
+
+void
+MyDerivedClassI::opLong1_async(Ice::Long l,
+ function<void (Ice::Long)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(l);
+}
+
+void
+MyDerivedClassI::opFloat1_async(Ice::Float f,
+ function<void (Ice::Float)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(f);
+}
+
+void
+MyDerivedClassI::opDouble1_async(Ice::Double d,
+ function<void (Ice::Double)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(d);
+}
+
+void
+MyDerivedClassI::opString1_async(string s,
+ function<void (const string&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(s);
+}
+
+void
+MyDerivedClassI::opStringS1_async(Test::StringS seq,
+ function<void (const Test::StringS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(seq);
+}
+
+void
+MyDerivedClassI::opByteBoolD1_async(Test::ByteBoolD dict,
+ function<void (const Test::ByteBoolD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(dict);
+}
+
+void
+MyDerivedClassI::opStringS2_async(Test::StringS seq,
+ function<void (const Test::StringS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(seq);
+}
+
+void
+MyDerivedClassI::opByteBoolD2_async(Test::ByteBoolD dict,
+ function<void (const Test::ByteBoolD&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(dict);
+}
+
+void
+MyDerivedClassI::opMyStruct1_async(Test::MyStruct1 s,
+ function<void (const Test::MyStruct1&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(s);
+}
+
+void
+MyDerivedClassI::opMyClass1_async(shared_ptr<Test::MyClass1> c,
+ function<void (const shared_ptr<Test::MyClass1>&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ response(c);
+}
+
+void
+MyDerivedClassI::opStringLiterals_async(function<void (const Test::StringS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::StringS data;
+ data.push_back(Test::s0);
+ data.push_back(Test::s1);
+ data.push_back(Test::s2);
+ data.push_back(Test::s3);
+ data.push_back(Test::s4);
+ data.push_back(Test::s5);
+ data.push_back(Test::s6);
+ data.push_back(Test::s7);
+ data.push_back(Test::s8);
+ data.push_back(Test::s9);
+ data.push_back(Test::s10);
+
+ data.push_back(Test::sw0);
+ data.push_back(Test::sw1);
+ data.push_back(Test::sw2);
+ data.push_back(Test::sw3);
+ data.push_back(Test::sw4);
+ data.push_back(Test::sw5);
+ data.push_back(Test::sw6);
+ data.push_back(Test::sw7);
+ data.push_back(Test::sw8);
+ data.push_back(Test::sw9);
+ data.push_back(Test::sw10);
+
+ data.push_back(Test::ss0);
+ data.push_back(Test::ss1);
+ data.push_back(Test::ss2);
+ data.push_back(Test::ss3);
+ data.push_back(Test::ss4);
+ data.push_back(Test::ss5);
+
+ data.push_back(Test::su0);
+ data.push_back(Test::su1);
+ data.push_back(Test::su2);
+
+ response(data);
+}
+
+void
+MyDerivedClassI::opWStringLiterals_async(function<void (const Test::WStringS&)> response,
+ function<void (exception_ptr)>,
+ const Ice::Current&)
+{
+ Test::WStringS data;
+ data.push_back(Test::ws0);
+ data.push_back(Test::ws1);
+ data.push_back(Test::ws2);
+ data.push_back(Test::ws3);
+ data.push_back(Test::ws4);
+ data.push_back(Test::ws5);
+ data.push_back(Test::ws6);
+ data.push_back(Test::ws7);
+ data.push_back(Test::ws8);
+ data.push_back(Test::ws9);
+ data.push_back(Test::ws10);
+
+ data.push_back(Test::wsw0);
+ data.push_back(Test::wsw1);
+ data.push_back(Test::wsw2);
+ data.push_back(Test::wsw3);
+ data.push_back(Test::wsw4);
+ data.push_back(Test::wsw5);
+ data.push_back(Test::wsw6);
+ data.push_back(Test::wsw7);
+ data.push_back(Test::wsw8);
+ data.push_back(Test::wsw9);
+ data.push_back(Test::wsw10);
+
+ data.push_back(Test::wss0);
+ data.push_back(Test::wss1);
+ data.push_back(Test::wss2);
+ data.push_back(Test::wss3);
+ data.push_back(Test::wss4);
+ data.push_back(Test::wss5);
+
+ data.push_back(Test::wsu0);
+ data.push_back(Test::wsu1);
+ data.push_back(Test::wsu2);
+
+ response(data);
+}
+#else
+
+class Thread_opVoid : public IceUtil::Thread
+{
+public:
+
+ Thread_opVoid(const Test::AMD_MyClass_opVoidPtr& cb) :
+ _cb(cb)
+ {
+ }
+
+ virtual void run()
+ {
+ _cb->ice_response();
+ }
+
+private:
+
+ const Test::AMD_MyClass_opVoidPtr _cb;
+};
+
+void
MyDerivedClassI::shutdown_async(const Test::AMD_MyClass_shutdownPtr& cb, const Ice::Current& current)
{
{
@@ -92,7 +1047,7 @@ MyDerivedClassI::delay_async(const Test::AMD_MyClass_delayPtr& cb, Ice::Int ms,
void
MyDerivedClassI::opVoid_async(const Test::AMD_MyClass_opVoidPtr& cb, const Ice::Current& current)
{
- test(current.mode == Ice::Normal);
+ test(current.mode == ICE_ENUM(OperationMode, Normal));
IceUtil::Mutex::Lock sync(_opVoidMutex);
if(_opVoidThread)
@@ -156,18 +1111,19 @@ MyDerivedClassI::opMyEnum_async(const Test::AMD_MyClass_opMyEnumPtr& cb,
Test::MyEnum p1,
const Ice::Current&)
{
- cb->ice_response(Test::enum3, p1);
+ cb->ice_response(ICE_ENUM(MyEnum, enum3), p1);
}
void
MyDerivedClassI::opMyClass_async(const Test::AMD_MyClass_opMyClassPtr& cb,
- const Test::MyClassPrx& p1,
+ const Test::MyClassPrxPtr& p1,
const Ice::Current& current)
{
- Test::MyClassPrx p2 = p1;
- Test::MyClassPrx p3 = Test::MyClassPrx::uncheckedCast(current.adapter->createProxy(
- current.adapter->getCommunicator()->stringToIdentity("noSuchIdentity")));
- cb->ice_response(Test::MyClassPrx::uncheckedCast(current.adapter->createProxy(current.id)), p2, p3);
+ Test::MyClassPrxPtr p2 = p1;
+ Test::MyClassPrxPtr p3 = ICE_UNCHECKED_CAST(
+ Test::MyClassPrx, current.adapter->createProxy(
+ current.adapter->getCommunicator()->stringToIdentity("noSuchIdentity")));
+ cb->ice_response(ICE_UNCHECKED_CAST(Test::MyClassPrx, current.adapter->createProxy(current.id)), p2, p3);
}
void
@@ -680,14 +1636,14 @@ MyDerivedClassI::opDoubleMarshaling_async(const Test::AMD_MyClass_opDoubleMarsha
void
MyDerivedClassI::opIdempotent_async(const Test::AMD_MyClass_opIdempotentPtr& cb, const Ice::Current& current)
{
- test(current.mode == Ice::Idempotent);
+ test(current.mode == ICE_ENUM(OperationMode, Idempotent));
cb->ice_response();
}
void
MyDerivedClassI::opNonmutating_async(const Test::AMD_MyClass_opNonmutatingPtr& cb, const Ice::Current& current)
{
- test(current.mode == Ice::Nonmutating);
+ test(current.mode == ICE_ENUM(OperationMode, Nonmutating));
cb->ice_response();
}
@@ -863,3 +1819,4 @@ MyDerivedClassI::opWStringLiterals_async(const Test::AMD_MyClass_opWStringLitera
data.push_back(Test::wsu2);
cb->ice_response(data);
}
+#endif
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-05 16:57:03 +0000