public static void CopyTo(this IBuffer source, UInt32 sourceIndex, IBuffer destination, UInt32 destinationIndex, UInt32 count)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (destination == null) throw new ArgumentNullException(nameof(destination));
if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
if (sourceIndex < 0) throw new ArgumentOutOfRangeException(nameof(sourceIndex));
if (destinationIndex < 0) throw new ArgumentOutOfRangeException(nameof(destinationIndex));
if (source.Capacity <= sourceIndex) throw new ArgumentException(SR.Argument_BufferIndexExceedsCapacity);
if (source.Capacity - sourceIndex < count) throw new ArgumentException(SR.Argument_InsufficientSpaceInSourceBuffer);
if (destination.Capacity <= destinationIndex) throw new ArgumentException(SR.Argument_BufferIndexExceedsCapacity);
if (destination.Capacity - destinationIndex < count) throw new ArgumentException(SR.Argument_InsufficientSpaceInTargetBuffer);
Contract.EndContractBlock();
// If source are destination are backed by managed arrays, use the arrays instead of the pointers as it does not require pinning:
Byte[] srcDataArr, destDataArr;
Int32 srcDataOffs, destDataOffs;
bool srcIsManaged = source.TryGetUnderlyingData(out srcDataArr, out srcDataOffs);
bool destIsManaged = destination.TryGetUnderlyingData(out destDataArr, out destDataOffs);
if (srcIsManaged && destIsManaged)
{
Debug.Assert(count <= Int32.MaxValue);
Debug.Assert(sourceIndex <= Int32.MaxValue);
Debug.Assert(destinationIndex <= Int32.MaxValue);
Buffer.BlockCopy(srcDataArr, srcDataOffs + (Int32)sourceIndex, destDataArr, destDataOffs + (Int32)destinationIndex, (Int32)count);
return;
}
IntPtr srcPtr, destPtr;
if (srcIsManaged)
{
Debug.Assert(count <= Int32.MaxValue);
Debug.Assert(sourceIndex <= Int32.MaxValue);
destPtr = destination.GetPointerAtOffset(destinationIndex);
Marshal.Copy(srcDataArr, srcDataOffs + (Int32)sourceIndex, destPtr, (Int32)count);
return;
}
if (destIsManaged)
{
Debug.Assert(count <= Int32.MaxValue);
Debug.Assert(destinationIndex <= Int32.MaxValue);
srcPtr = source.GetPointerAtOffset(sourceIndex);
Marshal.Copy(srcPtr, destDataArr, destDataOffs + (Int32)destinationIndex, (Int32)count);
return;
}
srcPtr = source.GetPointerAtOffset(sourceIndex);
destPtr = destination.GetPointerAtOffset(destinationIndex);
MemCopy(srcPtr, destPtr, count);
}
public static void CopyTo(this Byte[] source, Int32 sourceIndex, IBuffer destination, UInt32 destinationIndex, Int32 count)
{
if (source == null) throw new ArgumentNullException(nameof(source));
if (destination == null) throw new ArgumentNullException(nameof(destination));
if (count < 0) throw new ArgumentOutOfRangeException(nameof(count));
if (sourceIndex < 0) throw new ArgumentOutOfRangeException(nameof(sourceIndex));
if (destinationIndex < 0) throw new ArgumentOutOfRangeException(nameof(destinationIndex));
if (source.Length <= sourceIndex) throw new ArgumentException(SR.Argument_IndexOutOfArrayBounds, nameof(sourceIndex));
if (source.Length - sourceIndex < count) throw new ArgumentException(SR.Argument_InsufficientArrayElementsAfterOffset);
if (destination.Capacity - destinationIndex < count) throw new ArgumentException(SR.Argument_InsufficientSpaceInTargetBuffer);
Contract.EndContractBlock();
// If destination is backed by a managed array, use the array instead of the pointer as it does not require pinning:
Byte[] destDataArr;
Int32 destDataOffs;
if (destination.TryGetUnderlyingData(out destDataArr, out destDataOffs))
{
Buffer.BlockCopy(source, sourceIndex, destDataArr, (int)(destDataOffs + destinationIndex), count);
return;
}
IntPtr destPtr = destination.GetPointerAtOffset(destinationIndex);
Marshal.Copy(source, sourceIndex, destPtr, count);
}
