public static void Define(TypeBuilder typeB, Interface iface)
{
foreach (Method declMethod in iface.Methods)
{
//MethodBuilder method_builder = typeB.DefineMethod (declMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, declMethod.ReturnType, Mapper.GetTypes (ArgDirection.In, declMethod.GetParameters ()));
List <Type> parms = new List <Type> ();
if (declMethod.Arguments != null)
{
foreach (Argument arg in declMethod.Arguments)
{
if (arg.Direction == Introspection.ArgDirection.@in)
{
parms.Add(new Signature(arg.Type).ToType());
}
//if (arg.Direction == Introspection.ArgDirection.@out)
// parms.Add (new Signature (arg.Type).ToType ().MakeByRefType ());
}
}
Signature outSig = Signature.Empty;
//this just takes the last out arg and uses is as the return type
if (declMethod.Arguments != null)
{
foreach (Argument arg in declMethod.Arguments)
{
if (arg.Direction == Introspection.ArgDirection.@out)
{
outSig = new Signature(arg.Type);
}
}
}
Type retType = outSig == Signature.Empty ? typeof(void) : outSig.ToType();
MethodBuilder method_builder = typeB.DefineMethod(declMethod.Name, ifaceMethAttr, retType, parms.ToArray());
//define the parameter attributes and names
if (declMethod.Arguments != null)
{
int argNum = 0;
foreach (Argument arg in declMethod.Arguments)
{
if (arg.Direction == Introspection.ArgDirection.@in)
{
method_builder.DefineParameter(++argNum, ParameterAttributes.In, arg.Name);
}
//if (arg.Direction == Introspection.ArgDirection.@out)
// method_builder.DefineParameter (++argNum, ParameterAttributes.Out, arg.Name);
}
}
}
if (iface.Properties != null)
{
foreach (NDesk.DBus.Introspection.Property prop in iface.Properties)
{
Type propType = new Signature(prop.Type).ToType();
PropertyBuilder prop_builder = typeB.DefineProperty(prop.Name, PropertyAttributes.None, propType, Type.EmptyTypes);
if (prop.Access == propertyAccess.read || prop.Access == propertyAccess.readwrite)
{
prop_builder.SetGetMethod(typeB.DefineMethod("get_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, propType, Type.EmptyTypes));
}
if (prop.Access == propertyAccess.write || prop.Access == propertyAccess.readwrite)
{
prop_builder.SetSetMethod(typeB.DefineMethod("set_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { propType }));
}
}
}
if (iface.Signals != null)
{
foreach (NDesk.DBus.Introspection.Signal signal in iface.Signals)
{
//Type eventType = typeof (EventHandler);
Type eventType = typeof(VoidHandler);
EventBuilder event_builder = typeB.DefineEvent(signal.Name, EventAttributes.None, eventType);
event_builder.SetAddOnMethod(typeB.DefineMethod("add_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { eventType }));
event_builder.SetRemoveOnMethod(typeB.DefineMethod("remove_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] { eventType }));
}
}
//apply InterfaceAttribute
ConstructorInfo interfaceAttributeCtor = typeof(InterfaceAttribute).GetConstructor(new Type[] { typeof(string) });
CustomAttributeBuilder cab = new CustomAttributeBuilder(interfaceAttributeCtor, new object[] { iface.Name });
typeB.SetCustomAttribute(cab);
}
public void GetValue(Type type, out object val)
{
if (type == typeof(void))
{
val = null;
return;
}
if (type.IsArray)
{
Array valArr;
GetValue(type, out valArr);
val = valArr;
}
else if (type == typeof(ObjectPath))
{
ObjectPath valOP;
GetValue(out valOP);
val = valOP;
}
else if (type == typeof(Signature))
{
Signature valSig;
GetValue(out valSig);
val = valSig;
}
else if (type == typeof(object))
{
GetValue(out val);
}
else if (type == typeof(string))
{
string valStr;
GetValue(out valStr);
val = valStr;
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IDictionary <,>))
{
Type[] genArgs = type.GetGenericArguments();
//Type dictType = typeof (Dictionary<,>).MakeGenericType (genArgs);
//workaround for Mono bug #81035 (memory leak)
Type dictType = Mapper.GetGenericType(typeof(Dictionary <,>), genArgs);
val = Activator.CreateInstance(dictType, new object[0]);
System.Collections.IDictionary idict = (System.Collections.IDictionary)val;
GetValueToDict(genArgs[0], genArgs[1], idict);
}
else if (Mapper.IsPublic(type))
{
GetObject(type, out val);
}
else if (!type.IsPrimitive && !type.IsEnum)
{
GetValueStruct(type, out val);
}
else
{
DType dtype = Signature.TypeToDType(type);
GetValue(dtype, out val);
}
if (type.IsEnum)
{
val = Enum.ToObject(type, val);
}
}
public void GetValue(Signature sig, out object val)
{
GetValue(sig.ToType(), out val);
}
object ReadVariant(Signature sig)
{
return(ReadValue(sig.ToType()));
}
