private int ReadStruct(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantStruct)
{
int result = 0;
if (this.objectDelegate == null) // If no fields
{
variantStruct = null;
} // Ends if no fields
else // Else fields
{
object[] structFields;
result = this.ReadStruct(reader, out structFields);
if (result == 0) // If started struct
{
// Todo - instantiate the thing which holds onto the field types.
// Basically this is our existing container but with object[] instead of dbus_union[]
variantStruct = Udbus.Containers.dbus_union.CreateStruct(structFields, this.parent.Types.ToArray());
} // Ends if started struct
else // Else failed to start struct
{
variantStruct = null;
} // Ends else failed to start struct
} // Ends else fields
return(result);
}
public int ReadVariantUInt64(Udbus.Containers.dbus_union variant)
{
System.UInt64 val;
int result = this.ReadUInt64(out val);
variant.DbusUInt64 = val;
return(result);
}
public int ReadVariantInt32(Udbus.Containers.dbus_union variant)
{
System.Int32 val;
int result = this.ReadInt32(out val);
variant.DbusInt32 = val;
return(result);
}
public int ReadVariantString(Udbus.Containers.dbus_union variant)
{
string val;
int result = this.ReadString(out val);
variant.DbusString = val;
return(result);
}
public int ReadVariantDouble(Udbus.Containers.dbus_union variant)
{
double val;
int result = this.ReadDouble(out val);
variant.DbusDouble = val;
return(result);
}
public int ReadVariantBoolean(Udbus.Containers.dbus_union variant)
{
bool val;
int result = this.ReadBoolean(out val);
variant.DbusBoolean = val;
return(result);
}
public int ReadVariantByte(Udbus.Containers.dbus_union variant)
{
byte val;
int result = this.ReadByte(out val);
variant.DbusByte = val;
return(result);
}
private int ReadArrayObject(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantArray)
{
object[] output;
int result = reader.MarshalEnumerable(this.ObjectDelegate, this.Type, out output);
variantArray = Udbus.Containers.dbus_union.Create(output, this.owner.Types.ToArray());
return(result);
}
private int ReadDictionary(Udbus.Serialization.UdbusMessageReader reader, out Udbus.Containers.dbus_union variantDict)
{
Dictionary <object, object> dict;
int result = this.ReadDictionary(reader, out dict);
variantDict = Udbus.Containers.dbus_union.Create(dict, this.owner.Types.ToArray());
return(result);
}
public int ReadVariantObjectPath(Udbus.Containers.dbus_union variant)
{
Udbus.Types.UdbusObjectPath val;
int result = this.ReadObjectPath(out val);
variant.DbusObjectPath = val;
return(result);
}
public int ReadVariantVariant(Udbus.Containers.dbus_union variant)
{
Udbus.Containers.dbus_union val;
int result = this.ReadVariant(out val);
variant.DbusVariant = val;
return(result);
}
public int ReadVariantInt64(out Udbus.Containers.dbus_union variant)
{
System.Int64 val;
int result = this.ReadInt64(out val);
// variant.DbusInt64 = val;
variant = Udbus.Containers.dbus_union.Create(val);
return(result);
}
public int ReadVariantUInt32(out Udbus.Containers.dbus_union variant)
{
System.UInt32 val;
int result = this.ReadUInt32(out val);
// variant.DbusUInt32 = val;
variant = Udbus.Containers.dbus_union.Create(val);
return(result);
}
private int WriteDictionary(Udbus.Serialization.UdbusMessageBuilder builder, Udbus.Containers.dbus_union variantDict)
{
int result;
if (variantDict.IsDbusDictionary == false) // If not a dictionary
{
result = -1;
throw new System.InvalidCastException("object is a dbus_union, but not a dbus dictionary");
} // Ends if not a dictionary
else // Else a dictionary
{
result = builder.MarshalDict(variantDict.DbusDictionary, this.ObjectDelegateKey, this.ObjectDelegateValue);
} // Ends else a dictionary
return(result);
}
private int WriteDictionaryObject(Udbus.Serialization.UdbusMessageBuilder builder, object objDict)
{
int result;
if (objDict is Udbus.Containers.dbus_union == false)
{
result = -1;
throw new System.InvalidCastException("object is not a dbus_union");
}
else
{
Udbus.Containers.dbus_union variantDict = (Udbus.Containers.dbus_union)objDict;
result = this.WriteDictionary(builder, variantDict);
}
return(result);
}
// The object returned from a struct read is always a variant...
private int WriteStructObject(Udbus.Serialization.UdbusMessageBuilder builder, object objStruct)
{
int result;
if (objStruct is Udbus.Containers.dbus_union) // If it's a struct
{
Udbus.Containers.dbus_union variantStruct = (Udbus.Containers.dbus_union)objStruct;
result = this.WriteStruct(builder, variantStruct);
} // Ends if it's a struct
else if (objStruct is object[]) // Else if it's an array
{
object[] structFields = (object[])objStruct;
result = this.WriteStruct(builder, structFields);
} // Ends if it's an array
else // Else wrong type
{
result = -1;
throw new System.InvalidCastException("object is not a dbus_union or object[]");
} // Ends else wrong type
return(result);
}
static void Foo()
{
//public delegate int MarshalReadDelegate<T>(Udbus.Serialization.UdbusMessageReader reader, out T t); // This would actually probably be better, despite sample code.
//public delegate T MarshalReadResultDelegate<T>(Udbus.Serialization.UdbusMessageReader reader, out int result);
//public static int ReadString(UdbusMessageReader reader, out string value)
Udbus.Serialization.MarshalReadDelegate<string> ds = Udbus.Serialization.UdbusMessageReader.ReadString;
Udbus.Serialization.MarshalReadDelegate<Udbus.Containers.dbus_union> dvbool = Udbus.Serialization.UdbusMessageReader.ReadVariantBoolean;
Udbus.Serialization.MarshalReadDelegate<Udbus.Containers.dbus_union> dvbyte = Udbus.Serialization.UdbusMessageReader.ReadVariantByte;
//Udbus.Core.MarshalReadDelegate<Udbus.Containers.dbus_union> dvmulti = new Udbus.Core.MarshalReadDelegate<Udbus.Containers.dbus_union>();
//dvmulti += dvbool;
//dvmulti += dvbyte;
Udbus.Serialization.UdbusMessageReader reader = new Udbus.Serialization.UdbusMessageReader(null);
Udbus.Containers.dbus_union u1 = new Udbus.Containers.dbus_union();
reader.ReadVariantByte(u1);
reader.ReadVariantByte(out u1);
MarshalEventTest met = new MarshalEventTest();
met.foo += dvbool;
met.foo += dvbyte;
met.Dude(reader, out u1);
}
public Udbus.Containers.dbus_union ReadVariantVariant()
{
Udbus.Containers.dbus_union val = this.ReadVariant();
return(Udbus.Containers.dbus_union.Create(val));
}
private int WriteStruct(Udbus.Serialization.UdbusMessageBuilder builder, Udbus.Containers.dbus_union variantStruct)
{
return(this.WriteStruct(builder, variantStruct.DbusObjectStruct));
}
static public dbus_union Create(Udbus.Containers.dbus_union value)
{
return(new dbus_union {
DbusVariant = value
});
}
protected dbus_union(Udbus.Containers.dbus_union value)
{
this.DbusVariant = value;
}
public object GetDeserializedObject(object obj, Type targetType)
{
object result;
if (obj is DbusUnionSurrogate)
{
DbusUnionSurrogate unionSurrogate = (DbusUnionSurrogate)obj;
Udbus.Containers.dbus_union union = new Udbus.Containers.dbus_union();
switch (unionSurrogate.unionTypes[0])
{
case Udbus.Types.dbus_type.DBUS_BOOLEAN:
union.DbusBoolean = (bool)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_BYTE:
union.DbusByte = (byte)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_OBJECTPATH:
union.DbusObjectPath = new Udbus.Types.UdbusObjectPath((string)unionSurrogate.data);
break;
case Udbus.Types.dbus_type.DBUS_SIGNATURE:
union.DbusSignature = (Udbus.Types.dbus_sig)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_STRING:
union.DbusString = (string)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT16:
union.DbusInt16 = (Int16)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT16:
union.DbusUInt16 = (UInt16)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT32:
union.DbusInt32 = (Int32)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT32:
union.DbusUInt32 = (UInt32)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT64:
union.DbusInt64 = (Int64)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT64:
union.DbusUInt64 = (UInt64)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_DOUBLE:
union.DbusDouble = (double)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_ARRAY:
union.SetDbusObjectArray((object[])unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_STRUCT_BEGIN:
union.SetDbusObjectStruct((object[])unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_VARIANT:
union.DbusVariant = (Udbus.Containers.dbus_union)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_DICT_BEGIN:
union.SetDbusDictionary((Dictionary <object, object>)unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_INVALID:
break;
default:
throw new Exception(string.Format("Unkonwn dbus_type: {0}", unionSurrogate.unionTypes.ToString()));
}
result = union;
}
else
{
result = obj;
}
return(result);
}
public object GetObjectToSerialize(object obj, Type targetType)
{
object result;
if (obj is Udbus.Containers.dbus_union)
{
Udbus.Containers.dbus_union union = (Udbus.Containers.dbus_union)obj;
DbusUnionSurrogate unionSurrogate = new DbusUnionSurrogate();
unionSurrogate.unionTypes = Udbus.Types.dbus_sig.TruncatedCopy(union.Types);
switch (union.Type)
{
case Udbus.Types.dbus_type.DBUS_BOOLEAN:
unionSurrogate.data = union.DbusBoolean;
break;
case Udbus.Types.dbus_type.DBUS_BYTE:
unionSurrogate.data = union.DbusByte;
break;
case Udbus.Types.dbus_type.DBUS_OBJECTPATH:
unionSurrogate.data = union.DbusObjectPath.Path;
break;
case Udbus.Types.dbus_type.DBUS_SIGNATURE:
unionSurrogate.data = union.DbusSignature;
break;
case Udbus.Types.dbus_type.DBUS_STRING:
unionSurrogate.data = union.DbusString;
break;
case Udbus.Types.dbus_type.DBUS_INT16:
unionSurrogate.data = union.DbusInt16;
break;
case Udbus.Types.dbus_type.DBUS_UINT16:
unionSurrogate.data = union.DbusUInt16;
break;
case Udbus.Types.dbus_type.DBUS_INT32:
unionSurrogate.data = union.DbusInt32;
break;
case Udbus.Types.dbus_type.DBUS_UINT32:
unionSurrogate.data = union.DbusUInt32;
break;
case Udbus.Types.dbus_type.DBUS_INT64:
unionSurrogate.data = union.DbusInt64;
break;
case Udbus.Types.dbus_type.DBUS_UINT64:
unionSurrogate.data = union.DbusUInt64;
break;
case Udbus.Types.dbus_type.DBUS_DOUBLE:
unionSurrogate.data = union.DbusDouble;
break;
case Udbus.Types.dbus_type.DBUS_ARRAY:
unionSurrogate.data = union.DbusObjectArray;
break;
case Udbus.Types.dbus_type.DBUS_STRUCT_BEGIN:
unionSurrogate.data = union.DbusObjectStruct;
break;
case Udbus.Types.dbus_type.DBUS_VARIANT:
unionSurrogate.data = union.DbusVariant;
break;
case Udbus.Types.dbus_type.DBUS_DICT_BEGIN:
unionSurrogate.data = union.DbusDictionary;
break;
case Udbus.Types.dbus_type.DBUS_INVALID:
break;
default:
throw new Exception(string.Format("Unkonwn dbus_type for surrogate: {0}", union.Type.ToString()));
}
result = unionSurrogate;
}
else
{
result = obj;
}
return(result);
}
public int BodyAdd_VariantUInt64(Udbus.Containers.dbus_union variant)
{
return(this.BodyAdd_UInt64(variant.DbusUInt64).Result);
}
public int BodyAdd_VariantDouble(Udbus.Containers.dbus_union variant)
{
return(this.BodyAdd_Double(variant.DbusDouble).Result);
}
public static int ReadVariantVariant(UdbusMessageReader reader, out Udbus.Containers.dbus_union value)
{
return(reader.ReadVariantVariant(out value));
}
public static int ReadVariantDouble(UdbusMessageReader reader, Udbus.Containers.dbus_union value)
{
return(reader.ReadVariantDouble(value));
}
public Udbus.Containers.dbus_union ReadVariantVariantValue(out int result)
{
Udbus.Containers.dbus_union val = this.ReadVariantValue(out result);
return(Udbus.Containers.dbus_union.Create(val));
}
public int BodyAdd_VariantVariant(Udbus.Containers.dbus_union variant)
{
return(this.BodyAdd_Variant(variant.DbusVariant).Result);
}
public static int BodyAdd_VariantVariant(UdbusMessageBuilder builder, Udbus.Containers.dbus_union value)
{
return(builder.BodyAdd_VariantVariant(value));
}
private int WriteArrayObject(Udbus.Serialization.UdbusMessageBuilder builder, Udbus.Containers.dbus_union variantArray)
{
int result = builder.MarshalEnumerable(variantArray.DbusObjectArray, this.Type, this.ObjectDelegate);
return(result);
}
public object GetDeserializedObject(object obj, Type targetType)
{
object result;
if (obj is DbusUnionSurrogate)
{
DbusUnionSurrogate unionSurrogate = (DbusUnionSurrogate)obj;
Udbus.Containers.dbus_union union = new Udbus.Containers.dbus_union();
switch (unionSurrogate.unionTypes[0])
{
case Udbus.Types.dbus_type.DBUS_BOOLEAN:
union.DbusBoolean = (bool)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_BYTE:
union.DbusByte = (byte)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_OBJECTPATH:
union.DbusObjectPath = new Udbus.Types.UdbusObjectPath((string)unionSurrogate.data);
break;
case Udbus.Types.dbus_type.DBUS_SIGNATURE:
union.DbusSignature = (Udbus.Types.dbus_sig)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_STRING:
union.DbusString = (string)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT16:
union.DbusInt16 = (Int16)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT16:
union.DbusUInt16 = (UInt16)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT32:
union.DbusInt32 = (Int32)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT32:
union.DbusUInt32 = (UInt32)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_INT64:
union.DbusInt64 = (Int64)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_UINT64:
union.DbusUInt64 = (UInt64)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_DOUBLE:
union.DbusDouble = (double)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_ARRAY:
union.SetDbusObjectArray((object[])unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_STRUCT_BEGIN:
union.SetDbusObjectStruct((object[])unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_VARIANT:
union.DbusVariant = (Udbus.Containers.dbus_union)unionSurrogate.data;
break;
case Udbus.Types.dbus_type.DBUS_DICT_BEGIN:
union.SetDbusDictionary((Dictionary<object, object>)unionSurrogate.data, unionSurrogate.unionTypes);
break;
case Udbus.Types.dbus_type.DBUS_INVALID:
break;
default:
throw new Exception(string.Format("Unkonwn dbus_type: {0}", unionSurrogate.unionTypes.ToString()));
}
result = union;
}
else
{
result = obj;
}
return result;
}
