// Generated by Haxe 4.3.7 (patched: no System.Threading.Thread/Mutex)

#pragma warning disable 109, 114, 219, 429, 168, 162
namespace sys.thread._Thread {
	public class HaxeThread : global::haxe.lang.HxObject {
		
		static HaxeThread() {
			{
				global::sys.thread._Thread.HaxeThread.threadsMutex = new global::sys.thread.Mutex();
				global::sys.thread._Thread.HaxeThread.allocateCount = 0;
				global::sys.thread._Thread.HaxeThread.mainHaxeThread = new global::sys.thread._Thread.HaxeThread(((object) (null) ));
				global::sys.thread._Thread.HaxeThread.mainHaxeThread.events = new global::sys.thread.EventLoop();
			}
			
		}
		
		
		public HaxeThread(global::haxe.lang.EmptyObject empty) {
		}
		
		
		public HaxeThread(object native) {
			global::sys.thread._Thread.HaxeThread.__hx_ctor_sys_thread__Thread_HaxeThread(this, native);
		}
		
		
		protected static void __hx_ctor_sys_thread__Thread_HaxeThread(global::sys.thread._Thread.HaxeThread __hx_this, object native) {
			__hx_this.messages = new global::sys.thread.Deque<object>();
			{
				__hx_this.native = native;
			}
			
		}
		
		
		public static global::sys.thread._Thread.HaxeThread mainHaxeThread;
		
		public static global::sys.thread.Mutex threadsMutex;
		
		public static int allocateCount;
		
		public static global::sys.thread._Thread.HaxeThread @get() {
			return global::sys.thread._Thread.HaxeThread.mainHaxeThread;
		}
		
		
		public static global::sys.thread._Thread.HaxeThread current() {
			return global::sys.thread._Thread.HaxeThread.mainHaxeThread;
		}
		
		
		public static global::sys.thread._Thread.HaxeThread allocate(object native, bool withEventLoop) {
			global::sys.thread._Thread.HaxeThread hx = new global::sys.thread._Thread.HaxeThread(((object) (native) ));
			if (withEventLoop) {
				hx.events = new global::sys.thread.EventLoop();
			}
			
			return hx;
		}
		
		
		public static void runWithEventLoop(global::haxe.lang.Function job) {
			global::sys.thread._Thread.HaxeThread thread = global::sys.thread._Thread.HaxeThread.current();
			if (( thread.events == null )) {
				thread.events = new global::sys.thread.EventLoop();
				try {
					job.__hx_invoke0_o();
					thread.events.loop();
					thread.events = null;
				}
				catch (global::System.Exception _g){
					global::haxe.Exception e = global::haxe.Exception.caught(_g);
					thread.events = null;
					throw ((global::System.Exception) (global::haxe.Exception.thrown(e)) );
				}
				
				
			}
			else {
				job.__hx_invoke0_o();
			}
			
		}
		
		
		public object native;
		
		public global::sys.thread.EventLoop events;
		
		public global::sys.thread.Deque messages;
		
		public object readMessage(bool block) {
			return ((object) (global::haxe.lang.Runtime.callField(this.messages, "pop", 5594513, new object[]{block})) );
		}
		
		
		public virtual void sendMessage(object msg) {
			object __temp_expr1 = ((object) (global::haxe.lang.Runtime.callField(this.messages, "add", 4846113, new object[]{msg})) );
		}
		
		
		public override object __hx_setField(string field, int hash, object @value, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 889051340:
					{
						this.messages = ((global::sys.thread.Deque) (@value) );
						return @value;
					}
					
					
					case 376065817:
					{
						this.events = ((global::sys.thread.EventLoop) (@value) );
						return @value;
					}
					
					
					case 572311959:
					{
						this.native = ((object) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override object __hx_getField(string field, int hash, bool throwErrors, bool isCheck, bool handleProperties) {
			unchecked {
				switch (hash) {
					case 605915487:
					{
						return ((global::haxe.lang.Function) (new global::haxe.lang.Closure(this, "sendMessage", 605915487)) );
					}
					
					
					case 1828505873:
					{
						return ((global::haxe.lang.Function) (new global::haxe.lang.Closure(this, "readMessage", 1828505873)) );
					}
					
					
					case 889051340:
					{
						return this.messages;
					}
					
					
					case 376065817:
					{
						return this.events;
					}
					
					
					case 572311959:
					{
						return this.native;
					}
					
					
					default:
					{
						return base.__hx_getField(field, hash, throwErrors, isCheck, handleProperties);
					}
					
				}
				
			}
		}
		
		
		public override object __hx_invokeField(string field, int hash, object[] dynargs) {
			unchecked {
				switch (hash) {
					case 605915487:
					{
						this.sendMessage(dynargs[0]);
						break;
					}
					
					
					case 1828505873:
					{
						return this.readMessage(global::haxe.lang.Runtime.toBool(dynargs[0]));
					}
					
					
					default:
					{
						return base.__hx_invokeField(field, hash, dynargs);
					}
					
				}
				
				return null;
			}
		}
		
		
		public override void __hx_getFields(global::Array<string> baseArr) {
			baseArr.push("messages");
			baseArr.push("events");
			baseArr.push("native");
			base.__hx_getFields(baseArr);
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace sys.thread._Thread {
	public sealed class Thread_Impl_ {
		
		
		
		public static global::sys.thread._Thread.HaxeThread _new(global::sys.thread._Thread.HaxeThread thread) {
			return ((global::sys.thread._Thread.HaxeThread) (thread) );
		}
		
		
		public static global::sys.thread._Thread.HaxeThread create(global::haxe.lang.Function job) {
			global::sys.thread._Thread.HaxeThread hx = global::sys.thread._Thread.HaxeThread.allocate(((object) (null) ), false);
			job.__hx_invoke0_o();
			return ((global::sys.thread._Thread.HaxeThread) (hx) );
		}
		
		
		public static void runWithEventLoop(global::haxe.lang.Function job) {
			global::sys.thread._Thread.HaxeThread.runWithEventLoop(job);
		}
		
		
		public static global::sys.thread._Thread.HaxeThread createWithEventLoop(global::haxe.lang.Function job) {
			global::sys.thread._Thread.HaxeThread hx = global::sys.thread._Thread.HaxeThread.allocate(((object) (null) ), true);
			job.__hx_invoke0_o();
			return ((global::sys.thread._Thread.HaxeThread) (hx) );
		}
		
		
		public static global::sys.thread._Thread.HaxeThread current() {
			return ((global::sys.thread._Thread.HaxeThread) (global::sys.thread._Thread.HaxeThread.current()) );
		}
		
		
		public static object readMessage(bool block) {
			return ((global::sys.thread._Thread.HaxeThread) (global::sys.thread._Thread.HaxeThread.current()) ).readMessage(block);
		}
		
		
		public static void sendMessage(global::sys.thread._Thread.HaxeThread this1, object msg) {
			this1.sendMessage(msg);
		}
		
		
		public static object readMessageImpl(global::sys.thread._Thread.HaxeThread this1, bool block) {
			return this1.readMessage(block);
		}
		
		
		public static global::sys.thread.EventLoop get_events(global::sys.thread._Thread.HaxeThread this1) {
			if (( this1.events == null )) {
				throw new global::sys.thread.NoEventLoopException(default(string), default(global::haxe.Exception));
			}
			
			return this1.events;
		}
		
		
		public static void processEvents() {
			global::sys.thread._Thread.HaxeThread.current().events.loop();
		}
		
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace sys.thread._Thread {
	public class Thread_Impl__create_41__Fun : global::haxe.lang.Function {
		
		public Thread_Impl__create_41__Fun(global::haxe.lang.Function job) : base(0, 0) {
			this.job = job;
		}
		
		
		public override object __hx_invoke0_o() {
			this.Delegate();
			return null;
		}
		
		
		public void Delegate() {
			this.job.__hx_invoke0_o();
		}
		
		
		public global::haxe.lang.Function job;
		
	}
}



#pragma warning disable 109, 114, 219, 429, 168, 162
namespace sys.thread._Thread {
	public class Thread_Impl__createWithEventLoop_55__Fun : global::haxe.lang.Function {
		
		public Thread_Impl__createWithEventLoop_55__Fun(global::haxe.lang.Function job, global::sys.thread._Thread.HaxeThread[] hx) : base(0, 0) {
			this.job = job;
			this.hx = hx;
		}
		
		
		public override object __hx_invoke0_o() {
			this.Delegate();
			return null;
		}
		
		
		public void Delegate() {
			this.job.__hx_invoke0_o();
			if (( ((global::sys.thread._Thread.HaxeThread) (this.hx[0]) ) == null )) {
				global::sys.thread._Thread.HaxeThread.current().events.loop();
			}
			else {
				((global::sys.thread._Thread.HaxeThread) (this.hx[0]) ).events.loop();
			}
			
		}
		
		
		public global::haxe.lang.Function job;
		
		public global::sys.thread._Thread.HaxeThread[] hx;
		
	}
}