public boolean contains(PropertyVersion version) { if (version == PropertyVersion.DETACH) { return this != ATTACH; } else if (version == PropertyVersion.ATTACH) { return this != DETACH; } Arguments.mustNotBeNull("version", version); return false; } }
public static XSharedSessionBuilderImplementor wrap(SharedSessionBuilder sharedSessionBuilder, XSessionFactory factory) { if (sharedSessionBuilder instanceof XSharedSessionBuilderImplementor) { return (XSharedSessionBuilderImplementor)sharedSessionBuilder; } return (XSharedSessionBuilderImplementor)INSTANCE.createProxy( Arguments.mustBeInstanceOfValue("sharedSessionBuilder", sharedSessionBuilder, SessionBuilderImplementor.class), Arguments.mustNotBeNull("factory", factory) ); }
@Override public SimpleOrderPath.Builder get(String nodeName, GetterType getterType) { Arguments.mustNotBeEmpty("nodeName", Arguments.mustNotBeNull("nodeName", nodeName)); Arguments.mustNotBeNull("getterType", getterType); Object[] arr = this.arr; int len = this.len; if (len + 2 > arr.length) { Object[] newArr = new Object[len << 1]; System.arraycopy(arr, 0, newArr, 0, len); this.arr = arr = newArr; } arr[len] = nodeName; arr[len + 1] = getterType; this.len += 2; return this; }
TransientWrapper(Validator<T> raw) { this.raw = Arguments.mustNotBeInstanceOfValue( "raw", Arguments.mustNotBeInstanceOfValue( "raw", Arguments.mustNotBeNull("raw", raw), CombinedImpl.class ), Serializable.class ); }
protected ClassEnhancer(Class<?> clazz) { Arguments.mustNotBeNull("clazz", clazz); Arguments.mustBeClass("clazz", clazz); Arguments.mustNotBeFinal("clazz", clazz); this.clazz = clazz; }
public WhenClause(C condition, Expression<? extends R> result) { this.condition = Arguments.mustNotBeNull("condition", condition); this.result = Arguments.mustNotBeInstanceOfAnyOfValue( "result", Arguments.mustNotBeNull("result", result), ParameterExpression.class, LiteralExpression.class); }
protected AbstractWrapperXCollection( AbstractWrapperXCollection<E> parent, ViewInfo viewInfo) { Arguments.mustNotBeNull("parent", parent); Arguments.mustBeInstanceOfValue("this", this, View.class); Arguments.mustNotBeInstanceOfValue("this", this, Serializable.class); this.parent = parent; this.rootData = parent.rootData; this.viewInfo = viewInfo; XCollection<E> base = parent.getBase(true); if (base != null) { base = this.createBaseView(base, viewInfo); if (!(base instanceof View)) { throw new IllegalProgramException(CommonMessages.createBaseViewMustReturnView(this.getClass(), View.class)); } this.setBase(base); } }
private void validateParts(ComparatorPart[] parts) { Arguments.mustNotContainNullElements( "parts", Arguments.mustNotBeEmpty( "parts", Arguments.mustNotBeNull("parts", parts) ) ); for (int i = parts.length - 1; i >= 0; i--) { Arguments.mustBetweenValue( "parts[" + i + "]scalarPropertyId", parts[i].getScalarPropertyId(), 0, true, this.propertyArray.length, false ); } }
public ObjectModelMergeEventListener(Iterable<MergeEventListener> listeners) { Arguments.mustNotContainSpecialElements( "listeners", Arguments.mustNotBeEmpty("listeners", Arguments.mustNotBeNull("listeners", listeners)), ObjectModelMergeEventListener.class ); List<MergeEventListener> list = new ArrayList<>(); for (MergeEventListener listener : listeners) { list.add(listener); } this.listeners = list.toArray(new MergeEventListener[list.size()]); }
public PageBuilder(XTypedQuery<T> typedQuery, int pageIndex, int pageSize) { this.typedQuery = Arguments.mustNotBeNull("typedQuery", typedQuery); this.pageIndex = pageIndex; this.pageSize = Arguments.mustBeGreaterThanValue("pageSize", pageSize, 0); }
public ConstantExpression(XCriteriaBuilder criteriaBuilder, T value) { super(criteriaBuilder); Arguments.mustNotBeNull("value", value); Arguments.mustBeInstanceOfAnyOfValue( "value", value, Boolean.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class, BigInteger.class, BigDecimal.class, String.class); this.value = value; }
public void modify(Date startTime, Date endTime) { if (this.state != AnnualLeaveRequestState.CREATED) { throw new IllegalStateException( requestCanNotBeModified(this.state) ); } Arguments.mustNotBeNull("startTime", startTime); Arguments.mustNotBeNull("endTime", endTime); Arguments.mustBeGreaterThanOther("endTime", endTime, "startTime", startTime); Arguments.mustBeLessThanOrEqualToValue( "Time annual leave hours(endTime - startTime)", (endTime.getTime() - startTime.getTime()) / (60 * 60 * 1000), 160 ); this.startTime = startTime; this.endTime = endTime; }
Class<?> rawType, Type[] actualTypeArguments) { Arguments.mustNotBeNull("rawType", rawType); if (!(ownerType instanceof ParameterizedType)) { Arguments.mustNotBeEmptyWhen( whenOwnerTypeIsNotParameterizedType("ownerType"), "rawType.getTypeParameters()", this.ownerType = ownerType; } else { Arguments.mustBeInstanceOfAnyOfValue("ownerType", ownerType, Class.class, ParameterizedType.class); throw new AssertionError("Internal bug: impossible");
@Override public void validate(Object e) { if (e != null) { Arguments.mustBeInstanceOfValue("e", e, this.restrctionType); } }
public long createBook(Book book) { Arguments.mustBeNull( "book.id", Arguments.mustNotBeNull("book", book).getId() ); try (TransactionScope ts = new TransactionScope(this.connectionString)) { return ts.complete(this.bookRepository.mergeBook(book).getId()); } }
@SuppressWarnings("unchecked") protected final void replace(Object base) { Arguments.mustNotBeInstanceOfValue("this", this, View.class); Arguments.mustNotBeInstanceOfValue("base", base, View.class); Arguments.mustBeInstanceOfValue("base", base, XMap.class); // Unnecessary but for optimization if (this instanceof ModificationAware) { MAMap<K, V> oldBase = (MAMap<K, V>)this.base; if (oldBase != null) { oldBase.removeMapElementListener(this.eventDispatcher()); } } // Only need to change "root.base", because "this.base" will be // refreshed automatically when "this.getBase()" is called later. this.getRootData().setBase((XMap<K, V>)base); }
@Override public void setPreThrowable(Throwable preThrowable) { this.preThrowable = Arguments.mustBeInstanceOfAnyOfValue( "preThrowable", preThrowable, RuntimeException.class, Error.class); }
keyEqualityComparator, valueComparatorOrEqualityComparatorOrUnifiedComparator); Arguments.mustBeLessThanOrEqualToValue("initCapacity", initCapacity, MAX_CAPACITY); if (initCapacity < MIN_CAPACITY) { initCapacity = MIN_CAPACITY; Arguments.mustBeGreaterThanValue("loadFactor.floatValue()", loadFactor.floatValue(), 0); this.threshold = (int)(initCapacity * loadFactor);
protected final void checkSubListRange(int subListHeadHide, int subListTailHide) { Arguments.mustBeGreaterThanOrEqualToValue("subListHeadHide", subListHeadHide, 0); Arguments.mustBeGreaterThanOrEqualToValue("subListTailHide", subListTailHide, 0); Arguments.mustBeLessThanOrEqualToValue( "subListHeadHide + subListTailHide", subListHeadHide + subListTailHide, this.allSize()); }
public ArrayElements( BidiType bidiType, Object comparatorOrEqualityComparatorOrUnifiedComparator, int initCapacity, float expandFactor, Float collapseFactor) { super(bidiType, comparatorOrEqualityComparatorOrUnifiedComparator); Arguments.mustBeGreaterThanOrEqualToValue("initCapacity", initCapacity, 0); Arguments.mustBetweenValue("expandFactory", expandFactor, 1, true, 4, true); if (collapseFactor != null) { float factor = collapseFactor.floatValue(); Arguments.mustBetweenValue("expandFactory", factor, 0.1F, true, 0.9F, true); } if (initCapacity != 0) { this.data = new Object[initCapacity]; } }