public ConditionFragment setCondition(String[] lhs, String rhs) { this.lhs = lhs; this.rhs = ArrayHelper.fillArray(rhs, lhs.length); return this; }
public static String[] join(String[] x, String[] y, boolean[] use) { String[] result = new String[x.length + countTrue( use )]; System.arraycopy( x, 0, result, 0, x.length ); int k = x.length; for ( int i = 0; i < y.length; i++ ) { if ( use[i] ) { result[k++] = y[i]; } } return result; }
public boolean isUpdateable() { // if the property mapping consists of all formulas, // make it non-updateable return updateable && !ArrayHelper.isAllFalse( value.getColumnUpdateability() ); }
specifiedAliases.add( rootRtn.getAlias() ); entityAliases.add( rootRtn.getEntityAliases() ); ArrayHelper.addAll( querySpaces, persister.getQuerySpaces() ); includeInResultRowList.add( true ); entityOwners.add( -1 ); entityAliases.add( collRtn.getElementEntityAliases() ); ArrayHelper.addAll( querySpaces, elementPersister.getQuerySpaces() ); specifiedAliases.add( fetchRtn.getAlias() ); entityAliases.add( fetchRtn.getEntityAliases() ); ArrayHelper.addAll( querySpaces, persister.getQuerySpaces() ); includeInResultRowList.add( false ); entityOwners.add( ownerIndex ); entityAliases.add( fetchRtn.getElementEntityAliases() ); ArrayHelper.addAll( querySpaces, elementPersister.getQuerySpaces() ); this.entiytOwners = ArrayHelper.toIntArray( entityOwners ); this.entityAliases = new EntityAliases[entityAliases.size()]; for ( int i = 0; i < entityAliases.size(); i++ ) { this.collectionOwners = ArrayHelper.toIntArray( collectionOwners ); this.collectionAliases = new CollectionAliases[collectionAliases.size()]; for ( int i = 0; i < collectionAliases.size(); i++ ) { this.resultTypes = ArrayHelper.toTypeArray( resultTypes ); this.transformerAliases = ArrayHelper.toStringArray( specifiedAliases );
@Override public void registerCallbacks(Class entityClass, Callback[] callbacks) { if ( callbacks == null || callbacks.length == 0 ) { return; } final HashMap<Class, Callback[]> map = determineAppropriateCallbackMap( callbacks[0].getCallbackType() ); Callback[] entityCallbacks = map.get( entityClass ); if ( entityCallbacks != null ) { callbacks = ArrayHelper.join( entityCallbacks, callbacks ); } map.put( entityClass, callbacks ); }
/** * calculate the array hash (only the first level) */ public static int hash(char[] array) { int seed = SEED; for ( char anArray : array ) { seed = hash( seed, anArray ); } return seed; }
@AllowSysOut public static void main(String... args) { int[] batchSizes = ArrayHelper.getBatchSizes( 32 ); System.out.println( "Forward ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ); for ( int i = 0; i < batchSizes.length; i++ ) { System.out.println( "[" + i + "] -> " + batchSizes[i] ); } System.out.println( "Backward ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" ); for ( int i = batchSizes.length - 1; i >= 0; i-- ) { System.out.println( "[" + i + "] -> " + batchSizes[i] ); } } }
@Override public String toString() { return ArrayHelper.toString( styles ); } }
@Override public int[] getSourceLocations() { return ArrayHelper.toIntArray( sqlPositions ); }
public static boolean contains(Object[] array, Object object) { return indexOf( array, object ) > -1; }
owners = new int[joins]; ownerAssociationTypes = new EntityType[joins]; lockModeArray = ArrayHelper.fillArray( lockOptions.getLockMode(), joins ); if ( ArrayHelper.isAllNegative( owners ) ) { owners = null; if ( collectionOwners != null && ArrayHelper.isAllNegative( collectionOwners ) ) { collectionOwners = null;
protected interface InclusionChecker { boolean includeProperty(int propertyNumber); }
public static int[] getBatchSizes(int maxBatchSize) { int batchSize = maxBatchSize; int n = 1; while ( batchSize > 1 ) { batchSize = getNextBatchSize( batchSize ); n++; } int[] result = new int[n]; batchSize = maxBatchSize; for ( int i = 0; i < n; i++ ) { result[i] = batchSize; batchSize = getNextBatchSize( batchSize ); } return result; }
@Override public int[] sqlTypes(Mapping mapping) throws MappingException { return ArrayHelper.join( discriminatorType.sqlTypes( mapping ), identifierType.sqlTypes( mapping ) ); }
/** * calculate the array hash (only the first level) */ public static int hash(byte[] bytes) { int seed = SEED; for ( byte aByte : bytes ) { seed = hash( seed, aByte ); } return seed; }
public LegacyBatchingEntityLoader( OuterJoinLoadable persister, int maxBatchSize, LockMode lockMode, SessionFactoryImplementor factory, LoadQueryInfluencers loadQueryInfluencers) { super( persister ); this.batchSizes = ArrayHelper.getBatchSizes( maxBatchSize ); this.loaders = new Loader[ batchSizes.length ]; for ( int i = 0; i < batchSizes.length; i++ ) { this.loaders[i] = new EntityLoader( persister, batchSizes[i], lockMode, factory, loadQueryInfluencers); } }
@Override public String getName() { return "component" + ArrayHelper.toString( propertyNames ); }
@Override public int[] getSourceLocations() { return ArrayHelper.toIntArray( sqlPositions ); }
private int getSubclassPropertyIndex(String propertyName) { return ArrayHelper.indexOf( subclassPropertyNameClosure, propertyName ); }
public static int[] getBatchSizes(int maxBatchSize) { int batchSize = maxBatchSize; int n=1; while ( batchSize>1 ) { batchSize = getNextBatchSize(batchSize); n++; } int[] result = new int[n]; batchSize = maxBatchSize; for ( int i=0; i<n; i++ ) { result[i] = batchSize; batchSize = getNextBatchSize(batchSize); } return result; }