Sets this MutableBigInteger's value array to a copy of the specified
array. The intLen is set to the length of the specified array.
165091
void copyValue(int[] val) {
        int len = val.length;
        if (value.length < len)
            value = new int[len];
        System.arraycopy(val, 0, value, 0, len);
        intLen = len;
        offset = 0;
    }
1203782
void resizeArray(int newArraySize) {
		long[] newArray = new long[newArraySize];
		System.arraycopy(this.arrayOfBits, 0, newArray, 0,
				Math.min(this.arrayOfBits.length, newArraySize));
		this.arrayOfBits = newArray;
	}
1253635
public void set(final int i, final int[] e) {
        if (i >= list.length) list = Array.copyOf(list, newSize(i + 1));
        list[i] = e;
        size = Math.max(size, i + 1);
    }
323405
void copyTo(IntSet target) {
        if (target.elements.length < size) {
            target.elements = Arrays.copyOf(elements, elements.length);
        } else {
            System.arraycopy(elements, 0, target.elements, 0, size);
        }
        target.size = size;
    }
409338
public void setInTable(boolean inTable) {
        super.setInTable(inTable);
        for(int i = 0; i < this.items.size(); i++) {
            ((RtfBasicElement) this.items.get(i)).setInTable(inTable);
        }
    }
316759
private void setObjectSize(@NonNull final byte[] data, final int value) {
		data[2] = (byte) (value & 0xFF);
		data[3] = (byte) ((value >> 8) & 0xFF);
		data[4] = (byte) ((value >> 16) & 0xFF);
		data[5] = (byte) ((value >> 24) & 0xFF);
	}
758443
public void set(int index, byte value) {
        Preconditions.checkState(!this.readOnly, "Cannot modify a read-only ByteArraySegment.");
        Preconditions.checkElementIndex(index, this.length, "index");
        this.array[index + this.startOffset] = value;
    }
330613
public static byte[] intToByteArray(int value)
    {
        return new byte[]
        {
            (byte) (value >>> Constant.BYTE_4), (byte) (value >>> Constant.BYTE_3), (byte) (value >>> Constant.BYTE_2),
            (byte) value
        };
    }
926655
public int set(int i, int val) {
    checkIndex(i);
    int old = buf[i];
    buf[i] = val;
    return old;
  }
283179
public static void putLongLE(final byte[] array, final int offset, final long value) {
    array[offset    ] = (byte) (value       );
    array[offset + 1] = (byte) (value >>>  8);
    array[offset + 2] = (byte) (value >>> 16);
    array[offset + 3] = (byte) (value >>> 24);
    array[offset + 4] = (byte) (value >>> 32);
    array[offset + 5] = (byte) (value >>> 40);
    array[offset + 6] = (byte) (value >>> 48);
    array[offset + 7] = (byte) (value >>> 56);
  }
1144448
protected void setByteArrayValue(byte[] input, int offset, int length) {
        if ((offset + length) > input.length) {
            throw new IllegalArgumentException(
                            "Invalid length: " + offset + "+" + length + " > " + input.length);
        }
        this.sValue = null;
        this.bValue = input;
        this.offset = offset;
        this.valueLength = length;
        if (ELEM_ADDED != this.status) {
            this.status = ELEM_CHANGED;
        }
    }
127622
private void set(int position, boolean val) {
        // enlarge bitString if necessary
        if (position >= bitString.length) {
            boolean[] tmp = new boolean[position+1];
            System.arraycopy(bitString, 0, tmp, 0, bitString.length);
            bitString = tmp;
        }
        bitString[position] = val;
    }
1177360
@NonNull
    @Override
    public MutableArray setValue(int index, Object value) {
        synchronized (lock) {
            if (Fleece.valueWouldChange(value, internalArray.get(index), internalArray)
                && (!internalArray.set(index, Fleece.toCBLObject(value)))) {
                throwRangeException(index);
            }
            return this;
        }
    }
1260670
public static void putIntBE(final byte[] array, final int offset, final int value) {
    array[offset + 3] = (byte) (value       );
    array[offset + 2] = (byte) (value >>>  8);
    array[offset + 1] = (byte) (value >>> 16);
    array[offset    ] = (byte) (value >>> 24);
  }
976893
public void set(int[] initial) {
        resizeLock.lock();
        try {
            if (initial.length != length) {
                throw new IllegalArgumentException("Array length mismatch, expected " + length + ", got " + initial.length);
            }
            int unique = AtomicShortIntArray.getUnique(initial);
            int allowedPalette = AtomicShortIntPaletteBackingArray.getAllowedPalette(length);
            if (unique == 1) {
                store.set(new AtomicShortIntUniformBackingArray(length, initial[0]));
            } else if (unique > allowedPalette) {
                store.set(new AtomicShortIntDirectBackingArray(length, initial));
            } else {
                store.set(new AtomicShortIntPaletteBackingArray(length, unique, initial));
            }
        } finally {
            resizeLock.unlock();
        }
    }
27594
public void set(IntIntSortedVector other) {
        this.used = other.used;
        this.indices = IntArrays.copyOf(other.indices);
        this.values = IntArrays.copyOf(other.values);
    }
558172
public void setValue(char[] chars, int offset, int len) {
		checkNotNull(chars);
		if (offset < 0 || len < 0 || offset > chars.length - len) {
			throw new IndexOutOfBoundsException();
		}

		ensureSize(len);
		System.arraycopy(chars, offset, this.value, 0, len);
		this.len = len;
		this.hashCode = 0;
	}