Java Code Examples for io.micronaut.core.util.ArgumentUtils#requireNonNull()

/**
 * Default constructor.
 * @param applicationContext The application context
 * @param applicationConfiguration The application configuration
 * @param grpcServerConfiguration The GRPC server configuration
 * @param serverBuilder The server builder
 * @param eventPublisher The event publisher
 * @param computeInstanceMetadataResolver The computed instance metadata
 * @param metadataContributors The metadata contributors
 */
@Internal
GrpcEmbeddedServer(
        @Nonnull ApplicationContext applicationContext,
        @Nonnull ApplicationConfiguration applicationConfiguration,
        @Nonnull GrpcServerConfiguration grpcServerConfiguration,
        @Nonnull ServerBuilder<?> serverBuilder,
        @Nonnull ApplicationEventPublisher eventPublisher,
        @Nullable ComputeInstanceMetadataResolver computeInstanceMetadataResolver,
        @Nullable List<ServiceInstanceMetadataContributor> metadataContributors) {
    ArgumentUtils.requireNonNull("applicationContext", applicationContext);
    ArgumentUtils.requireNonNull("applicationConfiguration", applicationConfiguration);
    ArgumentUtils.requireNonNull("grpcServerConfiguration", grpcServerConfiguration);
    this.applicationContext = applicationContext;
    this.configuration = applicationConfiguration;
    this.grpcConfiguration = grpcServerConfiguration;
    this.eventPublisher = eventPublisher;
    this.server = serverBuilder.build();
    this.computeInstanceMetadataResolver = computeInstanceMetadataResolver;
    this.metadataContributors = metadataContributors;
}
 

@NonNull
@Override
public final <T> RuntimePersistentEntity<T> getEntity(@NonNull Class<T> type) {
    ArgumentUtils.requireNonNull("type", type);
    RuntimePersistentEntity<T> entity = entities.get(type);
    if (entity == null) {
        entity = new RuntimePersistentEntity<T>(type) {
            @Override
            protected RuntimePersistentEntity<T> getEntity(Class<T> type) {
                return AbstractSqlRepositoryOperations.this.getEntity(type);
            }
        };
        entities.put(type, entity);
    }
    return entity;
}
 

/**
 * constructor.
 *
 * @param lambdaContainerEnvironment The container environment
 * @param applicationContextBuilder  The context builder
 * @throws ContainerInitializationException if the container couldn't be started
 */
private MicronautLambdaContainerHandler(
        LambdaContainerState lambdaContainerEnvironment,
        ApplicationContextBuilder applicationContextBuilder) throws ContainerInitializationException {
    super(
            AwsProxyRequest.class,
            AwsProxyResponse.class,
            new MicronautRequestReader(lambdaContainerEnvironment),
            new MicronautResponseWriter(lambdaContainerEnvironment),
            new AwsProxySecurityContextWriter(),
            new MicronautAwsProxyExceptionHandler(lambdaContainerEnvironment)

    );
    ArgumentUtils.requireNonNull("applicationContextBuilder", applicationContextBuilder);
    this.lambdaContainerEnvironment = lambdaContainerEnvironment;
    this.applicationContextBuilder = applicationContextBuilder;
    initialize();
}
 

@Override
public <R> R executeRead(@NonNull TransactionCallback<Connection, R> callback) {
    ArgumentUtils.requireNonNull("callback", callback);
    return readTransactionTemplate.execute(status -> {
                try {
                    return callback.call(new JpaTransactionStatus(status));
                } catch (RuntimeException | Error ex) {
                    throw ex;
                } catch (Exception e) {
                    throw new UndeclaredThrowableException(e, "TransactionCallback threw undeclared checked exception");
                }
            }
    );
}
 

/**
 * Adds the specified criterion instance to the query.
 *
 * @param criterion The criterion instance
 */
@Override
public @NonNull
QueryModel add(@NonNull QueryModel.Criterion criterion) {
    ArgumentUtils.requireNonNull("criterion", criterion);
    QueryModel.Junction currentJunction = criteria;
    add(currentJunction, criterion);
    return this;
}
 

@Override
public <R> R executeWrite(@NonNull TransactionCallback<Connection, R> callback) {
    ArgumentUtils.requireNonNull("callback", callback);
    return writeTransactionTemplate.execute(status -> {
                try {
                    return callback.call(new JpaTransactionStatus(status));
                } catch (RuntimeException | Error ex) {
                    throw ex;
                } catch (Exception e) {
                    throw new UndeclaredThrowableException(e, "TransactionCallback threw undeclared checked exception");
                }
            }
    );
}
 

@Nonnull
@Override
public <K, V> Consumer<K, V> getConsumer(@Nonnull String id) {
    ArgumentUtils.requireNonNull("id", id);
    final Consumer consumer = consumers.get(id);
    if (consumer == null) {
        throw new IllegalArgumentException("No consumer found for ID: " + id);
    }
    return consumer;
}
 

/**
 * Return the mapped name for the given entity.
 * @param entity The entity
 * @return The mapped name
 */
default @NonNull String mappedName(@NonNull PersistentEntity entity) {
    ArgumentUtils.requireNonNull("entity", entity);
    return entity.getAnnotationMetadata().stringValue(MappedEntity.class)
            .filter(StringUtils::isNotEmpty)
            .orElseGet(() -> mappedName(entity.getSimpleName()));
}
 

@Override
public MutableHttpHeaders add(CharSequence header, CharSequence value) {
    ArgumentUtils.requireNonNull("header", header);
    ArgumentUtils.requireNonNull("value", value);
    multiValueHeaders.add(header.toString(), value.toString());
    return this;
}
 

@Nullable
@Override
public String get(CharSequence name) {
    ArgumentUtils.requireNonNull("name", name);

    final List<String> values = map.get(name.toString());
    if (values != null) {
        final Iterator<String> i = values.iterator();
        if (i.hasNext()) {
            return i.next();
        }
    }
    return null;
}
 

@Override
public MutableHttpHeaders remove(CharSequence header) {
    ArgumentUtils.requireNonNull("header", header);
    multiValueHeaders.remove(header.toString());
    return this;
}
 

/**
 * Default constructor.
 * @param configuration The configuration
 */
public GoogleCredentialsFactory(@Nonnull GoogleCredentialsConfiguration configuration) {
    ArgumentUtils.requireNonNull("configuration", configuration);
    this.configuration = configuration;
}
 

@Override
public List<String> getAll(CharSequence name) {
    ArgumentUtils.requireNonNull("name", name);
    return map.getOrDefault(name.toString(), Collections.emptyList());
}
 

/**
 * The bean types to exclude from being exposed by Spring's {@link org.springframework.beans.factory.BeanFactory} interface.
 * @param beanExcludes The bean types
 */
public void setBeanExcludes(@Nonnull List<Class<?>> beanExcludes) {
    ArgumentUtils.requireNonNull("beanExcludes", beanExcludes);
    this.beanExcludes = beanExcludes;
}
 

@Override
public MutableHttpHeaders remove(CharSequence header) {
    ArgumentUtils.requireNonNull("header", header);
    response.getHeaders().remove(header.toString());
    return this;
}
 

@Override
public Optional<String> getFirst(CharSequence name) {
    ArgumentUtils.requireNonNull("name", name);
    return googleRequest.getFirstQueryParameter(name.toString());
}
 

/**
 * Default constructor.
 * @param name The parameter name
 */
public QueryParameter(@NonNull String name) {
    ArgumentUtils.requireNonNull("name", name);
    this.name = name;
}
 

/**
 * Gets a new {@link MicronautLambdaContainerHandler} should be called exactly once.
 *
 * @param builder The builder to customize the context creation
 * @return The {@link MicronautLambdaContainerHandler}
 * @throws ContainerInitializationException if the container couldn't be started
 * @deprecated Use {@link #MicronautLambdaContainerHandler(ApplicationContextBuilder)} instead
 */
@Deprecated
public static MicronautLambdaContainerHandler getAwsProxyHandler(ApplicationContextBuilder builder) throws ContainerInitializationException {
    ArgumentUtils.requireNonNull("builder", builder);
    return new MicronautLambdaContainerHandler(new LambdaContainerState(), builder);
}
 

/**
 * Default constructor.
 *
 * @param asyncOperations The instance operations instance
 */
public ExecutorReactiveOperations(@NonNull ExecutorAsyncOperations asyncOperations) {
    ArgumentUtils.requireNonNull("asyncOperations", asyncOperations);
    this.asyncOperations = asyncOperations;
}
 

/**
 * Creates a query from the given entity.
 *
 * @param entity The entity
 * @return The query
 */
static @NonNull
QueryModel from(@NonNull PersistentEntity entity) {
    ArgumentUtils.requireNonNull("entity", entity);
    return new DefaultQuery(entity);
}