/** * Constructor. * @param delegate Delegate transaction (not null) */ public AbstractDelegatedTransaction(T delegate) { super(); ObjectUtils.argumentNotNull(delegate, "Delegate transaction must be not null"); this.delegate = delegate; }
/** * Constructor * @param value Constant value * @param type Value type (not null) */ public DefaultConstantExpression(T value, Class<? extends T> type) { super(); ObjectUtils.argumentNotNull(type, "Value type must be not null"); this.value = value; this.type = type; }
/** * Constructor. * @param queryAdapter Query adapter (not null) * @param queryDefinition Query definition (not null) */ public QueryAdapterQuery(QueryAdapter<? super D> queryAdapter, D queryDefinition) { super(queryDefinition); ObjectUtils.argumentNotNull(queryAdapter, "QueryAdapter must be not null"); this.queryAdapter = queryAdapter; }
/** * Constructor. * @param source Source context (not null) */ public DefaultLocalizationChangeEvent(LocalizationContext source) { super(); ObjectUtils.argumentNotNull(source, "LocalizationContext must be not null"); this.source = source; }
/** * Constructor * @param propertySet PropertySet instance to use */ @SuppressWarnings("unchecked") public AbstractPropertyBox(PropertySet<? extends Property> propertySet) { super(); ObjectUtils.argumentNotNull(propertySet, "PropertySet must be not null"); this.propertySet = (PropertySet<Property>) propertySet; }
@Override public void removeParameter(String name) { ObjectUtils.argumentNotNull(name, "Parameter name must be not null"); if (parameters != null) { parameters.remove(name); } }
@Override public void addParameter(String name, Object value) { ObjectUtils.argumentNotNull(name, "Parameter name must be not null"); if (parameters == null) { parameters = new HashMap<>(4); } parameters.put(name, value); }
@Override public void setDefaultBooleanLocalization(boolean value, Localizable message) { ObjectUtils.argumentNotNull(message, "Localizable message must be not null"); if (defaultBooleanLocalizations == null) { defaultBooleanLocalizations = new HashMap<>(2); } defaultBooleanLocalizations.put(Boolean.valueOf(value), message); }
@Override public <E extends Expression, R extends Expression> void removeExpressionResolver( ExpressionResolver<E, R> expressionResolver) { ObjectUtils.argumentNotNull(expressionResolver, "ExpressionResolver to remove must be not null"); resolvers.remove(expressionResolver); LOGGER.debug(() -> "Removed ExpressionResolver [" + expressionResolver + "] from registry [" + this + "]"); }
/** * Add a {@link QuerySort}. * @param sort the sort to add */ protected void addSort(QuerySort sort) { ObjectUtils.argumentNotNull(sort, "QuerySort must be not null"); if (this.sort == null) { this.sort = sort; } else { this.sort = this.sort.and(sort); } }
/** * Turn a query results {@link Iterator} into a {@link Stream}. * @param <T> Results type * @param queryResultsIterator Iterator to convert (not null) * @param closeHandler Optional close handler to perform closing operations when Stream is closed * @return Stream from Iterator */ public static <T> Stream<T> asResultsStream(Iterator<T> queryResultsIterator, Runnable closeHandler) { ObjectUtils.argumentNotNull(queryResultsIterator, "Iterator must be not null"); return asResultsStream(() -> queryResultsIterator, closeHandler); }
@Override public void addParameter(String name, Object value) { ObjectUtils.argumentNotNull(name, "Parameter name must be not null"); this.parameters.addParameter(name, value); }
/** * Gets the path full name, including any parent path, separated by a dot <code>.</code> character. * @param nameMapper The function to use to obtain the path name (not null) * @return Path full name */ default String fullName(Function<Path<?>, String> nameMapper) { ObjectUtils.argumentNotNull(nameMapper, "Path name mapper function must be not null"); return getParent().map(pr -> stream().map(p -> nameMapper.apply(p)) .collect(LinkedList<String>::new, LinkedList::addFirst, (a, b) -> a.addAll(0, b)).stream() .collect(Collectors.joining("."))).orElse(getName()); }
@Override public Optional<Property<?>> getProperty(String name) { ObjectUtils.argumentNotNull(name, "Property name must be not null"); return Optional.ofNullable(getNamePropertyCache().computeIfAbsent(name, pn -> { for (Property property : getPropertySet()) { if (pn.equals(property.getName())) { return property; } } return null; })); }
@Override public <PT extends P> Builder<P> add(PT property) { ObjectUtils.argumentNotNull(property, "Property must be not null"); if (!this.instance.contains(property)) { this.instance.add(property); } return this; }
@Override @Deprecated public O operationPaths(Path<?>[] paths) { ObjectUtils.argumentNotNull(paths, "Paths must be not null"); getDefinition().setPropertySet(asPropertySet(Arrays.asList(paths))); return getActualOperation(); }
/** * Build a sub query with given projection as selection. * @param <T> Subquery selection type * @param selection Query selection (not null) * @return Sub query instance */ @SuppressWarnings("unchecked") static <T> SubQuery<T> create(QueryProjection<T> selection) { ObjectUtils.argumentNotNull(selection, "Selection projection must be not null"); return create((Class<T>) selection.getType()).select(selection); }
@Override public <T> Q parameter(ConfigProperty<T> property, T value) { ObjectUtils.argumentNotNull(property, "ConfigProperty must be not null"); getQueryDefinition().addParameter(property.getKey(), value); return getActualBuilder(); }
@Override public <T> B parameter(ConfigProperty<T> property, T value) { ObjectUtils.argumentNotNull(property, "ConfigProperty must be not null"); getInstance().addParameter(property.getKey(), value); return getActualBuilder(); }
@SuppressWarnings("unchecked") @Override public <MODEL> B elementConverter(PropertyValueConverter<E, MODEL> elementConverter) { ObjectUtils.argumentNotNull(elementConverter, "Element value converter must be not null"); return converter(new CollectionCallbackPropertyValueConverter<>(getType(), elementConverter.getModelType(), v -> elementConverter.fromModel(v, (Property<E>) this), v -> elementConverter.toModel(v, (Property<E>) this), getDefaultInstanceProvider())); }