Returns a copy of the data array.
430023
protected static byte[] getDataCopy(byte[] data, int size) {
        if (data == null) {
            return NO_DATA;
        }
        byte[] newData = new byte[size];
        System.arraycopy(data, 0, newData, 0, size);
        return newData;
    }
1160421
public function getArrayCopy()
    {
        $obj_vars = get_object_vars($this);
        // keeping the object in each element produce an infinite loop...
        if (isset($obj_vars['object'])) {
            $obj_vars['object'] = $obj_vars['object']->getCode();
        }

        return $obj_vars;
    }
321135
public function getArrayCopy()
    {
        $obj_vars = get_object_vars($this);

        if (isset($obj_vars['postElements'])) {
            $obj_vars['postElements'] = $this->getPostElements()->toArray();
        }

        return $obj_vars;
    }
1099591
public long[] toLongArray() {
    long[] copy = new long[size];
    for (int i = 0; i < size; i++) {
      copy[i] = elements[i];
    }
    return copy;
  }
231233
public byte[] getValues() {
    byte[] copy = new byte[values.length];
    System.arraycopy(values, 0, copy, 0, values.length);
    return copy;
  }
982773
public DataObject[] getDataObjectArray(){
        DataObject[] res = new DataObject[this.dataList.size()];
        return this.dataList.toArray(res);
    }
849181
public function getArrayCopy()
    {
        $copy = [];
        foreach ((array)$this as $key => $value) {
            if (is_string($value)) {
                continue;
            }
            $element = $value->getElement();
            if (is_object($element)
                and method_exists($element, 'name')
                and $name = $element->name()
                and !($element instanceof Button)
            ) {
                $copy[$name] = $element->getValue();
            }
        }
        return $copy;
    }
563034
public static Object[] copy(Object[] objs)
	{
		if (objs == null)
			return null;

		Object[] results = new Object[objs.length];
		System.arraycopy(objs, 0, results, 0, results.length);

		return results;
	}
608141
function( key ) {

    if( this.data[ key ] == null ) {
      return this.data[ key ]
    }

    if( Array.isArray( this.data[ key ] ) ) {
      return this.data[ key ].map( function( prop ) {
        return prop.clone()
      })
    } else {
      return this.data[ key ].clone()
    }

  }
841534
private void copyArrays() {
        String[] oldSyms = mSymbols;
        int size = oldSyms.length;
        mSymbols = new String[size];
        System.arraycopy(oldSyms, 0, mSymbols, 0, size);
        Bucket[] oldBuckets = mBuckets;
        size = oldBuckets.length;
        mBuckets = new Bucket[size];
        System.arraycopy(oldBuckets, 0, mBuckets, 0, size);
    }
37619
public NDArray<T> cloneArray() {
        NDArray<T> copy = new NDArray<>(dimensions.clone());
        copy.values = values.clone();
        return copy;
    }
1314798
public double[] getRowPackedCopy()
    {
        double[] vals = new double[m * n];
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                vals[i * n + j] = A[i][j];
            }
        }
        return vals;
    }
964216
public byte[] toByteArray()
    {
        byte[] b = new byte[size()];
        unsafe.copyMemory(base, address, b, ARRAY_BYTE_BASE_OFFSET, size());
        return b;
    }
344124
static <T> T[] arraysCopyOf(T[] original, int newLength) {
    T[] copy = newArray(original, newLength);
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
  }
442689
public byte[] serialize() {
        if (currentByteArrayIndex == 0) {
            return new byte[0];
        }
        final byte[] extractedSerializedData = new byte[currentByteArrayIndex];
        System.arraycopy(serializedData, 0, extractedSerializedData, 0, currentByteArrayIndex);
        return extractedSerializedData;
    }
738605
public static int[] copyOf(int[] old, int length) {
    int[] newArray = new int[length];
    int minLength = Math.min(old.length, length);
    System.arraycopy(old, 0, newArray, 0, minLength);
    return newArray;
  }
559140
public synchronized final byte[] getBytes() {
        byte[] dest = new byte[data.length];
        System.arraycopy(data, 0, dest, 0, dest.length);
        return dest;
    }