internals/src/EflSharp/EflSharp/efl/efl_thread.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Efl {
   9
  10 [Efl.Thread.NativeMethods]
  11 [Efl.Eo.BindingEntity]
  12 public class Thread : Efl.Task, Efl.IThreadIO, Efl.Core.ICommandLine, Efl.Io.ICloser, Efl.Io.IReader, Efl.Io.IWriter
  13 {
  14     ///<summary>Pointer to the native class description.</summary>
  15     public override System.IntPtr NativeClass
  16     {
  17         get
  18         {
  19             if (((object)this).GetType() == typeof(Thread))
  20             {
  21                 return GetEflClassStatic();
  22             }
  23             else
  24             {
  25                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  26             }
  27         }
  28     }
  29
  30     [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  31         efl_thread_class_get();
  32     /// <summary>Initializes a new instance of the <see cref="Thread"/> class.</summary>
  33     /// <param name="parent">Parent instance.</param>
  34     public Thread(Efl.Object parent= null
  35             ) : base(efl_thread_class_get(), parent)
  36     {
  37         FinishInstantiation();
  38     }
  39
  40     /// <summary>Constructor to be used when objects are expected to be constructed from native code.</summary>
  41     /// <param name="ch">Tag struct storing the native handle of the object being constructed.</param>
  42     protected Thread(ConstructingHandle ch) : base(ch)
  43     {
  44     }
  45
  46     /// <summary>Initializes a new instance of the <see cref="Thread"/> class.
  47     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  48     /// <param name="wh">The native pointer to be wrapped.</param>
  49     protected Thread(Efl.Eo.Globals.WrappingHandle wh) : base(wh)
  50     {
  51     }
  52
  53     /// <summary>Initializes a new instance of the <see cref="Thread"/> class.
  54     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  55     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  56     /// <param name="parent">The Efl.Object parent of this instance.</param>
  57     protected Thread(IntPtr baseKlass, Efl.Object parent) : base(baseKlass, parent)
  58     {
  59     }
  60
  61     /// <summary>Notifies closed, when property is marked as true
  62     /// (Since EFL 1.22)</summary>
  63     public event EventHandler ClosedEvt
  64     {
  65         add
  66         {
  67             lock (eflBindingEventLock)
  68             {
  69                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  70                 {
  71                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
  72                     if (obj != null)
  73                     {
  74                         EventArgs args = EventArgs.Empty;
  75                         try
  76                         {
  77                             value?.Invoke(obj, args);
  78                         }
  79                         catch (Exception e)
  80                         {
  81                             Eina.Log.Error(e.ToString());
  82                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
  83                         }
  84                     }
  85                 };
  86
  87                 string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
  88                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
  89             }
  90         }
  91
  92         remove
  93         {
  94             lock (eflBindingEventLock)
  95             {
  96                 string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
  97                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
  98             }
  99         }
 100     }
 101     ///<summary>Method to raise event ClosedEvt.</summary>
 102     public void OnClosedEvt(EventArgs e)
 103     {
 104         var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
 105         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 106         if (desc == IntPtr.Zero)
 107         {
 108             Eina.Log.Error($"Failed to get native event {key}");
 109             return;
 110         }
 111
 112         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 113     }
 114     /// <summary>Notifies can_read property changed.
 115     /// If <see cref="Efl.Io.IReader.CanRead"/> is <c>true</c> there is data to <see cref="Efl.Io.IReader.Read"/> without blocking/error. If <see cref="Efl.Io.IReader.CanRead"/> is <c>false</c>, <see cref="Efl.Io.IReader.Read"/> would either block or fail.
 116     ///
 117     /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IReader.Read"/>, thus before it returns.
 118     /// (Since EFL 1.22)</summary>
 119     public event EventHandler<Efl.Io.IReaderCanReadChangedEvt_Args> CanReadChangedEvt
 120     {
 121         add
 122         {
 123             lock (eflBindingEventLock)
 124             {
 125                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 126                 {
 127                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 128                     if (obj != null)
 129                     {
 130                         Efl.Io.IReaderCanReadChangedEvt_Args args = new Efl.Io.IReaderCanReadChangedEvt_Args();
 131                         args.arg = Marshal.ReadByte(evt.Info) != 0;
 132                         try
 133                         {
 134                             value?.Invoke(obj, args);
 135                         }
 136                         catch (Exception e)
 137                         {
 138                             Eina.Log.Error(e.ToString());
 139                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 140                         }
 141                     }
 142                 };
 143
 144                 string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 145                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 146             }
 147         }
 148
 149         remove
 150         {
 151             lock (eflBindingEventLock)
 152             {
 153                 string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 154                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 155             }
 156         }
 157     }
 158     ///<summary>Method to raise event CanReadChangedEvt.</summary>
 159     public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
 160     {
 161         var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 162         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 163         if (desc == IntPtr.Zero)
 164         {
 165             Eina.Log.Error($"Failed to get native event {key}");
 166             return;
 167         }
 168
 169         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 170         try
 171         {
 172             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 173         }
 174         finally
 175         {
 176             Marshal.FreeHGlobal(info);
 177         }
 178     }
 179     /// <summary>Notifies end of stream, when property is marked as true.
 180     /// If this is used alongside with an <see cref="Efl.Io.ICloser"/>, then it should be emitted before that call.
 181     ///
 182     /// It should be emitted only once for an object unless it implements <see cref="Efl.Io.IPositioner.Seek"/>.
 183     ///
 184     /// The property <see cref="Efl.Io.IReader.CanRead"/> should change to <c>false</c> before this event is dispatched.
 185     /// (Since EFL 1.22)</summary>
 186     public event EventHandler EosEvt
 187     {
 188         add
 189         {
 190             lock (eflBindingEventLock)
 191             {
 192                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 193                 {
 194                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 195                     if (obj != null)
 196                     {
 197                         EventArgs args = EventArgs.Empty;
 198                         try
 199                         {
 200                             value?.Invoke(obj, args);
 201                         }
 202                         catch (Exception e)
 203                         {
 204                             Eina.Log.Error(e.ToString());
 205                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 206                         }
 207                     }
 208                 };
 209
 210                 string key = "_EFL_IO_READER_EVENT_EOS";
 211                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 212             }
 213         }
 214
 215         remove
 216         {
 217             lock (eflBindingEventLock)
 218             {
 219                 string key = "_EFL_IO_READER_EVENT_EOS";
 220                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 221             }
 222         }
 223     }
 224     ///<summary>Method to raise event EosEvt.</summary>
 225     public void OnEosEvt(EventArgs e)
 226     {
 227         var key = "_EFL_IO_READER_EVENT_EOS";
 228         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 229         if (desc == IntPtr.Zero)
 230         {
 231             Eina.Log.Error($"Failed to get native event {key}");
 232             return;
 233         }
 234
 235         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 236     }
 237     /// <summary>Notifies can_write property changed.
 238     /// If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>true</c> there is data to <see cref="Efl.Io.IWriter.Write"/> without blocking/error. If <see cref="Efl.Io.IWriter.CanWrite"/> is <c>false</c>, <see cref="Efl.Io.IWriter.Write"/> would either block or fail.
 239     ///
 240     /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IWriter.Write"/>, thus before it returns.
 241     /// (Since EFL 1.22)</summary>
 242     public event EventHandler<Efl.Io.IWriterCanWriteChangedEvt_Args> CanWriteChangedEvt
 243     {
 244         add
 245         {
 246             lock (eflBindingEventLock)
 247             {
 248                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 249                 {
 250                     var obj = Efl.Eo.Globals.WrapperSupervisorPtrToManaged(data).Target;
 251                     if (obj != null)
 252                     {
 253                         Efl.Io.IWriterCanWriteChangedEvt_Args args = new Efl.Io.IWriterCanWriteChangedEvt_Args();
 254                         args.arg = Marshal.ReadByte(evt.Info) != 0;
 255                         try
 256                         {
 257                             value?.Invoke(obj, args);
 258                         }
 259                         catch (Exception e)
 260                         {
 261                             Eina.Log.Error(e.ToString());
 262                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 263                         }
 264                     }
 265                 };
 266
 267                 string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 268                 AddNativeEventHandler(efl.Libs.Ecore, key, callerCb, value);
 269             }
 270         }
 271
 272         remove
 273         {
 274             lock (eflBindingEventLock)
 275             {
 276                 string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 277                 RemoveNativeEventHandler(efl.Libs.Ecore, key, value);
 278             }
 279         }
 280     }
 281     ///<summary>Method to raise event CanWriteChangedEvt.</summary>
 282     public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
 283     {
 284         var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 285         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Ecore, key);
 286         if (desc == IntPtr.Zero)
 287         {
 288             Eina.Log.Error($"Failed to get native event {key}");
 289             return;
 290         }
 291
 292         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 293         try
 294         {
 295             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 296         }
 297         finally
 298         {
 299             Marshal.FreeHGlobal(info);
 300         }
 301     }
 302     /// <returns>No description supplied.</returns>
 303     virtual public System.IntPtr GetIndata() {
 304          var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_indata_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 305         Eina.Error.RaiseIfUnhandledException();
 306         return _ret_var;
 307  }
 308     /// <param name="data">No description supplied.</param>
 309     virtual public void SetIndata(System.IntPtr data) {
 310                                  Efl.IThreadIOConcrete.NativeMethods.efl_threadio_indata_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),data);
 311         Eina.Error.RaiseIfUnhandledException();
 312                          }
 313     /// <returns>No description supplied.</returns>
 314     virtual public System.IntPtr GetOutdata() {
 315          var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_outdata_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 316         Eina.Error.RaiseIfUnhandledException();
 317         return _ret_var;
 318  }
 319     /// <param name="data">No description supplied.</param>
 320     virtual public void SetOutdata(System.IntPtr data) {
 321                                  Efl.IThreadIOConcrete.NativeMethods.efl_threadio_outdata_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),data);
 322         Eina.Error.RaiseIfUnhandledException();
 323                          }
 324     /// <param name="func">No description supplied.</param>
 325     virtual public void Call(EFlThreadIOCall func) {
 326                          GCHandle func_handle = GCHandle.Alloc(func);
 327         Efl.IThreadIOConcrete.NativeMethods.efl_threadio_call_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),GCHandle.ToIntPtr(func_handle), EFlThreadIOCallWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 328         Eina.Error.RaiseIfUnhandledException();
 329                          }
 330     /// <param name="func">No description supplied.</param>
 331     /// <returns>No description supplied.</returns>
 332     virtual public System.IntPtr CallSync(EFlThreadIOCallSync func) {
 333                          GCHandle func_handle = GCHandle.Alloc(func);
 334         var _ret_var = Efl.IThreadIOConcrete.NativeMethods.efl_threadio_call_sync_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),GCHandle.ToIntPtr(func_handle), EFlThreadIOCallSyncWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 335         Eina.Error.RaiseIfUnhandledException();
 336                         return _ret_var;
 337  }
 338     /// <summary>A commandline that encodes arguments in a command string. This command is unix shell-style, thus whitespace separates arguments unless escaped. Also a semi-colon &apos;;&apos;, ampersand &apos;&amp;&apos;, pipe/bar &apos;|&apos;, hash &apos;#&apos;, bracket, square brace, brace character (&apos;(&apos;, &apos;)&apos;, &apos;[&apos;, &apos;]&apos;, &apos;{&apos;, &apos;}&apos;), exclamation mark &apos;!&apos;,  backquote &apos;`&apos;, greator or less than (&apos;&gt;&apos; &apos;&lt;&apos;) character unless escaped or in quotes would cause args_count/value to not be generated properly, because it would force complex shell interpretation which will not be supported in evaluating the arg_count/value information, but the final shell may interpret this if this is executed via a command-line shell. To not be a complex shell command, it should be simple with paths, options and variable expansions, but nothing more complex involving the above unescaped characters.
 339     /// &quot;cat -option /path/file&quot; &quot;cat &apos;quoted argument&apos;&quot; &quot;cat ~/path/escaped argument&quot; &quot;/bin/cat escaped argument <c>VARIABLE</c>&quot; etc.
 340     ///
 341     /// It should not try and use &quot;complex shell features&quot; if you want the arg_count and arg_value set to be correct after setting the command string. For example none of:
 342     ///
 343     /// &quot;VAR=x /bin/command &amp;&amp; /bin/othercommand &gt;&amp; /dev/null&quot; &quot;VAR=x /bin/command `/bin/othercommand` | /bin/cmd2 &amp;&amp; cmd3 &amp;&quot; etc.
 344     ///
 345     /// If you set the command the arg_count/value property contents can change and be completely re-evaluated by parsing the command string into an argument array set along with interpreting escapes back into individual argument strings.</summary>
 346     virtual public System.String GetCommand() {
 347          var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 348         Eina.Error.RaiseIfUnhandledException();
 349         return _ret_var;
 350  }
 351     /// <summary>Use an array to fill this object
 352     /// Every element of a string is a argument.</summary>
 353     /// <param name="array">An array where every array field is an argument</param>
 354     /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 355     virtual public bool SetCommandArray(Eina.Array<Eina.Stringshare> array) {
 356          var _in_array = array.Handle;
 357 array.Own = false;
 358 array.OwnContent = false;
 359                         var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_array_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),_in_array);
 360         Eina.Error.RaiseIfUnhandledException();
 361                         return _ret_var;
 362  }
 363     /// <summary>Use a string to fill this object
 364     /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 365     /// <param name="str">A command in form of a string</param>
 366     /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 367     virtual public bool SetCommandString(System.String str) {
 368                                  var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_string_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),str);
 369         Eina.Error.RaiseIfUnhandledException();
 370                         return _ret_var;
 371  }
 372     /// <summary>Get the accessor which enables access to each argument that got passed to this object.</summary>
 373     virtual public Eina.Accessor<Eina.Stringshare> CommandAccess() {
 374          var _ret_var = Efl.Core.ICommandLineConcrete.NativeMethods.efl_core_command_line_command_access_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 375         Eina.Error.RaiseIfUnhandledException();
 376         return new Eina.Accessor<Eina.Stringshare>(_ret_var, false);
 377  }
 378     /// <summary>If true will notify object was closed.
 379     /// (Since EFL 1.22)</summary>
 380     /// <returns><c>true</c> if closed, <c>false</c> otherwise</returns>
 381     virtual public bool GetClosed() {
 382          var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_closed_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 383         Eina.Error.RaiseIfUnhandledException();
 384         return _ret_var;
 385  }
 386     /// <summary>If true will automatically close resources on exec() calls.
 387     /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 388     /// (Since EFL 1.22)</summary>
 389     /// <returns><c>true</c> if close on exec(), <c>false</c> otherwise</returns>
 390     virtual public bool GetCloseOnExec() {
 391          var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 392         Eina.Error.RaiseIfUnhandledException();
 393         return _ret_var;
 394  }
 395     /// <summary>If <c>true</c>, will close on exec() call.
 396     /// (Since EFL 1.22)</summary>
 397     /// <param name="close_on_exec"><c>true</c> if close on exec(), <c>false</c> otherwise</param>
 398     /// <returns><c>true</c> if could set, <c>false</c> if not supported or failed.</returns>
 399     virtual public bool SetCloseOnExec(bool close_on_exec) {
 400                                  var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_exec_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),close_on_exec);
 401         Eina.Error.RaiseIfUnhandledException();
 402                         return _ret_var;
 403  }
 404     /// <summary>If true will automatically close() on object invalidate.
 405     /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
 406     /// (Since EFL 1.22)</summary>
 407     /// <returns><c>true</c> if close on invalidate, <c>false</c> otherwise</returns>
 408     virtual public bool GetCloseOnInvalidate() {
 409          var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 410         Eina.Error.RaiseIfUnhandledException();
 411         return _ret_var;
 412  }
 413     /// <summary>If true will automatically close() on object invalidate.
 414     /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
 415     /// (Since EFL 1.22)</summary>
 416     /// <param name="close_on_invalidate"><c>true</c> if close on invalidate, <c>false</c> otherwise</param>
 417     virtual public void SetCloseOnInvalidate(bool close_on_invalidate) {
 418                                  Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),close_on_invalidate);
 419         Eina.Error.RaiseIfUnhandledException();
 420                          }
 421     /// <summary>Closes the Input/Output object.
 422     /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
 423     ///
 424     /// You can understand this method as close(2) libc function.
 425     /// (Since EFL 1.22)</summary>
 426     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 427     virtual public Eina.Error Close() {
 428          var _ret_var = Efl.Io.ICloserConcrete.NativeMethods.efl_io_closer_close_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 429         Eina.Error.RaiseIfUnhandledException();
 430         return _ret_var;
 431  }
 432     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 433     /// (Since EFL 1.22)</summary>
 434     /// <returns><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</returns>
 435     virtual public bool GetCanRead() {
 436          var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 437         Eina.Error.RaiseIfUnhandledException();
 438         return _ret_var;
 439  }
 440     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 441     /// (Since EFL 1.22)</summary>
 442     /// <param name="can_read"><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</param>
 443     virtual public void SetCanRead(bool can_read) {
 444                                  Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_can_read_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),can_read);
 445         Eina.Error.RaiseIfUnhandledException();
 446                          }
 447     /// <summary>If <c>true</c> will notify end of stream.
 448     /// (Since EFL 1.22)</summary>
 449     /// <returns><c>true</c> if end of stream, <c>false</c> otherwise</returns>
 450     virtual public bool GetEos() {
 451          var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 452         Eina.Error.RaiseIfUnhandledException();
 453         return _ret_var;
 454  }
 455     /// <summary>If <c>true</c> will notify end of stream.
 456     /// (Since EFL 1.22)</summary>
 457     /// <param name="is_eos"><c>true</c> if end of stream, <c>false</c> otherwise</param>
 458     virtual public void SetEos(bool is_eos) {
 459                                  Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_eos_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),is_eos);
 460         Eina.Error.RaiseIfUnhandledException();
 461                          }
 462     /// <summary>Reads data into a pre-allocated buffer.
 463     /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is to be defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
 464     ///
 465     /// You can understand this method as read(2) libc function.
 466     /// (Since EFL 1.22)</summary>
 467     /// <param name="rw_slice">Provides a pre-allocated memory to be filled up to rw_slice.len. It will be populated and the length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
 468     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 469     virtual public Eina.Error Read(ref  Eina.RwSlice rw_slice) {
 470                                  var _ret_var = Efl.Io.IReaderConcrete.NativeMethods.efl_io_reader_read_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ref rw_slice);
 471         Eina.Error.RaiseIfUnhandledException();
 472                         return _ret_var;
 473  }
 474     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 475     /// (Since EFL 1.22)</summary>
 476     /// <returns><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</returns>
 477     virtual public bool GetCanWrite() {
 478          var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_get_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)));
 479         Eina.Error.RaiseIfUnhandledException();
 480         return _ret_var;
 481  }
 482     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 483     /// (Since EFL 1.22)</summary>
 484     /// <param name="can_write"><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</param>
 485     virtual public void SetCanWrite(bool can_write) {
 486                                  Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_can_write_set_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),can_write);
 487         Eina.Error.RaiseIfUnhandledException();
 488                          }
 489     /// <summary>Writes data from a pre-populated buffer.
 490     /// This operation will be executed immediately and may or may not block the caller thread for some time. The details of blocking behavior is defined by the implementation and may be subject to other parameters such as non-blocking flags, maximum timeout or even retry attempts.
 491     ///
 492     /// You can understand this method as write(2) libc function.
 493     /// (Since EFL 1.22)</summary>
 494     /// <param name="slice">Provides a pre-populated memory to be used up to slice.len. The returned slice will be adapted as length will be set to the actually used amount of bytes, which can be smaller than the request.</param>
 495     /// <param name="remaining">Convenience to output the remaining parts of slice that was not written. If the full slice was written, this will be a slice of zero-length.</param>
 496     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 497     virtual public Eina.Error Write(ref  Eina.Slice slice, ref  Eina.Slice remaining) {
 498                                                          var _ret_var = Efl.Io.IWriterConcrete.NativeMethods.efl_io_writer_write_ptr.Value.Delegate((IsGeneratedBindingClass ? this.NativeHandle : Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass)),ref slice, ref remaining);
 499         Eina.Error.RaiseIfUnhandledException();
 500                                         return _ret_var;
 501  }
 502     /// <value>No description supplied.</value>
 503     public System.IntPtr Indata {
 504         get { return GetIndata(); }
 505         set { SetIndata(value); }
 506     }
 507     /// <value>No description supplied.</value>
 508     public System.IntPtr Outdata {
 509         get { return GetOutdata(); }
 510         set { SetOutdata(value); }
 511     }
 512     /// <summary>A commandline that encodes arguments in a command string. This command is unix shell-style, thus whitespace separates arguments unless escaped. Also a semi-colon &apos;;&apos;, ampersand &apos;&amp;&apos;, pipe/bar &apos;|&apos;, hash &apos;#&apos;, bracket, square brace, brace character (&apos;(&apos;, &apos;)&apos;, &apos;[&apos;, &apos;]&apos;, &apos;{&apos;, &apos;}&apos;), exclamation mark &apos;!&apos;,  backquote &apos;`&apos;, greator or less than (&apos;&gt;&apos; &apos;&lt;&apos;) character unless escaped or in quotes would cause args_count/value to not be generated properly, because it would force complex shell interpretation which will not be supported in evaluating the arg_count/value information, but the final shell may interpret this if this is executed via a command-line shell. To not be a complex shell command, it should be simple with paths, options and variable expansions, but nothing more complex involving the above unescaped characters.
 513     /// &quot;cat -option /path/file&quot; &quot;cat &apos;quoted argument&apos;&quot; &quot;cat ~/path/escaped argument&quot; &quot;/bin/cat escaped argument <c>VARIABLE</c>&quot; etc.
 514     ///
 515     /// It should not try and use &quot;complex shell features&quot; if you want the arg_count and arg_value set to be correct after setting the command string. For example none of:
 516     ///
 517     /// &quot;VAR=x /bin/command &amp;&amp; /bin/othercommand &gt;&amp; /dev/null&quot; &quot;VAR=x /bin/command `/bin/othercommand` | /bin/cmd2 &amp;&amp; cmd3 &amp;&quot; etc.
 518     ///
 519     /// If you set the command the arg_count/value property contents can change and be completely re-evaluated by parsing the command string into an argument array set along with interpreting escapes back into individual argument strings.</summary>
 520     public System.String Command {
 521         get { return GetCommand(); }
 522     }
 523     /// <summary>Use an array to fill this object
 524     /// Every element of a string is a argument.</summary>
 525     /// <value>An array where every array field is an argument</value>
 526     public Eina.Array<Eina.Stringshare> CommandArray {
 527         set { SetCommandArray(value); }
 528     }
 529     /// <summary>Use a string to fill this object
 530     /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 531     /// <value>A command in form of a string</value>
 532     public System.String CommandString {
 533         set { SetCommandString(value); }
 534     }
 535     /// <summary>If true will notify object was closed.
 536     /// (Since EFL 1.22)</summary>
 537     /// <value><c>true</c> if closed, <c>false</c> otherwise</value>
 538     public bool Closed {
 539         get { return GetClosed(); }
 540     }
 541     /// <summary>If true will automatically close resources on exec() calls.
 542     /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 543     /// (Since EFL 1.22)</summary>
 544     /// <value><c>true</c> if close on exec(), <c>false</c> otherwise</value>
 545     public bool CloseOnExec {
 546         get { return GetCloseOnExec(); }
 547         set { SetCloseOnExec(value); }
 548     }
 549     /// <summary>If true will automatically close() on object invalidate.
 550     /// If the object was disconnected from its parent (including the main loop) without close, this property will state whenever it should be closed or not.
 551     /// (Since EFL 1.22)</summary>
 552     /// <value><c>true</c> if close on invalidate, <c>false</c> otherwise</value>
 553     public bool CloseOnInvalidate {
 554         get { return GetCloseOnInvalidate(); }
 555         set { SetCloseOnInvalidate(value); }
 556     }
 557     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 558     /// (Since EFL 1.22)</summary>
 559     /// <value><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</value>
 560     public bool CanRead {
 561         get { return GetCanRead(); }
 562         set { SetCanRead(value); }
 563     }
 564     /// <summary>If <c>true</c> will notify end of stream.
 565     /// (Since EFL 1.22)</summary>
 566     /// <value><c>true</c> if end of stream, <c>false</c> otherwise</value>
 567     public bool Eos {
 568         get { return GetEos(); }
 569         set { SetEos(value); }
 570     }
 571     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 572     /// (Since EFL 1.22)</summary>
 573     /// <value><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</value>
 574     public bool CanWrite {
 575         get { return GetCanWrite(); }
 576         set { SetCanWrite(value); }
 577     }
 578     private static IntPtr GetEflClassStatic()
 579     {
 580         return Efl.Thread.efl_thread_class_get();
 581     }
 582     /// <summary>Wrapper for native methods and virtual method delegates.
 583     /// For internal use by generated code only.</summary>
 584     public new class NativeMethods : Efl.Task.NativeMethods
 585     {
 586         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Ecore);
 587         /// <summary>Gets the list of Eo operations to override.</summary>
 588         /// <returns>The list of Eo operations to be overload.</returns>
 589         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 590         {
 591             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 592             var methods = Efl.Eo.Globals.GetUserMethods(type);
 593
 594             if (efl_threadio_indata_get_static_delegate == null)
 595             {
 596                 efl_threadio_indata_get_static_delegate = new efl_threadio_indata_get_delegate(indata_get);
 597             }
 598
 599             if (methods.FirstOrDefault(m => m.Name == "GetIndata") != null)
 600             {
 601                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_indata_get"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_indata_get_static_delegate) });
 602             }
 603
 604             if (efl_threadio_indata_set_static_delegate == null)
 605             {
 606                 efl_threadio_indata_set_static_delegate = new efl_threadio_indata_set_delegate(indata_set);
 607             }
 608
 609             if (methods.FirstOrDefault(m => m.Name == "SetIndata") != null)
 610             {
 611                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_indata_set"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_indata_set_static_delegate) });
 612             }
 613
 614             if (efl_threadio_outdata_get_static_delegate == null)
 615             {
 616                 efl_threadio_outdata_get_static_delegate = new efl_threadio_outdata_get_delegate(outdata_get);
 617             }
 618
 619             if (methods.FirstOrDefault(m => m.Name == "GetOutdata") != null)
 620             {
 621                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_outdata_get"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_outdata_get_static_delegate) });
 622             }
 623
 624             if (efl_threadio_outdata_set_static_delegate == null)
 625             {
 626                 efl_threadio_outdata_set_static_delegate = new efl_threadio_outdata_set_delegate(outdata_set);
 627             }
 628
 629             if (methods.FirstOrDefault(m => m.Name == "SetOutdata") != null)
 630             {
 631                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_outdata_set"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_outdata_set_static_delegate) });
 632             }
 633
 634             if (efl_threadio_call_static_delegate == null)
 635             {
 636                 efl_threadio_call_static_delegate = new efl_threadio_call_delegate(call);
 637             }
 638
 639             if (methods.FirstOrDefault(m => m.Name == "Call") != null)
 640             {
 641                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_call"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_call_static_delegate) });
 642             }
 643
 644             if (efl_threadio_call_sync_static_delegate == null)
 645             {
 646                 efl_threadio_call_sync_static_delegate = new efl_threadio_call_sync_delegate(call_sync);
 647             }
 648
 649             if (methods.FirstOrDefault(m => m.Name == "CallSync") != null)
 650             {
 651                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_threadio_call_sync"), func = Marshal.GetFunctionPointerForDelegate(efl_threadio_call_sync_static_delegate) });
 652             }
 653
 654             if (efl_core_command_line_command_get_static_delegate == null)
 655             {
 656                 efl_core_command_line_command_get_static_delegate = new efl_core_command_line_command_get_delegate(command_get);
 657             }
 658
 659             if (methods.FirstOrDefault(m => m.Name == "GetCommand") != null)
 660             {
 661                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_get"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_get_static_delegate) });
 662             }
 663
 664             if (efl_core_command_line_command_array_set_static_delegate == null)
 665             {
 666                 efl_core_command_line_command_array_set_static_delegate = new efl_core_command_line_command_array_set_delegate(command_array_set);
 667             }
 668
 669             if (methods.FirstOrDefault(m => m.Name == "SetCommandArray") != null)
 670             {
 671                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_array_set"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_array_set_static_delegate) });
 672             }
 673
 674             if (efl_core_command_line_command_string_set_static_delegate == null)
 675             {
 676                 efl_core_command_line_command_string_set_static_delegate = new efl_core_command_line_command_string_set_delegate(command_string_set);
 677             }
 678
 679             if (methods.FirstOrDefault(m => m.Name == "SetCommandString") != null)
 680             {
 681                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_string_set"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_string_set_static_delegate) });
 682             }
 683
 684             if (efl_core_command_line_command_access_static_delegate == null)
 685             {
 686                 efl_core_command_line_command_access_static_delegate = new efl_core_command_line_command_access_delegate(command_access);
 687             }
 688
 689             if (methods.FirstOrDefault(m => m.Name == "CommandAccess") != null)
 690             {
 691                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_core_command_line_command_access"), func = Marshal.GetFunctionPointerForDelegate(efl_core_command_line_command_access_static_delegate) });
 692             }
 693
 694             if (efl_io_closer_closed_get_static_delegate == null)
 695             {
 696                 efl_io_closer_closed_get_static_delegate = new efl_io_closer_closed_get_delegate(closed_get);
 697             }
 698
 699             if (methods.FirstOrDefault(m => m.Name == "GetClosed") != null)
 700             {
 701                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_closed_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_closed_get_static_delegate) });
 702             }
 703
 704             if (efl_io_closer_close_on_exec_get_static_delegate == null)
 705             {
 706                 efl_io_closer_close_on_exec_get_static_delegate = new efl_io_closer_close_on_exec_get_delegate(close_on_exec_get);
 707             }
 708
 709             if (methods.FirstOrDefault(m => m.Name == "GetCloseOnExec") != null)
 710             {
 711                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_get_static_delegate) });
 712             }
 713
 714             if (efl_io_closer_close_on_exec_set_static_delegate == null)
 715             {
 716                 efl_io_closer_close_on_exec_set_static_delegate = new efl_io_closer_close_on_exec_set_delegate(close_on_exec_set);
 717             }
 718
 719             if (methods.FirstOrDefault(m => m.Name == "SetCloseOnExec") != null)
 720             {
 721                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_exec_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_exec_set_static_delegate) });
 722             }
 723
 724             if (efl_io_closer_close_on_invalidate_get_static_delegate == null)
 725             {
 726                 efl_io_closer_close_on_invalidate_get_static_delegate = new efl_io_closer_close_on_invalidate_get_delegate(close_on_invalidate_get);
 727             }
 728
 729             if (methods.FirstOrDefault(m => m.Name == "GetCloseOnInvalidate") != null)
 730             {
 731                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_get_static_delegate) });
 732             }
 733
 734             if (efl_io_closer_close_on_invalidate_set_static_delegate == null)
 735             {
 736                 efl_io_closer_close_on_invalidate_set_static_delegate = new efl_io_closer_close_on_invalidate_set_delegate(close_on_invalidate_set);
 737             }
 738
 739             if (methods.FirstOrDefault(m => m.Name == "SetCloseOnInvalidate") != null)
 740             {
 741                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close_on_invalidate_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_on_invalidate_set_static_delegate) });
 742             }
 743
 744             if (efl_io_closer_close_static_delegate == null)
 745             {
 746                 efl_io_closer_close_static_delegate = new efl_io_closer_close_delegate(close);
 747             }
 748
 749             if (methods.FirstOrDefault(m => m.Name == "Close") != null)
 750             {
 751                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_closer_close"), func = Marshal.GetFunctionPointerForDelegate(efl_io_closer_close_static_delegate) });
 752             }
 753
 754             if (efl_io_reader_can_read_get_static_delegate == null)
 755             {
 756                 efl_io_reader_can_read_get_static_delegate = new efl_io_reader_can_read_get_delegate(can_read_get);
 757             }
 758
 759             if (methods.FirstOrDefault(m => m.Name == "GetCanRead") != null)
 760             {
 761                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_get_static_delegate) });
 762             }
 763
 764             if (efl_io_reader_can_read_set_static_delegate == null)
 765             {
 766                 efl_io_reader_can_read_set_static_delegate = new efl_io_reader_can_read_set_delegate(can_read_set);
 767             }
 768
 769             if (methods.FirstOrDefault(m => m.Name == "SetCanRead") != null)
 770             {
 771                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_can_read_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_can_read_set_static_delegate) });
 772             }
 773
 774             if (efl_io_reader_eos_get_static_delegate == null)
 775             {
 776                 efl_io_reader_eos_get_static_delegate = new efl_io_reader_eos_get_delegate(eos_get);
 777             }
 778
 779             if (methods.FirstOrDefault(m => m.Name == "GetEos") != null)
 780             {
 781                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_get_static_delegate) });
 782             }
 783
 784             if (efl_io_reader_eos_set_static_delegate == null)
 785             {
 786                 efl_io_reader_eos_set_static_delegate = new efl_io_reader_eos_set_delegate(eos_set);
 787             }
 788
 789             if (methods.FirstOrDefault(m => m.Name == "SetEos") != null)
 790             {
 791                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_eos_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_eos_set_static_delegate) });
 792             }
 793
 794             if (efl_io_reader_read_static_delegate == null)
 795             {
 796                 efl_io_reader_read_static_delegate = new efl_io_reader_read_delegate(read);
 797             }
 798
 799             if (methods.FirstOrDefault(m => m.Name == "Read") != null)
 800             {
 801                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_reader_read"), func = Marshal.GetFunctionPointerForDelegate(efl_io_reader_read_static_delegate) });
 802             }
 803
 804             if (efl_io_writer_can_write_get_static_delegate == null)
 805             {
 806                 efl_io_writer_can_write_get_static_delegate = new efl_io_writer_can_write_get_delegate(can_write_get);
 807             }
 808
 809             if (methods.FirstOrDefault(m => m.Name == "GetCanWrite") != null)
 810             {
 811                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_get_static_delegate) });
 812             }
 813
 814             if (efl_io_writer_can_write_set_static_delegate == null)
 815             {
 816                 efl_io_writer_can_write_set_static_delegate = new efl_io_writer_can_write_set_delegate(can_write_set);
 817             }
 818
 819             if (methods.FirstOrDefault(m => m.Name == "SetCanWrite") != null)
 820             {
 821                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_can_write_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_can_write_set_static_delegate) });
 822             }
 823
 824             if (efl_io_writer_write_static_delegate == null)
 825             {
 826                 efl_io_writer_write_static_delegate = new efl_io_writer_write_delegate(write);
 827             }
 828
 829             if (methods.FirstOrDefault(m => m.Name == "Write") != null)
 830             {
 831                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_writer_write"), func = Marshal.GetFunctionPointerForDelegate(efl_io_writer_write_static_delegate) });
 832             }
 833
 834             descs.AddRange(base.GetEoOps(type));
 835             return descs;
 836         }
 837         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 838         /// <returns>The native class pointer.</returns>
 839         public override IntPtr GetEflClass()
 840         {
 841             return Efl.Thread.efl_thread_class_get();
 842         }
 843
 844         #pragma warning disable CA1707, CS1591, SA1300, SA1600
 845
 846
 847         private delegate System.IntPtr efl_threadio_indata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 848
 849
 850         public delegate System.IntPtr efl_threadio_indata_get_api_delegate(System.IntPtr obj);
 851
 852         public static Efl.Eo.FunctionWrapper<efl_threadio_indata_get_api_delegate> efl_threadio_indata_get_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_indata_get_api_delegate>(Module, "efl_threadio_indata_get");
 853
 854         private static System.IntPtr indata_get(System.IntPtr obj, System.IntPtr pd)
 855         {
 856             Eina.Log.Debug("function efl_threadio_indata_get was called");
 857             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 858             if (ws != null)
 859             {
 860             System.IntPtr _ret_var = default(System.IntPtr);
 861                 try
 862                 {
 863                     _ret_var = ((Thread)ws.Target).GetIndata();
 864                 }
 865                 catch (Exception e)
 866                 {
 867                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 868                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 869                 }
 870
 871         return _ret_var;
 872
 873             }
 874             else
 875             {
 876                 return efl_threadio_indata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 877             }
 878         }
 879
 880         private static efl_threadio_indata_get_delegate efl_threadio_indata_get_static_delegate;
 881
 882
 883         private delegate void efl_threadio_indata_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr data);
 884
 885
 886         public delegate void efl_threadio_indata_set_api_delegate(System.IntPtr obj,  System.IntPtr data);
 887
 888         public static Efl.Eo.FunctionWrapper<efl_threadio_indata_set_api_delegate> efl_threadio_indata_set_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_indata_set_api_delegate>(Module, "efl_threadio_indata_set");
 889
 890         private static void indata_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr data)
 891         {
 892             Eina.Log.Debug("function efl_threadio_indata_set was called");
 893             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 894             if (ws != null)
 895             {
 896
 897                 try
 898                 {
 899                     ((Thread)ws.Target).SetIndata(data);
 900                 }
 901                 catch (Exception e)
 902                 {
 903                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 904                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 905                 }
 906
 907
 908             }
 909             else
 910             {
 911                 efl_threadio_indata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), data);
 912             }
 913         }
 914
 915         private static efl_threadio_indata_set_delegate efl_threadio_indata_set_static_delegate;
 916
 917
 918         private delegate System.IntPtr efl_threadio_outdata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 919
 920
 921         public delegate System.IntPtr efl_threadio_outdata_get_api_delegate(System.IntPtr obj);
 922
 923         public static Efl.Eo.FunctionWrapper<efl_threadio_outdata_get_api_delegate> efl_threadio_outdata_get_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_outdata_get_api_delegate>(Module, "efl_threadio_outdata_get");
 924
 925         private static System.IntPtr outdata_get(System.IntPtr obj, System.IntPtr pd)
 926         {
 927             Eina.Log.Debug("function efl_threadio_outdata_get was called");
 928             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 929             if (ws != null)
 930             {
 931             System.IntPtr _ret_var = default(System.IntPtr);
 932                 try
 933                 {
 934                     _ret_var = ((Thread)ws.Target).GetOutdata();
 935                 }
 936                 catch (Exception e)
 937                 {
 938                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 939                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 940                 }
 941
 942         return _ret_var;
 943
 944             }
 945             else
 946             {
 947                 return efl_threadio_outdata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 948             }
 949         }
 950
 951         private static efl_threadio_outdata_get_delegate efl_threadio_outdata_get_static_delegate;
 952
 953
 954         private delegate void efl_threadio_outdata_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr data);
 955
 956
 957         public delegate void efl_threadio_outdata_set_api_delegate(System.IntPtr obj,  System.IntPtr data);
 958
 959         public static Efl.Eo.FunctionWrapper<efl_threadio_outdata_set_api_delegate> efl_threadio_outdata_set_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_outdata_set_api_delegate>(Module, "efl_threadio_outdata_set");
 960
 961         private static void outdata_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr data)
 962         {
 963             Eina.Log.Debug("function efl_threadio_outdata_set was called");
 964             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
 965             if (ws != null)
 966             {
 967
 968                 try
 969                 {
 970                     ((Thread)ws.Target).SetOutdata(data);
 971                 }
 972                 catch (Exception e)
 973                 {
 974                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 975                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 976                 }
 977
 978
 979             }
 980             else
 981             {
 982                 efl_threadio_outdata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), data);
 983             }
 984         }
 985
 986         private static efl_threadio_outdata_set_delegate efl_threadio_outdata_set_static_delegate;
 987
 988
 989         private delegate void efl_threadio_call_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 990
 991
 992         public delegate void efl_threadio_call_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 993
 994         public static Efl.Eo.FunctionWrapper<efl_threadio_call_api_delegate> efl_threadio_call_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_call_api_delegate>(Module, "efl_threadio_call");
 995
 996         private static void call(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb)
 997         {
 998             Eina.Log.Debug("function efl_threadio_call was called");
 999             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1000             if (ws != null)
1001             {
1002                             EFlThreadIOCallWrapper func_wrapper = new EFlThreadIOCallWrapper(func, func_data, func_free_cb);
1003
1004                 try
1005                 {
1006                     ((Thread)ws.Target).Call(func_wrapper.ManagedCb);
1007                 }
1008                 catch (Exception e)
1009                 {
1010                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1011                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1012                 }
1013
1014
1015             }
1016             else
1017             {
1018                 efl_threadio_call_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
1019             }
1020         }
1021
1022         private static efl_threadio_call_delegate efl_threadio_call_static_delegate;
1023
1024
1025         private delegate System.IntPtr efl_threadio_call_sync_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
1026
1027
1028         public delegate System.IntPtr efl_threadio_call_sync_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
1029
1030         public static Efl.Eo.FunctionWrapper<efl_threadio_call_sync_api_delegate> efl_threadio_call_sync_ptr = new Efl.Eo.FunctionWrapper<efl_threadio_call_sync_api_delegate>(Module, "efl_threadio_call_sync");
1031
1032         private static System.IntPtr call_sync(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb)
1033         {
1034             Eina.Log.Debug("function efl_threadio_call_sync was called");
1035             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1036             if (ws != null)
1037             {
1038                             EFlThreadIOCallSyncWrapper func_wrapper = new EFlThreadIOCallSyncWrapper(func, func_data, func_free_cb);
1039             System.IntPtr _ret_var = default(System.IntPtr);
1040                 try
1041                 {
1042                     _ret_var = ((Thread)ws.Target).CallSync(func_wrapper.ManagedCb);
1043                 }
1044                 catch (Exception e)
1045                 {
1046                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1047                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1048                 }
1049
1050                         return _ret_var;
1051
1052             }
1053             else
1054             {
1055                 return efl_threadio_call_sync_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), func_data, func, func_free_cb);
1056             }
1057         }
1058
1059         private static efl_threadio_call_sync_delegate efl_threadio_call_sync_static_delegate;
1060
1061         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1062         private delegate System.String efl_core_command_line_command_get_delegate(System.IntPtr obj, System.IntPtr pd);
1063
1064         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
1065         public delegate System.String efl_core_command_line_command_get_api_delegate(System.IntPtr obj);
1066
1067         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_get_api_delegate> efl_core_command_line_command_get_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_get_api_delegate>(Module, "efl_core_command_line_command_get");
1068
1069         private static System.String command_get(System.IntPtr obj, System.IntPtr pd)
1070         {
1071             Eina.Log.Debug("function efl_core_command_line_command_get was called");
1072             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1073             if (ws != null)
1074             {
1075             System.String _ret_var = default(System.String);
1076                 try
1077                 {
1078                     _ret_var = ((Thread)ws.Target).GetCommand();
1079                 }
1080                 catch (Exception e)
1081                 {
1082                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1083                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1084                 }
1085
1086         return _ret_var;
1087
1088             }
1089             else
1090             {
1091                 return efl_core_command_line_command_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1092             }
1093         }
1094
1095         private static efl_core_command_line_command_get_delegate efl_core_command_line_command_get_static_delegate;
1096
1097         [return: MarshalAs(UnmanagedType.U1)]
1098         private delegate bool efl_core_command_line_command_array_set_delegate(System.IntPtr obj, System.IntPtr pd,  System.IntPtr array);
1099
1100         [return: MarshalAs(UnmanagedType.U1)]
1101         public delegate bool efl_core_command_line_command_array_set_api_delegate(System.IntPtr obj,  System.IntPtr array);
1102
1103         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_array_set_api_delegate> efl_core_command_line_command_array_set_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_array_set_api_delegate>(Module, "efl_core_command_line_command_array_set");
1104
1105         private static bool command_array_set(System.IntPtr obj, System.IntPtr pd, System.IntPtr array)
1106         {
1107             Eina.Log.Debug("function efl_core_command_line_command_array_set was called");
1108             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1109             if (ws != null)
1110             {
1111         var _in_array = new Eina.Array<Eina.Stringshare>(array, true, true);
1112                             bool _ret_var = default(bool);
1113                 try
1114                 {
1115                     _ret_var = ((Thread)ws.Target).SetCommandArray(_in_array);
1116                 }
1117                 catch (Exception e)
1118                 {
1119                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1120                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1121                 }
1122
1123                         return _ret_var;
1124
1125             }
1126             else
1127             {
1128                 return efl_core_command_line_command_array_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), array);
1129             }
1130         }
1131
1132         private static efl_core_command_line_command_array_set_delegate efl_core_command_line_command_array_set_static_delegate;
1133
1134         [return: MarshalAs(UnmanagedType.U1)]
1135         private delegate bool efl_core_command_line_command_string_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String str);
1136
1137         [return: MarshalAs(UnmanagedType.U1)]
1138         public delegate bool efl_core_command_line_command_string_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String str);
1139
1140         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_string_set_api_delegate> efl_core_command_line_command_string_set_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_string_set_api_delegate>(Module, "efl_core_command_line_command_string_set");
1141
1142         private static bool command_string_set(System.IntPtr obj, System.IntPtr pd, System.String str)
1143         {
1144             Eina.Log.Debug("function efl_core_command_line_command_string_set was called");
1145             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1146             if (ws != null)
1147             {
1148                                     bool _ret_var = default(bool);
1149                 try
1150                 {
1151                     _ret_var = ((Thread)ws.Target).SetCommandString(str);
1152                 }
1153                 catch (Exception e)
1154                 {
1155                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1156                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1157                 }
1158
1159                         return _ret_var;
1160
1161             }
1162             else
1163             {
1164                 return efl_core_command_line_command_string_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), str);
1165             }
1166         }
1167
1168         private static efl_core_command_line_command_string_set_delegate efl_core_command_line_command_string_set_static_delegate;
1169
1170
1171         private delegate System.IntPtr efl_core_command_line_command_access_delegate(System.IntPtr obj, System.IntPtr pd);
1172
1173
1174         public delegate System.IntPtr efl_core_command_line_command_access_api_delegate(System.IntPtr obj);
1175
1176         public static Efl.Eo.FunctionWrapper<efl_core_command_line_command_access_api_delegate> efl_core_command_line_command_access_ptr = new Efl.Eo.FunctionWrapper<efl_core_command_line_command_access_api_delegate>(Module, "efl_core_command_line_command_access");
1177
1178         private static System.IntPtr command_access(System.IntPtr obj, System.IntPtr pd)
1179         {
1180             Eina.Log.Debug("function efl_core_command_line_command_access was called");
1181             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1182             if (ws != null)
1183             {
1184             Eina.Accessor<Eina.Stringshare> _ret_var = default(Eina.Accessor<Eina.Stringshare>);
1185                 try
1186                 {
1187                     _ret_var = ((Thread)ws.Target).CommandAccess();
1188                 }
1189                 catch (Exception e)
1190                 {
1191                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1192                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1193                 }
1194
1195         return _ret_var.Handle;
1196
1197             }
1198             else
1199             {
1200                 return efl_core_command_line_command_access_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1201             }
1202         }
1203
1204         private static efl_core_command_line_command_access_delegate efl_core_command_line_command_access_static_delegate;
1205
1206         [return: MarshalAs(UnmanagedType.U1)]
1207         private delegate bool efl_io_closer_closed_get_delegate(System.IntPtr obj, System.IntPtr pd);
1208
1209         [return: MarshalAs(UnmanagedType.U1)]
1210         public delegate bool efl_io_closer_closed_get_api_delegate(System.IntPtr obj);
1211
1212         public static Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate> efl_io_closer_closed_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_closed_get_api_delegate>(Module, "efl_io_closer_closed_get");
1213
1214         private static bool closed_get(System.IntPtr obj, System.IntPtr pd)
1215         {
1216             Eina.Log.Debug("function efl_io_closer_closed_get was called");
1217             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1218             if (ws != null)
1219             {
1220             bool _ret_var = default(bool);
1221                 try
1222                 {
1223                     _ret_var = ((Thread)ws.Target).GetClosed();
1224                 }
1225                 catch (Exception e)
1226                 {
1227                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1228                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1229                 }
1230
1231         return _ret_var;
1232
1233             }
1234             else
1235             {
1236                 return efl_io_closer_closed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1237             }
1238         }
1239
1240         private static efl_io_closer_closed_get_delegate efl_io_closer_closed_get_static_delegate;
1241
1242         [return: MarshalAs(UnmanagedType.U1)]
1243         private delegate bool efl_io_closer_close_on_exec_get_delegate(System.IntPtr obj, System.IntPtr pd);
1244
1245         [return: MarshalAs(UnmanagedType.U1)]
1246         public delegate bool efl_io_closer_close_on_exec_get_api_delegate(System.IntPtr obj);
1247
1248         public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate> efl_io_closer_close_on_exec_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_get_api_delegate>(Module, "efl_io_closer_close_on_exec_get");
1249
1250         private static bool close_on_exec_get(System.IntPtr obj, System.IntPtr pd)
1251         {
1252             Eina.Log.Debug("function efl_io_closer_close_on_exec_get was called");
1253             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1254             if (ws != null)
1255             {
1256             bool _ret_var = default(bool);
1257                 try
1258                 {
1259                     _ret_var = ((Thread)ws.Target).GetCloseOnExec();
1260                 }
1261                 catch (Exception e)
1262                 {
1263                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1264                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1265                 }
1266
1267         return _ret_var;
1268
1269             }
1270             else
1271             {
1272                 return efl_io_closer_close_on_exec_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1273             }
1274         }
1275
1276         private static efl_io_closer_close_on_exec_get_delegate efl_io_closer_close_on_exec_get_static_delegate;
1277
1278         [return: MarshalAs(UnmanagedType.U1)]
1279         private delegate bool efl_io_closer_close_on_exec_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
1280
1281         [return: MarshalAs(UnmanagedType.U1)]
1282         public delegate bool efl_io_closer_close_on_exec_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
1283
1284         public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate> efl_io_closer_close_on_exec_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_exec_set_api_delegate>(Module, "efl_io_closer_close_on_exec_set");
1285
1286         private static bool close_on_exec_set(System.IntPtr obj, System.IntPtr pd, bool close_on_exec)
1287         {
1288             Eina.Log.Debug("function efl_io_closer_close_on_exec_set was called");
1289             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1290             if (ws != null)
1291             {
1292                                     bool _ret_var = default(bool);
1293                 try
1294                 {
1295                     _ret_var = ((Thread)ws.Target).SetCloseOnExec(close_on_exec);
1296                 }
1297                 catch (Exception e)
1298                 {
1299                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1300                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1301                 }
1302
1303                         return _ret_var;
1304
1305             }
1306             else
1307             {
1308                 return efl_io_closer_close_on_exec_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_exec);
1309             }
1310         }
1311
1312         private static efl_io_closer_close_on_exec_set_delegate efl_io_closer_close_on_exec_set_static_delegate;
1313
1314         [return: MarshalAs(UnmanagedType.U1)]
1315         private delegate bool efl_io_closer_close_on_invalidate_get_delegate(System.IntPtr obj, System.IntPtr pd);
1316
1317         [return: MarshalAs(UnmanagedType.U1)]
1318         public delegate bool efl_io_closer_close_on_invalidate_get_api_delegate(System.IntPtr obj);
1319
1320         public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate> efl_io_closer_close_on_invalidate_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_get_api_delegate>(Module, "efl_io_closer_close_on_invalidate_get");
1321
1322         private static bool close_on_invalidate_get(System.IntPtr obj, System.IntPtr pd)
1323         {
1324             Eina.Log.Debug("function efl_io_closer_close_on_invalidate_get was called");
1325             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1326             if (ws != null)
1327             {
1328             bool _ret_var = default(bool);
1329                 try
1330                 {
1331                     _ret_var = ((Thread)ws.Target).GetCloseOnInvalidate();
1332                 }
1333                 catch (Exception e)
1334                 {
1335                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1336                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1337                 }
1338
1339         return _ret_var;
1340
1341             }
1342             else
1343             {
1344                 return efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1345             }
1346         }
1347
1348         private static efl_io_closer_close_on_invalidate_get_delegate efl_io_closer_close_on_invalidate_get_static_delegate;
1349
1350
1351         private delegate void efl_io_closer_close_on_invalidate_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
1352
1353
1354         public delegate void efl_io_closer_close_on_invalidate_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
1355
1356         public static Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate> efl_io_closer_close_on_invalidate_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_on_invalidate_set_api_delegate>(Module, "efl_io_closer_close_on_invalidate_set");
1357
1358         private static void close_on_invalidate_set(System.IntPtr obj, System.IntPtr pd, bool close_on_invalidate)
1359         {
1360             Eina.Log.Debug("function efl_io_closer_close_on_invalidate_set was called");
1361             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1362             if (ws != null)
1363             {
1364
1365                 try
1366                 {
1367                     ((Thread)ws.Target).SetCloseOnInvalidate(close_on_invalidate);
1368                 }
1369                 catch (Exception e)
1370                 {
1371                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1372                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1373                 }
1374
1375
1376             }
1377             else
1378             {
1379                 efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), close_on_invalidate);
1380             }
1381         }
1382
1383         private static efl_io_closer_close_on_invalidate_set_delegate efl_io_closer_close_on_invalidate_set_static_delegate;
1384
1385
1386         private delegate Eina.Error efl_io_closer_close_delegate(System.IntPtr obj, System.IntPtr pd);
1387
1388
1389         public delegate Eina.Error efl_io_closer_close_api_delegate(System.IntPtr obj);
1390
1391         public static Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate> efl_io_closer_close_ptr = new Efl.Eo.FunctionWrapper<efl_io_closer_close_api_delegate>(Module, "efl_io_closer_close");
1392
1393         private static Eina.Error close(System.IntPtr obj, System.IntPtr pd)
1394         {
1395             Eina.Log.Debug("function efl_io_closer_close was called");
1396             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1397             if (ws != null)
1398             {
1399             Eina.Error _ret_var = default(Eina.Error);
1400                 try
1401                 {
1402                     _ret_var = ((Thread)ws.Target).Close();
1403                 }
1404                 catch (Exception e)
1405                 {
1406                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1407                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1408                 }
1409
1410         return _ret_var;
1411
1412             }
1413             else
1414             {
1415                 return efl_io_closer_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1416             }
1417         }
1418
1419         private static efl_io_closer_close_delegate efl_io_closer_close_static_delegate;
1420
1421         [return: MarshalAs(UnmanagedType.U1)]
1422         private delegate bool efl_io_reader_can_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
1423
1424         [return: MarshalAs(UnmanagedType.U1)]
1425         public delegate bool efl_io_reader_can_read_get_api_delegate(System.IntPtr obj);
1426
1427         public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate> efl_io_reader_can_read_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_get_api_delegate>(Module, "efl_io_reader_can_read_get");
1428
1429         private static bool can_read_get(System.IntPtr obj, System.IntPtr pd)
1430         {
1431             Eina.Log.Debug("function efl_io_reader_can_read_get was called");
1432             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1433             if (ws != null)
1434             {
1435             bool _ret_var = default(bool);
1436                 try
1437                 {
1438                     _ret_var = ((Thread)ws.Target).GetCanRead();
1439                 }
1440                 catch (Exception e)
1441                 {
1442                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1443                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1444                 }
1445
1446         return _ret_var;
1447
1448             }
1449             else
1450             {
1451                 return efl_io_reader_can_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1452             }
1453         }
1454
1455         private static efl_io_reader_can_read_get_delegate efl_io_reader_can_read_get_static_delegate;
1456
1457
1458         private delegate void efl_io_reader_can_read_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_read);
1459
1460
1461         public delegate void efl_io_reader_can_read_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_read);
1462
1463         public static Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate> efl_io_reader_can_read_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_can_read_set_api_delegate>(Module, "efl_io_reader_can_read_set");
1464
1465         private static void can_read_set(System.IntPtr obj, System.IntPtr pd, bool can_read)
1466         {
1467             Eina.Log.Debug("function efl_io_reader_can_read_set was called");
1468             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1469             if (ws != null)
1470             {
1471
1472                 try
1473                 {
1474                     ((Thread)ws.Target).SetCanRead(can_read);
1475                 }
1476                 catch (Exception e)
1477                 {
1478                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1479                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1480                 }
1481
1482
1483             }
1484             else
1485             {
1486                 efl_io_reader_can_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_read);
1487             }
1488         }
1489
1490         private static efl_io_reader_can_read_set_delegate efl_io_reader_can_read_set_static_delegate;
1491
1492         [return: MarshalAs(UnmanagedType.U1)]
1493         private delegate bool efl_io_reader_eos_get_delegate(System.IntPtr obj, System.IntPtr pd);
1494
1495         [return: MarshalAs(UnmanagedType.U1)]
1496         public delegate bool efl_io_reader_eos_get_api_delegate(System.IntPtr obj);
1497
1498         public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate> efl_io_reader_eos_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_get_api_delegate>(Module, "efl_io_reader_eos_get");
1499
1500         private static bool eos_get(System.IntPtr obj, System.IntPtr pd)
1501         {
1502             Eina.Log.Debug("function efl_io_reader_eos_get was called");
1503             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1504             if (ws != null)
1505             {
1506             bool _ret_var = default(bool);
1507                 try
1508                 {
1509                     _ret_var = ((Thread)ws.Target).GetEos();
1510                 }
1511                 catch (Exception e)
1512                 {
1513                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1514                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1515                 }
1516
1517         return _ret_var;
1518
1519             }
1520             else
1521             {
1522                 return efl_io_reader_eos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1523             }
1524         }
1525
1526         private static efl_io_reader_eos_get_delegate efl_io_reader_eos_get_static_delegate;
1527
1528
1529         private delegate void efl_io_reader_eos_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool is_eos);
1530
1531
1532         public delegate void efl_io_reader_eos_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool is_eos);
1533
1534         public static Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate> efl_io_reader_eos_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_eos_set_api_delegate>(Module, "efl_io_reader_eos_set");
1535
1536         private static void eos_set(System.IntPtr obj, System.IntPtr pd, bool is_eos)
1537         {
1538             Eina.Log.Debug("function efl_io_reader_eos_set was called");
1539             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1540             if (ws != null)
1541             {
1542
1543                 try
1544                 {
1545                     ((Thread)ws.Target).SetEos(is_eos);
1546                 }
1547                 catch (Exception e)
1548                 {
1549                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1550                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1551                 }
1552
1553
1554             }
1555             else
1556             {
1557                 efl_io_reader_eos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), is_eos);
1558             }
1559         }
1560
1561         private static efl_io_reader_eos_set_delegate efl_io_reader_eos_set_static_delegate;
1562
1563
1564         private delegate Eina.Error efl_io_reader_read_delegate(System.IntPtr obj, System.IntPtr pd,  ref  Eina.RwSlice rw_slice);
1565
1566
1567         public delegate Eina.Error efl_io_reader_read_api_delegate(System.IntPtr obj,  ref  Eina.RwSlice rw_slice);
1568
1569         public static Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate> efl_io_reader_read_ptr = new Efl.Eo.FunctionWrapper<efl_io_reader_read_api_delegate>(Module, "efl_io_reader_read");
1570
1571         private static Eina.Error read(System.IntPtr obj, System.IntPtr pd, ref  Eina.RwSlice rw_slice)
1572         {
1573             Eina.Log.Debug("function efl_io_reader_read was called");
1574             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1575             if (ws != null)
1576             {
1577                                     Eina.Error _ret_var = default(Eina.Error);
1578                 try
1579                 {
1580                     _ret_var = ((Thread)ws.Target).Read(ref rw_slice);
1581                 }
1582                 catch (Exception e)
1583                 {
1584                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1585                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1586                 }
1587
1588                         return _ret_var;
1589
1590             }
1591             else
1592             {
1593                 return efl_io_reader_read_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref rw_slice);
1594             }
1595         }
1596
1597         private static efl_io_reader_read_delegate efl_io_reader_read_static_delegate;
1598
1599         [return: MarshalAs(UnmanagedType.U1)]
1600         private delegate bool efl_io_writer_can_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
1601
1602         [return: MarshalAs(UnmanagedType.U1)]
1603         public delegate bool efl_io_writer_can_write_get_api_delegate(System.IntPtr obj);
1604
1605         public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate> efl_io_writer_can_write_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_get_api_delegate>(Module, "efl_io_writer_can_write_get");
1606
1607         private static bool can_write_get(System.IntPtr obj, System.IntPtr pd)
1608         {
1609             Eina.Log.Debug("function efl_io_writer_can_write_get was called");
1610             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1611             if (ws != null)
1612             {
1613             bool _ret_var = default(bool);
1614                 try
1615                 {
1616                     _ret_var = ((Thread)ws.Target).GetCanWrite();
1617                 }
1618                 catch (Exception e)
1619                 {
1620                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1621                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1622                 }
1623
1624         return _ret_var;
1625
1626             }
1627             else
1628             {
1629                 return efl_io_writer_can_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1630             }
1631         }
1632
1633         private static efl_io_writer_can_write_get_delegate efl_io_writer_can_write_get_static_delegate;
1634
1635
1636         private delegate void efl_io_writer_can_write_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_write);
1637
1638
1639         public delegate void efl_io_writer_can_write_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_write);
1640
1641         public static Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate> efl_io_writer_can_write_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_can_write_set_api_delegate>(Module, "efl_io_writer_can_write_set");
1642
1643         private static void can_write_set(System.IntPtr obj, System.IntPtr pd, bool can_write)
1644         {
1645             Eina.Log.Debug("function efl_io_writer_can_write_set was called");
1646             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1647             if (ws != null)
1648             {
1649
1650                 try
1651                 {
1652                     ((Thread)ws.Target).SetCanWrite(can_write);
1653                 }
1654                 catch (Exception e)
1655                 {
1656                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1657                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1658                 }
1659
1660
1661             }
1662             else
1663             {
1664                 efl_io_writer_can_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_write);
1665             }
1666         }
1667
1668         private static efl_io_writer_can_write_set_delegate efl_io_writer_can_write_set_static_delegate;
1669
1670
1671         private delegate Eina.Error efl_io_writer_write_delegate(System.IntPtr obj, System.IntPtr pd,  ref  Eina.Slice slice,  ref  Eina.Slice remaining);
1672
1673
1674         public delegate Eina.Error efl_io_writer_write_api_delegate(System.IntPtr obj,  ref  Eina.Slice slice,  ref  Eina.Slice remaining);
1675
1676         public static Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate> efl_io_writer_write_ptr = new Efl.Eo.FunctionWrapper<efl_io_writer_write_api_delegate>(Module, "efl_io_writer_write");
1677
1678         private static Eina.Error write(System.IntPtr obj, System.IntPtr pd, ref  Eina.Slice slice, ref  Eina.Slice remaining)
1679         {
1680             Eina.Log.Debug("function efl_io_writer_write was called");
1681             var ws = Efl.Eo.Globals.GetWrapperSupervisor(obj);
1682             if (ws != null)
1683             {
1684                                 remaining = default( Eina.Slice);                            Eina.Error _ret_var = default(Eina.Error);
1685                 try
1686                 {
1687                     _ret_var = ((Thread)ws.Target).Write(ref slice, ref remaining);
1688                 }
1689                 catch (Exception e)
1690                 {
1691                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1692                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1693                 }
1694
1695                                         return _ret_var;
1696
1697             }
1698             else
1699             {
1700                 return efl_io_writer_write_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref slice, ref remaining);
1701             }
1702         }
1703
1704         private static efl_io_writer_write_delegate efl_io_writer_write_static_delegate;
1705
1706         #pragma warning restore CA1707, CS1591, SA1300, SA1600
1707
1708 }
1709 }
1710 }
1711