Returns the list of addresses that matches the specified type. Examples of address
type are: TO, CC, BCC, etc..

@param type Examples of address type are: TO, CC, BCC, etc.
@return the list of addresses that matches the specified type.
552287
public List<Address> getAddressesOfType(Type type) {
        List<Address> answer = new ArrayList<>(addresses.size());
        for (Address address : addresses) {
            if (address.getType().equals(type)) {
                answer.add(address);
            }
        }

        return answer;
    }
1150805
public <C> C mapTo(Class<C> type) {
    DataFormatMapper mapper = dataFormat.getMapper();
    return mapper.mapInternalToJava(jsonNode, type);
  }
877438
public List<String> getMissing(String type) {

		List<String> missing = new ArrayList<>();

		ContentsDao contentsDao = geoPackage.getContentsDao();

		GenericRawResults<String[]> results = null;
		try {

			StringBuilder query = new StringBuilder();
			query.append("SELECT ");
			query.append(Contents.COLUMN_TABLE_NAME);
			query.append(" FROM ");
			query.append(Contents.TABLE_NAME);

			StringBuilder where = new StringBuilder();

			String[] queryArgs;
			if (type != null && !type.isEmpty()) {
				where.append(Contents.COLUMN_DATA_TYPE);
				where.append(" = ?");
				queryArgs = new String[] { type };
			} else {
				queryArgs = new String[] {};
				type = null;
			}

			if (contentsIdDao.isTableExists()) {
				if (where.length() > 0) {
					where.append(" AND ");
				}
				where.append(Contents.COLUMN_TABLE_NAME);
				where.append(" NOT IN (SELECT ");
				where.append(ContentsId.COLUMN_TABLE_NAME);
				where.append(" FROM ");
				where.append(ContentsId.TABLE_NAME);
				where.append(")");
			}

			if (where.length() > 0) {
				query.append(" WHERE ").append(where);
			}

			results = contentsDao.queryRaw(query.toString(), queryArgs);
			for (String[] resultRow : results) {
				missing.add(resultRow[0]);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to query for missing contents ids. GeoPackage: "
							+ geoPackage.getName() + ", Type: " + type, e);
		} finally {
			if (results != null) {
				try {
					results.close();
				} catch (IOException e) {
					logger.log(Level.WARNING,
							"Failed to close generic raw results from missing contents ids query. type: "
									+ type, e);
				}
			}
		}

		return missing;
	}
115187
@SuppressWarnings("static-method")
	protected List<JvmTypeParameter> getTypeParametersFor(XtendTypeDeclaration type) {
		if (type instanceof XtendClass) {
			return ((XtendClass) type).getTypeParameters();
		}
		if (type instanceof XtendInterface) {
			return ((XtendInterface) type).getTypeParameters();
		}
		return Collections.emptyList();
	}
607670
public <T extends Mapping> T getMapping(MappingType type)
    {
        return (T) mappings.get(type);
    }
384942
public String getTypeNameForCast(Class<?> type) {
        Integer jdbcType = jdbcTypeMapping.get(type);
        if (jdbcType == null) {
            jdbcType = javaTypeMapping.getType(type).getSQLTypes()[0];
        }
        return templates.getCastTypeNameForCode(jdbcType);
    }
1219587
@Override
	public List<String> getHeadLines(final String type) {
		ArrayList<String> lines = headers.get(type);
		return lines == null ? null : Collections.unmodifiableList(lines);
	}
980498
public static <T> List<Class<?>> getPublicConcreteSubTypesOf(final Class<T> type) {
        return ClassGraphFacade.getPublicConcreteSubTypesOf(type);
    }
991269
protected List<BindInfo> getBeanBinders(@NotNull Class<?> type) {
        List<BindInfo> bindings = beanInfoByClass.get(type);
        if (bindings != null) {
            return bindings;
        }
        bindings = new ArrayList<>();

        // check all public fields
        for (Field f : type.getFields()) {
            int modifiers = f.getModifiers();
            if (!isPublic(modifiers) || isStatic(modifiers) || isTransient(modifiers)) {
                continue; //ignore
            }
            DbBinder binder = findBinderByType(f.getType(), null);
            if (binder != null) {
                bindings.add(new BindInfo(f.getName(), binder, 0, f, null));
            }
        }

        // check all public get/is methods
        for (Method m : type.getMethods()) {
            int modifiers = m.getModifiers();
            String methodName = m.getName();
            if (!isPublic(modifiers) || isStatic(modifiers) || m.getParameterCount() != 0 || !(methodName.startsWith("get") || methodName.startsWith("is"))) {
                continue; //ignore
            }
            String suffix = methodName.startsWith("is") ? methodName.substring(2) : methodName.substring(3);
            String propertyName = Character.toLowerCase(suffix.charAt(0)) + suffix.substring(1);
            if (bindings.stream().filter(b -> b.mappedName.equals(propertyName)).findAny().orElse(null) != null) { // field has higher priority.
                continue;
            }
            DbBinder binder = findBinderByType(m.getReturnType(), null);
            if (binder != null) {
                bindings.add(new BindInfo(propertyName, binder, 0, null, m));
            }
        }
        beanInfoByClass.put(type, bindings);
        return bindings;
    }
811287
public List<String> getAllIdList(String index, String type) {
        return extractIdList(searchAll(index, type));
    }
391698
protected List<TypeName> getExtractedTypes(TypeName permutationType, TypeName paramType) {
    return match(permutationType)
        .when(typeOf(ParameterizedTypeName.class)).get(
            t -> {
              if (isDecomposableBuilder(t.rawType)) {
                return t.typeArguments.subList(1, t.typeArguments.size());
              } else if (t.rawType.equals(MATCH_ANY)) {
                return ImmutableList.of(paramType);
              } else {
                return Collections.<TypeName>emptyList();
              }
            })
        .when(typeOf(TypeVariableName.class)).get(t -> ImmutableList.of())
        .when(typeOf(ClassName.class)).get(t -> ImmutableList.of(paramType))
        .orElse(t -> ImmutableList.of(t))
        .getMatch();
  }
1169785
public List<MethodParameter> getParametersOfType(Class<?> type) {

		Assert.notNull(type, "Type must not be null!");

		return getParameters().stream() //
				.filter(it -> it.getParameterType().equals(type)) //
				.collect(Collectors.toList());
	}
707727
public <T extends Mapping> T findMapping(MappingType type)
    {
        return (T) this.findMapping(type, DEFAULT_PREDICATE);
    }
860039
public ArrayList<String> credit_balance_GET(OvhType type) throws IOException {
		String qPath = "/me/credit/balance";
		StringBuilder sb = path(qPath);
		query(sb, "type", type);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, t1);
	}
613941
private static List<Field> getAllFields(Class type) {
		final List<Field> fields = new ArrayList<>();
		for (Class<?> c = type; c != null; c = c.getSuperclass()) {
			fields.addAll(Arrays.asList(c.getDeclaredFields()));
		}
		return fields;
	}
55942
public static List<OpenCLDevice> listDevices(TYPE type) {
      final OpenCLPlatform platform = new OpenCLPlatform(0, null, null, null);
      final ArrayList<OpenCLDevice> results = new ArrayList<>();

      for (final OpenCLPlatform p : platform.getOpenCLPlatforms()) {
         for (final OpenCLDevice device : p.getOpenCLDevices()) {
            if (type == null || device.getType() == type) {
               results.add(device);
            }
         }
      }

      return results;
   }
1120209
public List<MemberState> getRemoteMemberStates(Member.Type type) {
    List<MemberState> members = memberTypes.get(type);
    return members != null ? members : Collections.EMPTY_LIST;
  }