internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, MethodInfo[] methodinfo)
{
// loop to find match, return invoker w/ or /wo error
MethodBase[] _methods = null;
var pynargs = (int)Runtime.PyTuple_Size(args);
var isGeneric = false;
if (info != null)
{
_methods = new MethodBase[1];
_methods.SetValue(info, 0);
}
else
{
_methods = GetMethods();
}
// TODO: Clean up
foreach (MethodBase mi in _methods)
{
if (mi.IsGenericMethod)
{
isGeneric = true;
}
ParameterInfo[] pi = mi.GetParameters();
ArrayList defaultArgList;
bool paramsArray;
if (!MatchesArgumentCount(pynargs, pi, out paramsArray, out defaultArgList))
{
continue;
}
var outs = 0;
var margs = TryConvertArguments(pi, paramsArray, args, pynargs, defaultArgList,
needsResolution: _methods.Length > 1,
outs: out outs);
if (margs == null)
{
continue;
}
object target = null;
if (!mi.IsStatic && inst != IntPtr.Zero)
{
//CLRObject co = (CLRObject)ManagedType.GetManagedObject(inst);
// InvalidCastException: Unable to cast object of type
// 'pyRevitLabs.PythonNet.ClassObject' to type 'pyRevitLabs.PythonNet.CLRObject'
var co = ManagedType.GetManagedObject(inst) as CLRObject;
// Sanity check: this ensures a graceful exit if someone does
// something intentionally wrong like call a non-static method
// on the class rather than on an instance of the class.
// XXX maybe better to do this before all the other rigmarole.
if (co == null)
{
return(null);
}
target = co.inst;
}
return(new Binding(mi, target, margs, outs));
}
// We weren't able to find a matching method but at least one
// is a generic method and info is null. That happens when a generic
// method was not called using the [] syntax. Let's introspect the
// type of the arguments and use it to construct the correct method.
if (isGeneric && info == null && methodinfo != null)
{
Type[] types = Runtime.PythonArgsToTypeArray(args, true);
MethodInfo mi = MatchParameters(methodinfo, types);
return(Bind(inst, args, kw, mi, null));
}
return(null);
}
internal static bool ToManagedValue(IntPtr value, Type obType,
out object result, bool setError)
{
if (obType == typeof(PyObject))
{
Runtime.XIncref(value); // PyObject() assumes ownership
result = new PyObject(value);
return(true);
}
// Common case: if the Python value is a wrapped managed object
// instance, just return the wrapped object.
ManagedType mt = ManagedType.GetManagedObject(value);
result = null;
if (mt != null)
{
if (mt is CLRObject)
{
object tmp = ((CLRObject)mt).inst;
if (obType.IsInstanceOfType(tmp))
{
result = tmp;
return(true);
}
Exceptions.SetError(Exceptions.TypeError, $"value cannot be converted to {obType}");
return(false);
}
if (mt is ClassBase)
{
result = ((ClassBase)mt).type;
return(true);
}
// shouldn't happen
return(false);
}
if (value == Runtime.PyNone && !obType.IsValueType)
{
result = null;
return(true);
}
if (obType.IsGenericType && obType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (value == Runtime.PyNone)
{
result = null;
return(true);
}
// Set type to underlying type
obType = obType.GetGenericArguments()[0];
}
if (obType.IsArray)
{
return(ToArray(value, obType, out result, setError));
}
if (obType.IsEnum)
{
return(ToEnum(value, obType, out result, setError));
}
// Conversion to 'Object' is done based on some reasonable default
// conversions (Python string -> managed string, Python int -> Int32 etc.).
if (obType == objectType)
{
if (Runtime.IsStringType(value))
{
return(ToPrimitive(value, stringType, out result, setError));
}
if (Runtime.PyBool_Check(value))
{
return(ToPrimitive(value, boolType, out result, setError));
}
if (Runtime.PyInt_Check(value))
{
return(ToPrimitive(value, int32Type, out result, setError));
}
if (Runtime.PyLong_Check(value))
{
return(ToPrimitive(value, int64Type, out result, setError));
}
if (Runtime.PyFloat_Check(value))
{
return(ToPrimitive(value, doubleType, out result, setError));
}
if (Runtime.PySequence_Check(value))
{
return(ToArray(value, typeof(object[]), out result, setError));
}
if (setError)
{
Exceptions.SetError(Exceptions.TypeError, "value cannot be converted to Object");
}
return(false);
}
// Conversion to 'Type' is done using the same mappings as above for objects.
if (obType == typeType)
{
if (value == Runtime.PyStringType)
{
result = stringType;
return(true);
}
if (value == Runtime.PyBoolType)
{
result = boolType;
return(true);
}
if (value == Runtime.PyIntType)
{
result = int32Type;
return(true);
}
if (value == Runtime.PyLongType)
{
result = int64Type;
return(true);
}
if (value == Runtime.PyFloatType)
{
result = doubleType;
return(true);
}
if (value == Runtime.PyListType || value == Runtime.PyTupleType)
{
result = typeof(object[]);
return(true);
}
if (setError)
{
Exceptions.SetError(Exceptions.TypeError, "value cannot be converted to Type");
}
return(false);
}
return(ToPrimitive(value, obType, out result, setError));
}
