io.micronaut.core.order.OrderUtil Java Examples

/**
 * Return an unmodifiable snapshot list of all registered synchronizations
 * for the current thread.
 * @return unmodifiable List of TransactionSynchronization instances
 * @throws IllegalStateException if synchronization is not active
 * @see TransactionSynchronization
 */
public static List<TransactionSynchronization> getSynchronizations() throws IllegalStateException {
    Set<TransactionSynchronization> synchs = SYNCHRONIZATIONS.get();
    if (synchs == null) {
        throw new IllegalStateException("Transaction synchronization is not active");
    }
    // Return unmodifiable snapshot, to avoid ConcurrentModificationExceptions
    // while iterating and invoking synchronization callbacks that in turn
    // might register further synchronizations.
    if (synchs.isEmpty()) {
        return Collections.emptyList();
    } else {
        // Sort lazily here, not in registerSynchronization.
        List<TransactionSynchronization> sortedSynchs = new ArrayList<>(synchs);
        OrderUtil.sort(sortedSynchs);
        return Collections.unmodifiableList(sortedSynchs);
    }
}
 

/**
 * Default constructor.
 */
public AlexaFunction() {
    buildApplicationContext();
    applicationContext.inject(this);
    this.skillStreamHandler = new MicronautSkillStreamHandler(
            applicationContext.getBeansOfType(AlexaSkill.class)
                    .stream()
                    .sorted(OrderUtil.COMPARATOR)
                    .toArray(AlexaSkill[]::new));
}
 

@Nonnull
@Override
 public AlexaSkill<RequestEnvelope, ResponseEnvelope> buildSkill(@Nonnull @NotNull SkillBuilder<?> skillBuilder,
                                                                 @Nullable AlexaSkillConfiguration alexaSkillConfiguration) {

    SkillBeans skillBeans = alexaSkillConfiguration == null ? unqualifiedSkillBeans : this.skillBeans.get(alexaSkillConfiguration.getName());
    skillBeans.getRequestHandlers()
            .stream()
            .sorted(OrderUtil.COMPARATOR)
            .forEach(skillBuilder::addRequestHandler);

    skillBeans.getExceptionHandlers()
            .stream()
            .sorted(OrderUtil.COMPARATOR)
            .forEach(skillBuilder::addExceptionHandler);

    skillBeans.getRequestInterceptors()
            .stream()
            .sorted(OrderUtil.COMPARATOR)
            .forEach(skillBuilder::addRequestInterceptor);

    skillBeans.getResponseInterceptors()
            .stream()
            .sorted(OrderUtil.COMPARATOR)
            .forEach(skillBuilder::addResponseInterceptor);

    if (alexaSkillConfiguration != null) {
        skillBuilder = skillBuilder.withSkillId(alexaSkillConfiguration.getSkillId());
    }
    return skillBuilder.build();
}
 

/**
 * The default constructor.
 *
 * @param registries The other registries
 */
public CompositeSerdeRegistry(SerdeRegistry... registries) {
    this.registries = new ArrayList<>(
            registries != null ? Arrays.asList(registries) : Collections.emptyList()
    );

    OrderUtil.sort(registries);
}
 

private List<MethodCandidate> initializeMethodCandidates(VisitorContext context) {
    List<MethodCandidate> finderList = Arrays.asList(
            new FindByFinder(),
            new ExistsByFinder(),
            new SaveEntityMethod(),
            new SaveOneMethod(),
            new SaveAllMethod(),
            new ListMethod(),
            new CountMethod(),
            new DeleteByMethod(),
            new DeleteMethod(),
            new CountByMethod(),
            new UpdateMethod(),
            new UpdateEntityMethod(),
            new UpdateByMethod(),
            new ListSliceMethod(),
            new FindSliceByMethod(),
            new ListSliceMethod(),
            new FindPageByMethod(),
            new ListPageMethod(),
            new FindOneMethod(),
            new FindByIdsMethod(),
            new FindOneSpecificationMethod(),
            new CountSpecificationMethod(),
            new FindAllSpecificationMethod(),
            new FindPageSpecificationMethod()
    );
    SoftServiceLoader<MethodCandidate> otherCandidates = SoftServiceLoader.load(MethodCandidate.class);
    for (ServiceDefinition<MethodCandidate> definition : otherCandidates) {
        if (definition.isPresent()) {
            try {
                finderList.add(definition.load());
            } catch (Exception e) {
                context.warn("Could not load Data method candidate [" + definition.getName() + "]: " + e.getMessage(), null);
            }
        }
    }
    OrderUtil.sort(finderList);
    return finderList;
}
 

/**
 *
 * @param skills List of available Skills
 */
public DefaultRequestEnvelopeService(List<Skill> skills) {
    this.skills = skills.stream().sorted(OrderUtil.COMPARATOR).collect(Collectors.toList());
}