--- /dev/null
+//
+// System.Threading.ApartmentState.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public enum ApartmentState {
+ MTA,
+ STA,
+ Unknown
+ }
+}
--- /dev/null
+//
+// System.Threading.AutoResetEvent.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class AutoResetEvent : WaitHandle
+ {
+ public AutoResetEvent(bool initialState) {
+ // FIXME
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.IOCompletionCallback.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ // 'unsafe' wasn't in the spec, but the compiler insists because of
+ // the pointer.
+ public unsafe delegate void IOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped *pOVERLAP);
+}
--- /dev/null
+//
+// System.Threading.Interlocked.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class Interlocked
+ {
+ public static int CompareExchange(ref int location1, int value, int comparand) {
+ // lock
+ if(comparand==location1) {
+ int ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+ return(location1);
+ }
+
+ public static object CompareExchange(ref object location1, object value, object comparand) {
+ // lock
+ if(comparand==location1) {
+ object ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+ return(location1);
+ }
+
+ public static float CompareExchange(ref float location1, float value, float comparand) {
+ // lock
+ if(comparand==location1) {
+ float ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+ return(location1);
+ }
+
+ public static int Decrement(ref int location) {
+ // lock
+ location--;
+ return(location);
+ }
+
+ public static long Decrement(ref long location) {
+ // lock
+ location--;
+ return(location);
+ }
+
+ public static int Exchange(ref int location1, int value) {
+ // lock
+ int ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+
+ public static object Exchange(ref object location1, object value) {
+ // lock
+ object ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+
+ public static float Exchange(ref float location1, float value) {
+ // lock
+ float ret;
+
+ ret=location1;
+ location1=value;
+ return(ret);
+ }
+
+ public static int Increment(ref int location) {
+ // lock
+ location++;
+ return(location);
+ }
+
+ public static long Increment(ref long location) {
+ // lock
+ location++;
+ return(location);
+ }
+ }
+}
+
--- /dev/null
+//
+// System.Threading.LockCookie.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public struct LockCookie
+ {
+ }
+}
--- /dev/null
+//
+// System.Threading.ManualResetEvent.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+namespace System.Threading
+{
+ public sealed class ManualResetEvent : WaitHandle
+ {
+ // FIXME
+ }
+}
--- /dev/null
+//
+// System.Threading.Monitor.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class Monitor
+ {
+ public static void Enter(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ if(obj.GetType().IsValueType==true) {
+ throw new ArgumentException("Value type");
+ }
+ // FIXME
+ }
+
+ public static void Exit(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ if(obj.GetType().IsValueType==true) {
+ throw new ArgumentException("Value type");
+ }
+ // FIXME
+ }
+
+ public static void Pulse(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // FIXME
+ }
+
+ public static void PulseAll(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // FIXME
+ }
+
+ public static bool TryEnter(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ if(obj.GetType().IsValueType==true) {
+ throw new ArgumentException("Value type");
+ }
+
+ // FIXME
+ return(false);
+ }
+
+ public static bool TryEnter(object obj, int millisecondsTimeout) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ if(obj.GetType().IsValueType==true) {
+ throw new ArgumentException("Value type");
+ }
+ if(millisecondsTimeout<0) {
+ throw new ArgumentException("millisecondsTimeout negative");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public static bool TryEnter(object obj, TimeSpan timeout) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ if(obj.GetType().IsValueType==true) {
+ throw new ArgumentException("Value type");
+ }
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("timeout out of range");
+ }
+
+ // FIXME
+ return(false);
+ }
+
+ public static bool Wait(object obj) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public static bool Wait(object obj, int millisecondsTimeout) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public static bool Wait(object obj, TimeSpan timeout) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // LAMESPEC: says to throw ArgumentException too
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("timeout out of range");
+ }
+
+ // FIXME
+ return(false);
+ }
+
+ public static bool Wait(object obj, int millisecondsTimeout, bool exitContext) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public static bool Wait(object obj, TimeSpan timeout, bool exitContext) {
+ if(obj==null) {
+ throw new ArgumentNullException("obj");
+ }
+ // LAMESPEC: says to throw ArgumentException too
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("timeout out of range");
+ }
+
+ // FIXME
+ return(false);
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.Mutex.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class Mutex : WaitHandle
+ {
+ public Mutex() {
+ // FIXME
+ }
+
+ public Mutex(bool initiallyOwned) {
+ // FIXME
+ }
+
+ public Mutex(bool initiallyOwned, string name) {
+ // FIXME
+ }
+
+ public Mutex(bool initiallyOwned, string name, out bool gotOwnership) {
+ // FIXME
+ gotOwnership=false;
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.NativeOverlapped.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+using System.Runtime.InteropServices;
+
+namespace System.Threading
+{
+ public struct NativeOverlapped {
+ public int EventHandle;
+ public int InternalHigh;
+ public int InternalLow;
+ public int OffsetHigh;
+ public int OffsetLow;
+ public GCHandle ReservedClassLib;
+ public int ReservedCOR1;
+ public GCHandle ReservedCOR2;
+ }
+}
--- /dev/null
+//
+// System.Threading.Overlapped.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public class Overlapped
+ {
+ unsafe public static void Free(NativeOverlapped *nativeOverlappedPtr) {
+ // FIXME
+ }
+
+ unsafe public static Overlapped Unpack(NativeOverlapped *nativeOverlappedPtr) {
+ // FIXME
+ return(new Overlapped());
+ }
+
+ public Overlapped() {
+ // FIXME
+ }
+
+ public Overlapped(int offsetLo, int offsetHi, int hEvent, IAsyncResult ar) {
+ // FIXME
+ }
+
+ public IAsyncResult AsyncResult {
+ get {
+ // FIXME
+ return(null);
+ }
+
+ set {
+ }
+ }
+
+ public int EventHandle {
+ get {
+ // FIXME
+ return(0);
+ }
+
+ set {
+ }
+ }
+
+ public int OffsetHigh {
+ get {
+ // FIXME
+ return(0);
+ }
+
+ set {
+ }
+ }
+
+ public int OffsetLow {
+ get {
+ // FIXME
+ return(0);
+ }
+
+ set {
+ }
+ }
+
+ unsafe public NativeOverlapped *Pack(IOCompletionCallback iocb) {
+ // FIXME
+ return(null);
+ }
+
+ unsafe public NativeOverlapped *UnsafePack(IOCompletionCallback iocb) {
+ // FIXME
+ return(null);
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.ReaderWriterLock.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class ReaderWriterLock
+ {
+ public ReaderWriterLock() {
+ // FIXME
+ }
+
+ public bool IsReaderLockHeld {
+ get {
+ // FIXME
+ return(false);
+ }
+ }
+
+ public bool IsWriterLockHeld {
+ get {
+ // FIXME
+ return(false);
+ }
+ }
+
+ public int WriterSeqNum {
+ get {
+ // FIXME
+ return(0);
+ }
+ }
+
+ public void AcquireReaderLock(int millisecondsTimeout) {
+ // FIXME
+ }
+
+ public void AcquireReaderLock(TimeSpan timeout) {
+ // FIXME
+ }
+
+ public void AcquireWriterLock(int millisecondsTimeout) {
+ // FIXME
+ }
+
+ public void AcquireWriterLock(TimeSpan timeout) {
+ // FIXME
+ }
+
+ public bool AnyWritersSince(int seqNum) {
+ // FIXME
+ return(false);
+ }
+
+ public void DowngradeFromWriterLock(ref LockCookie lockCookie) {
+ // FIXME
+ }
+
+ public LockCookie ReleaseLock() {
+ // FIXME
+ return(new LockCookie());
+ }
+
+ public void ReleaseReaderLock() {
+ // FIXME
+ }
+
+ public void ReleaseWriterLock() {
+ // FIXME
+ }
+
+ public void RestoreLock(ref LockCookie lockCookie) {
+ // FIXME
+ }
+
+ public LockCookie UpgradeToWriterLock(int millisecondsTimeout) {
+ // FIXME
+ return(new LockCookie());
+ }
+
+ public LockCookie UpgradeToWriterLock(TimeSpan timeout) {
+ // FIXME
+ return(new LockCookie());
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.RegisteredWaitHandle.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class RegisteredWaitHandle
+ {
+ public bool Unregister(WaitHandle waitObject) {
+ // FIXME
+ return(false);
+ }
+
+ ~RegisteredWaitHandle() {
+ // FIXME
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.SynchronizationLockException.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+using System.Runtime.Serialization;
+
+namespace System.Threading
+{
+ public class SynchronizationLockException : SystemException
+ {
+ public SynchronizationLockException()
+ : base ("Synchronization Error") {
+ }
+
+ public SynchronizationLockException(string message)
+ : base (message) {
+ }
+
+ protected SynchronizationLockException(SerializationInfo info, StreamingContext context)
+ : base (info, context) {
+ }
+
+ public SynchronizationLockException(string message, Exception innerException)
+ : base (message, innerException) {
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.Thread.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+using System.Runtime.Remoting.Contexts;
+using System.Security.Principal;
+using System.Globalization;
+
+namespace System.Threading
+{
+ public sealed class Thread
+ {
+ public static Context CurrentContext {
+ get {
+ // FIXME
+ return(null);
+ }
+ }
+
+ public static IPrincipal CurrentPrincipal {
+ get {
+ // FIXME
+ return(null);
+ }
+
+ set {
+ }
+ }
+
+ public static Thread CurrentThread {
+ get {
+ // FIXME
+ return(null);
+ }
+ }
+
+ public static LocalDataStoreSlot AllocateDataSlot() {
+ // FIXME
+ return(null);
+ }
+
+ public static LocalDataStoreSlot AllocateNamedDataSlot(string name) {
+ // FIXME
+ return(null);
+ }
+
+ public static void FreeNamedDataSlot(string name) {
+ // FIXME
+ }
+
+ public static object GetData(LocalDataStoreSlot slot) {
+ // FIXME
+ return(null);
+ }
+
+ public static AppDomain GetDomain() {
+ // FIXME
+ return(null);
+ }
+
+ public static int GetDomainID() {
+ // FIXME
+ return(0);
+ }
+
+ public static LocalDataStoreSlot GetNamedDataSlot(string name) {
+ // FIXME
+ return(null);
+ }
+
+ public static void ResetAbort() {
+ // FIXME
+ }
+
+ public static void SetData(LocalDataStoreSlot slot, object data) {
+ // FIXME
+ }
+
+ public static void Sleep(int millisecondsTimeout) {
+ if(millisecondsTimeout<0) {
+ throw new ArgumentException("Negative timeout");
+ }
+ // FIXME
+ }
+
+ public static void Sleep(TimeSpan timeout) {
+ // LAMESPEC: says to throw ArgumentException too
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("Timeout out of range");
+ }
+ // FIXME
+ }
+
+ public Thread(ThreadStart start) {
+ if(start==null) {
+ throw new ArgumentNullException("Null ThreadStart");
+ }
+ // FIXME
+ }
+
+ public ApartmentState ApartmentState {
+ get {
+ // FIXME
+ return(ApartmentState.Unknown);
+ }
+
+ set {
+ }
+ }
+
+ public CultureInfo CurrentCulture {
+ get {
+ // FIXME
+ return(null);
+ }
+
+ set {
+ }
+ }
+
+ public CultureInfo CurrentUICulture {
+ get {
+ // FIXME
+ return(null);
+ }
+
+ set {
+ }
+ }
+
+ public bool IsAlive {
+ get {
+ // FIXME
+ return(false);
+ }
+ }
+
+ public bool IsBackground {
+ get {
+ // FIXME
+ return(false);
+ }
+
+ set {
+ }
+ }
+
+ public string Name {
+ get {
+ // FIXME
+ return("none");
+ }
+
+ set {
+ }
+ }
+
+ public ThreadPriority Priority {
+ get {
+ // FIXME
+ return(ThreadPriority.Lowest);
+ }
+
+ set {
+ }
+ }
+
+ public ThreadState ThreadState {
+ get {
+ // FIXME
+ return(ThreadState.Unstarted);
+ }
+ }
+
+ public void Abort() {
+ // FIXME
+ }
+
+ public void Abort(object stateInfo) {
+ // FIXME
+ }
+
+ public void Interrupt() {
+ // FIXME
+ }
+
+ public void Join() {
+ // FIXME
+ }
+
+ public bool Join(int millisecondsTimeout) {
+ if(millisecondsTimeout<0) {
+ throw new ArgumentException("Timeout less than zero");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public bool Join(TimeSpan timeout) {
+ // LAMESPEC: says to throw ArgumentException too
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("timeout out of range");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public void Resume() {
+ // FIXME
+ }
+
+ public void Start() {
+ // FIXME
+ }
+
+ public void Suspend() {
+ // FIXME
+ }
+
+ ~Thread() {
+ // FIXME
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.ThreadAbortException.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class ThreadAbortException : SystemException
+ {
+ public object ExceptionState {
+ get {
+ // FIXME
+ return(null);
+ }
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.ThreadInterruptedException.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+using System.Runtime.Serialization;
+
+namespace System.Threading
+{
+ public class ThreadInterruptedException : SystemException
+ {
+ public ThreadInterruptedException()
+ : base ("Thread interrupted") {
+ }
+
+ public ThreadInterruptedException(string message)
+ : base (message) {
+ }
+
+ protected ThreadInterruptedException(SerializationInfo info, StreamingContext context)
+ : base (info, context) {
+ }
+
+ public ThreadInterruptedException(string message, Exception innerException)
+ : base (message, innerException) {
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.ThreadPool.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class ThreadPool
+ {
+ public static bool BindHandle(IntPtr osHandle) {
+ // FIXME
+ return(false);
+ }
+
+ public static bool QueueUserWorkItem(WaitCallback callback) {
+ // FIXME
+ return(false);
+ }
+
+ public static bool QueueUserWorkItem(WaitCallback callback, object state) {
+ // FIXME
+ return(false);
+ }
+
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ if(millisecondsTimeOutInterval < -1) {
+ throw new ArgumentOutOfRangeException("timeout < -1");
+ }
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ if(millisecondsTimeOutInterval < -1) {
+ throw new ArgumentOutOfRangeException("timeout < -1");
+ }
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, TimeSpan timeout, bool executeOnlyOnce) {
+ // LAMESPEC: I assume it means "timeout" when it says "millisecondsTimeOutInterval"
+ if(timeout.Milliseconds < -1) {
+ throw new ArgumentOutOfRangeException("timeout < -1");
+ }
+ if(timeout.Milliseconds > Int32.MaxValue) {
+ throw new NotSupportedException("timeout too large");
+ }
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ // FIXME
+ return(null);
+ }
+
+ public static bool UnsafeQueueUserWorkItem(WaitCallback callback, object state) {
+ // FIXME
+ return(false);
+ }
+
+ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, TimeSpan timeout, bool executeOnlyOnce) {
+ // FIXME
+ return(null);
+ }
+
+ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callback, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce) {
+ // FIXME
+ return(null);
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.ThreadStart.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public delegate void ThreadStart();
+}
--- /dev/null
+//
+// System.Threading.ThreadStateException.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+using System.Runtime.Serialization;
+
+namespace System.Threading
+{
+ public class ThreadStateException : SystemException
+ {
+ public ThreadStateException()
+ : base ("Thread State Error") {
+ }
+
+ public ThreadStateException(string message)
+ : base (message) {
+ }
+
+ protected ThreadStateException(SerializationInfo info, StreamingContext context)
+ : base (info, context) {
+ }
+
+ public ThreadStateException(string message, Exception innerException)
+ : base (message, innerException) {
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.Timeout.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class Timeout
+ {
+ public const int Infinite=-1;
+ }
+}
--- /dev/null
+//
+// System.Threading.Timer.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public sealed class Timer : IDisposable
+ {
+ public Timer(TimerCallback callback, object state, int dueTime, int period) {
+ if(dueTime < -1) {
+ throw new ArgumentOutOfRangeException("Due time < -1");
+ }
+ if(period < -1) {
+ throw new ArgumentOutOfRangeException("Period < -1");
+ }
+
+ // FIXME
+ }
+
+ public Timer(TimerCallback callback, object state, long dueTime, long period) {
+ if(dueTime < -1) {
+ throw new ArgumentOutOfRangeException("Due time < -1");
+ }
+ if(period < -1) {
+ throw new ArgumentOutOfRangeException("Period < -1");
+ }
+ // FIXME
+ }
+
+ public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period) {
+ if(dueTime.Milliseconds < 0 || dueTime.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("Due time out of range");
+ }
+ if(period.Milliseconds < 0 || period.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("Period out of range");
+ }
+ // FIXME
+ }
+
+ public Timer(TimerCallback callback, object state, uint dueTime, uint period) {
+ // FIXME
+ }
+
+ public bool Change(int dueTime, int period) {
+ if(dueTime < -1) {
+ throw new ArgumentOutOfRangeException("Due time < -1");
+ }
+ if(period < -1) {
+ throw new ArgumentOutOfRangeException("Period < -1");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public bool Change(long dueTime, long period) {
+ if(dueTime < -1) {
+ throw new ArgumentOutOfRangeException("Due time < -1");
+ }
+ if(period < -1) {
+ throw new ArgumentOutOfRangeException("Period < -1");
+ }
+ if(dueTime > 4294967294) {
+ throw new NotSupportedException("Due time too large");
+ }
+ if(period > 4294967294) {
+ throw new NotSupportedException("Period too large");
+ }
+ // FIXME
+ return(false);
+ }
+
+ public bool Change(TimeSpan dueTime, TimeSpan period) {
+ // FIXME
+ return(false);
+ }
+
+ public bool Change(uint dueTime, uint period) {
+ // FIXME
+ return(false);
+ }
+
+ public void Dispose() {
+ // FIXME
+ }
+
+ public bool Dispose(WaitHandle notifyObject) {
+ // FIXME
+ return(false);
+ }
+
+ ~Timer() {
+ // FIXME
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.TimerCallback.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public delegate void TimerCallback(object state);
+}
--- /dev/null
+//
+// System.Threading.WaitCallback.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public delegate void WaitCallback(object state);
+}
--- /dev/null
+//
+// System.Threading.WaitHandle.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public abstract class WaitHandle : MarshalByRefObject, IDisposable
+ {
+ public static bool WaitAll(WaitHandle[] waitHandles) {
+ // FIXME
+ return(false);
+ }
+
+ public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext) {
+ // FIXME
+ return(false);
+ }
+
+ public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext) {
+ // FIXME
+ return(false);
+ }
+
+ public static int WaitAny(WaitHandle[] waitHandles) {
+ // FIXME
+ return(0);
+ }
+
+ public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext) {
+ // FIXME
+ return(0);
+ }
+
+ public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext) {
+ if(timeout.Milliseconds < 0 || timeout.Milliseconds > Int32.MaxValue) {
+ throw new ArgumentOutOfRangeException("Timeout out of range");
+ }
+ // FIXME
+ return(0);
+ }
+
+ public WaitHandle() {
+ // FIXME
+ }
+
+ public virtual IntPtr Handle {
+ get {
+ // FIXME
+ return new IntPtr();
+ }
+
+ set {
+ // FIXME
+ }
+ }
+
+ public virtual void Close() {
+ // FIXME
+ }
+
+ protected static readonly IntPtr InvalidHandle;
+
+ private bool disposed = false;
+
+ public void Dispose() {
+ Dispose(true);
+ // Take yourself off the Finalization queue
+ GC.SuppressFinalize(this);
+ }
+
+ protected virtual void Dispose(bool explicitDisposing) {
+ // Check to see if Dispose has already been called.
+ if(!this.disposed) {
+ // If this is a call to Dispose,
+ // dispose all managed resources.
+ if(explicitDisposing) {
+ // Free up stuff here
+ //Components.Dispose();
+ }
+
+ // Release unmanaged resources
+ // Note that this is not thread safe.
+ // Another thread could start
+ // disposing the object after the
+ // managed resources are disposed, but
+ // before the disposed flag is set to
+ // true.
+ this.disposed=true;
+ //Release(handle);
+ //handle=IntPtr.Zero;
+ }
+ }
+
+ ~WaitHandle() {
+ Dispose(false);
+ }
+ }
+}
--- /dev/null
+//
+// System.Threading.WaitOrTimerCallback.cs
+//
+// Author:
+// Dick Porter (dick@ximian.com)
+//
+// (C) Ximian, Inc. http://www.ximian.com
+//
+
+
+namespace System.Threading
+{
+ public delegate void WaitOrTimerCallback(object state, bool timedOut);
+}
+ApartmentState.cs
+AutoResetEvent.cs
+IOCompletionCallback.cs
+Interlocked.cs
+LockCookie.cs
+ManualResetEvent.cs
+Monitor.cs
+Mutex.cs
+NativeOverlapped.cs
+Overlapped.cs
+ReaderWriterLock.cs
+RegisteredWaitHandle.cs
+SynchronizationLockException.cs
+Thread.cs
+ThreadAbortException.cs
+ThreadInterruptedException.cs
+ThreadPool.cs
ThreadPriority.cs
+ThreadStart.cs
ThreadState.cs
+ThreadStateException.cs
+Timeout.cs
+Timer.cs
+TimerCallback.cs
+WaitCallback.cs
+WaitHandle.cs
+WaitOrTimerCallback.cs
projects / mono.git / commitdiff