Returns a list of type tags that refer to this type starting from the
        base of the struct hierarchy.
180416
def _get_subtype_tags(self):
        
        assert self.is_member_of_enumerated_subtypes_tree(), \
            'Not a part of a subtypes tree.'
        cur = self.parent_type
        cur_dt = self
        tags = []
        while cur:
            assert cur.has_enumerated_subtypes()
            for subtype_field in cur.get_enumerated_subtypes():
                if subtype_field.data_type is cur_dt:
                    tags.append(subtype_field.name)
                    break
            else:
                assert False, 'Could not find?!'
            cur_dt = cur
            cur = cur.parent_type
        tags.reverse()
        return tuple(tags)
1346035
public Set<Tag> getDescendantTags(Tag tag)
    {
        Set<Tag> ancestors = new HashSet<>();
        getDescendantTags(tag, ancestors);
        return ancestors;
    }
459340
public Set<TagModel> getDescendantTags(TagModel tag)
    {
        Set<TagModel> ancestors = new HashSet<>();
        getDescendantTags(tag, ancestors);
        return ancestors;
    }
1141729
def struct_types(self):
        
        it = ffi.lib.LLVMPY_ModuleTypesIter(self)
        return _TypesIterator(it, dict(module=self))
351907
public List<FunctionType<TldTaglibType<T>>> getAllFunction()
   {
      List<FunctionType<TldTaglibType<T>>> list = new ArrayList<FunctionType<TldTaglibType<T>>>();
      List<Node> nodeList = childNode.get("function");
      for(Node node: nodeList)
      {
         FunctionType<TldTaglibType<T>>  type = new FunctionTypeImpl<TldTaglibType<T>>(this, "function", childNode, node);
         list.add(type);
      }
      return list;
   }
329902
private static function processTag(BaseTag $tag)
    {
        $types = [];

        if (method_exists($tag, 'getType') && is_callable([$tag, 'getType'])) {
            if (($type = $tag->getType()) !== null) {
                $types[] = $type;
            }
        }

        if (method_exists($tag, 'getArguments') && is_callable([$tag, 'getArguments'])) {
            foreach ($tag->getArguments() as $param) {
                if (($type = $param['type'] ?? null) !== null) {
                    $types[] = $type;
                }
            }
        }

        return $types;
    }
291007
public Set<String> getSupportedTypes(){
		Set<String> typeset = new HashSet<String>();
		Set<String> set = factory.DefaultLabelAlphabet().toSet();
		Iterator<String> itt = set.iterator();
		while(itt.hasNext()){
			String type = itt.next();
			if(type.length() ==1 )
				continue;
			typeset.add(type.substring(1));
		}
		return typeset;
	}
1252346
def List(self, name, initial=None):
        
        return types.List(name, self.api, initial=initial)
516643
def subtags(self):
        
        data = self.data
        subtags = []

        # if tag is grandfathered return no subtags
        if 'record' in data and self.data['record']['Type'] == 'grandfathered':
            return subtags

        codes = data['tag'].split('-')
        # Try and find the language tag.
        for i, code in enumerate(codes):

            # Singletons and anything after are unhandled.
            if len(code) == 1:
                #Stop the loop (stop processing after a singleton).
                break

            # Check for non-existent tag.
            if code not in index:
                continue
            types = index[code]

            # Language subtags may only appear at the beginning of the tag, otherwise the subtag type is indeterminate.
            if 'language' in types and i == 0:
                subtags.append(Subtag(code, 'language'))
                continue

            if len(code) == 2:
                # Should be a region
                if 'region' in types:
                    subtags.append(Subtag(code, 'region'))
                # Error case: language subtag in the wrong place.
                elif 'language' in types:
                    subtags.append(Subtag(code, 'language'))

            elif len(code) == 3:
                # Could be a numeric region code e.g. '001' for 'World'.
                if 'region' in types:
                    subtags.append(Subtag(code, 'region'))
                elif 'extlang' in types:
                    subtags.append(Subtag(code, 'extlang'))
                # Error case: language subtag in the wrong place.
                elif 'language' in types:
                    subtags.append(Subtag(code, 'language'))

            elif len(code) == 4:
                # Could be a numeric variant
                if 'variant' in types:
                    subtags.append(Subtag(code, 'variant'))
                elif 'script' in types:
                    subtags.append(Subtag(code, 'script'))

            else:
                # Should be a variant
                if 'variant' in types:
                    subtags.append(Subtag(code, 'variant'))

        return subtags
18911
def list_tags(self):
        
        from highton.models.tag import Tag
        return fields.ListField(
            name=self.ENDPOINT,
            init_class=Tag
        ).decode(
            self.element_from_string(
                self._get_request(
                    endpoint=self.ENDPOINT + '/' + str(self.id) + '/' + Tag.ENDPOINT,
                ).text
            )
        )
799130
def get_tags(self, tagtype):
        '''  '''
        return [t for t in self.__tags if t.tagtype == tagtype]
671619
public List<String> getTags() {
        return mBodyMap.containsKey(BoxItem.FIELD_TAGS) ?
                (List<String>) mBodyMap.get(BoxItem.FIELD_TAGS) :
                null;
    }
723318
public List<TagFileType<TldTaglibType<T>>> getAllTagFile()
   {
      List<TagFileType<TldTaglibType<T>>> list = new ArrayList<TagFileType<TldTaglibType<T>>>();
      List<Node> nodeList = childNode.get("tag-file");
      for(Node node: nodeList)
      {
         TagFileType<TldTaglibType<T>>  type = new TagFileTypeImpl<TldTaglibType<T>>(this, "tag-file", childNode, node);
         list.add(type);
      }
      return list;
   }
1139622
public List<TldExtensionType<TldTaglibType<T>>> getAllTaglibExtension()
   {
      List<TldExtensionType<TldTaglibType<T>>> list = new ArrayList<TldExtensionType<TldTaglibType<T>>>();
      List<Node> nodeList = childNode.get("taglib-extension");
      for(Node node: nodeList)
      {
         TldExtensionType<TldTaglibType<T>>  type = new TldExtensionTypeImpl<TldTaglibType<T>>(this, "taglib-extension", childNode, node);
         list.add(type);
      }
      return list;
   }
802167
def fmt_type(data_type, inside_namespace=None):
    
    if is_struct_type(data_type) and data_type.has_enumerated_subtypes():
        possible_types = []
        possible_subtypes = data_type.get_all_subtypes_with_tags()
        for _, subtype in possible_subtypes:
            possible_types.append(fmt_polymorphic_type_reference(subtype, inside_namespace))
        if data_type.is_catch_all():
            possible_types.append(fmt_polymorphic_type_reference(data_type, inside_namespace))
        return fmt_union(possible_types)
    else:
        return fmt_type_name(data_type, inside_namespace)
767516
def _get_tags(self):
        # type: () -> List[str]
        
        tags = self.data.get('tags', None)
        if not tags:
            return list()
        return [x['name'] for x in tags]
1300457
public Set<Tag> getAncestorTags(Tag tag)
    {
        Set<Tag> ancestors = new HashSet<>();
        getAncestorTags(tag, ancestors);
        return ancestors;
    }