Helper method to get the types to be included in the query target

@return a set of Types
767979
private ImmutableSet<Type> targetTypes(Computable.Targetable<?> query) {
        if (query.of().isEmpty()) {
            throw GraqlQueryException.statisticsAttributeTypesNotSpecified();
        }

        return query.of().stream()
                .map(t -> {
                    Label label = Label.of(t);
                    Type type = tx.getSchemaConcept(label);
                    if (type == null) throw GraqlQueryException.labelNotFound(label);
                    if (!type.isAttributeType()) throw GraqlQueryException.mustBeAttributeType(type.label());
                    return type;
                })
                .flatMap(Type::subs)
                .collect(CommonUtil.toImmutableSet());
    }
633246
def determine_types(self):
        
        from nefertari.elasticsearch import ES
        collections = self.get_collections()
        resources = self.get_resources(collections)
        models = set([res.view.Model for res in resources])
        es_models = [mdl for mdl in models if mdl
                     and getattr(mdl, '_index_enabled', False)]
        types = [ES.src2type(mdl.__name__) for mdl in es_models]
        return types
48992
private Collection<String> createEnablesQuery() {
        Collection<String> query = null;
        Collection<String> requiredFeatures = getRequireFeature();
        if (requiredFeatures != null) {
            query = new ArrayList<String>();
            for (String required : requiredFeatures) {
                String temp = "wlpInformation.provideFeature=" + required;

                String version = findVersion();
                if (version != null) {
                    temp += "&wlpInformation.appliesToFilterInfo.minVersion.value=";
                    temp += version;
                }

                temp += "&type=";
                temp += getType().getValue(); // get the long name of the Type
                query.add(temp);
            }
        }
        return query;
    }
1374599
public Set<Type> getTypes(String path)
  {
    LinkedList<Type> types = new LinkedList<>();
    for (Reference reference : references)
    {
      if (Preconditions.checkNotNull(path).equals(reference.refResource))
      {
        types.add(reference.type);
      }
    }
    return Sets.immutableEnumSet(types);
  }
671937
public List<InjectionTargetType<PersistenceUnitRefType<T>>> getAllInjectionTarget()
   {
      List<InjectionTargetType<PersistenceUnitRefType<T>>> list = new ArrayList<InjectionTargetType<PersistenceUnitRefType<T>>>();
      List<Node> nodeList = childNode.get("injection-target");
      for(Node node: nodeList)
      {
         InjectionTargetType<PersistenceUnitRefType<T>>  type = new InjectionTargetTypeImpl<PersistenceUnitRefType<T>>(this, "injection-target", childNode, node);
         list.add(type);
      }
      return list;
   }
1000545
private static void getContainedGenericTypes(CompositeType<?> typeInfo, List<GenericTypeInfo<?>> target) {
		for (int i = 0; i < typeInfo.getArity(); i++) {
			TypeInformation<?> type = typeInfo.getTypeAt(i);
			if (type instanceof CompositeType) {
				getContainedGenericTypes((CompositeType<?>) type, target);
			} else if (type instanceof GenericTypeInfo) {
				if (!target.contains(type)) {
					target.add((GenericTypeInfo<?>) type);
				}
			}
		}
	}
1183129
public java.util.List<String> getInstanceTypes() {
        if (instanceTypes == null) {
            instanceTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return instanceTypes;
    }
679356
public static List<Scanner> getScanners(final Query query) {
    final List<Scanner> scanners = new ArrayList<Scanner>(
        Const.SALT_WIDTH() > 0 ? Const.SALT_BUCKETS() : 1);
    if (Const.SALT_WIDTH() > 0) {
      for (int i = 0; i < Const.SALT_BUCKETS(); i++) {
        scanners.add(((TsdbQuery) query).getScanner(i));
      }
    } else {
      scanners.add(((TsdbQuery) query).getScanner());
    }
    return scanners;
  }
432762
public List<Class<?>> getTypes(boolean noAbstractTypes) {
		List<Class<?>> typeList = new ArrayList<Class<?>>();
		this.addType(typeList, noAbstractTypes);
		return typeList;
	}
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;
	}
125187
public List<SqlResultSetMapping<EntityMappings<T>>> getAllSqlResultSetMapping()
   {
      List<SqlResultSetMapping<EntityMappings<T>>> list = new ArrayList<SqlResultSetMapping<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("sql-result-set-mapping");
      for(Node node: nodeList)
      {
         SqlResultSetMapping<EntityMappings<T>>  type = new SqlResultSetMappingImpl<EntityMappings<T>>(this, "sql-result-set-mapping", childNode, node);
         list.add(type);
      }
      return list;
   }
148623
public IAtomType[] getAllAtomTypes() {
        logger.debug("Returning list of size: ", getSize());
        return (IAtomType[]) atomTypes.values().toArray(new IAtomType[atomTypes.size()]);
    }
649935
public com.google.api.ads.admanager.axis.v201902.LabelType[] getTypes() {
        return types;
    }
343896
public Set<Type> getDataModelTypes()
        throws CacheReloadException
    {
        final Set<Type> ret = new HashSet<>();
        for (final Long id : this.dataModelTypes) {
            ret.add(Type.get(id));
        }
        return Collections.unmodifiableSet(ret);
    }
504213
public Type[] getParameterTypes() {
        Type[] types = new Type[parameterNames.size()];
        for (int i = 0; i < types.length; i++) {
            types[i] = String.class;
        }

        return 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;
    }
287707
function getSupportedDataTypes () {
  var types = [];

  // NOTE: More frequently-used types come first, to improve lookup speed
  if (typeof Uint8Array === 'function') {
    types.push(Uint8Array);
  }
  if (typeof Uint16Array === 'function') {
    types.push(Uint16Array);
  }
  if (typeof ArrayBuffer === 'function') {
    types.push(ArrayBuffer);
  }
  if (typeof Uint32Array === 'function') {
    types.push(Uint32Array);
  }
  if (typeof Int8Array === 'function') {
    types.push(Int8Array);
  }
  if (typeof Int16Array === 'function') {
    types.push(Int16Array);
  }
  if (typeof Int32Array === 'function') {
    types.push(Int32Array);
  }
  if (typeof Uint8ClampedArray === 'function') {
    types.push(Uint8ClampedArray);
  }
  if (typeof Float32Array === 'function') {
    types.push(Float32Array);
  }
  if (typeof Float64Array === 'function') {
    types.push(Float64Array);
  }
  if (typeof DataView === 'function') {
    types.push(DataView);
  }

  return types;
}