Finds all documents with the an id or key in the argument

@param ids
an iterable with ids/keys of documents to get
@return an iterable with documents in the collection which have a id/key in the argument
437896
@Override
	public Iterable<T> findAllById(final Iterable<ID> ids) {
		return arangoOperations.find(ids, domainClass);
	}
906986
@SuppressWarnings("unchecked")
	public static <T> List<T> getAny(Collection<T> collection, int... indexes) {
		final int size = collection.size();
		final ArrayList<T> result = new ArrayList<>();
		if (collection instanceof List) {
			final List<T> list = ((List<T>) collection);
			for (int index : indexes) {
				if (index < 0) {
					index += size;
				}
				result.add(list.get(index));
			}
		} else {
			Object[] array = ((Collection<T>) collection).toArray();
			for (int index : indexes) {
				if (index < 0) {
					index += size;
				}
				result.add((T) array[index]);
			}
		}
		return result;
	}
22728
public static Map<Identity, JsonNode> getDocumentIdMap(List<JsonNode> list, List<String> identityFields) {
        Map<Identity, JsonNode> map = new HashMap<>();
        if (list != null) {
            LOGGER.debug("Getting doc IDs for {} docs, fields={}", list.size(), identityFields);
            for (JsonNode node : list) {
                Identity id = new Identity(node, identityFields);
                LOGGER.debug("ID={}", id);
                map.put(id, node);
            }
        }
        return map;
    }
523149
public function getByIds(array $ids, array $params = [])
    {
        return $this->executeRequest(
            RequestMethodEnum::GET,
            ResourceMethodEnum::GET_BY_IDS,
            $params,
            $ids
        );
    }
1291293
def find(self, collection, selector={}):
        """"""
        results = []
        for _id, doc in self.collection_data.data.get(collection, {}).items():
            doc.update({'_id': _id})
            if selector == {}:
                results.append(doc)
            for key, value in selector.items():
                if key in doc and doc[key] == value:
                    results.append(doc)
        return results
305769
@Override
    public List<T> getAll(final Collection<String> ids) {
        if (ids == null || ids.size() == 0) {
            return Collections.<T> emptyList();
        }

        // we need a List of ids to partition
        final List<String> idList;
        if (ids instanceof List) {
            idList = (List<String>) ids;
        } else {
            idList = Lists.newArrayList(ids);
        }

        // fetch records in groups of X
        List<T> result = null;
        for (final List<String> partition : Lists.partition(idList, config.getPartitionSize())) {
            result = doGetAll(result, partition);
        }

        // make sure we always return non-null list
        if (result == null) {
            return Collections.<T> emptyList();
        }
        return result;
    }
776576
public Set<String> getIdsForIdsWithAncestors(Collection<String> termIds) {
        Stack<String> idsToConsider = new Stack<String>();
        idsToConsider.addAll(termIds);
        Set<String> resultIds = new HashSet<String>();
        while (!idsToConsider.isEmpty()) {
            String id = idsToConsider.pop();
            if (!resultIds.contains(id)) {
                resultIds.add(id);
                if (terms.containsKey(id))
                    idsToConsider.addAll(terms.get(id).getIsA());
            }
        }
        return resultIds;
    }
1176774
public QueryBuilder removeParentIds(final Collection<Integer> ids) {
        if (ids != null) {
            parentIds.removeAll(ids);
        }
        return this;
    }
1050212
public List<T> list(List<Long> ids)
    {
        List<T> ret = new ArrayList<T>();

        if(ids != null)
        {
            for(Long id : ids)
            {
                T resource = get(id);
                if(resource != null)
                    ret.add(resource);
            }
        }

        return ret;
    }
57298
public static MongoDS getDS(Collection<String> groups) {
		return getDS(groups.toArray(new String[groups.size()]));
	}
1171446
public function getWithFilter(int $id, array $keys): array
    {
        return $this->parent->performAPICallWithJsonResponse(
            'get',
            '/series/'.$id.'/filter',
            [
                'query' => ['keys' => join(',', $keys)]
            ]
        );
    }
1119677
public function findById(array $ids)
    {
        $mongoIds = $this->idsToMongo($ids);
        $cachedDocuments = $this->findCachedDocuments($mongoIds);

        if ($this->areAllDocumentsCached($cachedDocuments, $mongoIds)) {
            return $cachedDocuments;
        }

        $idsToQuery = $this->getIdsToQuery($cachedDocuments, $mongoIds);
        $queriedDocuments = $this->queryDocumentsByIds($idsToQuery);

        return array_merge($cachedDocuments, $queriedDocuments);
    }
119494
@Override
    public List<T> getAll(final String... ids) {
        if (ids == null || ids.length == 0) {
            return Collections.<T> emptyList();
        }

        // delegate to internal method that partitions the list into smaller groups and aggregates
        // the result
        return getAll(Lists.newArrayList(ids));
    }
841468
public function findByIds($ids)
    {
        if (!is_array($ids)) {
            $ids = explode(',', $ids);
        }

        return $this->createQueryBuilder('ml')
            ->andWhere('ml.id IN (:ids)')
            ->setParameter('ids', $ids)
            ->getQuery()
            ->getResult();
    }
590000
public Set<DOCUMENT> query(@NonNull Iterable<KEY> keys, @NonNull Predicate<? super DOCUMENT> filter) {
      return Streams.asParallelStream(keys)
                    .flatMap(key -> index.get(key).stream())
                    .map(documents::get)
                    .filter(filter)
                    .collect(Collectors.toSet());
   }
98122
public static @CheckForNull <T extends Descriptor> T findById(Collection<? extends T> list, String id) {
        for (T d : list) {
            if(d.getId().equals(id))
                return d;
        }
        return null;
    }
533286
public Map<String, Set<String>> queriesForIds(Collection<String> ids) {
        Set<String> idsWithParents = getIdsForIdsWithAncestors(ids);
        Map<String, Set<String>> queries = new HashMap<String, Set<String>>();
        for (String id : idsWithParents) {
            queries.put(id, getIdsForIdWithDescendants(id));
        }
        return queries;
    }