Looks up a Collection of Containers by their identifiers.

The returned Collection preserves the iteration order of the passed-in Collection.

@return Collection of Containers.
162342
public Collection<C> getAll(Collection<String> ids){
		Set<C> list = new LinkedHashSet<C>();

		for(String id : ids){
			C container = get(id);

			if(container != null){
				list.add(container);
			}
		}

		return list;
	}
516828
public function getCollections()
    {
        if ($this->collections) {
            return $this->collections;
        }

        $collectionMapper = ($this->container->dataMapper)('CollectionMapper');

        return $this->collections = $collectionMapper->find();
    }
681225
def containers(self) -> list:
        

        all_containers: List = list()
        for slot in self:
            all_containers += slot.get_children_list()

        for container in all_containers:
            if getattr(container, 'stackable', False):
                all_containers += container.get_children_list()

        return all_containers
1259481
def getContainers(self):
        
        _containers = []
        for container in self.bika_setup.bika_containers.objectValues():
            containertype = container.getContainerType()
            if containertype and containertype.UID() == self.UID():
                _containers.append(container)
        return _containers
1179225
@VisibleForTesting
  static Map<Integer, Container> getContainers(
      PackingPlan currentPackingPlan, Resource maxContainerResource, Resource padding,
      Map<String, TreeSet<Integer>> componentIndexes, TreeSet<Integer> taskIds) {
    Map<Integer, Container> containers = new HashMap<>();

    Resource capacity = maxContainerResource;
    for (PackingPlan.ContainerPlan currentContainerPlan : currentPackingPlan.getContainers()) {
      Container container =
          new Container(currentContainerPlan.getId(), capacity, padding);
      for (PackingPlan.InstancePlan instancePlan : currentContainerPlan.getInstances()) {
        addToContainer(container, instancePlan, componentIndexes, taskIds);
      }
      containers.put(currentContainerPlan.getId(), container);
    }
    return containers;
  }
68547
public List<SimpleOrderedMap<Object>> list() {
    List<SimpleOrderedMap<Object>> list = new ArrayList<>();
    for (Entry<String, String> entry : idToVersion.entrySet()) {
      SimpleOrderedMap<Object> item = new SimpleOrderedMap<>();
      item.add("id", entry.getKey());
      item.add("size", versionToItem.get(entry.getValue()).size);
      item.add("version", entry.getValue());
      item.add("expiration", expirationVersion.get(entry.getValue()));
      list.add(item);
    }
    return list;
  }
1130209
public function get()
    {
        $identities = [];
        $origData   = $this->optimizer->getOrigData();
        $containers = $this->optimizer->getData('search_container') ?? [];

        if (!$this->optimizer->isObjectNew()) {
            $containers = array_unique(
                array_keys(array_merge($this->optimizer->getSearchContainers(), $origData['search_containers'] ?? []))
            );
        }

        if (in_array('quick_search_container', $containers)) {
            $identities = array_merge($identities, $this->getSearchQueryIdentities());
        }

        if (in_array('catalog_view_container', $containers)) {
            $identities = array_merge($identities, $this->getCategoryIdentities());
        }

        return $identities;
    }
36219
public Set<Algorithm> getAlgorithms() {
		if (algorithms == null) {
			algorithms = Collections.unmodifiableSet(new HashSet<>(
					this.idsToAlgorithms.values()));
		}
		return algorithms;
	}
439052
public java.util.List<String> getObjectIds() {
        if (objectIds == null) {
            objectIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return objectIds;
    }
253580
public Set<String> entries() {
        Set<String> es = this.entries;
        if (es == null) {
            // lazily scan the entries
            this.entries = scan();
        }
        return this.entries;
    }
1015666
public List<Identifier> getIdentifiers() {
        if (mIdentifiers.getClass().isInstance(UNMODIFIABLE_LIST_OF_IDENTIFIER)) {
            return mIdentifiers;
        }
        else {
            return Collections.unmodifiableList(mIdentifiers);
        }
    }
499043
public Set<Map.Entry<A,B>> entrySet() {
	return new AbstractSet<Map.Entry<A,B>>() {
	    public int size() {
		return map.size();
	    }
	    public Iterator<Map.Entry<A,B>> iterator() {
		return new Iterator<Map.Entry<A,B>>() {
		    private final Iterator<Map.Entry<A,B>> it = map.entrySet().iterator();
		    private Map.Entry<A,B> last = null;
		    public boolean hasNext() {
			return it.hasNext(); 
		    }
		    public Map.Entry<A,B> next() { 
		        last = it.next();
			return last;
		    }
		    public void remove() {
			it.remove();
			revMap.remove(last.getValue());
		    }
		};
	    }
	    public boolean remove(Object o) {
		if(!(o instanceof Map.Entry/*<A,B>*/)) return false;
		@SuppressWarnings("unchecked")
		Map.Entry<A,B> entry = (Map.Entry<A,B>) o;
		B currValue = BijMap.this.get(entry.getKey());
		if((currValue == null) || !currValue.equals(entry.getValue())) return false;
		BijMap.this.remove(entry.getKey());
		return true;
	    }
	    public void clear() {
		BijMap.this.clear();
	    }
	};
    }
252835
public static Collector<Link, ?, Links> collector() {
		return Collectors.collectingAndThen(Collectors.toList(), Links::of);
	}
1239867
public Set<TypeSignature> findNamedTypes() {
        final Set<TypeSignature> collectedNamedTypes = new HashSet<>();
        methods().forEach(m -> {
            findNamedTypes(collectedNamedTypes, m.returnTypeSignature());
            m.parameters().forEach(p -> findNamedTypes(collectedNamedTypes, p.typeSignature()));
            m.exceptionTypeSignatures().forEach(s -> findNamedTypes(collectedNamedTypes, s));
        });

        return ImmutableSortedSet.copyOf(comparing(TypeSignature::name), collectedNamedTypes);
    }
391765
private Set<String> findClassLabelsInHasContainers() {
    Set<String> classLabels = new HashSet<>();

    HasContainer container = this.hasContainers.stream().filter(hasContainer -> isLabelKey(hasContainer.getKey())).findFirst()
        .orElseGet(() -> {
          String defaultClass = Vertex.class.isAssignableFrom(getReturnClass()) ? "V" : "E";
          HasContainer defaultContainer = new HasContainer(T.label.name(), P.eq(defaultClass));
          return defaultContainer;
        });

    Object value = container.getValue();

    //The ugly part. Is there anyway to know the return type of a predicate value ?
    if (value instanceof List) {
      ((List) value).forEach(label -> classLabels.add((String) label));
    } else {
      classLabels.add((String) value);
    }

    return classLabels;
  }
810257
public final java.util.Iterator getObjectStoreIterator()
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass
                        , "getObjectStoreIterator"
                            );
        java.util.Iterator objectStoreIterator = objectManagerState.getObjectStoreIterator();

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass
                       , "getObjectStoreIterator"
                       , new Object[] { objectStoreIterator }
                            );
        return objectStoreIterator;
    }
1082497
public final Set<Entry<String, L[]>> getEntries() {
        return (this.map != null)
                ? this.map.entrySet()
                : Collections.<Entry<String, L[]>>emptySet();
    }