/** This method is called by Swing to delete text from this document. */ @Override public void remove(int offset, int length) throws BadLocationException { if (length == 0) return; if (undone > 0) { now = now - undone; undone = 0; } // clear the REDO entries String string = toString().substring(offset, offset + length); super.remove(offset, length); if (now > 0 && !insert[now - 1]) { // merge with last edit if possible if (where[now - 1] == offset) { text[now - 1] += string; return; } if (where[now - 1] == offset + length) { where[now - 1] = offset; text[now - 1] = string + text[now - 1]; return; } } if (now >= MAXUNDO) { arraycopy(insert, 1, insert, 0, MAXUNDO - 1); arraycopy(text, 1, text, 0, MAXUNDO - 1); arraycopy(where, 1, where, 0, MAXUNDO - 1); now--; } insert[now] = false; text[now] = string; where[now] = offset; now++; }
/** This method is called by Swing to insert a String into this document. */ @Override public void insertString(int offset, String string, AttributeSet attr) throws BadLocationException { if (string.length() == 0) return; else if (string.indexOf('\r') >= 0) string = Util.convertLineBreak(string); // we don't want '\r' if (undone > 0) { now = now - undone; undone = 0; } // clear the REDO entries super.insertString(offset, string, attr); if (now > 0 && insert[now - 1]) { // merge with last edit if possible if (where[now - 1] == offset - text[now - 1].length()) { text[now - 1] += string; return; } } if (now >= MAXUNDO) { arraycopy(insert, 1, insert, 0, MAXUNDO - 1); arraycopy(text, 1, text, 0, MAXUNDO - 1); arraycopy(where, 1, where, 0, MAXUNDO - 1); now--; } insert[now] = true; text[now] = string; where[now] = offset; now++; }
private int enumerate(ThreadGroup list[], int n, boolean recurse) { int ngroupsSnapshot = 0; ThreadGroup[] groupsSnapshot = null; synchronized (this) { if (destroyed) { return 0; } int ng = ngroups; if (ng > list.length - n) { ng = list.length - n; } if (ng > 0) { System.arraycopy(groups, 0, list, n, ng); n += ng; } if (recurse) { ngroupsSnapshot = ngroups; if (groups != null) { groupsSnapshot = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } } } if (recurse) { for (int i = 0; i < ngroupsSnapshot; i++) { n = groupsSnapshot[i].enumerate(list, n, true); } } return n; }
/** * Adds post advices to the pointcut. * * @param advicesToAdd the advices to add */ public void addPostAdvices(final String[] advicesToAdd) { for (int i = 0; i < advicesToAdd.length; i++) { if (advicesToAdd[i] == null || advicesToAdd[i].trim().length() == 0) throw new IllegalArgumentException( "name of advice to add can not be null or an empty string"); } synchronized (m_postNames) { synchronized (m_postIndexes) { final String[] clone = new String[advicesToAdd.length]; java.lang.System.arraycopy(advicesToAdd, 0, clone, 0, advicesToAdd.length); final String[] tmp = new String[m_postNames.length + advicesToAdd.length]; java.lang.System.arraycopy(m_postNames, 0, tmp, 0, m_postNames.length); java.lang.System.arraycopy(clone, 0, tmp, m_postNames.length, tmp.length); m_postNames = new String[tmp.length]; java.lang.System.arraycopy(tmp, 0, m_postNames, 0, tmp.length); m_postIndexes = new IndexTuple[m_postNames.length]; for (int j = 0; j < m_postNames.length; j++) { m_postIndexes[j] = SystemLoader.getSystem(m_uuid).getAdviceIndexFor(m_postNames[j]); } } } }
/** * Removes a StmtLine (0..*). * * @param index The index of the StmtLine to get. */ public void removeStmtLine(int index) { if (this.stmtLine == null) throw new java.lang.ArrayIndexOutOfBoundsException(); biz.c24.io.training.statements.StatementLine[] temp = this.stmtLine; this.stmtLine = new biz.c24.io.training.statements.StatementLine[temp.length - 1]; java.lang.System.arraycopy(temp, 0, this.stmtLine, 0, index); java.lang.System.arraycopy(temp, index + 1, this.stmtLine, index, temp.length - index - 1); if (this.stmtLine.length == 0) this.stmtLine = null; }
static final AttributeDefinition[] concat( AttributeDefinition[] common, AttributeDefinition... specific) { int size = common.length + specific.length; AttributeDefinition[] result = new AttributeDefinition[size]; arraycopy(common, 0, result, 0, common.length); arraycopy(specific, 0, result, common.length, specific.length); return result; }
/** * Appends the given array to this array. * * @param aas The array to append to this one. * @return A new array that has appended the given array. */ public Array<A> append(final Array<A> aas) { final Object[] x = new Object[a.length + aas.a.length]; arraycopy(a, 0, x, 0, a.length); arraycopy(aas.a, 0, x, a.length, aas.a.length); return new Array<A>(x); }
public void write(byte[] buffer, int offset, int length) { if (count + length >= bytes.length) { byte[] newBytes = new byte[(count + length) * 2]; System.arraycopy(bytes, 0, newBytes, 0, count); bytes = newBytes; } System.arraycopy(buffer, offset, bytes, count, length); count += length; }
/** * Insert a subarray of the <code>char[]</code> argument into this <code>StringBuffer</code>. * * @param offset the place to insert in this buffer * @param str the <code>char[]</code> to insert * @param str_offset the index in <code>str</code> to start inserting from * @param len the number of characters to insert * @return this <code>StringBuffer</code> * @throws NullPointerException if <code>str</code> is <code>null</code> * @throws StringIndexOutOfBoundsException if any index is out of bounds * @since 1.2 */ public synchronized StringBuffer insert(int offset, char[] str, int str_offset, int len) { if (offset < 0 || offset > count || len < 0 || str_offset < 0 || str_offset > str.length - len) throw new StringIndexOutOfBoundsException(); ensureCapacity_unsynchronized(count + len); System.arraycopy(value, offset, value, offset + len, count - offset); System.arraycopy(str, str_offset, value, offset, len); count += len; return this; }
public Object decode(InputStream inStream) throws IOException { LinkedList<byte[]> blocks = new LinkedList<byte[]>(); byte[] curr = new byte[BLOCK_SIZE]; blocks.add(curr); int totalRead = 0; int read; for (int i = 0; i < curr.length; i++) { totalRead += (read = inStream.read(curr)); if (read < curr.length) break; blocks.add(curr = new byte[BLOCK_SIZE]); } byte[] newByte = new byte[totalRead]; int offset = 0; int copySize; for (byte[] block : blocks) { if ((totalRead - (block.length + offset)) < 0) { copySize = totalRead % block.length; } else { copySize = block.length; } arraycopy(block, 0, newByte, offset, copySize); offset += block.length; } return decode(newByte); }
private static HardDisk[] getHardDisks(Properties props, String propPrefix) { HardDisk[] rv = null; if (props != null) { for (int i = 0; i < 2; i++) { HardDisk disk = null; String prefix = String.format("%sharddisk.%d.", propPrefix, i + 1); String diskModel = EmuUtil.getProperty(props, prefix + "model"); String fileName = EmuUtil.getProperty(props, prefix + "file"); if (!diskModel.isEmpty() && !fileName.isEmpty()) { int c = EmuUtil.getIntProperty(props, prefix + "cylinders", 0); int h = EmuUtil.getIntProperty(props, prefix + "heads", 0); int n = EmuUtil.getIntProperty(props, prefix + "sectors_per_track", 0); if ((c > 0) && (h > 0) && (n > 0)) { disk = new HardDisk(diskModel, c, h, n, fileName); } } if (disk != null) { if (rv != null) { HardDisk[] a = new HardDisk[rv.length + 1]; System.arraycopy(rv, 0, a, 0, rv.length); rv = a; } else { rv = new HardDisk[1]; } rv[rv.length - 1] = disk; } } } return rv; }
char[] toCharArray() { // Arrays.copyOfRange() requires Java 6 int size = size(); char[] result = new char[size]; arraycopy(array, start, result, 0, size); return result; }
void list(PrintStream out, int indent) { int ngroupsSnapshot; ThreadGroup[] groupsSnapshot; synchronized (this) { for (int j = 0; j < indent; j++) { out.print(" "); } out.println(this); indent += 4; for (int i = 0; i < nthreads; i++) { for (int j = 0; j < indent; j++) { out.print(" "); } out.println(threads[i]); } ngroupsSnapshot = ngroups; if (groups != null) { groupsSnapshot = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } } for (int i = 0; i < ngroupsSnapshot; i++) { groupsSnapshot[i].list(out, indent); } }
private int enumerate(Thread list[], int n, boolean recurse) { int ngroupsSnapshot = 0; ThreadGroup[] groupsSnapshot = null; synchronized (this) { if (destroyed) { return 0; } int nt = nthreads; if (nt > list.length - n) { nt = list.length - n; } for (int i = 0; i < nt; i++) { if (threads[i].isAlive()) { list[n++] = threads[i]; } } if (recurse) { ngroupsSnapshot = ngroups; if (groups != null) { groupsSnapshot = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } } } if (recurse) { for (int i = 0; i < ngroupsSnapshot; i++) { n = groupsSnapshot[i].enumerate(list, n, true); } } return n; }
public static char[] copyOfRange(final char[] a, final int from, final int to) { final int len = to - from; if (len < 0) throw new IllegalArgumentException(from + " > " + to); final char[] copy = new char[len]; System.arraycopy(a, from, copy, 0, Math.min(a.length - from, len)); return copy; }
/** * Create the element from this builder. * * @return Element */ public Element create() { mRS.validate(); Element[] ein = new Element[mCount]; String[] sin = new String[mCount]; int[] asin = new int[mCount]; java.lang.System.arraycopy(mElements, 0, ein, 0, mCount); java.lang.System.arraycopy(mElementNames, 0, sin, 0, mCount); java.lang.System.arraycopy(mArraySizes, 0, asin, 0, mCount); long[] ids = new long[ein.length]; for (int ct = 0; ct < ein.length; ct++) { ids[ct] = ein[ct].getID(mRS); } long id = mRS.nElementCreate2(ids, sin, asin); return new Element(id, mRS, ein, sin, asin); }
/** * Destroys this thread group and all of its subgroups. This thread group must be empty, * indicating that all threads that had been in this thread group have since stopped. * * <p>First, the <code>checkAccess</code> method of this thread group is called with no arguments; * this may result in a security exception. * * @exception IllegalThreadStateException if the thread group is not empty or if the thread group * has already been destroyed. * @exception SecurityException if the current thread cannot modify this thread group. * @see java.lang.ThreadGroup#checkAccess() * @since JDK1.0 */ public final void destroy() { int ngroupsSnapshot; ThreadGroup[] groupsSnapshot; synchronized (this) { checkAccess(); if (destroyed || (nthreads > 0)) { throw new IllegalThreadStateException(); } ngroupsSnapshot = ngroups; if (groups != null) { groupsSnapshot = new ThreadGroup[ngroupsSnapshot]; System.arraycopy(groups, 0, groupsSnapshot, 0, ngroupsSnapshot); } else { groupsSnapshot = null; } if (parent != null) { destroyed = true; ngroups = 0; groups = null; nthreads = 0; threads = null; } } for (int i = 0; i < ngroupsSnapshot; i += 1) { groupsSnapshot[i].destroy(); } if (parent != null) { parent.remove(this); } }
long[] toLongArray() { // Arrays.copyOfRange() requires Java 6 int size = size(); long[] result = new long[size]; arraycopy(array, start, result, 0, size); return result; }
private PASSTHRU_MSG passThruMessage(byte... data) { PASSTHRU_MSG msg = passThruMessage(); msg.dataSize = new NativeLong(data.length); arraycopy(data, 0, msg.data, 0, data.length); msg.write(); return msg; }
@Override public void onPreviewFrame(byte[] data, Camera camera) { if (!mMoSyncPreviewFrameEventEnabled) { if (!mMoSyncPreviewAutoFocusEventEnabled) { // Return the buffer if in use if (mIsUsingPreviewCallbackBuffer) camera.addCallbackBuffer(data); return; } if (!mMoSyncPreviewHasFocus) { // Return the buffer if in use if (mIsUsingPreviewCallbackBuffer) camera.addCallbackBuffer(data); return; } // Restore the flag for the next auto focus event mMoSyncPreviewHasFocus = false; } if (!mSendEvent) { // Return the buffer if in use if (mIsUsingPreviewCallbackBuffer) camera.addCallbackBuffer(data); return; } lock.lock(); try { if (data != null) { mSendEvent = false; System.arraycopy(data, 0, mImageBuffer, 0, data.length); // To the time consuming task in a new thread new Thread( new Runnable() { public void run() { YUV420toRGB8888(); int[] event = new int[1]; event[0] = MAAPI_consts.EVENT_TYPE_CAMERA_PREVIEW; mMoSyncThread.postEvent(event); } }) .start(); } } catch (Exception e) { Log.i("Camera API", "Got exception:" + e.toString()); } finally { lock.unlock(); // Return the buffer if in use if (mIsUsingPreviewCallbackBuffer) camera.addCallbackBuffer(data); } }
public void write(int b) { if (count == bytes.length) { byte[] newBytes = new byte[count * 2]; System.arraycopy(bytes, 0, newBytes, 0, count); bytes = newBytes; } bytes[count++] = (byte) b; }
/** * Insert the <code>char</code> argument into this <code>StringBuffer</code>. * * @param offset the place to insert in this buffer * @param ch the <code>char</code> to insert * @return this <code>StringBuffer</code> * @throws StringIndexOutOfBoundsException if offset is out of bounds */ public synchronized StringBuffer insert(int offset, char ch) { if (offset < 0 || offset > count) throw new StringIndexOutOfBoundsException(offset); ensureCapacity_unsynchronized(count + 1); System.arraycopy(value, offset, value, offset + 1, count - offset); value[offset] = ch; count++; return this; }
public byte[] toByteArray() { if (count == bytes.length) { return bytes; } byte[] result = new byte[count]; System.arraycopy(bytes, 0, result, 0, count); return result; }
/** * Append part of the <code>char</code> array to this <code>StringBuffer</code>. This is similar * (but more efficient) than <code>append(new String(data, offset, count))</code>, except in the * case of null. * * @param data the <code>char[]</code> to append * @param offset the start location in <code>str</code> * @param count the number of characters to get from <code>str</code> * @return this <code>StringBuffer</code> * @throws NullPointerException if <code>str</code> is <code>null</code> * @throws IndexOutOfBoundsException if offset or count is out of range (while unspecified, this * is a StringIndexOutOfBoundsException) */ public synchronized StringBuffer append(char[] data, int offset, int count) { if (offset < 0 || count < 0 || offset > data.length - count) throw new StringIndexOutOfBoundsException(); ensureCapacity_unsynchronized(this.count + count); System.arraycopy(data, offset, value, this.count, count); this.count += count; return this; }
/** * Adds a StmtLine (0..*). * * @param value The new StmtLine. */ public void addStmtLine(biz.c24.io.training.statements.StatementLine value) { biz.c24.io.training.statements.StatementLine[] temp = this.stmtLine; this.stmtLine = new biz.c24.io.training.statements.StatementLine[temp == null ? 1 : (temp.length + 1)]; if (temp != null) java.lang.System.arraycopy(temp, 0, this.stmtLine, 0, temp.length); this.stmtLine[this.stmtLine.length - 1] = value; ((biz.c24.io.api.data.ComplexDataObject) value).setParent(this, "StmtLine"); }
@SuppressWarnings({"SuspiciousSystemArraycopy", "unchecked", "ObjectEquality", "RedundantCast"}) public static <T, U> T[] copyOf(final U[] a, final int len, final Class<? extends T[]> newType) { final T[] copy = (Object) newType == Object[].class ? (T[]) new Object[len] : (T[]) java.lang.reflect.Array.newInstance(newType.getComponentType(), len); System.arraycopy(a, 0, copy, 0, Math.min(a.length, len)); return copy; }
private static final int[] createRankArray(final int[] input) { final int[] sorted = new int[input.length], ranks = new int[input.length]; arraycopy(input, 0, sorted, 0, input.length); sort(sorted); // tuned quicksort, O(n log n) for (int i = 0; i < input.length; i++) { ranks[i] = indexOf(sorted, input[i]); } return ranks; }
float[] flatten2DimArray(float[][] twoDimArray) { // Converts an array of two dimensions into a single dimension array row by row. float[] flatArray = new float[twoDimArray.length * twoDimArray[0].length]; for (int row = 0; row < twoDimArray.length; row++) { int offset = row * twoDimArray[row].length; arraycopy(twoDimArray[row], 0, flatArray, offset, twoDimArray[row].length); } return flatArray; }
/** * Delete characters from this <code>StringBuffer</code>. <code>delete(10, 12)</code> will delete * 10 and 11, but not 12. It is harmless for end to be larger than length(). * * @param start the first character to delete * @param end the index after the last character to delete * @return this <code>StringBuffer</code> * @throws StringIndexOutOfBoundsException if start or end are out of bounds * @since 1.2 */ public synchronized StringBuffer delete(int start, int end) { if (start < 0 || start > count || start > end) throw new StringIndexOutOfBoundsException(start); if (end > count) end = count; // This will unshare if required. ensureCapacity_unsynchronized(count); if (count - end != 0) System.arraycopy(value, end, value, start, count - end); count -= end - start; return this; }
public synchronized void readBandData( Band destBand, int sourceOffsetX, int sourceOffsetY, int sourceWidth, int sourceHeight, int sourceStepX, int sourceStepY, ProductData destBuffer, ProgressMonitor pm) throws IOException, InvalidRangeException { if (mustFlipY) { sourceOffsetY = destBand.getSceneRasterHeight() - (sourceOffsetY + sourceHeight); } if (mustFlipX) { sourceOffsetX = destBand.getSceneRasterWidth() - (sourceOffsetX + sourceWidth); } sourceOffsetY += leadLineSkip; start[0] = sourceOffsetY; start[1] = sourceOffsetX; stride[0] = sourceStepY; stride[1] = sourceStepX; count[0] = sourceHeight; count[1] = sourceWidth; Object buffer = destBuffer.getElems(); Variable variable = variableMap.get(destBand); pm.beginTask("Reading band '" + variable.getShortName() + "'...", sourceHeight); try { Section section = new Section(start, count, stride); Array array; int[] newshape = {sourceHeight, sourceWidth}; array = variable.read(section); if (array.getRank() == 3) { array = array.reshapeNoCopy(newshape); } Object storage; if (mustFlipX && !mustFlipY) { storage = array.flip(1).copyTo1DJavaArray(); } else if (!mustFlipX && mustFlipY) { storage = array.flip(0).copyTo1DJavaArray(); } else if (mustFlipX && mustFlipY) { storage = array.flip(0).flip(1).copyTo1DJavaArray(); } else { storage = array.copyTo1DJavaArray(); } arraycopy(storage, 0, buffer, 0, destBuffer.getNumElems()); } finally { pm.done(); } }