/** * 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; }
/** * Constructor for non-leaf nodes. * @param name Serialization name */ public DefaultPropertySetSerializationNode(String name) { super(); ObjectUtils.argumentNotNull(name, "Serialization name must be not null"); this.name = name; this.property = null; }
@Override public void removeParameter(String name) { ObjectUtils.argumentNotNull(name, "Parameter name must be not null"); if (parameters != null) { parameters.remove(name); } }
/** * Append a sort expression * @param sort Sort to append to current sorts */ public void addSort(QuerySort sort) { ObjectUtils.argumentNotNull(sort, "Sort to append must be not null"); sorts.add(sort); }
@Override public RestClient removeDefaultHeader(String name) { ObjectUtils.argumentNotNull(name, "Header name must be not null"); defaultHeaders.remove(name); return this; }
@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); }
/** * Add an inserted key * @param key Key path (not null) * @param value Key value */ public void addInsertedKey(Path<?> key, Object value) { ObjectUtils.argumentNotNull(key, "Key path must be not null"); if (insertedKeys == null) { insertedKeys = new HashMap<>(4); } insertedKeys.put(key, value); }
@Override public Optional<DeviceInfo> getDeviceInfo(UI ui) { ObjectUtils.argumentNotNull(ui, "UI must be not null"); return Optional.ofNullable(deviceInfos.get(ui)); }
@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); }
/** * Obtain a builder to create and populate a {@link PropertySet} which supports given {@link Property} type. * @param <P> Property type * @param propertyType The property type managed by the {@link PropertySet} to build (not null) * @return A new {@link PropertySet} builder * @since 5.1.0 */ static <P extends Property> Builder<P> builder(Class<? extends P> propertyType) { ObjectUtils.argumentNotNull(propertyType, "Property type must be not null"); return new DefaultPropertySet.DefaultBuilder<>(); }
/** * Bind a {@link PropertyValuePresenter} to the given property. The presenter will be provided when the property to * render is the same as the given property. * @param <T> Property base type * @param property The property to present (not null) * @param presenter The PropertyPresenter to register (not null) */ default <T> void forProperty(Property<? extends T> property, PropertyValuePresenter<? super T> presenter) { ObjectUtils.argumentNotNull(property, "Property must be not null"); register(p -> property.equals(p), presenter); }
/** * Add a sort clause using a {@link Supplier}. * @param sortSupplier The {@link QuerySort} clause {@link Supplier} (not null) * @return the {@link QuerySortSupport} which contains the added sort clause (usually the same instance) * @since 5.1.2 */ default C sort(Supplier<QuerySort> sortSupplier) { ObjectUtils.argumentNotNull(sortSupplier, "QuerySort supplier must be not null"); return sort(sortSupplier.get()); }
@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); } }
/** * Add a filter clause using a {@link Supplier}. * @param filterSupplier The {@link QueryFilter} clause {@link Supplier} (not null) * @return the {@link QueryFilterSupport} which contains the added filter clause (usually the same instance) * @since 5.1.2 */ default C filter(Supplier<QueryFilter> filterSupplier) { ObjectUtils.argumentNotNull(filterSupplier, "QueryFilter supplier must be not null"); return filter(filterSupplier.get()); }
@Override public void removeBeanPropertySetPostProcessor(BeanPropertySetPostProcessor beanPropertySetPostProcessor) { ObjectUtils.argumentNotNull(beanPropertySetPostProcessor, "BeanPropertySetPostProcessor must be not null"); propertySetPostProcessors.remove(beanPropertySetPostProcessor); LOGGER.debug(() -> "Unregistered BeanPropertySetPostProcessor [" + beanPropertySetPostProcessor + "]"); }