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; }