/** * Because index population is effectively single-threaded. For parallel population each thread has its own part so single-threaded even there. */ private static OpenOption[] withNoStriping( OpenOption[] openOptions ) { return ArrayUtils.add( openOptions, PageCacheOpenOptions.NO_CHANNEL_STRIPING ); }
private static int[] findRecursiveTypes(final ParameterizedType p) { final Type[] filteredArgumentTypes = Arrays.copyOf(p.getActualTypeArguments(), p.getActualTypeArguments().length); int[] indexesToRemove = {}; for (int i = 0; i < filteredArgumentTypes.length; i++) { if (filteredArgumentTypes[i] instanceof TypeVariable<?>) { if (containsVariableTypeSameParametrizedTypeBound(((TypeVariable<?>) filteredArgumentTypes[i]), p)) { indexesToRemove = ArrayUtils.add(indexesToRemove, i); } } } return indexesToRemove; }
public Class<?>[] getSuperClassHierarchy(Class<?> ceilingEntity) { Class<?>[] entities = new Class<?>[]{}; if (ceilingEntity != null) { entities = ArrayUtils.add(entities, ceilingEntity); while (!ceilingEntity.getSuperclass().equals(Object.class)) { entities = ArrayUtils.add(entities, ceilingEntity.getSuperclass()); ceilingEntity = ceilingEntity.getSuperclass(); } } return entities; }
public static BuildCommand echoWithPrefix(String format, Object...args) { return echo("[%s] " + format, (Object[]) ArrayUtils.add(args, 0, GoConstants.PRODUCT_NAME)); }
/** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, byteArrays). * @param byteArrays an array of byte arrays. * @return a new {@link Guid}. * @throws IOException */ public Guid append(byte[]... byteArrays) throws IOException { if (byteArrays == null || byteArrays.length == 0) { return this; } return fromByteArrays(ArrayUtils.add(byteArrays, this.sha)); }
/** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, guids). Equivalent to * combine(this, guid1, guid2, ...) * @param guids an array of {@link Guid}. * @return a new {@link Guid}. * @throws IOException */ public Guid append(Guid... guids) throws IOException { if (guids == null || guids.length == 0) { return this; } return combine(ArrayUtils.add(guids, this)); }
static void validateQuery( IndexCapability capability, IndexOrder indexOrder, IndexQuery[] predicates ) { if ( indexOrder != IndexOrder.NONE ) { ValueCategory valueCategory = predicates[0].valueGroup().category(); IndexOrder[] orderCapability = capability.orderCapability( valueCategory ); if ( !ArrayUtil.contains( orderCapability, indexOrder ) ) { orderCapability = ArrayUtils.add( orderCapability, IndexOrder.NONE ); throw new UnsupportedOperationException( format( "Tried to query index with unsupported order %s. Supported orders for query %s are %s.", indexOrder, Arrays.toString( predicates ), Arrays.toString( orderCapability ) ) ); } } } }
@Override public String describe() { if (null != argList && !argList.isEmpty()) { return CommandUtils.shellJoin((String[]) ArrayUtils.add(argList.toStringArray(), 0, command)); } if (null != args && !"".equals(args)) { return command + " " + args; } return command; }
/** * Creates a new {@link Guid} which is a unique, replicable representation of the pair (this, objs). * @param objs an array of {@link HasGuid}. * @return a new {@link Guid}. * @throws IOException */ public Guid append(HasGuid... objs) throws IOException { if (objs == null || objs.length == 0) { return this; } return fromHasGuid(ArrayUtils.add(objs, new SimpleHasGuid(this))); }
@Test public void testAddObjectArrayBoolean() { boolean[] newArray; newArray = ArrayUtils.add(null, false); assertTrue(Arrays.equals(new boolean[]{false}, newArray)); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(null, true); assertTrue(Arrays.equals(new boolean[]{true}, newArray)); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); final boolean[] array1 = new boolean[]{true, false, true}; newArray = ArrayUtils.add(array1, false); assertTrue(Arrays.equals(new boolean[]{true, false, true, false}, newArray)); assertEquals(Boolean.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayChar() { char[] newArray; newArray = ArrayUtils.add((char[])null, (char)0); assertTrue(Arrays.equals(new char[]{0}, newArray)); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((char[])null, (char)1); assertTrue(Arrays.equals(new char[]{1}, newArray)); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); final char[] array1 = new char[]{1, 2, 3}; newArray = ArrayUtils.add(array1, (char)0); assertTrue(Arrays.equals(new char[]{1, 2, 3, 0}, newArray)); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, (char)4); assertTrue(Arrays.equals(new char[]{1, 2, 3, 4}, newArray)); assertEquals(Character.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayDouble() { double[] newArray; newArray = ArrayUtils.add((double[])null, 0); assertTrue(Arrays.equals(new double[]{0}, newArray)); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((double[])null, 1); assertTrue(Arrays.equals(new double[]{1}, newArray)); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); final double[] array1 = new double[]{1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertTrue(Arrays.equals(new double[]{1, 2, 3, 0}, newArray)); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, 4); assertTrue(Arrays.equals(new double[]{1, 2, 3, 4}, newArray)); assertEquals(Double.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayLong() { long[] newArray; newArray = ArrayUtils.add((long[])null, 0); assertTrue(Arrays.equals(new long[]{0}, newArray)); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((long[])null, 1); assertTrue(Arrays.equals(new long[]{1}, newArray)); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); final long[] array1 = new long[]{1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertTrue(Arrays.equals(new long[]{1, 2, 3, 0}, newArray)); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, 4); assertTrue(Arrays.equals(new long[]{1, 2, 3, 4}, newArray)); assertEquals(Long.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayByte() { byte[] newArray; newArray = ArrayUtils.add((byte[])null, (byte)0); assertTrue(Arrays.equals(new byte[]{0}, newArray)); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((byte[])null, (byte)1); assertTrue(Arrays.equals(new byte[]{1}, newArray)); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); final byte[] array1 = new byte[]{1, 2, 3}; newArray = ArrayUtils.add(array1, (byte)0); assertTrue(Arrays.equals(new byte[]{1, 2, 3, 0}, newArray)); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, (byte)4); assertTrue(Arrays.equals(new byte[]{1, 2, 3, 4}, newArray)); assertEquals(Byte.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayInt() { int[] newArray; newArray = ArrayUtils.add((int[])null, 0); assertTrue(Arrays.equals(new int[]{0}, newArray)); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((int[])null, 1); assertTrue(Arrays.equals(new int[]{1}, newArray)); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); final int[] array1 = new int[]{1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertTrue(Arrays.equals(new int[]{1, 2, 3, 0}, newArray)); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, 4); assertTrue(Arrays.equals(new int[]{1, 2, 3, 4}, newArray)); assertEquals(Integer.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayShort() { short[] newArray; newArray = ArrayUtils.add((short[])null, (short)0); assertTrue(Arrays.equals(new short[]{0}, newArray)); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((short[])null, (short)1); assertTrue(Arrays.equals(new short[]{1}, newArray)); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); final short[] array1 = new short[]{1, 2, 3}; newArray = ArrayUtils.add(array1, (short)0); assertTrue(Arrays.equals(new short[]{1, 2, 3, 0}, newArray)); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, (short)4); assertTrue(Arrays.equals(new short[]{1, 2, 3, 4}, newArray)); assertEquals(Short.TYPE, newArray.getClass().getComponentType()); }
@Test public void testAddObjectArrayFloat() { float[] newArray; newArray = ArrayUtils.add((float[])null, 0); assertTrue(Arrays.equals(new float[]{0}, newArray)); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add((float[])null, 1); assertTrue(Arrays.equals(new float[]{1}, newArray)); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); final float[] array1 = new float[]{1, 2, 3}; newArray = ArrayUtils.add(array1, 0); assertTrue(Arrays.equals(new float[]{1, 2, 3, 0}, newArray)); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(array1, 4); assertTrue(Arrays.equals(new float[]{1, 2, 3, 4}, newArray)); assertEquals(Float.TYPE, newArray.getClass().getComponentType()); }
@Test public void testLANG571(){ final String[] stringArray=null; final String aString=null; try { @SuppressWarnings("unused") final String[] sa = ArrayUtils.add(stringArray, aString); fail("Should have caused IllegalArgumentException"); } catch (final IllegalArgumentException iae){ //expected } try { @SuppressWarnings({ "unused", "deprecation" }) final String[] sa = ArrayUtils.add(stringArray, 0, aString); fail("Should have caused IllegalArgumentException"); } catch (final IllegalArgumentException iae){ //expected } }
@Test public void testAddObjectArrayObject() { Object[] newArray; //show that not casting is okay newArray = ArrayUtils.add((Object[])null, "a"); assertTrue(Arrays.equals(new String[]{"a"}, newArray)); assertTrue(Arrays.equals(new Object[]{"a"}, newArray)); assertEquals(String.class, newArray.getClass().getComponentType()); //show that not casting to Object[] is okay and will assume String based on "a" final String[] newStringArray = ArrayUtils.add(null, "a"); assertTrue(Arrays.equals(new String[]{"a"}, newStringArray)); assertTrue(Arrays.equals(new Object[]{"a"}, newStringArray)); assertEquals(String.class, newStringArray.getClass().getComponentType()); final String[] stringArray1 = new String[]{"a", "b", "c"}; newArray = ArrayUtils.add(stringArray1, null); assertTrue(Arrays.equals(new String[]{"a", "b", "c", null}, newArray)); assertEquals(String.class, newArray.getClass().getComponentType()); newArray = ArrayUtils.add(stringArray1, "d"); assertTrue(Arrays.equals(new String[]{"a", "b", "c", "d"}, newArray)); assertEquals(String.class, newArray.getClass().getComponentType()); Number[] numberArray1 = new Number[]{Integer.valueOf(1), Double.valueOf(2)}; newArray = ArrayUtils.add(numberArray1, Float.valueOf(3)); assertTrue(Arrays.equals(new Number[]{Integer.valueOf(1), Double.valueOf(2), Float.valueOf(3)}, newArray)); assertEquals(Number.class, newArray.getClass().getComponentType()); numberArray1 = null; newArray = ArrayUtils.add(numberArray1, Float.valueOf(3)); assertTrue(Arrays.equals(new Float[]{Float.valueOf(3)}, newArray)); assertEquals(Float.class, newArray.getClass().getComponentType()); }
private PagedFile createNewIndexFile( PageCache pageCache, File indexFile, int pageSizeForCreation ) throws IOException { // First time monitor.noStoreFile(); int pageSize = pageSizeForCreation == 0 ? pageCache.pageSize() : pageSizeForCreation; if ( pageSize > pageCache.pageSize() ) { throw new MetadataMismatchException( "Tried to create tree with page size %d" + ", but page cache used to create it has a smaller page size %d" + " so cannot be created", pageSize, pageCache.pageSize() ); } // We need to create this index PagedFile pagedFile = pageCache.map( indexFile, pageSize, add( openOptions, StandardOpenOption.CREATE ) ); created = true; return pagedFile; }