private static PyType InitPyType(Type type, ClassBase impl) { var pyType = TypeManager.GetOrCreateClass(type); // Set the handle attributes on the implementing instance. impl.tpHandle = impl.pyHandle = pyType.Handle; return(pyType); }
private static void InitClassBase(Type type, ClassBase impl) { // Ensure, that matching Python type exists first. // It is required for self-referential classes // (e.g. with members, that refer to the same class) var pyType = TypeManager.GetOrCreateClass(type); // Set the handle attributes on the implementing instance. impl.tpHandle = impl.pyHandle = pyType.Handle; // First, we introspect the managed type and build some class // information, including generating the member descriptors // that we'll be putting in the Python class __dict__. ClassInfo info = GetClassInfo(type); impl.indexer = info.indexer; impl.richcompare = new Dictionary <int, MethodObject>(); // Now we force initialize the Python type object to reflect the given // managed type, filling the Python type slots with thunks that // point to the managed methods providing the implementation. TypeManager.GetOrInitializeClass(impl, type); // Finally, initialize the class __dict__ and return the object. using var dict = Runtime.PyObject_GenericGetDict(pyType.Reference); if (impl.dotNetMembers == null) { impl.dotNetMembers = new List <string>(); } IDictionaryEnumerator iter = info.members.GetEnumerator(); while (iter.MoveNext()) { var item = (ManagedType)iter.Value; var name = (string)iter.Key; impl.dotNetMembers.Add(name); Runtime.PyDict_SetItemString(dict, name, item.ObjectReference); // Decref the item now that it's been used. item.DecrRefCount(); if (ClassBase.CilToPyOpMap.TryGetValue(name, out var pyOp)) { impl.richcompare.Add(pyOp, (MethodObject)item); } } // If class has constructors, generate an __doc__ attribute. NewReference doc = default; Type marker = typeof(DocStringAttribute); var attrs = (Attribute[])type.GetCustomAttributes(marker, false); if (attrs.Length != 0) { var attr = (DocStringAttribute)attrs[0]; string docStr = attr.DocString; doc = NewReference.DangerousFromPointer(Runtime.PyString_FromString(docStr)); Runtime.PyDict_SetItem(dict, PyIdentifier.__doc__, doc); } var co = impl as ClassObject; // If this is a ClassObject AND it has constructors, generate a __doc__ attribute. // required that the ClassObject.ctors be changed to internal if (co != null) { if (co.NumCtors > 0) { // Implement Overloads on the class object if (!CLRModule._SuppressOverloads) { var ctors = new ConstructorBinding(type, pyType, co.binder); // ExtensionType types are untracked, so don't Incref() them. // TODO: deprecate __overloads__ soon... Runtime.PyDict_SetItem(dict, PyIdentifier.__overloads__, ctors.ObjectReference); Runtime.PyDict_SetItem(dict, PyIdentifier.Overloads, ctors.ObjectReference); ctors.DecrRefCount(); } // don't generate the docstring if one was already set from a DocStringAttribute. if (!CLRModule._SuppressDocs && doc.IsNull()) { doc = co.GetDocString(); Runtime.PyDict_SetItem(dict, PyIdentifier.__doc__, doc); } } } doc.Dispose(); // The type has been modified after PyType_Ready has been called // Refresh the type Runtime.PyType_Modified(pyType.Reference); }
private static ClassInfo GetClassInfo(Type type) { var ci = new ClassInfo(); var methods = new Hashtable(); ArrayList list; MethodInfo meth; ManagedType ob; string name; object item; Type tp; int i, n; MemberInfo[] info = type.GetMembers(BindingFlags); var local = new Hashtable(); var items = new ArrayList(); MemberInfo m; // Loop through once to find out which names are declared for (i = 0; i < info.Length; i++) { m = info[i]; if (m.DeclaringType == type) { local[m.Name] = 1; } } // only [Flags] enums support bitwise operations if (type.IsEnum && type.IsFlagsEnum()) { var opsImpl = typeof(EnumOps <>).MakeGenericType(type); foreach (var op in opsImpl.GetMethods(OpsHelper.BindingFlags)) { local[op.Name] = 1; } info = info.Concat(opsImpl.GetMethods(OpsHelper.BindingFlags)).ToArray(); } // Now again to filter w/o losing overloaded member info for (i = 0; i < info.Length; i++) { m = info[i]; if (local[m.Name] != null) { items.Add(m); } } if (type.IsInterface) { // Interface inheritance seems to be a different animal: // more contractual, less structural. Thus, a Type that // represents an interface that inherits from another // interface does not return the inherited interface's // methods in GetMembers. For example ICollection inherits // from IEnumerable, but ICollection's GetMemebers does not // return GetEnumerator. // // Not sure if this is the correct way to fix this, but it // seems to work. Thanks to Bruce Dodson for the fix. Type[] inheritedInterfaces = type.GetInterfaces(); for (i = 0; i < inheritedInterfaces.Length; ++i) { Type inheritedType = inheritedInterfaces[i]; MemberInfo[] imembers = inheritedType.GetMembers(BindingFlags); for (n = 0; n < imembers.Length; n++) { m = imembers[n]; if (local[m.Name] == null) { items.Add(m); } } } // All interface implementations inherit from Object, // but GetMembers don't return them either. var objFlags = BindingFlags.Public | BindingFlags.Instance; foreach (var mi in typeof(object).GetMembers(objFlags)) { if (local[mi.Name] == null) { items.Add(mi); } } } for (i = 0; i < items.Count; i++) { var mi = (MemberInfo)items[i]; switch (mi.MemberType) { case MemberTypes.Method: meth = (MethodInfo)mi; if (!ShouldBindMethod(meth)) { continue; } name = meth.Name; item = methods[name]; if (item == null) { item = methods[name] = new ArrayList(); } list = (ArrayList)item; list.Add(meth); continue; case MemberTypes.Property: var pi = (PropertyInfo)mi; if (!ShouldBindProperty(pi)) { continue; } // Check for indexer ParameterInfo[] args = pi.GetIndexParameters(); if (args.GetLength(0) > 0) { Indexer idx = ci.indexer; if (idx == null) { ci.indexer = new Indexer(); idx = ci.indexer; } idx.AddProperty(pi); continue; } ob = new PropertyObject(pi); ci.members[pi.Name] = ob; continue; case MemberTypes.Field: var fi = (FieldInfo)mi; if (!ShouldBindField(fi)) { continue; } ob = new FieldObject(fi); ci.members[mi.Name] = ob; continue; case MemberTypes.Event: var ei = (EventInfo)mi; if (!ShouldBindEvent(ei)) { continue; } ob = new EventObject(ei); ci.members[ei.Name] = ob; continue; case MemberTypes.NestedType: tp = (Type)mi; if (!(tp.IsNestedPublic || tp.IsNestedFamily || tp.IsNestedFamORAssem)) { continue; } // Note the given instance might be uninitialized ob = GetClass(tp); if (ob.pyHandle == IntPtr.Zero && ob is ClassObject) { ob.pyHandle = ob.tpHandle = TypeManager.GetOrCreateClass(tp).Handle; } Debug.Assert(ob.pyHandle != IntPtr.Zero); // GetClass returns a Borrowed ref. ci.members owns the reference. ob.IncrRefCount(); ci.members[mi.Name] = ob; continue; } } IDictionaryEnumerator iter = methods.GetEnumerator(); while (iter.MoveNext()) { name = (string)iter.Key; list = (ArrayList)iter.Value; var mlist = (MethodInfo[])list.ToArray(typeof(MethodInfo)); ob = new MethodObject(type, name, mlist); ci.members[name] = ob; if (mlist.Any(OperatorMethod.IsOperatorMethod)) { string pyName = OperatorMethod.GetPyMethodName(name); string pyNameReverse = OperatorMethod.ReversePyMethodName(pyName); OperatorMethod.FilterMethods(mlist, out var forwardMethods, out var reverseMethods); // Only methods where the left operand is the declaring type. if (forwardMethods.Length > 0) { ci.members[pyName] = new MethodObject(type, name, forwardMethods); } // Only methods where only the right operand is the declaring type. if (reverseMethods.Length > 0) { ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods); } } } if (ci.indexer == null && type.IsClass) { // Indexer may be inherited. var parent = type.BaseType; while (parent != null && ci.indexer == null) { foreach (var prop in parent.GetProperties()) { var args = prop.GetIndexParameters(); if (args.GetLength(0) > 0) { ci.indexer = new Indexer(); ci.indexer.AddProperty(prop); break; } } parent = parent.BaseType; } } return(ci); }