FilesExpand file tree

 master

/

interfaceobject.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

77 lines (65 loc) · 2.37 KB

 master

/

interfaceobject.cs

Copy path

Top

File metadata and controls

• Code
• Blame

77 lines (65 loc) · 2.37 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

using System;

using System.Reflection;

using System.Runtime.InteropServices;

namespace Python.Runtime

{

/// <summary>

/// Provides the implementation for reflected interface types. Managed

/// interfaces are represented in Python by actual Python type objects.

/// Each of those type objects is associated with an instance of this

/// class, which provides the implementation for the Python type.

/// </summary>

internal class InterfaceObject : ClassBase

{

internal ConstructorInfo ctor;

internal InterfaceObject(Type tp) : base(tp)

{

var coclass = (CoClassAttribute)Attribute.GetCustomAttribute(tp, cc_attr);

if (coclass != null)

{

ctor = coclass.CoClass.GetConstructor(Type.EmptyTypes);

}

}

private static Type cc_attr;

static InterfaceObject()

{

cc_attr = typeof(CoClassAttribute);

}

/// <summary>

/// Implements __new__ for reflected interface types.

/// </summary>

public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)

{

var self = (InterfaceObject)GetManagedObject(tp);

int nargs = Runtime.PyTuple_Size(args);

Type type = self.type;

object obj;

if (nargs == 1)

{

IntPtr inst = Runtime.PyTuple_GetItem(args, 0);

var co = GetManagedObject(inst) as CLRObject;

if (co == null || !type.IsInstanceOfType(co.inst))

{

Exceptions.SetError(Exceptions.TypeError, $"object does not implement {type.Name}");

return IntPtr.Zero;

}

obj = co.inst;

}

else if (nargs == 0 && self.ctor != null)

{

obj = self.ctor.Invoke(null);

if (obj == null || !type.IsInstanceOfType(obj))

{

Exceptions.SetError(Exceptions.TypeError, "CoClass default constructor failed");

return IntPtr.Zero;

}

}

else

{

Exceptions.SetError(Exceptions.TypeError, "interface takes exactly one argument");

return IntPtr.Zero;

}

return CLRObject.GetInstHandle(obj, self.pyHandle);

}

}

}