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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import itertools
from .composition_parts import WithCodeGeneratorInfo
from .composition_parts import WithComponent
from .composition_parts import WithDebugInfo
from .composition_parts import WithExposure
from .composition_parts import WithExtendedAttributes
from .constant import Constant
from .ir_map import IRMap
from .make_copy import make_copy
from .operation import Operation
from .operation import OperationGroup
from .user_defined_type import UserDefinedType
class CallbackInterface(UserDefinedType, WithExtendedAttributes,
WithCodeGeneratorInfo, WithExposure, WithComponent,
WithDebugInfo):
"""https://webidl.spec.whatwg.org/#idl-interfaces"""
class IR(IRMap.IR, WithExtendedAttributes, WithCodeGeneratorInfo,
WithExposure, WithComponent, WithDebugInfo):
def __init__(self,
identifier,
constants=None,
operations=None,
extended_attributes=None,
component=None,
debug_info=None):
if constants is None:
constants = []
if operations is None:
operations = []
assert isinstance(constants, (list, tuple))
assert isinstance(operations, (list, tuple))
assert all(
isinstance(constant, Constant.IR) for constant in constants)
assert all(
isinstance(operation, Operation.IR)
for operation in operations)
IRMap.IR.__init__(
self,
identifier=identifier,
kind=IRMap.IR.Kind.CALLBACK_INTERFACE)
WithExtendedAttributes.__init__(self, extended_attributes)
WithCodeGeneratorInfo.__init__(self)
WithExposure.__init__(self)
WithComponent.__init__(self, component)
WithDebugInfo.__init__(self, debug_info)
self.attributes = []
self.constants = constants
self.constructors = []
self.constructor_groups = []
self.legacy_factory_functions = []
self.legacy_factory_function_groups = []
self.operations = operations
self.operation_groups = []
self.inherited = None
self.direct_subclasses = []
self.subclasses = []
self.tag = None
self.max_subclass_tag = None
def iter_all_members(self):
list_of_members = [
self.constants,
self.operations,
]
return itertools.chain(*list_of_members)
def iter_all_overload_groups(self):
return iter(self.operation_groups)
def __init__(self, ir):
assert isinstance(ir, CallbackInterface.IR)
ir = make_copy(ir)
UserDefinedType.__init__(self, ir.identifier)
WithExtendedAttributes.__init__(self, ir, readonly=True)
WithCodeGeneratorInfo.__init__(self, ir, readonly=True)
WithExposure.__init__(self, ir, readonly=True)
WithComponent.__init__(self, ir, readonly=True)
WithDebugInfo.__init__(self, ir)
self._constants = tuple([
Constant(constant_ir, owner=self) for constant_ir in ir.constants
])
self._operations = tuple([
Operation(operation_ir, owner=self)
for operation_ir in ir.operations
])
self._operation_groups = tuple([
OperationGroup(operation_group_ir,
list(
filter(
lambda x: x.identifier == operation_group_ir
.identifier, self._operations)),
owner=self)
for operation_group_ir in ir.operation_groups
])
self._tag = ir.tag
self._max_subclass_tag = ir.max_subclass_tag
@property
def attributes(self):
"""Returns attributes."""
return ()
@property
def constants(self):
"""Returns constants."""
return self._constants
@property
def constructors(self):
"""Returns constructors."""
return ()
@property
def constructor_groups(self):
"""Returns groups of constructors."""
return ()
@property
def legacy_factory_functions(self):
"""Returns legacy factory functions."""
return ()
@property
def legacy_factory_function_groups(self):
"""Returns groups of overloaded legacy factory functions."""
return ()
@property
def operations(self):
"""Returns operations."""
return self._operations
@property
def operation_groups(self):
"""Returns groups of overloaded operations."""
return self._operation_groups
@property
def tag(self):
"""Returns a tag integer or None."""
return self._tag
@property
def max_subclass_tag(self):
"""Returns a tag integer or None."""
return self._max_subclass_tag
# UserDefinedType overrides
@property
def is_callback_interface(self):
return True
|
