//
// AMD
//
public override void amdAdd_async(Test.AMD_MyObject_amdAdd cb, int x, int y, Ice.Current current)
{
Thread thread = new Thread(delegate()
{
Thread.Sleep(10);
cb.ice_response(x + y);
});
thread.IsBackground = true;
thread.Start();
}
public void shutdown_async(Test.AMD_MyClass_shutdown cb, Ice.Current current)
{
while(_opVoidThread != null)
{
_opVoidThread.Join();
_opVoidThread = null;
}
current.adapter.getCommunicator().shutdown();
cb.ice_response();
}
public void opBoolS_async(Test.AMD_MyClass_opBoolS cb, Test.BoolS p1, Test.BoolS p2, Ice.Current current)
{
Test.BoolS p3 = new Test.BoolS();
p3.AddRange(p1);
p3.AddRange(p2);
Test.BoolS r = new Test.BoolS();
for(int i = 0; i < p1.Count; i++)
{
r.Add(p1[p1.Count - (i + 1)]);
}
cb.ice_response(r, p3);
}
public void opBoolSS_async(Test.AMD_MyClass_opBoolSS cb, bool[][] p1, bool[][] p2,
Ice.Current current)
{
bool[][] p3 = new bool[p1.Length + p2.Length][];
Array.Copy(p1, p3, p1.Length);
Array.Copy(p2, 0, p3, p1.Length, p2.Length);
bool[][] r = new bool[p1.Length][];
for(int i = 0; i < p1.Length; i++)
{
r[i] = p1[p1.Length - (i + 1)];
}
cb.ice_response(r, p3);
}
public override void opBoolBoolSD_async(Test.AMD_MyClass_opBoolBoolSD cb,
Dictionary<bool, bool[]> p1,
Dictionary<bool, bool[]> p2,
Ice.Current current)
{
Dictionary<bool, bool[]> p3 = p2;
Dictionary<bool, bool[]> r = new Dictionary<bool, bool[]>();
foreach(KeyValuePair<bool, bool[]> e in p1)
{
r[e.Key] = e.Value;
}
foreach(KeyValuePair<bool, bool[]> e in p2)
{
r[e.Key] = e.Value;
}
cb.ice_response(r,p3);
}
public override void amdAddWithRetry_async(Test.AMD_MyObject_amdAddWithRetry cb, int x, int y, Ice.Current current)
{
Thread thread = new Thread(delegate()
{
Thread.Sleep(10);
cb.ice_response(x + y);
});
thread.IsBackground = true;
thread.Start();
if(current.ctx.ContainsKey("retry") && current.ctx["retry"].Equals("no"))
{
return;
}
else
{
throw new Test.RetryException();
}
}
public override void opMyStruct1_async(Test.AMD_MyDerivedClass_opMyStruct1 cb, Test.MyStruct1 value,
Ice.Current current)
{
cb.ice_response(value);
}
public override void opStringS2_async(Test.AMD_MyClass_opStringS2 cb, string[] value, Ice.Current current)
{
cb.ice_response(value);
}
public override void opFloat1_async(Test.AMD_MyClass_opFloat1 cb, float value, Ice.Current current)
{
cb.ice_response(value);
}
public override void opDerived_async(Test.AMD_MyDerivedClass_opDerived cb, Ice.Current current)
{
cb.ice_response();
}
public override void opIdempotent_async(Test.AMD_MyClass_opIdempotent cb, Ice.Current current)
{
test(current.mode == Ice.OperationMode.Idempotent);
cb.ice_response();
}
public override void opStringStringD_async(Test.AMD_MyClass_opStringStringD cb, Dictionary<string, string> p1,
Dictionary<string, string> p2, Ice.Current current)
{
Dictionary<string, string> p3 = p1;
Dictionary<string, string> r = new Dictionary<string, string>();
foreach(KeyValuePair<string, string> e in p1)
{
r[e.Key] = e.Value;
}
foreach(KeyValuePair<string, string> e in p2)
{
r[e.Key] = e.Value;
}
cb.ice_response(r, p3);
}
public override void opString_async(Test.AMD_MyClass_opString cb, string p1, string p2, Ice.Current current)
{
cb.ice_response(p1 + " " + p2, p2 + " " + p1);
}
public override void opShortIntLongSS_async(Test.AMD_MyClass_opShortIntLongSS cb, short[][] p1,
int[][] p2, long[][] p3, Ice.Current current)
{
short[][] p4 = p1;
int[][] p5 = new int[p2.Length][];
for(int i = 0; i < p2.Length; i++)
{
p5[i] = p2[p2.Length - (i + 1)];
}
long[][] p6 = new long[p3.Length + p3.Length][];
Array.Copy(p3, p6, p3.Length);
Array.Copy(p3, 0, p6, p3.Length, p3.Length);
cb.ice_response(p3, p4, p5, p6);
}
public override void opShortIntLong_async(Test.AMD_MyClass_opShortIntLong cb, short p1, int p2, long p3,
Ice.Current current)
{
cb.ice_response(p3, p1, p2, p3);
}
public override void opDoubleMarshaling_async(Test.AMD_MyClass_opDoubleMarshaling cb, double p1, double[] p2,
Ice.Current current)
{
double d = 1278312346.0 / 13.0;
test(p1 == d);
for(int i = 0; i < p2.Length; ++i)
{
test(p2[i] == d);
}
cb.ice_response();
}
public override void opStringSSS_async(Test.AMD_MyClass_opStringSSS cb, string[][][] p1, string[][][] p2,
Ice.Current current)
{
string[][][] p3 = new string[p1.Length + p2.Length][][];
Array.Copy(p1, p3, p1.Length);
Array.Copy(p2, 0, p3, p1.Length, p2.Length);
string[][][] r = new string[p2.Length][][];
for(int i = 0; i < p2.Length; i++)
{
r[i] = p2[p2.Length - (i + 1)];
}
cb.ice_response(r, p3);
}
public override void opMyStructMyEnumD_async(Test.AMD_MyClass_opMyStructMyEnumD cb,
Dictionary<Test.MyStruct, Test.MyEnum> p1,
Dictionary<Test.MyStruct, Test.MyEnum> p2, Ice.Current current)
{
Dictionary<Test.MyStruct, Test.MyEnum> p3 = p1;
Dictionary<Test.MyStruct, Test.MyEnum> r = new Dictionary<Test.MyStruct, Test.MyEnum>();
foreach(KeyValuePair<Test.MyStruct, Test.MyEnum> e in p1)
{
r[e.Key] = e.Value;
}
foreach(KeyValuePair<Test.MyStruct, Test.MyEnum> e in p2)
{
r[e.Key] = e.Value;
}
cb.ice_response(r, p3);
}
public override void opStruct_async(Test.AMD_MyClass_opStruct cb, Test.Structure p1, Test.Structure p2,
Ice.Current current)
{
Test.Structure p3 = p1;
p3.s.s = "a new string";
cb.ice_response(p2, p3);
}
public override void opMyStructMyEnumDS_async(Test.AMD_MyClass_opMyStructMyEnumDS cb,
Dictionary<Test.MyStruct, Test.MyEnum>[] p1,
Dictionary<Test.MyStruct, Test.MyEnum>[] p2,
Ice.Current current)
{
Dictionary<Test.MyStruct, Test.MyEnum>[] p3 = new Dictionary<Test.MyStruct, Test.MyEnum>[p1.Length + p2.Length];
Array.Copy(p2, p3, p2.Length);
Array.Copy(p1, 0, p3, p2.Length, p1.Length);
Dictionary<Test.MyStruct, Test.MyEnum>[] r = new Dictionary<Test.MyStruct, Test.MyEnum>[p1.Length];
for(int i = 0; i < p1.Length; i++)
{
r[i] = p1[p1.Length - (i + 1)];
}
cb.ice_response(r,p3);
}
public override void opNonmutating_async(Test.AMD_MyClass_opNonmutating cb, Ice.Current current)
{
test(current.mode == Ice.OperationMode.Nonmutating);
cb.ice_response();
}
public override void opMyEnumMyEnumSD_async(Test.AMD_MyClass_opMyEnumMyEnumSD cb,
Dictionary<Test.MyEnum, Test.MyEnum[]> p1,
Dictionary<Test.MyEnum, Test.MyEnum[]> p2,
Ice.Current ice)
{
Dictionary<Test.MyEnum, Test.MyEnum[]> p3 = p2;
Dictionary<Test.MyEnum, Test.MyEnum[]> r = new Dictionary<Test.MyEnum, Test.MyEnum[]>();
foreach(KeyValuePair<Test.MyEnum, Test.MyEnum[]> e in p1)
{
r[e.Key] = e.Value;
}
foreach(KeyValuePair<Test.MyEnum, Test.MyEnum[]> e in p2)
{
r[e.Key] = e.Value;
}
cb.ice_response(r,p3);
}
public override void opLong1_async(Test.AMD_MyClass_opLong1 cb, long value, Ice.Current current)
{
cb.ice_response(value);
}
public override void opIntS_async(Test.AMD_MyClass_opIntS cb, int[] s, Ice.Current current)
{
int[] r = new int[s.Length];
for(int i = 0; i < s.Length; ++i)
{
r[i] = -s[i];
}
cb.ice_response(r);
}
public override void opDouble1_async(Test.AMD_MyClass_opDouble1 cb, double value, Ice.Current current)
{
cb.ice_response(value);
}
public override void opContext_async(Test.AMD_MyClass_opContext cb, Ice.Current current)
{
cb.ice_response(current.ctx);
}
public override void opByteBoolD2_async(Test.AMD_MyClass_opByteBoolD2 cb, Dictionary<byte, bool> value,
Ice.Current current)
{
cb.ice_response(value);
}
public override void opByteSOneway_async(Test.AMD_MyClass_opByteSOneway cb, byte[] s, Ice.Current current)
{
lock(this)
{
++_opByteSOnewayCallCount;
}
cb.ice_response();
}
public override void delay_async(Test.AMD_MyClass_delay cb, int ms, Ice.Current current)
{
System.Threading.Thread.Sleep(ms);
cb.ice_response();
}
public override void opByteSOnewayCallCount_async(Test.AMD_MyClass_opByteSOnewayCallCount cb, Ice.Current current)
{
lock(this)
{
int count = _opByteSOnewayCallCount;
_opByteSOnewayCallCount = 0;
cb.ice_response(count);
}
}
