code/System/Memory.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Reflection;

namespace Sylloge
{
    public static class Memory
    {
        #region Constants

        #region 'Standard' (base 10) byte measurements

        public const uint KB = 1000;
        public const uint MB = (1000 * Sylloge.Memory.KB);
        public const uint GB = (1000 * Sylloge.Memory.MB);
        public const ulong TB = (1000L * Sylloge.Memory.GB);

        #endregion

        #region 'Scientific' (base 2) byte measurements

        public const uint KiB = 1024;
        public const uint MiB = (1024 * Sylloge.Memory.KiB);
        public const uint GiB = (1024 * Sylloge.Memory.MiB);
        public const ulong TiB = (1024L * Sylloge.Memory.GiB);

        #endregion

        #endregion

        public static bool Compare(Array arr1, Array arr2)
        {
            if (arr1 == null || arr2 == null) { throw new System.ArgumentNullException((arr1 == null) ? "arr1" : "arr2"); }
            if (arr1 == arr2) { return true; } // are the pointers the same?
            if (arr1.Length == 0 || arr2.Length == 0) { throw new System.ArgumentException("array cannot be 0 length"); }
            if (arr1.LongLength != arr2.LongLength) { return false; }
            long size = arr1.LongLength;
            bool m2 = (size % 2 == 0);
            bool m4 = (size % 4 == 0);
            bool m8 = (size % 8 == 0);
            for (long x = 0; x < size; ) {
                if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                if (m2) {
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                }
                if (m4) {
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                }
                if (m8) {
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                    if (arr1.GetValue(x) != arr2.GetValue(x)) { return false; } x++;
                }
            }
            return true;
        }

        public static void Copy(Array source, int sourceOffset, Array dest, int destOffest, int count)
        {
            if (source == null || source.Length == 0) { throw new System.ArgumentException("Source must not be null or empty"); }
            if (dest == null || dest.Length == 0) { throw new System.ArgumentException("Destination must not be null or 0-length"); }
            if (sourceOffset >= source.Length) { throw new System.ArgumentOutOfRangeException("sourceOffset", "Source offset is greater than source length"); }
            if (destOffest >= dest.Length) { throw new System.ArgumentOutOfRangeException("destOffest", "Destination offset is greater than destination length"); }
            if (count > (dest.Length - destOffest)) { throw new System.ArgumentOutOfRangeException("count", "Count is greater than the destination length - offset"); }
            Sylloge.Memory.Set(dest, destOffest, count, 0x00);
            // if count > the diff between src.len and offset, then BlockCopy throws an error
            // so we want to copy differnece of the 2 instead of count in that instance so we
            // get the bytes we want without the error
            int cnt = ((count > (source.Length - sourceOffset)) ? (source.Length - sourceOffset) : count);
            System.Buffer.BlockCopy(source, sourceOffset, dest, destOffest, cnt);
        }

        public static void Copy(Array source, Array dest)
        {
            Sylloge.Memory.Copy(source, 0, dest, 0, source.Length);
        }

        public static bool IsBitSet(byte b, int pos)
        {
            if (pos < 0) { throw new System.ArgumentOutOfRangeException("Position must be greater than 0"); }
            if (pos > 7) { throw new System.ArgumentOutOfRangeException("Position must be less than 8"); }
            return ((b & (1 << pos)) != 0);
        }

        public static byte SetBit(byte b, int pos)
        {
            if (pos < 0) { throw new System.ArgumentOutOfRangeException("Position must be greater than 0"); }
            if (pos > 7) { throw new System.ArgumentOutOfRangeException("Position must be less than 8"); }
            return (b |= (byte)(1 << pos));
        }

        public static Array Set(Array dest, long count, object value)
        {
            if (dest == null || dest.Length == 0) { throw new System.ArgumentException("Destination must not be null or empty"); }
            if (count > dest.LongLength) { throw new System.ArgumentOutOfRangeException("size", "must be less than destination length"); }
            bool m2 = (count % 2 == 0);
            bool m4 = (count % 4 == 0);
            bool m8 = (count % 8 == 0);
            for (long x = 0; x < count; ) {
                dest.SetValue(value, x++);
                if (m2) { dest.SetValue(value, x++); }
                if (m4) {
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                }
                if (m8) {
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                }
            }
            return dest;
        }

        public static Array Set(Array dest, long offset, long count, byte value)
        {
            if (dest == null || dest.Length == 0) { throw new System.ArgumentException("Destination must not be null or empty"); }
            if (count > dest.LongLength) { throw new System.ArgumentOutOfRangeException("count", "must be less than destination length"); }
            if (offset < 0 || offset > dest.LongLength) { throw new System.ArgumentOutOfRangeException("count", "must be less than array length and greater than 0"); }
            if (count > (dest.LongLength - offset)) { throw new System.ArgumentOutOfRangeException("count", "must be less than destination length - offset"); }
            bool m2 = (count % 2 == 0);
            bool m4 = (count % 4 == 0);
            bool m8 = (count % 8 == 0);
            for (long x = offset; x < count; ) {
                dest.SetValue(value, x++);
                if (m2) { dest.SetValue(value, x++); }
                if (m4) {
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                }
                if (m8) {
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                    dest.SetValue(value, x++);
                }
            }
            return dest;
        }

        public static Array SwapValueOrder(Array value)
        {
            if (value == null || value.Length <= 0) { throw new System.ArgumentException("Value cannot be empty"); }
            object h, l;
            for (int i = (value.Length - 1), ni = 0; i > ni; i--, ni++) {
                h = value.GetValue(i);
                l = value.GetValue(ni);
                value.SetValue(l, i);
                value.SetValue(h, ni);
            }
            return value;
        }

        public static Array SwapValueOrder(Array value, int index, int count, bool returnWholeValue)
        {
            if (value == null || value.Length <= 0) { throw new System.ArgumentException("Value cannot be empty"); }
            if (count <= 0 || count > value.Length) { throw new System.ArgumentOutOfRangeException("count", "Count must be greater than 0 and less than value length"); }
            if (index < 0 || index > value.Length) { throw new System.ArgumentOutOfRangeException("index", "Index must be greater than 0 and less than value length"); }
            if ((index + count) > value.Length) { throw new System.ArgumentOutOfRangeException("Index + count cannot exceed array limit"); }
            Array nb = Array.CreateInstance(value.GetValue(0).GetType(), count);
            System.Buffer.BlockCopy(value, index, nb, 0, count);
            nb = Sylloge.Memory.SwapValueOrder(nb);
            if (returnWholeValue) {
                //Array ret = value;
                System.Buffer.BlockCopy(nb, 0, value, index, count);
                return value;
            }
            return nb;
        }

        public static Array SwapValueOrder(Array value, int index, int count)
        {
            return Sylloge.Memory.SwapValueOrder(value, index, count, false);
        }

        public static byte[] SwapByteOrder(byte[] value)
        {
            return (byte[])SwapValueOrder(value);
        }

        public static byte[] SwapByteOrder(byte[] value, int index, int count, bool returnWholeValue)
        {
            return (byte[])Sylloge.Memory.SwapValueOrder(value, index, count, returnWholeValue);
        }

        public static byte[] SwapByteOrder(byte[] value, int index, int count)
        {
            return Sylloge.Memory.SwapByteOrder(value, index, count, false);
        }

        /*
        public static void SwapByteOrder(ref byte[] value)
        {
            value = Sylloge.Memory.SwapByteOrder(value);
        }

        public static void SwapByteOrder(ref byte[] value, int index, int count, bool returnWholeValue)
        {
            value = Sylloge.Memory.SwapByteOrder(value, index, count, returnWholeValue);
        }

        public static void SwapByteOrder(ref byte[] value, int index, int count)
        {
            value = Sylloge.Memory.SwapByteOrder(value, index, count, true);
        }
        */
    }
}