First commit

hGameTest/bin/linux/obj/include/haxe/io/Bytes.h

@@ -0,0 +1,138 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Bytes
+#define INCLUDED_haxe_io_Bytes
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_38344beec7696400
+#define INCLUDED_38344beec7696400
+#include "cpp/Int64.h"
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Bytes_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Bytes_obj OBJ_;
+		Bytes_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5b931193 };
+
+		void __construct(int length,::Array< unsigned char > b);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Bytes")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.Bytes"); }
+		static hx::ObjectPtr< Bytes_obj > __new(int length,::Array< unsigned char > b);
+		static hx::ObjectPtr< Bytes_obj > __alloc(hx::Ctx *_hx_ctx,int length,::Array< unsigned char > b);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Bytes_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Bytes",4b,78,c5,50); }
+
+		static  ::haxe::io::Bytes alloc(int length);
+		static ::Dynamic alloc_dyn();
+
+		static  ::haxe::io::Bytes ofString(::String s, ::haxe::io::Encoding encoding);
+		static ::Dynamic ofString_dyn();
+
+		static  ::haxe::io::Bytes ofData(::Array< unsigned char > b);
+		static ::Dynamic ofData_dyn();
+
+		static  ::haxe::io::Bytes ofHex(::String s);
+		static ::Dynamic ofHex_dyn();
+
+		static int fastGet(::Array< unsigned char > b,int pos);
+		static ::Dynamic fastGet_dyn();
+
+		int length;
+		::Array< unsigned char > b;
+		int get(int pos);
+		::Dynamic get_dyn();
+
+		void set(int pos,int v);
+		::Dynamic set_dyn();
+
+		void blit(int pos, ::haxe::io::Bytes src,int srcpos,int len);
+		::Dynamic blit_dyn();
+
+		void fill(int pos,int len,int value);
+		::Dynamic fill_dyn();
+
+		 ::haxe::io::Bytes sub(int pos,int len);
+		::Dynamic sub_dyn();
+
+		int compare( ::haxe::io::Bytes other);
+		::Dynamic compare_dyn();
+
+		Float getDouble(int pos);
+		::Dynamic getDouble_dyn();
+
+		Float getFloat(int pos);
+		::Dynamic getFloat_dyn();
+
+		void setDouble(int pos,Float v);
+		::Dynamic setDouble_dyn();
+
+		void setFloat(int pos,Float v);
+		::Dynamic setFloat_dyn();
+
+		int getUInt16(int pos);
+		::Dynamic getUInt16_dyn();
+
+		void setUInt16(int pos,int v);
+		::Dynamic setUInt16_dyn();
+
+		int getInt32(int pos);
+		::Dynamic getInt32_dyn();
+
+		 cpp::Int64Struct getInt64(int pos);
+		::Dynamic getInt64_dyn();
+
+		void setInt32(int pos,int v);
+		::Dynamic setInt32_dyn();
+
+		void setInt64(int pos, cpp::Int64Struct v);
+		::Dynamic setInt64_dyn();
+
+		::String getString(int pos,int len, ::haxe::io::Encoding encoding);
+		::Dynamic getString_dyn();
+
+		::String readString(int pos,int len);
+		::Dynamic readString_dyn();
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+		::String toHex();
+		::Dynamic toHex_dyn();
+
+		::Array< unsigned char > getData();
+		::Dynamic getData_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Bytes */ 

hGameTest/bin/linux/obj/include/haxe/io/BytesBuffer.h

@@ -0,0 +1,57 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_BytesBuffer
+#define INCLUDED_haxe_io_BytesBuffer
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesBuffer)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesBuffer_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef BytesBuffer_obj OBJ_;
+		BytesBuffer_obj();
+
+	public:
+		enum { _hx_ClassId = 0x418818bb };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesBuffer")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.BytesBuffer"); }
+		static hx::ObjectPtr< BytesBuffer_obj > __new();
+		static hx::ObjectPtr< BytesBuffer_obj > __alloc(hx::Ctx *_hx_ctx);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytesBuffer_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesBuffer",ab,73,22,f6); }
+
+		::Array< unsigned char > b;
+		 ::haxe::io::Bytes getBytes();
+		::Dynamic getBytes_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesBuffer */ 

hGameTest/bin/linux/obj/include/haxe/io/BytesInput.h

@@ -0,0 +1,65 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_BytesInput
+#define INCLUDED_haxe_io_BytesInput
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_haxe_io_Input
+#include <haxe/io/Input.h>
+#endif
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,BytesInput)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES BytesInput_obj : public  ::haxe::io::Input_obj
+{
+	public:
+		typedef  ::haxe::io::Input_obj super;
+		typedef BytesInput_obj OBJ_;
+		BytesInput_obj();
+
+	public:
+		enum { _hx_ClassId = 0x2a8878af };
+
+		void __construct( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.BytesInput")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.BytesInput"); }
+		static hx::ObjectPtr< BytesInput_obj > __new( ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static hx::ObjectPtr< BytesInput_obj > __alloc(hx::Ctx *_hx_ctx, ::haxe::io::Bytes b, ::Dynamic pos, ::Dynamic len);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~BytesInput_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("BytesInput",bf,cb,76,e6); }
+
+		::Array< unsigned char > b;
+		int pos;
+		int len;
+		int totlen;
+		int readByte();
+
+		int readBytes( ::haxe::io::Bytes buf,int pos,int len);
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_BytesInput */ 

hGameTest/bin/linux/obj/include/haxe/io/Encoding.h

@@ -0,0 +1,37 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Encoding
+#define INCLUDED_haxe_io_Encoding
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+namespace haxe{
+namespace io{
+
+
+class Encoding_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Encoding_obj OBJ_;
+
+	public:
+		Encoding_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Encoding",33,a6,6d,22); }
+		::String __ToString() const { return HX_("Encoding.",db,8b,f5,be) + _hx_tag; }
+
+		static ::haxe::io::Encoding RawNative;
+		static inline ::haxe::io::Encoding RawNative_dyn() { return RawNative; }
+		static ::haxe::io::Encoding UTF8;
+		static inline ::haxe::io::Encoding UTF8_dyn() { return UTF8; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Encoding */ 

hGameTest/bin/linux/obj/include/haxe/io/Eof.h

@@ -0,0 +1,67 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Eof
+#define INCLUDED_haxe_io_Eof
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_STACK_FRAME(_hx_pos_f9cd114f27426261_29_new)
+HX_DECLARE_CLASS2(haxe,io,Eof)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Eof_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Eof_obj OBJ_;
+		Eof_obj();
+
+	public:
+		enum { _hx_ClassId = 0x41324090 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Eof")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Eof"); }
+
+		inline static hx::ObjectPtr< Eof_obj > __new() {
+			hx::ObjectPtr< Eof_obj > __this = new Eof_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Eof_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Eof_obj *__this = (Eof_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Eof_obj), false, "haxe.io.Eof"));
+			*(void **)__this = Eof_obj::_hx_vtable;
+{
+            	HX_STACKFRAME(&_hx_pos_f9cd114f27426261_29_new)
+            	}
+		
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Eof_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Eof",9c,bc,34,00); }
+
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Eof */ 

hGameTest/bin/linux/obj/include/haxe/io/Error.h

@@ -0,0 +1,41 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Error
+#define INCLUDED_haxe_io_Error
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Error)
+namespace haxe{
+namespace io{
+
+
+class Error_obj : public hx::EnumBase_obj
+{
+	typedef hx::EnumBase_obj super;
+		typedef Error_obj OBJ_;
+
+	public:
+		Error_obj() {};
+		HX_DO_ENUM_RTTI;
+		static void __boot();
+		static void __register();
+		static bool __GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		::String GetEnumName( ) const { return HX_("haxe.io.Error",68,16,01,55); }
+		::String __ToString() const { return HX_("Error.",86,f7,fc,85) + _hx_tag; }
+
+		static ::haxe::io::Error Blocked;
+		static inline ::haxe::io::Error Blocked_dyn() { return Blocked; }
+		static ::haxe::io::Error Custom( ::Dynamic e);
+		static ::Dynamic Custom_dyn();
+		static ::haxe::io::Error OutsideBounds;
+		static inline ::haxe::io::Error OutsideBounds_dyn() { return OutsideBounds; }
+		static ::haxe::io::Error Overflow;
+		static inline ::haxe::io::Error Overflow_dyn() { return Overflow; }
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Error */ 

hGameTest/bin/linux/obj/include/haxe/io/FPHelper.h

@@ -0,0 +1,75 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_FPHelper
+#define INCLUDED_haxe_io_FPHelper
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+#ifndef INCLUDED_38344beec7696400
+#define INCLUDED_38344beec7696400
+#include "cpp/Int64.h"
+#endif
+HX_DECLARE_CLASS2(haxe,io,FPHelper)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES FPHelper_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef FPHelper_obj OBJ_;
+		FPHelper_obj();
+
+	public:
+		enum { _hx_ClassId = 0x349ee9e4 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.FPHelper")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.FPHelper"); }
+
+		inline static hx::ObjectPtr< FPHelper_obj > __new() {
+			hx::ObjectPtr< FPHelper_obj > __this = new FPHelper_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< FPHelper_obj > __alloc(hx::Ctx *_hx_ctx) {
+			FPHelper_obj *__this = (FPHelper_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(FPHelper_obj), false, "haxe.io.FPHelper"));
+			*(void **)__this = FPHelper_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~FPHelper_obj();
+
+		HX_DO_RTTI_ALL;
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("FPHelper",58,42,63,db); }
+
+		static Float i32ToFloat(int i);
+		static ::Dynamic i32ToFloat_dyn();
+
+		static int floatToI32(Float f);
+		static ::Dynamic floatToI32_dyn();
+
+		static Float i64ToDouble(int low,int high);
+		static ::Dynamic i64ToDouble_dyn();
+
+		static  cpp::Int64Struct doubleToI64(Float v);
+		static ::Dynamic doubleToI64_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_FPHelper */ 

hGameTest/bin/linux/obj/include/haxe/io/Input.h

@@ -0,0 +1,94 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Input
+#define INCLUDED_haxe_io_Input
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Bytes)
+HX_DECLARE_CLASS2(haxe,io,Encoding)
+HX_DECLARE_CLASS2(haxe,io,Input)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Input_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Input_obj OBJ_;
+		Input_obj();
+
+	public:
+		enum { _hx_ClassId = 0x5c18cd32 };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Input")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Input"); }
+
+		inline static hx::ObjectPtr< Input_obj > __new() {
+			hx::ObjectPtr< Input_obj > __this = new Input_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Input_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Input_obj *__this = (Input_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Input_obj), false, "haxe.io.Input"));
+			*(void **)__this = Input_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Input_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Input",ea,33,4b,51); }
+
+		bool bigEndian;
+		virtual int readByte();
+		::Dynamic readByte_dyn();
+
+		virtual int readBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readBytes_dyn();
+
+		virtual void close();
+		::Dynamic close_dyn();
+
+		void readFullBytes( ::haxe::io::Bytes s,int pos,int len);
+		::Dynamic readFullBytes_dyn();
+
+		 ::haxe::io::Bytes read(int nbytes);
+		::Dynamic read_dyn();
+
+		::String readLine();
+		::Dynamic readLine_dyn();
+
+		int readInt16();
+		::Dynamic readInt16_dyn();
+
+		int readUInt16();
+		::Dynamic readUInt16_dyn();
+
+		int readInt32();
+		::Dynamic readInt32_dyn();
+
+		::String readString(int len, ::haxe::io::Encoding encoding);
+		::Dynamic readString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Input */ 

hGameTest/bin/linux/obj/include/haxe/io/Output.h

@@ -0,0 +1,58 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Output
+#define INCLUDED_haxe_io_Output
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Output)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Output_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Output_obj OBJ_;
+		Output_obj();
+
+	public:
+		enum { _hx_ClassId = 0x3473efad };
+
+		void __construct();
+		inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="haxe.io.Output")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,false,"haxe.io.Output"); }
+
+		inline static hx::ObjectPtr< Output_obj > __new() {
+			hx::ObjectPtr< Output_obj > __this = new Output_obj();
+			__this->__construct();
+			return __this;
+		}
+
+		inline static hx::ObjectPtr< Output_obj > __alloc(hx::Ctx *_hx_ctx) {
+			Output_obj *__this = (Output_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Output_obj), false, "haxe.io.Output"));
+			*(void **)__this = Output_obj::_hx_vtable;
+			return __this;
+		}
+
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Output_obj();
+
+		HX_DO_RTTI_ALL;
+		static void __register();
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Output",21,83,15,41); }
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Output */ 

hGameTest/bin/linux/obj/include/haxe/io/Path.h

@@ -0,0 +1,72 @@
+// Generated by Haxe 4.0.5
+#ifndef INCLUDED_haxe_io_Path
+#define INCLUDED_haxe_io_Path
+
+#ifndef HXCPP_H
+#include <hxcpp.h>
+#endif
+
+HX_DECLARE_CLASS2(haxe,io,Path)
+
+namespace haxe{
+namespace io{
+
+
+class HXCPP_CLASS_ATTRIBUTES Path_obj : public hx::Object
+{
+	public:
+		typedef hx::Object super;
+		typedef Path_obj OBJ_;
+		Path_obj();
+
+	public:
+		enum { _hx_ClassId = 0x044b6ab5 };
+
+		void __construct(::String path);
+		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="haxe.io.Path")
+			{ return hx::Object::operator new(inSize,inContainer,inName); }
+		inline void *operator new(size_t inSize, int extra)
+			{ return hx::Object::operator new(inSize+extra,true,"haxe.io.Path"); }
+		static hx::ObjectPtr< Path_obj > __new(::String path);
+		static hx::ObjectPtr< Path_obj > __alloc(hx::Ctx *_hx_ctx,::String path);
+		static void * _hx_vtable;
+		static Dynamic __CreateEmpty();
+		static Dynamic __Create(hx::DynamicArray inArgs);
+		//~Path_obj();
+
+		HX_DO_RTTI_ALL;
+		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
+		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
+		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
+		void __GetFields(Array< ::String> &outFields);
+		static void __register();
+		void __Mark(HX_MARK_PARAMS);
+		void __Visit(HX_VISIT_PARAMS);
+		bool _hx_isInstanceOf(int inClassId);
+		::String __ToString() const { return HX_("Path",c5,11,2b,35); }
+
+		static ::String withoutDirectory(::String path);
+		static ::Dynamic withoutDirectory_dyn();
+
+		static ::String directory(::String path);
+		static ::Dynamic directory_dyn();
+
+		static ::String addTrailingSlash(::String path);
+		static ::Dynamic addTrailingSlash_dyn();
+
+		static ::String removeTrailingSlashes(::String path);
+		static ::Dynamic removeTrailingSlashes_dyn();
+
+		::String dir;
+		::String file;
+		::String ext;
+		bool backslash;
+		virtual ::String toString();
+		::Dynamic toString_dyn();
+
+};
+
+} // end namespace haxe
+} // end namespace io
+
+#endif /* INCLUDED_haxe_io_Path */