mirror of
https://github.com/zxing/zxing.git
synced 2024-09-20 21:47:32 -07:00
7854d30103
git-svn-id: https://zxing.googlecode.com/svn/trunk@817 59b500cc-1b3d-0410-9834-0bbf25fbcc57
457 lines
13 KiB
C#
Executable file
457 lines
13 KiB
C#
Executable file
/*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
|
|
/// <summary>
|
|
/// This interface should be implemented by any class whose instances are intended
|
|
/// to be executed by a thread.
|
|
/// </summary>
|
|
public interface IThreadRunnable
|
|
{
|
|
/// <summary>
|
|
/// This method has to be implemented in order that starting of the thread causes the object's
|
|
/// run method to be called in that separately executing thread.
|
|
/// </summary>
|
|
void Run();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Contains conversion support elements such as classes, interfaces and static methods.
|
|
/// </summary>
|
|
public class SupportClass
|
|
{
|
|
|
|
|
|
|
|
/// <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>
|
|
/// Copies an array of chars obtained from a String into a specified array of chars
|
|
/// </summary>
|
|
/// <param name="sourceString">The String to get the chars from</param>
|
|
/// <param name="sourceStart">Position of the String to start getting the chars</param>
|
|
/// <param name="sourceEnd">Position of the String to end getting the chars</param>
|
|
/// <param name="destinationArray">Array to return the chars</param>
|
|
/// <param name="destinationStart">Position of the destination array of chars to start storing the chars</param>
|
|
/// <returns>An array of chars</returns>
|
|
public static void GetCharsFromString(System.String sourceString, int sourceStart, int sourceEnd, char[] destinationArray, int destinationStart)
|
|
{
|
|
int sourceCounter;
|
|
int destinationCounter;
|
|
sourceCounter = sourceStart;
|
|
destinationCounter = destinationStart;
|
|
while (sourceCounter < sourceEnd)
|
|
{
|
|
destinationArray[destinationCounter] = (char) sourceString[sourceCounter];
|
|
sourceCounter++;
|
|
destinationCounter++;
|
|
}
|
|
}
|
|
|
|
/*******************************/
|
|
/// <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(System.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>
|
|
/// Sets the capacity for the specified ArrayList
|
|
/// </summary>
|
|
/// <param name="vector">The ArrayList which capacity will be set</param>
|
|
/// <param name="newCapacity">The new capacity value</param>
|
|
public static void SetCapacity(System.Collections.ArrayList vector, int newCapacity)
|
|
{
|
|
if (newCapacity > vector.Count)
|
|
vector.AddRange(new Array[newCapacity-vector.Count]);
|
|
else if (newCapacity < vector.Count)
|
|
vector.RemoveRange(newCapacity, vector.Count - newCapacity);
|
|
vector.Capacity = newCapacity;
|
|
}
|
|
|
|
|
|
|
|
/*******************************/
|
|
/// <summary>
|
|
/// This method returns the literal value received
|
|
/// </summary>
|
|
/// <param name="literal">The literal to return</param>
|
|
/// <returns>The received value</returns>
|
|
public static long Identity(long literal)
|
|
{
|
|
return literal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the literal value received
|
|
/// </summary>
|
|
/// <param name="literal">The literal to return</param>
|
|
/// <returns>The received value</returns>
|
|
public static ulong Identity(ulong literal)
|
|
{
|
|
return literal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the literal value received
|
|
/// </summary>
|
|
/// <param name="literal">The literal to return</param>
|
|
/// <returns>The received value</returns>
|
|
public static float Identity(float literal)
|
|
{
|
|
return literal;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the literal value received
|
|
/// </summary>
|
|
/// <param name="literal">The literal to return</param>
|
|
/// <returns>The received value</returns>
|
|
public static double Identity(double literal)
|
|
{
|
|
return literal;
|
|
}
|
|
|
|
/*******************************/
|
|
/// <summary>
|
|
/// Support class used to handle threads
|
|
/// </summary>
|
|
public class ThreadClass : IThreadRunnable
|
|
{
|
|
/// <summary>
|
|
/// The instance of System.Threading.Thread
|
|
/// </summary>
|
|
private System.Threading.Thread threadField;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the ThreadClass class
|
|
/// </summary>
|
|
public ThreadClass()
|
|
{
|
|
threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the Thread class.
|
|
/// </summary>
|
|
/// <param name="Name">The name of the thread</param>
|
|
public ThreadClass(System.String Name)
|
|
{
|
|
threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
|
|
this.Name = Name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the Thread class.
|
|
/// </summary>
|
|
/// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
|
|
public ThreadClass(System.Threading.ThreadStart Start)
|
|
{
|
|
threadField = new System.Threading.Thread(Start);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the Thread class.
|
|
/// </summary>
|
|
/// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
|
|
/// <param name="Name">The name of the thread</param>
|
|
public ThreadClass(System.Threading.ThreadStart Start, System.String Name)
|
|
{
|
|
threadField = new System.Threading.Thread(Start);
|
|
this.Name = Name;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method has no functionality unless the method is overridden
|
|
/// </summary>
|
|
public virtual void Run()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Causes the operating system to change the state of the current thread instance to ThreadState.Running
|
|
/// </summary>
|
|
public virtual void Start()
|
|
{
|
|
threadField.Start();
|
|
}
|
|
|
|
///// <summary>
|
|
///// Interrupts a thread that is in the WaitSleepJoin thread state
|
|
///// </summary>
|
|
//public virtual void Interrupt()
|
|
//{
|
|
// threadField.Interrupt();
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Gets the current thread instance
|
|
/// </summary>
|
|
public System.Threading.Thread Instance
|
|
{
|
|
get
|
|
{
|
|
return threadField;
|
|
}
|
|
set
|
|
{
|
|
threadField = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the name of the thread
|
|
/// </summary>
|
|
public System.String Name
|
|
{
|
|
get
|
|
{
|
|
return threadField.Name;
|
|
}
|
|
set
|
|
{
|
|
if (threadField.Name == null)
|
|
threadField.Name = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating the scheduling priority of a thread
|
|
/// </summary>
|
|
public System.Threading.ThreadPriority Priority
|
|
{
|
|
get
|
|
{
|
|
return threadField.Priority;
|
|
}
|
|
set
|
|
{
|
|
threadField.Priority = value;
|
|
}
|
|
}
|
|
|
|
///// <summary>
|
|
///// Gets a value indicating the execution status of the current thread
|
|
///// </summary>
|
|
//public bool IsAlive
|
|
//{
|
|
// get
|
|
// {
|
|
// return threadField.IsAlive;
|
|
// }
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Gets or sets a value indicating whether or not a thread is a background thread.
|
|
/// </summary>
|
|
public bool IsBackground
|
|
{
|
|
get
|
|
{
|
|
return threadField.IsBackground;
|
|
}
|
|
set
|
|
{
|
|
threadField.IsBackground = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Blocks the calling thread until a thread terminates
|
|
/// </summary>
|
|
public void Join()
|
|
{
|
|
threadField.Join();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Blocks the calling thread until a thread terminates or the specified time elapses
|
|
/// </summary>
|
|
/// <param name="MiliSeconds">Time of wait in milliseconds</param>
|
|
public void Join(int MiliSeconds)
|
|
{
|
|
lock(this)
|
|
{
|
|
threadField.Join(MiliSeconds);
|
|
}
|
|
}
|
|
|
|
///// <summary>
|
|
///// Blocks the calling thread until a thread terminates or the specified time elapses
|
|
///// </summary>
|
|
///// <param name="MiliSeconds">Time of wait in milliseconds</param>
|
|
///// <param name="NanoSeconds">Time of wait in nanoseconds</param>
|
|
//public void Join(long MiliSeconds, int NanoSeconds)
|
|
//{
|
|
// lock(this)
|
|
// {
|
|
// threadField.Join(new System.TimeSpan(MiliSeconds * 10000 + NanoSeconds * 100));
|
|
// }
|
|
//}
|
|
|
|
///// <summary>
|
|
///// Resumes a thread that has been suspended
|
|
///// </summary>
|
|
//public void Resume()
|
|
//{
|
|
// threadField.Resume();
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Raises a ThreadAbortException in the thread on which it is invoked,
|
|
/// to begin the process of terminating the thread. Calling this method
|
|
/// usually terminates the thread
|
|
/// </summary>
|
|
public void Abort()
|
|
{
|
|
threadField.Abort();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raises a ThreadAbortException in the thread on which it is invoked,
|
|
/// to begin the process of terminating the thread while also providing
|
|
/// exception information about the thread termination.
|
|
/// Calling this method usually terminates the thread.
|
|
/// </summary>
|
|
/// <param name="stateInfo">An object that contains application-specific information, such as state, which can be used by the thread being aborted</param>
|
|
public void Abort(System.Object stateInfo)
|
|
{
|
|
lock(this)
|
|
{
|
|
threadField.Abort(stateInfo);
|
|
}
|
|
}
|
|
|
|
///// <summary>
|
|
///// Suspends the thread, if the thread is already suspended it has no effect
|
|
///// </summary>
|
|
//public void Suspend()
|
|
//{
|
|
// threadField.Suspend();
|
|
//}
|
|
|
|
/// <summary>
|
|
/// Obtain a String that represents the current Object
|
|
/// </summary>
|
|
/// <returns>A String that represents the current Object</returns>
|
|
public override System.String ToString()
|
|
{
|
|
return "Thread[" + Name + "," + Priority.ToString() + "," + "" + "]";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the currently running thread
|
|
/// </summary>
|
|
/// <returns>The currently running thread</returns>
|
|
public static ThreadClass Current()
|
|
{
|
|
ThreadClass CurrentThread = new ThreadClass();
|
|
CurrentThread.Instance = System.Threading.Thread.CurrentThread;
|
|
return CurrentThread;
|
|
}
|
|
}
|
|
|
|
|
|
}
|