Returns the set of types contained within this set
973754
public Set<T> types() {
        // NOTE: purely unoptimized!
        Set<T> types = new HashSet<T>();
        for (Object o : edges.values()) {
            Set<T> s = (Set<T>)o;
            types.addAll(s);
        }
        return types;
    }
487421
def dtypes(self):
        
        return [(str(f.name), f.dataType.simpleString()) for f in self.schema.fields]
733912
public Set<String> getKeys(Class<?> type) {
        return data.entrySet().stream().filter(val -> type.isAssignableFrom(val.getValue()
                .getClass())).map(Map.Entry::getKey).collect(Collectors
                .toSet());
    }
504213
public Type[] getParameterTypes() {
        Type[] types = new Type[parameterNames.size()];
        for (int i = 0; i < types.length; i++) {
            types[i] = String.class;
        }

        return types;
    }
1004457
public static Set<TypeElement>
            typesIn(Set<? extends Element> elements) {
        return setFilter(elements, TYPE_KINDS, TypeElement.class);
    }
788546
public Set<MessageDescriptor<? extends M>> getSubtypes() {
		if (subtypes != null) {
			return subtypes;
		}

		Set<MessageDescriptor<? extends M>> list = new HashSet<MessageDescriptor<? extends M>>();
		for (Provider<MessageDescriptor<? extends M>> provider : subtypeProviders) {
			MessageDescriptor<? extends M> subtype = provider.get();
			list.add(subtype);
		}

		Map<Enum<?>, MessageDescriptor<? extends M>> map = new HashMap<Enum<?>,
				MessageDescriptor<? extends M>>();
		for (MessageDescriptor<? extends M> subtype : list) {
			map.put(subtype.getDiscriminatorValue(), subtype);
		}

		subtypes = ImmutableCollections.set(list);
		subtypeMap = ImmutableCollections.map(map);
		return subtypes;
	}
81528
def types(subtag):
        
        if subtag in index:
            types = index[subtag]
            return [type for type in types.keys() if type != 'redundant' or type != 'grandfathered']
        else:
            return []
142135
def types():
        
        if Message._types is None:
            Message._types = {}
            classes_to_process = [Message]
            while classes_to_process:
                atom = classes_to_process.pop()
                classes_to_process += atom.__subclasses__()
                Message._types[atom.__name__] = atom
        return Message._types
990013
public String[] getTypes() {
        String[] types = new String[columns.getColumns().size()];
        for (int i = 0; i < columns.getColumns().size(); i++) {
            types[i] = columns.getColumns().get(i).getType();
        }
        return types;
    }
1281331
public <T extends TypeDefinition> List<T> getTypes(Class<T> targetClass) {
        return types.values().stream()
                .filter(targetClass::isInstance)
                .map(targetClass::cast)
                .collect(Collectors.toList());
    }
970937
public Iterator getAllBaseTypes()
    {
        ArrayList baseTypes = new ArrayList();

        baseTypes.addAll(_directBaseTypes.values());

        for (int idx = baseTypes.size() - 1; idx >= 0; idx--)
        {
            ClassDescriptorDef curClassDef = (ClassDescriptorDef)baseTypes.get(idx);

            for (Iterator it = curClassDef.getDirectBaseTypes(); it.hasNext();)
            {
                ClassDescriptorDef curBaseTypeDef = (ClassDescriptorDef)it.next();

                if (!baseTypes.contains(curBaseTypeDef))
                {
                    baseTypes.add(0, curBaseTypeDef);
                    idx++;
                }
            }
        }
        return baseTypes.iterator();
    }
666110
function getTypes()
    {
        $t = array();
        foreach ($this->getElements('xrd:Type') as $elem) {
            $c = $this->parser->content($elem);
            if ($c) {
                $t[] = $c;
            }
        }
        return $t;
    }
442058
public List<TypeLiteral<?>> getParameterTypes() {
    if (parameterTypes == null) {
      parameterTypes = getDeclaringType().getParameterTypes(getMember());
    }
    return parameterTypes;
  }
523022
def types(self):
        ''' 
        '''
        neurites = self._obj.neurites if hasattr(self._obj, 'neurites') else (self._obj,)
        return (neu.type for neu in neurites)
148623
public IAtomType[] getAllAtomTypes() {
        logger.debug("Returning list of size: ", getSize());
        return (IAtomType[]) atomTypes.values().toArray(new IAtomType[atomTypes.size()]);
    }
498933
def get_datatypes(self):
        
        datatypes = set()
        for element in self.elements:
            if isinstance(element, PolygonSet):
                datatypes.update(element.datatypes)
            elif isinstance(element, CellReference) or isinstance(
                    element, CellArray):
                datatypes.update(element.ref_cell.get_datatypes())
        return datatypes
937661
public function getTypes()
    {
        if (!array_key_exists('value', $this->types)) {
            return;
        }

        //return an array, no matter one or many types defined
        if (is_array($this->types['value']) && count($this->types['value']) > 1) {
            return $this->types['value'];
        } else {
            return [$this->types['value']];
        }
    }