public override Ice.Optional <Test.MyEnum> opMyEnum(Ice.Optional <Test.MyEnum> p1, out Ice.Optional <Test.MyEnum> p3,
Ice.Current current)
{
p3 = p1;
return(p1);
}
opSerializableAsync(Ice.Optional <SerializableClass> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpSerializableResult>(new Initial_OpSerializableResult(p1, p1)));
}
opIntOneOptionalDictAsync(Ice.Optional <Dictionary <int, OneOptional> > p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpIntOneOptionalDictResult>(new Initial_OpIntOneOptionalDictResult(p1, p1)));
}
opStringSeqAsync(Ice.Optional <string[]> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpStringSeqResult>(new Initial_OpStringSeqResult(p1, p1)));
}
opFixedStructListAsync(Ice.Optional <LinkedList <FixedStruct> > p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpFixedStructListResult>(new Initial_OpFixedStructListResult(p1, p1)));
}
opOneOptionalProxyAsync(Ice.Optional <OneOptionalPrx> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpOneOptionalProxyResult>(new Initial_OpOneOptionalProxyResult(p1, p1)));
}
opFloatSeqAsync(Ice.Optional <float[]> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpFloatSeqResult>(new Initial_OpFloatSeqResult(p1, p1)));
}
public override Ice.Optional <bool> opBool(Ice.Optional <bool> p1, out Ice.Optional <bool> p3, Ice.Current current)
{
p3 = p1;
return(p1);
}
public override Ice.Optional <short> opShort(Ice.Optional <short> p1, out Ice.Optional <short> p3, Ice.Current current)
{
p3 = p1;
return(p1);
}
public override void opDerivedException(Ice.Optional <int> a, Ice.Optional <string> b,
Ice.Optional <Test.OneOptional> o, Ice.Current current)
{
throw new Test.DerivedException(false, a, b, o, b, o);
}
public override Ice.Optional <byte> opByte(Ice.Optional <byte> p1, out Ice.Optional <byte> p3, Ice.Current current)
{
p3 = p1;
return(p1);
}
public override void returnOptionalClass(bool req, out Ice.Optional <Test.OneOptional> o, Ice.Current current)
{
o = new Test.OneOptional(53);
}
public override void sendOptionalClass(bool req, Ice.Optional <Test.OneOptional> o, Ice.Current current)
{
}
public override Ice.Optional <String[]> opStringSeq(Ice.Optional <String[]> p1, out Ice.Optional <String[]> p3,
Ice.Current current)
{
p3 = p1;
return(p1);
}
public override int run(string[] args)
{
if (args.Length > 0)
{
Console.Error.WriteLine(appName() + ": too many arguments");
return(1);
}
ContactDBPrx contactdb = ContactDBPrxHelper.checkedCast(communicator().propertyToProxy("ContactDB.Proxy"));
if (contactdb == null)
{
Console.Error.WriteLine(appName() + ": invalid proxy");
return(1);
}
//
// Add a contact for "john". All parameters are provided.
//
String johnNumber = "123-456-7890";
contactdb.addContact("john", NumberType.HOME, johnNumber, 0);
Console.Write("Checking john... ");
//
// Find the phone number for "john".
//
Ice.Optional <String> number = contactdb.queryNumber("john");
//
// HasValue tests if an optional value is set.
//
if (!number.HasValue)
{
Console.Write("number is incorrect ");
}
//
// Call Value to retrieve the optional value.
//
if (!number.Value.Equals(johnNumber))
{
Console.Write("number is incorrect ");
}
// Optional can also be used in an out parameter.
Ice.Optional <int> dialgroup;
contactdb.queryDialgroup("john", out dialgroup);
if (!dialgroup.HasValue || dialgroup.Value != 0)
{
Console.Write("dialgroup is incorrect ");
}
Contact info = contactdb.query("john");
//
// All of the info parameters should be set. Each of the optional members
// of the class map to Ice.Optional<T> member.
//
if (!info.type.HasValue || !info.number.HasValue || !info.dialGroup.HasValue)
{
Console.Write("info is incorrect ");
}
if (info.type.Value != NumberType.HOME || !info.number.Value.Equals(johnNumber) || info.dialGroup.Value != 0)
{
Console.Write("info is incorrect ");
}
Console.WriteLine("ok");
//
// Add a contact for "steve". The behavior of the server is to
// default construct the Contact, and then assign all set parameters.
// Since the default value of NumberType in the slice definition
// is NumberType.HOME and in this case the NumberType is unset it will take
// the default value.
//
// The C# mapping permits Ice.Util.None to be passed to unset optional values.
//
String steveNumber = "234-567-8901";
contactdb.addContact("steve", Ice.Util.None, steveNumber, 1);
Console.Write("Checking steve... ");
number = contactdb.queryNumber("steve");
if (!number.Value.Equals(steveNumber))
{
Console.Write("number is incorrect ");
}
info = contactdb.query("steve");
//
// Check the value for the NumberType.
//
if (!info.type.HasValue || info.type.Value != NumberType.HOME)
{
Console.Write("info is incorrect ");
}
if (!info.number.Value.Equals(steveNumber) || info.dialGroup.Value != 1)
{
Console.Write("info is incorrect ");
}
contactdb.queryDialgroup("steve", out dialgroup);
if (!dialgroup.HasValue || dialgroup.Value != 1)
{
Console.Write("dialgroup is incorrect ");
}
Console.WriteLine("ok");
//
// Add a contact from "frank". Here the dialGroup field isn't set.
//
String frankNumber = "345-678-9012";
contactdb.addContact("frank", NumberType.CELL, frankNumber, Ice.Util.None);
Console.Write("Checking frank... ");
number = contactdb.queryNumber("frank");
if (!number.Value.Equals(frankNumber))
{
Console.Write("number is incorrect ");
}
info = contactdb.query("frank");
//
// The dial group field should be unset.
//
if (info.dialGroup.HasValue)
{
Console.Write("info is incorrect ");
}
if (info.type.Value != NumberType.CELL || !info.number.Value.Equals(frankNumber))
{
Console.Write("info is incorrect ");
}
contactdb.queryDialgroup("frank", out dialgroup);
if (dialgroup.HasValue)
{
Console.Write("dialgroup is incorrect ");
}
Console.WriteLine("ok");
//
// Add a contact from "anne". The number field isn't set.
//
contactdb.addContact("anne", NumberType.OFFICE, Ice.Util.None, 2);
Console.Write("Checking anne... ");
number = contactdb.queryNumber("anne");
if (number.HasValue)
{
Console.Write("number is incorrect ");
}
info = contactdb.query("anne");
//
// The number field should be unset.
//
if (info.number.HasValue)
{
Console.Write("info is incorrect ");
}
if (info.type.Value != NumberType.OFFICE || info.dialGroup.Value != 2)
{
Console.Write("info is incorrect ");
}
contactdb.queryDialgroup("anne", out dialgroup);
if (!dialgroup.HasValue || dialgroup.Value != 2)
{
Console.Write("dialgroup is incorrect ");
}
//
// The optional fields can be used to determine what fields to
// update on the contact. Here we update only the number for anne,
// the remainder of the fields are unchanged.
//
String anneNumber = "456-789-0123";
contactdb.updateContact("anne", Ice.Util.None, new Ice.Optional <String>(anneNumber), Ice.Util.None);
number = contactdb.queryNumber("anne");
if (!number.Value.Equals(anneNumber))
{
Console.Write("number is incorrect ");
}
info = contactdb.query("anne");
if (!info.number.Value.Equals(anneNumber) || info.type.Value != NumberType.OFFICE || info.dialGroup.Value != 2)
{
Console.Write("info is incorrect ");
}
Console.WriteLine("ok");
contactdb.shutdown();
return(0);
}
public override Ice.Optional <int> opInt(Ice.Optional <int> p1, out Ice.Optional <int> p3, Ice.Current current)
{
p3 = p1;
return(p1);
}
opMyEnumAsync(Ice.Optional <MyEnum> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpMyEnumResult>(new Initial_OpMyEnumResult(p1, p1)));
}
public override Ice.Optional <float> opFloat(Ice.Optional <float> p1, out Ice.Optional <float> p3, Ice.Current current)
{
p3 = p1;
return(p1);
}
opBoolSeqAsync(Ice.Optional <bool[]> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpBoolSeqResult>(new Initial_OpBoolSeqResult(p1, p1)));
}
public override Ice.Optional <double> opDouble(Ice.Optional <double> p1, out Ice.Optional <double> p3,
Ice.Current current)
{
p3 = p1;
return(p1);
}
opDoubleSeqAsync(Ice.Optional <double[]> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpDoubleSeqResult>(new Initial_OpDoubleSeqResult(p1, p1)));
}
public override Ice.Optional <string> opString(Ice.Optional <string> p1, out Ice.Optional <string> p3,
Ice.Current current)
{
p3 = p1;
return(p1);
}
opSmallStructListAsync(Ice.Optional <List <SmallStruct> > p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpSmallStructListResult>(new Initial_OpSmallStructListResult(p1, p1)));
}
public override Ice.ObjectPrx getClientProxy(out Ice.Optional <bool> hasRoutingTable, Ice.Current current)
{
hasRoutingTable = new Ice.Optional <bool>(true);
_controller.checkCallPause(current);
return(null);
}
opVarStructSeqAsync(Ice.Optional <VarStruct[]> p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpVarStructSeqResult>(new Initial_OpVarStructSeqResult(p1, p1)));
}
public override void addContact(string name, Ice.Optional <Demo.NumberType> type, Ice.Optional <string> number, Ice.Optional <int> dialGroup,
Ice.Current current)
{
Contact contact = new Contact();
contact.name = name;
if (type.HasValue)
{
contact.type = type;
}
if (number.HasValue)
{
contact.number = number;
}
if (dialGroup.HasValue)
{
contact.dialGroup = dialGroup;
}
_contacts[name] = contact;
}
opStringIntDictAsync(Ice.Optional <Dictionary <string, int> > p1, Ice.Current current)
{
return(Task.FromResult <Initial_OpStringIntDictResult>(new Initial_OpStringIntDictResult(p1, p1)));
}
public override void updateContact(string name, Ice.Optional <Demo.NumberType> type, Ice.Optional <string> number,
Ice.Optional <int> dialGroup, Ice.Current current)
{
Contact c;
if (_contacts.TryGetValue(name, out c))
{
if (type.HasValue)
{
c.type = type;
}
if (number.HasValue)
{
c.number = number;
}
if (dialGroup.HasValue)
{
c.dialGroup = dialGroup;
}
}
}
sendOptionalClassAsync(bool req, Ice.Optional <OneOptional> o, Ice.Current current)
{
return(null);
}
opMG2(Ice.Optional <Test.G> p1, Ice.Current current)
{
return(new Test.Initial_OpMG2MarshaledResult(p1, p1, current));
}
