Lines Matching refs:self
52 def __init__(self): argument
53 self._parent = None
54 self._name = None
57 def parent(self): argument
58 return self._parent
61 def name(self): argument
62 return self._name
64 def find_all(self, pred): argument
75 if pred(self):
76 yield self
78 if self._get_children() is None:
81 for i in self._get_children():
85 def find_first(self, pred): argument
95 for i in self.find_all(pred):
100 def find_parent_first(self, pred): argument
110 for i in self.find_parents(pred):
115 def find_parents(self, pred): argument
126 parent = self.parent
133 def sort_children(self): argument
137 self._sort_by_name(self._children)
139 def _sort_by_name(self, what): argument
142 def _get_name(self): argument
146 def _get_children(self): argument
147 return (i for i in self._children)
149 def _children_name_map_matching(self, match=lambda x: True): argument
151 for i in self._get_children():
164 def validate_tree(self): argument
173 children = self._get_children()
177 for child in self._get_children():
178 if child.parent != self:
181 %(child, self, child.parent)
188 def __str__(self): argument
189 return "<%s name='%s'>" %(self.__class__, self.name)
202 def __init__(self): argument
208 self._entries = []
210 self._entry_map = { 'static': {}, 'dynamic': {}, 'controls': {} }
211 self._entries_ordered = [] # list of ordered Entry/Clone instances
212 self._clones = []
215 self._name = None
216 self._parent = None
217 self._outer_namespaces = None
218 self._tags = []
219 self._types = []
222 def outer_namespaces(self): argument
223 if self._outer_namespaces is None:
226 return (i for i in self._outer_namespaces)
229 def tags(self): argument
230 return (i for i in self._tags)
233 def types(self): argument
234 return (i for i in self._types)
236 def _get_properties(self): argument
238 for i in self._entries:
241 for i in self._clones:
244 def insert_tag(self, tag, description=""): argument
259 tag_ids = [tg.name for tg in self.tags if tg.name == tag]
261 self._tags.append(Tag(tag, self, description))
263 def insert_type(self, type_name, type_selector="typedef", **kwargs): argument
286 type_names = [tp.name for tp in self.types if tp.name == tp]
288 self._types.append(Typedef(type_name, self, kwargs.get('languages')))
290 def insert_entry(self, entry): argument
303 self._entries.append(e)
304 self._entry_map[e.kind][e.name] = e
305 self._entries_ordered.append(e)
307 def insert_clone(self, clone): argument
323 self._entry_map[c.kind][c.name] = c
324 self._clones.append(c)
325 self._entries_ordered.append(c)
327 def prune_clones(self): argument
336 for p in self._clones:
350 self._clones.remove(p)
351 self._entry_map[p.kind].pop(p.name)
352 self._entries_ordered.remove(p)
354 def is_entry_this_kind(self, entry, kind): argument
368 return entry.name in self._entry_map[kind]
372 def construct_graph(self): argument
381 self.validate_tree()
382 self._construct_tags()
383 self.validate_tree()
384 self._construct_types()
385 self.validate_tree()
386 self._construct_clones()
387 self.validate_tree()
388 self._construct_outer_namespaces()
389 self.validate_tree()
391 def _construct_tags(self): argument
392 tag_dict = self._dictionary_by_name(self.tags)
393 for p in self._get_properties():
404 def _construct_types(self): argument
405 type_dict = self._dictionary_by_name(self.types)
406 for p in self._get_properties():
414 def _construct_clones(self): argument
415 for p in self._clones:
417 target_entry = self._entry_map[target_kind].get(p.name)
427 def _construct_outer_namespaces(self): argument
429 if self._outer_namespaces is None: #the first time this runs
430 self._outer_namespaces = []
432 root = self._dictionary_by_name(self._outer_namespaces)
436 for p in self._entries_ordered:
438 ons = root.get(ons_name, OuterNamespace(ons_name, self))
448 self._construct_sections(ons)
450 if ons not in self._outer_namespaces:
451 self._outer_namespaces.append(ons)
455 def _construct_sections(self, outer_namespace): argument
457 sections_dict = self._dictionary_by_name(outer_namespace.sections)
481 self._construct_kinds(sec)
492 def _construct_kinds(self, section): argument
517 self._construct_inner_namespaces(kind)
519 self._construct_entries(kind)
530 def _construct_inner_namespaces(self, parent, depth=0): argument
532 ins_dict = self._dictionary_by_name(parent.namespaces)
550 self._construct_inner_namespaces(ins, depth + 1)
553 self._construct_entries(ins, depth + 1)
564 def _construct_entries(self, parent, depth=0): argument
566 entry_dict = self._dictionary_by_name(parent.entries)
587 def _get_children(self): argument
588 if self.outer_namespaces is not None:
589 for i in self.outer_namespaces:
592 if self.tags is not None:
593 for i in self.tags:
607 def __init__(self, name, parent, description=""): argument
608 self._name = name # 'id' attribute in XML
609 self._id = name
610 self._description = description
611 self._parent = parent
614 self._entries = [] # filled in by Metadata#construct_tags
617 def id(self): argument
618 return self._id
621 def description(self): argument
622 return self._description
625 def entries(self): argument
626 return (i for i in self._entries)
628 def _get_children(self): argument
641 def __init__(self, name, parent, languages=None): argument
642 self._name = name
643 self._parent = parent
646 self._entries = [] # filled in by Metadata#construct_types
648 self._languages = languages or {}
651 def languages(self): argument
652 return self._languages
655 def entries(self): argument
656 return (i for i in self._entries)
658 def _get_children(self): argument
670 def __init__(self, name, parent, sections=[]): argument
671 self._name = name
672 self._parent = parent # MetadataSet
673 self._sections = sections[:]
674 self._leafs = []
676 self._children = self._sections
679 def sections(self): argument
680 return (i for i in self._sections)
694 def __init__(self, name, parent, description=None, kinds=[]): argument
695 self._name = name
696 self._parent = parent
697 self._description = description
698 self._kinds = kinds[:]
700 self._leafs = []
704 def description(self): argument
705 return self._description
708 def kinds(self): argument
709 return (i for i in self._kinds)
711 def sort_children(self): argument
712 self.validate_tree()
714 find_child = lambda x: [i for i in self._get_children() if i.name == x]
718 self._kinds = new_lst
719 self.validate_tree()
721 def _get_children(self): argument
722 return (i for i in self.kinds)
725 def merged_kinds(self): argument
740 new_kinds_lst = reduce(aggregate_by_name, self.kinds, [])
745 def combine_kinds_into_single_node(self): argument
768 combined = Kind(name="combined", parent=self)
770 for k in self._get_children():
788 def __init__(self, name, parent): argument
789 self._name = name
790 self._parent = parent
791 self._namespaces = []
792 self._entries = []
794 self._leafs = []
797 def namespaces(self): argument
798 return self._namespaces
801 def entries(self): argument
802 return self._entries
805 def merged_entries(self): argument
806 for i in self.entries:
809 def sort_children(self): argument
810 self._namespaces.sort(key=self._get_name())
811 self._entries.sort(key=self._get_name())
813 def _get_children(self): argument
814 for i in self.namespaces:
816 for i in self.entries:
819 def combine_children_by_name(self): argument
852 return Kind._combine_children_by_name(self, new_type=type(self))
856 def _combine_children_by_name(self, new_type): argument
860 for ins in self.namespaces:
862 InnerNamespace(ins.name, parent=self))
866 for ent in self.entries:
870 kind = new_type(self.name, self.parent)
888 def __init__(self, name, parent): argument
889 self._name = name
890 self._parent = parent
891 self._namespaces = []
892 self._entries = []
893 self._leafs = []
896 def namespaces(self): argument
897 return self._namespaces
900 def entries(self): argument
901 return self._entries
904 def merged_entries(self): argument
905 for i in self.entries:
908 def sort_children(self): argument
909 self._namespaces.sort(key=self._get_name())
910 self._entries.sort(key=self._get_name())
912 def _get_children(self): argument
913 for i in self.namespaces:
915 for i in self.entries:
918 def combine_children_by_name(self): argument
952 return Kind._combine_children_by_name(self, new_type=type(self))
968 def __init__(self, name, parent, argument
970 self._name = name # str, e.g. 'ON' or 'OFF'
971 self._id = id # int, e.g. '0'
972 self._deprecated = deprecated # bool
973 self._optional = optional # bool
974 self._hidden = hidden # bool
975 self._ndk_hidden = ndk_hidden # bool
976 self._notes = notes # None or str
977 self._parent = parent
980 def id(self): argument
981 return self._id
984 def deprecated(self): argument
985 return self._deprecated
988 def optional(self): argument
989 return self._optional
992 def hidden(self): argument
993 return self._hidden
996 def ndk_hidden(self): argument
997 return self._ndk_hidden
1000 def notes(self): argument
1001 return self._notes
1003 def _get_children(self): argument
1016 def __init__(self, parent, values, ids={}, deprecateds=[], argument
1018 self._values = \
1019 [ EnumValue(val, self, ids.get(val), val in deprecateds, val in optionals, val in hiddens, \
1023 self._parent = parent
1024 self._name = None
1027 def values(self): argument
1028 return (i for i in self._values)
1031 def has_values_with_id(self): argument
1032 return bool(any(i for i in self.values if i.id))
1034 def _get_children(self): argument
1035 return (i for i in self._values)
1094 def __init__(self, **kwargs): argument
1143 self._name = kwargs['name']
1144 self._type = kwargs['type']
1145 self._kind = kwargs['kind'] # static, dynamic, or controls
1147 self._init_common(**kwargs)
1150 def type(self): argument
1151 return self._type
1154 def kind(self): argument
1155 return self._kind
1158 def visibility(self): argument
1159 return self._visibility
1162 def applied_visibility(self): argument
1163 return self._visibility or 'system'
1166 def applied_ndk_visible(self): argument
1167 if self._visibility in ("public", "ndk_public"):
1172 def synthetic(self): argument
1173 return self._synthetic
1176 def hwlevel(self): argument
1177 return self._hwlevel
1180 def deprecated(self): argument
1181 return self._deprecated
1185 def optional(self): argument
1186 return self._optional
1189 def applied_optional(self): argument
1190 return self._optional or False
1193 def name_short(self): argument
1194 return self.get_name_minimal()
1197 def container(self): argument
1198 return self._container
1201 def container_sizes(self): argument
1202 if self._container_sizes is None:
1205 return (i for i in self._container_sizes)
1208 def tuple_values(self): argument
1209 if self._tuple_values is None:
1212 return (i for i in self._tuple_values)
1215 def description(self): argument
1216 return self._description
1219 def range(self): argument
1220 return self._range
1223 def units(self): argument
1224 return self._units
1227 def details(self): argument
1228 return self._details
1231 def hal_details(self): argument
1232 return self._hal_details
1235 def tags(self): argument
1236 if self._tags is None:
1239 return (i for i in self._tags)
1242 def type_notes(self): argument
1243 return self._type_notes
1246 def typedef(self): argument
1247 return self._typedef
1250 def enum(self): argument
1251 return self._enum
1253 def _get_children(self): argument
1254 if self.enum:
1255 yield self.enum
1257 def sort_children(self): argument
1260 def is_clone(self): argument
1269 def _init_common(self, **kwargs): argument
1271 self._parent = None # filled in by Metadata::_construct_entries
1273 self._container = kwargs.get('container')
1274 self._container_sizes = kwargs.get('container_sizes')
1284 self._tuple_values = kwargs.get('tuple_values')
1286 self._description = kwargs.get('description')
1287 self._range = kwargs.get('range')
1288 self._units = kwargs.get('units')
1289 self._details = kwargs.get('details')
1290 self._hal_details = kwargs.get('hal_details')
1292 self._tag_ids = kwargs.get('tag_ids', [])
1293 self._tags = None # Filled in by Metadata::_construct_tags
1295 self._type_notes = kwargs.get('type_notes')
1296 self._type_name = kwargs.get('type_name')
1297 self._typedef = None # Filled in by Metadata::_construct_types
1300 self._enum = Enum(self, enum_values, enum_ids, enum_deprecateds, enum_optionals,
1303 self._enum = None
1305 self._visibility = kwargs.get('visibility')
1306 self._synthetic = kwargs.get('synthetic', False)
1307 self._hwlevel = kwargs.get('hwlevel')
1308 self._deprecated = kwargs.get('deprecated', False)
1309 self._optional = kwargs.get('optional')
1310 self._ndk_visible = kwargs.get('ndk_visible')
1312 self._property_keys = kwargs
1314 def merge(self): argument
1319 return MergedEntry(self)
1323 def get_name_as_list(self): argument
1331 return self.name.split(".")
1333 def get_inner_namespace_list(self): argument
1341 return self.get_name_as_list()[2:-1]
1343 def get_outer_namespace(self): argument
1355 return self.get_name_as_list()[0]
1357 def get_section(self): argument
1369 return self.get_name_as_list()[1]
1371 def get_name_minimal(self): argument
1382 return self.get_name_as_list()[-1]
1384 def get_path_without_name(self): argument
1392 return ".".join(self.get_name_as_list()[0:-1])
1408 def __init__(self, entry=None, **kwargs): argument
1446 self._entry = entry # Entry object
1447 self._target_kind = kwargs['target_kind']
1448 self._name = kwargs['name'] # same as entry.name
1449 self._kind = kwargs['kind']
1452 self._type = None
1455 self._init_common(**kwargs)
1458 def entry(self): argument
1459 return self._entry
1462 def target_kind(self): argument
1463 return self._target_kind
1465 def is_clone(self): argument
1484 def __init__(self, entry): argument
1497 setattr(self, p, getattr(entry, p) or getattr(entry.entry, p))
1499 setattr(self, p, getattr(entry, p))
1518 setattr(self, p, getattr(entry.entry, p))
1520 setattr(self, p, getattr(entry, p))