@Override public Collection<V> values() { return decorated().values(); }
@Override public Collection<V> values() { return UnmodifiableCollection.unmodifiableCollection(decorated().values()); }
@Override public Collection<SchemaDescription> getSchemaDescriptions() { return parsedSchemas.values(); }
@Override public Collection<PrismSchema> getSchemas() { return parsedSchemas.values().stream() .filter(s -> s.getSchema() != null) .map(s -> s.getSchema()) .collect(Collectors.toList()); }
@NotNull private <TD extends TypeDefinition> Collection<TD> resolveGlobalTypeDefinitionsWithoutNamespace(String typeLocalName, Class<TD> definitionClass) { List<TD> rv = new ArrayList<>(); for (SchemaDescription schemaDescription : parsedSchemas.values()) { PrismSchema schema = schemaDescription.getSchema(); if (schema != null) { rv.addAll(schema.findTypeDefinitionsByType(new QName(schema.getNamespace(), typeLocalName), definitionClass)); } } return rv; }
@NotNull private <ID extends ItemDefinition> List<ID> resolveGlobalItemDefinitionsWithoutNamespace(String localPart, Class<ID> definitionClass, @Nullable List<String> ignoredNamespaces) { List<ID> found = new ArrayList<>(); for (SchemaDescription schemaDescription : parsedSchemas.values()) { PrismSchema schema = schemaDescription.getSchema(); if (schema == null) { // is this possible? continue; } if (namespaceMatches(schema.getNamespace(), ignoredNamespaces)) { continue; } ItemDefinition def = schema.findItemDefinitionByElementName(new QName(localPart), definitionClass); if (def != null) { found.add((ID) def); } } return found; }
/** * Moving workers to correct groups (and renaming them if needed). * We assume none of the workers are currently being executed. */ private MovedClosed moveWorkers(List<Task> currentWorkers, MultiValuedMap<String, WorkerKey> shouldBeWorkers, OperationResult result) throws SchemaException, ObjectNotFoundException, ObjectAlreadyExistsException { int moved = 0, closed = 0; Iterator<WorkerKey> shouldBeIterator = shouldBeWorkers.values().iterator(); for (Task worker : new ArrayList<>(currentWorkers)) { if (shouldBeIterator.hasNext()) { WorkerKey shouldBeNext = shouldBeIterator.next(); moveWorker(worker, shouldBeNext, result); currentWorkers.remove(worker); shouldBeIterator.remove(); moved++; } else { if (worker.getExecutionStatus() != TaskExecutionStatus.CLOSED) { LOGGER.info("Closing superfluous worker task {}", worker); taskManager.suspendAndCloseTaskQuietly(worker, TaskManager.DO_NOT_WAIT, result); closed++; } } } LOGGER.trace("After moveWorkers (result: {} moved, {} closed):\nCurrent workers: {}\nShould be workers: {}", moved, closed, currentWorkers, shouldBeWorkers); return new MovedClosed(moved, closed); }
private <TD extends TypeDefinition> TD resolveGlobalTypeDefinitionWithoutNamespace(String typeLocalName, Class<TD> definitionClass) { TD found = null; for (SchemaDescription schemaDescription : parsedSchemas.values()) { PrismSchema schema = schemaDescription.getSchema(); if (schema == null) { // is this possible? continue; } TD def = schema.findTypeDefinitionByType(new QName(schema.getNamespace(), typeLocalName), definitionClass); if (def != null) { if (found != null) { throw new IllegalArgumentException("Multiple possible resolutions for unqualified type name " + typeLocalName + " (e.g. in " + def.getTypeName() + " and " + found.getTypeName()); } found = def; } } return found; }
for (UdpRequest req : socketIdToRequests.values()) { int id = addressToSocketId.get(req.getSourceAddress());
modificationsForId.values().forEach(mod -> offspring.addModification(mod)); rv.offsprings.add(offspring); } else {
WorkersManagementType workersCfg = wsCfg.getWorkers(); for (WorkerKey keyToCreate : keysToCreate.values()) { TaskType worker = new TaskType(prismContext); worker.setName(PolyStringType.fromOrig(keyToCreate.name));
dump("C5", 0); runs.values().forEach(r -> r.assertFocus("jack").assertFocusAssignment("->Pirate"));