initial commit

util/SystemUtils.cs

@@ -0,0 +1,208 @@
+using System;
+
+namespace ThoughtWorks.QRCode.Codec.Util
+{
+
+    /// <summary>
+    /// Contains conversion support elements such as classes, interfaces and static methods.
+    /// </summary>
+    public class SystemUtils
+    {
+        /// <summary>Reads a number of characters from the current source Stream and writes the data to the target array at the specified index.</summary>
+        /// <param name="sourceStream">The source Stream to read from.</param>
+        /// <param name="target">Contains the array of characteres read from the source Stream.</param>
+        /// <param name="start">The starting index of the target array.</param>
+        /// <param name="count">The maximum number of characters to read from the source Stream.</param>
+        /// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the end of the stream is reached.</returns>
+        public static System.Int32 ReadInput(System.IO.Stream sourceStream, sbyte[] target, int start, int count)
+        {
+            // Returns 0 bytes if not enough space in target
+            if (target.Length == 0)
+                return 0;
+
+            byte[] receiver = new byte[target.Length];
+            int bytesRead = sourceStream.Read(receiver, start, count);
+
+            // Returns -1 if EOF
+            if (bytesRead == 0)
+                return -1;
+
+            for (int i = start; i < start + bytesRead; i++)
+                target[i] = (sbyte)receiver[i];
+
+            return bytesRead;
+        }
+
+        /// <summary>Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index.</summary>
+        /// <param name="sourceTextReader">The source TextReader to read from</param>
+        /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
+        /// <param name="start">The starting index of the target array.</param>
+        /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
+        /// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the end of the stream is reached.</returns>
+        public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, short[] target, int start, int count)
+        {
+            // Returns 0 bytes if not enough space in target
+            if (target.Length == 0) return 0;
+
+            char[] charArray = new char[target.Length];
+            int bytesRead = sourceTextReader.Read(charArray, start, count);
+
+            // Returns -1 if EOF
+            if (bytesRead == 0) return -1;
+
+            for (int index = start; index < start + bytesRead; index++)
+                target[index] = (short)charArray[index];
+
+            return bytesRead;
+        }
+
+        /*******************************/
+        /// <summary>
+        /// Writes the exception stack trace to the received stream
+        /// </summary>
+        /// <param name="throwable">Exception to obtain information from</param>
+        /// <param name="stream">Output sream used to write to</param>
+        public static void WriteStackTrace(System.Exception throwable, System.IO.TextWriter stream)
+        {
+            stream.Write(throwable.StackTrace);
+            stream.Flush();
+        }
+
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static int URShift(int number, int bits)
+        {
+            if (number >= 0)
+                return number >> bits;
+            else
+                return (number >> bits) + (2 << ~bits);
+        }
+
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static int URShift(int number, long bits)
+        {
+            return URShift(number, (int)bits);
+        }
+
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static long URShift(long number, int bits)
+        {
+            if (number >= 0)
+                return number >> bits;
+            else
+                return (number >> bits) + (2L << ~bits);
+        }
+
+        /// <summary>
+        /// Performs an unsigned bitwise right shift with the specified number
+        /// </summary>
+        /// <param name="number">Number to operate on</param>
+        /// <param name="bits">Ammount of bits to shift</param>
+        /// <returns>The resulting number from the shift operation</returns>
+        public static long URShift(long number, long bits)
+        {
+            return URShift(number, (int)bits);
+        }
+
+        /*******************************/
+        /// <summary>
+        /// Converts an array of sbytes to an array of bytes
+        /// </summary>
+        /// <param name="sbyteArray">The array of sbytes to be converted</param>
+        /// <returns>The new array of bytes</returns>
+        public static byte[] ToByteArray(sbyte[] sbyteArray)
+        {
+            byte[] byteArray = null;
+
+            if (sbyteArray != null)
+            {
+                byteArray = new byte[sbyteArray.Length];
+                for (int index = 0; index < sbyteArray.Length; index++)
+                    byteArray[index] = (byte)sbyteArray[index];
+            }
+            return byteArray;
+        }
+
+        /// <summary>
+        /// Converts a string to an array of bytes
+        /// </summary>
+        /// <param name="sourceString">The string to be converted</param>
+        /// <returns>The new array of bytes</returns>
+        public static byte[] ToByteArray(String sourceString)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
+        }
+
+        /// <summary>
+        /// Converts a array of object-type instances to a byte-type array.
+        /// </summary>
+        /// <param name="tempObjectArray">Array to convert.</param>
+        /// <returns>An array of byte type elements.</returns>
+        public static byte[] ToByteArray(System.Object[] tempObjectArray)
+        {
+            byte[] byteArray = null;
+            if (tempObjectArray != null)
+            {
+                byteArray = new byte[tempObjectArray.Length];
+                for (int index = 0; index < tempObjectArray.Length; index++)
+                    byteArray[index] = (byte)tempObjectArray[index];
+            }
+            return byteArray;
+        }
+
+        /*******************************/
+        /// <summary>
+        /// Receives a byte array and returns it transformed in an sbyte array
+        /// </summary>
+        /// <param name="byteArray">Byte array to process</param>
+        /// <returns>The transformed array</returns>
+        public static sbyte[] ToSByteArray(byte[] byteArray)
+        {
+            sbyte[] sbyteArray = null;
+            if (byteArray != null)
+            {
+                sbyteArray = new sbyte[byteArray.Length];
+                for (int index = 0; index < byteArray.Length; index++)
+                    sbyteArray[index] = (sbyte)byteArray[index];
+            }
+            return sbyteArray;
+        }
+
+
+        /*******************************/
+        /// <summary>
+        /// Converts an array of sbytes to an array of chars
+        /// </summary>
+        /// <param name="sByteArray">The array of sbytes to convert</param>
+        /// <returns>The new array of chars</returns>
+        public static char[] ToCharArray(sbyte[] sByteArray)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetChars(ToByteArray(sByteArray));
+        }
+
+        /// <summary>
+        /// Converts an array of bytes to an array of chars
+        /// </summary>
+        /// <param name="byteArray">The array of bytes to convert</param>
+        /// <returns>The new array of chars</returns>
+        public static char[] ToCharArray(byte[] byteArray)
+        {
+            return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
+        }
+
+    }
+}