internals/src/EflSharp/EflSharp/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.ComponentModel;
   7 namespace Efl {
   8 /// <summary></summary>
   9 [ThreadNativeInherit]
  10 public class Thread : Efl.Task, Efl.Eo.IWrapper,Efl.ThreadIO,Efl.Core.CommandLine,Efl.Io.Closer,Efl.Io.Reader,Efl.Io.Writer
  11 {
  12    public new static System.IntPtr klass = System.IntPtr.Zero;
  13    public new static Efl.ThreadNativeInherit nativeInherit = new Efl.ThreadNativeInherit();
  14    ///<summary>Pointer to the native class description.</summary>
  15    public override System.IntPtr NativeClass {
  16       get {
  17          if (((object)this).GetType() == typeof (Thread))
  18             return Efl.ThreadNativeInherit.GetEflClassStatic();
  19          else
  20             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  21       }
  22    }
  23    [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  24       efl_thread_class_get();
  25    ///<summary>Creates a new instance.</summary>
  26    ///<param name="parent">Parent instance.</param>
  27    public Thread(Efl.Object parent= null
  28          ) :
  29       base(efl_thread_class_get(), typeof(Thread), parent)
  30    {
  31       FinishInstantiation();
  32    }
  33    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  34    public Thread(System.IntPtr raw) : base(raw)
  35    {
  36             register_event_proxies();
  37    }
  38    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  39    protected Thread(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  40    ///<summary>Casts obj into an instance of this type.</summary>
  41    public new static Thread static_cast(Efl.Object obj)
  42    {
  43       if (obj == null)
  44          throw new System.ArgumentNullException("obj");
  45       return new Thread(obj.NativeHandle);
  46    }
  47    ///<summary>Verifies if the given object is equal to this one.</summary>
  48    public override bool Equals(object obj)
  49    {
  50       var other = obj as Efl.Object;
  51       if (other == null)
  52          return false;
  53       return this.NativeHandle == other.NativeHandle;
  54    }
  55    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  56    public override int GetHashCode()
  57    {
  58       return this.NativeHandle.ToInt32();
  59    }
  60    ///<summary>Turns the native pointer into a string representation.</summary>
  61    public override String ToString()
  62    {
  63       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  64    }
  65 private static object ClosedEvtKey = new object();
  66    /// <summary>Notifies closed, when property is marked as true
  67    /// 1.19</summary>
  68    public event EventHandler ClosedEvt
  69    {
  70       add {
  71          lock (eventLock) {
  72             string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
  73             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_ClosedEvt_delegate)) {
  74                eventHandlers.AddHandler(ClosedEvtKey , value);
  75             } else
  76                Eina.Log.Error($"Error adding proxy for event {key}");
  77          }
  78       }
  79       remove {
  80          lock (eventLock) {
  81             string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
  82             if (remove_cpp_event_handler(key, this.evt_ClosedEvt_delegate)) {
  83                eventHandlers.RemoveHandler(ClosedEvtKey , value);
  84             } else
  85                Eina.Log.Error($"Error removing proxy for event {key}");
  86          }
  87       }
  88    }
  89    ///<summary>Method to raise event ClosedEvt.</summary>
  90    public void On_ClosedEvt(EventArgs e)
  91    {
  92       EventHandler evt;
  93       lock (eventLock) {
  94       evt = (EventHandler)eventHandlers[ClosedEvtKey];
  95       }
  96       evt?.Invoke(this, e);
  97    }
  98    Efl.EventCb evt_ClosedEvt_delegate;
  99    private void on_ClosedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 100    {
 101       EventArgs args = EventArgs.Empty;
 102       try {
 103          On_ClosedEvt(args);
 104       } catch (Exception e) {
 105          Eina.Log.Error(e.ToString());
 106          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 107       }
 108    }
 109
 110 private static object Can_readChangedEvtKey = new object();
 111    /// <summary>Notifies can_read property changed.
 112    /// If <see cref="Efl.Io.Reader.CanRead"/> is <c>true</c> there is data to <see cref="Efl.Io.Reader.Read"/> without blocking/error. If <see cref="Efl.Io.Reader.CanRead"/> is <c>false</c>, <see cref="Efl.Io.Reader.Read"/> would either block or fail.
 113    ///
 114    /// Note that usually this event is dispatched from inside <see cref="Efl.Io.Reader.Read"/>, thus before it returns.
 115    /// 1.19</summary>
 116    public event EventHandler<Efl.Io.ReaderCan_readChangedEvt_Args> Can_readChangedEvt
 117    {
 118       add {
 119          lock (eventLock) {
 120             string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 121             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_Can_readChangedEvt_delegate)) {
 122                eventHandlers.AddHandler(Can_readChangedEvtKey , value);
 123             } else
 124                Eina.Log.Error($"Error adding proxy for event {key}");
 125          }
 126       }
 127       remove {
 128          lock (eventLock) {
 129             string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 130             if (remove_cpp_event_handler(key, this.evt_Can_readChangedEvt_delegate)) {
 131                eventHandlers.RemoveHandler(Can_readChangedEvtKey , value);
 132             } else
 133                Eina.Log.Error($"Error removing proxy for event {key}");
 134          }
 135       }
 136    }
 137    ///<summary>Method to raise event Can_readChangedEvt.</summary>
 138    public void On_Can_readChangedEvt(Efl.Io.ReaderCan_readChangedEvt_Args e)
 139    {
 140       EventHandler<Efl.Io.ReaderCan_readChangedEvt_Args> evt;
 141       lock (eventLock) {
 142       evt = (EventHandler<Efl.Io.ReaderCan_readChangedEvt_Args>)eventHandlers[Can_readChangedEvtKey];
 143       }
 144       evt?.Invoke(this, e);
 145    }
 146    Efl.EventCb evt_Can_readChangedEvt_delegate;
 147    private void on_Can_readChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 148    {
 149       Efl.Io.ReaderCan_readChangedEvt_Args args = new Efl.Io.ReaderCan_readChangedEvt_Args();
 150       args.arg = evt.Info != IntPtr.Zero;
 151       try {
 152          On_Can_readChangedEvt(args);
 153       } catch (Exception e) {
 154          Eina.Log.Error(e.ToString());
 155          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 156       }
 157    }
 158
 159 private static object EosEvtKey = new object();
 160    /// <summary>Notifies end of stream, when property is marked as true.
 161    /// If this is used alongside with an <see cref="Efl.Io.Closer"/>, then it should be emitted before that call.
 162    ///
 163    /// It should be emitted only once for an object unless it implements <see cref="Efl.Io.Positioner.Seek"/>.
 164    ///
 165    /// The property <see cref="Efl.Io.Reader.CanRead"/> should change to <c>false</c> before this event is dispatched.
 166    /// 1.19</summary>
 167    public event EventHandler EosEvt
 168    {
 169       add {
 170          lock (eventLock) {
 171             string key = "_EFL_IO_READER_EVENT_EOS";
 172             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_EosEvt_delegate)) {
 173                eventHandlers.AddHandler(EosEvtKey , value);
 174             } else
 175                Eina.Log.Error($"Error adding proxy for event {key}");
 176          }
 177       }
 178       remove {
 179          lock (eventLock) {
 180             string key = "_EFL_IO_READER_EVENT_EOS";
 181             if (remove_cpp_event_handler(key, this.evt_EosEvt_delegate)) {
 182                eventHandlers.RemoveHandler(EosEvtKey , value);
 183             } else
 184                Eina.Log.Error($"Error removing proxy for event {key}");
 185          }
 186       }
 187    }
 188    ///<summary>Method to raise event EosEvt.</summary>
 189    public void On_EosEvt(EventArgs e)
 190    {
 191       EventHandler evt;
 192       lock (eventLock) {
 193       evt = (EventHandler)eventHandlers[EosEvtKey];
 194       }
 195       evt?.Invoke(this, e);
 196    }
 197    Efl.EventCb evt_EosEvt_delegate;
 198    private void on_EosEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 199    {
 200       EventArgs args = EventArgs.Empty;
 201       try {
 202          On_EosEvt(args);
 203       } catch (Exception e) {
 204          Eina.Log.Error(e.ToString());
 205          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 206       }
 207    }
 208
 209 private static object Can_writeChangedEvtKey = new object();
 210    /// <summary>Notifies can_write property changed.
 211    /// If <see cref="Efl.Io.Writer.CanWrite"/> is <c>true</c> there is data to <see cref="Efl.Io.Writer.Write"/> without blocking/error. If <see cref="Efl.Io.Writer.CanWrite"/> is <c>false</c>, <see cref="Efl.Io.Writer.Write"/> would either block or fail.
 212    ///
 213    /// Note that usually this event is dispatched from inside <see cref="Efl.Io.Writer.Write"/>, thus before it returns.
 214    /// 1.19</summary>
 215    public event EventHandler<Efl.Io.WriterCan_writeChangedEvt_Args> Can_writeChangedEvt
 216    {
 217       add {
 218          lock (eventLock) {
 219             string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 220             if (add_cpp_event_handler(efl.Libs.Efl, key, this.evt_Can_writeChangedEvt_delegate)) {
 221                eventHandlers.AddHandler(Can_writeChangedEvtKey , value);
 222             } else
 223                Eina.Log.Error($"Error adding proxy for event {key}");
 224          }
 225       }
 226       remove {
 227          lock (eventLock) {
 228             string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 229             if (remove_cpp_event_handler(key, this.evt_Can_writeChangedEvt_delegate)) {
 230                eventHandlers.RemoveHandler(Can_writeChangedEvtKey , value);
 231             } else
 232                Eina.Log.Error($"Error removing proxy for event {key}");
 233          }
 234       }
 235    }
 236    ///<summary>Method to raise event Can_writeChangedEvt.</summary>
 237    public void On_Can_writeChangedEvt(Efl.Io.WriterCan_writeChangedEvt_Args e)
 238    {
 239       EventHandler<Efl.Io.WriterCan_writeChangedEvt_Args> evt;
 240       lock (eventLock) {
 241       evt = (EventHandler<Efl.Io.WriterCan_writeChangedEvt_Args>)eventHandlers[Can_writeChangedEvtKey];
 242       }
 243       evt?.Invoke(this, e);
 244    }
 245    Efl.EventCb evt_Can_writeChangedEvt_delegate;
 246    private void on_Can_writeChangedEvt_NativeCallback(System.IntPtr data, ref Efl.Event_StructInternal evt)
 247    {
 248       Efl.Io.WriterCan_writeChangedEvt_Args args = new Efl.Io.WriterCan_writeChangedEvt_Args();
 249       args.arg = evt.Info != IntPtr.Zero;
 250       try {
 251          On_Can_writeChangedEvt(args);
 252       } catch (Exception e) {
 253          Eina.Log.Error(e.ToString());
 254          Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 255       }
 256    }
 257
 258    protected override void register_event_proxies()
 259    {
 260       base.register_event_proxies();
 261       evt_ClosedEvt_delegate = new Efl.EventCb(on_ClosedEvt_NativeCallback);
 262       evt_Can_readChangedEvt_delegate = new Efl.EventCb(on_Can_readChangedEvt_NativeCallback);
 263       evt_EosEvt_delegate = new Efl.EventCb(on_EosEvt_NativeCallback);
 264       evt_Can_writeChangedEvt_delegate = new Efl.EventCb(on_Can_writeChangedEvt_NativeCallback);
 265    }
 266    /// <summary></summary>
 267    /// <returns>No description supplied.</returns>
 268    virtual public  System.IntPtr GetIndata() {
 269        var _ret_var = Efl.ThreadIONativeInherit.efl_threadio_indata_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 270       Eina.Error.RaiseIfUnhandledException();
 271       return _ret_var;
 272  }
 273    /// <summary></summary>
 274    /// <param name="data">No description supplied.</param>
 275    /// <returns></returns>
 276    virtual public  void SetIndata(  System.IntPtr data) {
 277                          Efl.ThreadIONativeInherit.efl_threadio_indata_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), data);
 278       Eina.Error.RaiseIfUnhandledException();
 279                    }
 280    /// <summary></summary>
 281    /// <returns>No description supplied.</returns>
 282    virtual public  System.IntPtr GetOutdata() {
 283        var _ret_var = Efl.ThreadIONativeInherit.efl_threadio_outdata_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 284       Eina.Error.RaiseIfUnhandledException();
 285       return _ret_var;
 286  }
 287    /// <summary></summary>
 288    /// <param name="data">No description supplied.</param>
 289    /// <returns></returns>
 290    virtual public  void SetOutdata(  System.IntPtr data) {
 291                          Efl.ThreadIONativeInherit.efl_threadio_outdata_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), data);
 292       Eina.Error.RaiseIfUnhandledException();
 293                    }
 294    /// <summary></summary>
 295    /// <param name="func">No description supplied.</param>
 296    /// <returns></returns>
 297    virtual public  void Call( EFlThreadIOCall func) {
 298                    GCHandle func_handle = GCHandle.Alloc(func);
 299       Efl.ThreadIONativeInherit.efl_threadio_call_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),GCHandle.ToIntPtr(func_handle), EFlThreadIOCallWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 300       Eina.Error.RaiseIfUnhandledException();
 301                    }
 302    /// <summary></summary>
 303    /// <param name="func">No description supplied.</param>
 304    /// <returns>No description supplied.</returns>
 305    virtual public  System.IntPtr CallSync( EFlThreadIOCallSync func) {
 306                    GCHandle func_handle = GCHandle.Alloc(func);
 307       var _ret_var = Efl.ThreadIONativeInherit.efl_threadio_call_sync_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),GCHandle.ToIntPtr(func_handle), EFlThreadIOCallSyncWrapper.Cb, Efl.Eo.Globals.free_gchandle);
 308       Eina.Error.RaiseIfUnhandledException();
 309                   return _ret_var;
 310  }
 311    /// <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.
 312    /// &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.
 313    ///
 314    /// 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:
 315    ///
 316    /// &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.
 317    ///
 318    /// 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>
 319    /// <returns></returns>
 320    virtual public  System.String GetCommand() {
 321        var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 322       Eina.Error.RaiseIfUnhandledException();
 323       return _ret_var;
 324  }
 325    /// <summary>Use an array to fill this object
 326    /// Every element of a string is a argument.</summary>
 327    /// <param name="array">An array where every array field is an argument</param>
 328    /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 329    virtual public bool SetCommandArray( Eina.Array< System.String> array) {
 330        var _in_array = array.Handle;
 331 array.Own = false;
 332 array.OwnContent = false;
 333                   var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_array_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), _in_array);
 334       Eina.Error.RaiseIfUnhandledException();
 335                   return _ret_var;
 336  }
 337    /// <summary>Use a string to fill this object
 338    /// The string will be split at every unescaped &apos; &apos;, every resulting substring will be a new argument to the command line.</summary>
 339    /// <param name="str">A command in form of a string</param>
 340    /// <returns>On success <c>true</c>, <c>false</c> otherwise</returns>
 341    virtual public bool SetCommandString(  System.String str) {
 342                          var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_string_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), str);
 343       Eina.Error.RaiseIfUnhandledException();
 344                   return _ret_var;
 345  }
 346    /// <summary>Get the accessor which enables access to each argument that got passed to this object.</summary>
 347    /// <returns></returns>
 348    virtual public Eina.Accessor< System.String> CommandAccess() {
 349        var _ret_var = Efl.Core.CommandLineNativeInherit.efl_core_command_line_command_access_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 350       Eina.Error.RaiseIfUnhandledException();
 351       return new Eina.Accessor< System.String>(_ret_var, false, false);
 352  }
 353    /// <summary>If true will notify object was closed.
 354    /// 1.19</summary>
 355    /// <returns><c>true</c> if closed, <c>false</c> otherwise
 356    /// 1.19</returns>
 357    virtual public bool GetClosed() {
 358        var _ret_var = Efl.Io.CloserNativeInherit.efl_io_closer_closed_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 359       Eina.Error.RaiseIfUnhandledException();
 360       return _ret_var;
 361  }
 362    /// <summary>If true will automatically close resources on exec() calls.
 363    /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 364    /// 1.19</summary>
 365    /// <returns><c>true</c> if close on exec(), <c>false</c> otherwise
 366    /// 1.19</returns>
 367    virtual public bool GetCloseOnExec() {
 368        var _ret_var = Efl.Io.CloserNativeInherit.efl_io_closer_close_on_exec_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 369       Eina.Error.RaiseIfUnhandledException();
 370       return _ret_var;
 371  }
 372    /// <summary>If <c>true</c>, will close on exec() call.
 373    /// 1.19</summary>
 374    /// <param name="close_on_exec"><c>true</c> if close on exec(), <c>false</c> otherwise
 375    /// 1.19</param>
 376    /// <returns><c>true</c> if could set, <c>false</c> if not supported or failed.
 377    /// 1.19</returns>
 378    virtual public bool SetCloseOnExec( bool close_on_exec) {
 379                          var _ret_var = Efl.Io.CloserNativeInherit.efl_io_closer_close_on_exec_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), close_on_exec);
 380       Eina.Error.RaiseIfUnhandledException();
 381                   return _ret_var;
 382  }
 383    /// <summary>If true will automatically close() on object invalidate.
 384    /// 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.
 385    /// 1.19</summary>
 386    /// <returns><c>true</c> if close on invalidate, <c>false</c> otherwise
 387    /// 1.19</returns>
 388    virtual public bool GetCloseOnInvalidate() {
 389        var _ret_var = Efl.Io.CloserNativeInherit.efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 390       Eina.Error.RaiseIfUnhandledException();
 391       return _ret_var;
 392  }
 393    /// <summary>If true will automatically close() on object invalidate.
 394    /// 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.
 395    /// 1.19</summary>
 396    /// <param name="close_on_invalidate"><c>true</c> if close on invalidate, <c>false</c> otherwise
 397    /// 1.19</param>
 398    /// <returns></returns>
 399    virtual public  void SetCloseOnInvalidate( bool close_on_invalidate) {
 400                          Efl.Io.CloserNativeInherit.efl_io_closer_close_on_invalidate_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), close_on_invalidate);
 401       Eina.Error.RaiseIfUnhandledException();
 402                    }
 403    /// <summary>Closes the Input/Output object.
 404    /// 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.
 405    ///
 406    /// You can understand this method as close(2) libc function.
 407    /// 1.19</summary>
 408    /// <returns>0 on succeed, a mapping of errno otherwise
 409    /// 1.19</returns>
 410    virtual public  Eina.Error Close() {
 411        var _ret_var = Efl.Io.CloserNativeInherit.efl_io_closer_close_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 412       Eina.Error.RaiseIfUnhandledException();
 413       return _ret_var;
 414  }
 415    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Reader.Read"/> can be called without blocking or failing.
 416    /// 1.19</summary>
 417    /// <returns><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise
 418    /// 1.19</returns>
 419    virtual public bool GetCanRead() {
 420        var _ret_var = Efl.Io.ReaderNativeInherit.efl_io_reader_can_read_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 421       Eina.Error.RaiseIfUnhandledException();
 422       return _ret_var;
 423  }
 424    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Reader.Read"/> can be called without blocking or failing.
 425    /// 1.19</summary>
 426    /// <param name="can_read"><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise
 427    /// 1.19</param>
 428    /// <returns></returns>
 429    virtual public  void SetCanRead( bool can_read) {
 430                          Efl.Io.ReaderNativeInherit.efl_io_reader_can_read_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), can_read);
 431       Eina.Error.RaiseIfUnhandledException();
 432                    }
 433    /// <summary>If <c>true</c> will notify end of stream.
 434    /// 1.19</summary>
 435    /// <returns><c>true</c> if end of stream, <c>false</c> otherwise
 436    /// 1.19</returns>
 437    virtual public bool GetEos() {
 438        var _ret_var = Efl.Io.ReaderNativeInherit.efl_io_reader_eos_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 439       Eina.Error.RaiseIfUnhandledException();
 440       return _ret_var;
 441  }
 442    /// <summary>If <c>true</c> will notify end of stream.
 443    /// 1.19</summary>
 444    /// <param name="is_eos"><c>true</c> if end of stream, <c>false</c> otherwise
 445    /// 1.19</param>
 446    /// <returns></returns>
 447    virtual public  void SetEos( bool is_eos) {
 448                          Efl.Io.ReaderNativeInherit.efl_io_reader_eos_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), is_eos);
 449       Eina.Error.RaiseIfUnhandledException();
 450                    }
 451    /// <summary>Reads data into a pre-allocated buffer.
 452    /// 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.
 453    ///
 454    /// You can understand this method as read(2) libc function.
 455    /// 1.19</summary>
 456    /// <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.
 457    /// 1.19</param>
 458    /// <returns>0 on succeed, a mapping of errno otherwise
 459    /// 1.19</returns>
 460    virtual public  Eina.Error Read( ref Eina.RwSlice rw_slice) {
 461                          var _ret_var = Efl.Io.ReaderNativeInherit.efl_io_reader_read_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ref rw_slice);
 462       Eina.Error.RaiseIfUnhandledException();
 463                   return _ret_var;
 464  }
 465    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Writer.Write"/> can be called without blocking or failing.
 466    /// 1.19</summary>
 467    /// <returns><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise
 468    /// 1.19</returns>
 469    virtual public bool GetCanWrite() {
 470        var _ret_var = Efl.Io.WriterNativeInherit.efl_io_writer_can_write_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 471       Eina.Error.RaiseIfUnhandledException();
 472       return _ret_var;
 473  }
 474    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Writer.Write"/> can be called without blocking or failing.
 475    /// 1.19</summary>
 476    /// <param name="can_write"><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise
 477    /// 1.19</param>
 478    /// <returns></returns>
 479    virtual public  void SetCanWrite( bool can_write) {
 480                          Efl.Io.WriterNativeInherit.efl_io_writer_can_write_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), can_write);
 481       Eina.Error.RaiseIfUnhandledException();
 482                    }
 483    /// <summary>Writes data from a pre-populated buffer.
 484    /// 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.
 485    ///
 486    /// You can understand this method as write(2) libc function.
 487    /// 1.19</summary>
 488    /// <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.
 489    /// 1.19</param>
 490    /// <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.
 491    /// 1.19</param>
 492    /// <returns>0 on succeed, a mapping of errno otherwise
 493    /// 1.19</returns>
 494    virtual public  Eina.Error Write( ref Eina.Slice slice,  ref Eina.Slice remaining) {
 495                                            var _ret_var = Efl.Io.WriterNativeInherit.efl_io_writer_write_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), ref slice,  ref remaining);
 496       Eina.Error.RaiseIfUnhandledException();
 497                               return _ret_var;
 498  }
 499    /// <summary></summary>
 500 /// <value>No description supplied.</value>
 501    public  System.IntPtr Indata {
 502       get { return GetIndata(); }
 503       set { SetIndata( value); }
 504    }
 505    /// <summary></summary>
 506 /// <value>No description supplied.</value>
 507    public  System.IntPtr Outdata {
 508       get { return GetOutdata(); }
 509       set { SetOutdata( value); }
 510    }
 511    /// <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.
 512 /// &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.
 513 ///
 514 /// 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:
 515 ///
 516 /// &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.
 517 ///
 518 /// 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>
 519 /// <value></value>
 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< System.String> 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 /// 1.19</summary>
 537 /// <value><c>true</c> if closed, <c>false</c> otherwise
 538 /// 1.19</value>
 539    public bool Closed {
 540       get { return GetClosed(); }
 541    }
 542    /// <summary>If true will automatically close resources on exec() calls.
 543 /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 544 /// 1.19</summary>
 545 /// <value><c>true</c> if close on exec(), <c>false</c> otherwise
 546 /// 1.19</value>
 547    public bool CloseOnExec {
 548       get { return GetCloseOnExec(); }
 549       set { SetCloseOnExec( value); }
 550    }
 551    /// <summary>If true will automatically close() on object invalidate.
 552 /// 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.
 553 /// 1.19</summary>
 554 /// <value><c>true</c> if close on invalidate, <c>false</c> otherwise
 555 /// 1.19</value>
 556    public bool CloseOnInvalidate {
 557       get { return GetCloseOnInvalidate(); }
 558       set { SetCloseOnInvalidate( value); }
 559    }
 560    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Reader.Read"/> can be called without blocking or failing.
 561 /// 1.19</summary>
 562 /// <value><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise
 563 /// 1.19</value>
 564    public bool CanRead {
 565       get { return GetCanRead(); }
 566       set { SetCanRead( value); }
 567    }
 568    /// <summary>If <c>true</c> will notify end of stream.
 569 /// 1.19</summary>
 570 /// <value><c>true</c> if end of stream, <c>false</c> otherwise
 571 /// 1.19</value>
 572    public bool Eos {
 573       get { return GetEos(); }
 574       set { SetEos( value); }
 575    }
 576    /// <summary>If <c>true</c> will notify <see cref="Efl.Io.Writer.Write"/> can be called without blocking or failing.
 577 /// 1.19</summary>
 578 /// <value><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise
 579 /// 1.19</value>
 580    public bool CanWrite {
 581       get { return GetCanWrite(); }
 582       set { SetCanWrite( value); }
 583    }
 584    private static new  IntPtr GetEflClassStatic()
 585    {
 586       return Efl.Thread.efl_thread_class_get();
 587    }
 588 }
 589 public class ThreadNativeInherit : Efl.TaskNativeInherit{
 590    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Ecore);
 591    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 592    {
 593       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 594       if (efl_threadio_indata_get_static_delegate == null)
 595       efl_threadio_indata_get_static_delegate = new efl_threadio_indata_get_delegate(indata_get);
 596       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)});
 597       if (efl_threadio_indata_set_static_delegate == null)
 598       efl_threadio_indata_set_static_delegate = new efl_threadio_indata_set_delegate(indata_set);
 599       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)});
 600       if (efl_threadio_outdata_get_static_delegate == null)
 601       efl_threadio_outdata_get_static_delegate = new efl_threadio_outdata_get_delegate(outdata_get);
 602       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)});
 603       if (efl_threadio_outdata_set_static_delegate == null)
 604       efl_threadio_outdata_set_static_delegate = new efl_threadio_outdata_set_delegate(outdata_set);
 605       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)});
 606       if (efl_threadio_call_static_delegate == null)
 607       efl_threadio_call_static_delegate = new efl_threadio_call_delegate(call);
 608       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)});
 609       if (efl_threadio_call_sync_static_delegate == null)
 610       efl_threadio_call_sync_static_delegate = new efl_threadio_call_sync_delegate(call_sync);
 611       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)});
 612       if (efl_core_command_line_command_get_static_delegate == null)
 613       efl_core_command_line_command_get_static_delegate = new efl_core_command_line_command_get_delegate(command_get);
 614       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)});
 615       if (efl_core_command_line_command_array_set_static_delegate == null)
 616       efl_core_command_line_command_array_set_static_delegate = new efl_core_command_line_command_array_set_delegate(command_array_set);
 617       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)});
 618       if (efl_core_command_line_command_string_set_static_delegate == null)
 619       efl_core_command_line_command_string_set_static_delegate = new efl_core_command_line_command_string_set_delegate(command_string_set);
 620       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)});
 621       if (efl_core_command_line_command_access_static_delegate == null)
 622       efl_core_command_line_command_access_static_delegate = new efl_core_command_line_command_access_delegate(command_access);
 623       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)});
 624       if (efl_io_closer_closed_get_static_delegate == null)
 625       efl_io_closer_closed_get_static_delegate = new efl_io_closer_closed_get_delegate(closed_get);
 626       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)});
 627       if (efl_io_closer_close_on_exec_get_static_delegate == null)
 628       efl_io_closer_close_on_exec_get_static_delegate = new efl_io_closer_close_on_exec_get_delegate(close_on_exec_get);
 629       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)});
 630       if (efl_io_closer_close_on_exec_set_static_delegate == null)
 631       efl_io_closer_close_on_exec_set_static_delegate = new efl_io_closer_close_on_exec_set_delegate(close_on_exec_set);
 632       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)});
 633       if (efl_io_closer_close_on_invalidate_get_static_delegate == null)
 634       efl_io_closer_close_on_invalidate_get_static_delegate = new efl_io_closer_close_on_invalidate_get_delegate(close_on_invalidate_get);
 635       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)});
 636       if (efl_io_closer_close_on_invalidate_set_static_delegate == null)
 637       efl_io_closer_close_on_invalidate_set_static_delegate = new efl_io_closer_close_on_invalidate_set_delegate(close_on_invalidate_set);
 638       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)});
 639       if (efl_io_closer_close_static_delegate == null)
 640       efl_io_closer_close_static_delegate = new efl_io_closer_close_delegate(close);
 641       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)});
 642       if (efl_io_reader_can_read_get_static_delegate == null)
 643       efl_io_reader_can_read_get_static_delegate = new efl_io_reader_can_read_get_delegate(can_read_get);
 644       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)});
 645       if (efl_io_reader_can_read_set_static_delegate == null)
 646       efl_io_reader_can_read_set_static_delegate = new efl_io_reader_can_read_set_delegate(can_read_set);
 647       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)});
 648       if (efl_io_reader_eos_get_static_delegate == null)
 649       efl_io_reader_eos_get_static_delegate = new efl_io_reader_eos_get_delegate(eos_get);
 650       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)});
 651       if (efl_io_reader_eos_set_static_delegate == null)
 652       efl_io_reader_eos_set_static_delegate = new efl_io_reader_eos_set_delegate(eos_set);
 653       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)});
 654       if (efl_io_reader_read_static_delegate == null)
 655       efl_io_reader_read_static_delegate = new efl_io_reader_read_delegate(read);
 656       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)});
 657       if (efl_io_writer_can_write_get_static_delegate == null)
 658       efl_io_writer_can_write_get_static_delegate = new efl_io_writer_can_write_get_delegate(can_write_get);
 659       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)});
 660       if (efl_io_writer_can_write_set_static_delegate == null)
 661       efl_io_writer_can_write_set_static_delegate = new efl_io_writer_can_write_set_delegate(can_write_set);
 662       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)});
 663       if (efl_io_writer_write_static_delegate == null)
 664       efl_io_writer_write_static_delegate = new efl_io_writer_write_delegate(write);
 665       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)});
 666       descs.AddRange(base.GetEoOps(type));
 667       return descs;
 668    }
 669    public override IntPtr GetEflClass()
 670    {
 671       return Efl.Thread.efl_thread_class_get();
 672    }
 673    public static new  IntPtr GetEflClassStatic()
 674    {
 675       return Efl.Thread.efl_thread_class_get();
 676    }
 677
 678
 679     private delegate  System.IntPtr efl_threadio_indata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 680
 681
 682     public delegate  System.IntPtr efl_threadio_indata_get_api_delegate(System.IntPtr obj);
 683     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");
 684     private static  System.IntPtr indata_get(System.IntPtr obj, System.IntPtr pd)
 685    {
 686       Eina.Log.Debug("function efl_threadio_indata_get was called");
 687       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 688       if(wrapper != null) {
 689                    System.IntPtr _ret_var = default( System.IntPtr);
 690          try {
 691             _ret_var = ((Thread)wrapper).GetIndata();
 692          } catch (Exception e) {
 693             Eina.Log.Warning($"Callback error: {e.ToString()}");
 694             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 695          }
 696       return _ret_var;
 697       } else {
 698          return efl_threadio_indata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 699       }
 700    }
 701    private static efl_threadio_indata_get_delegate efl_threadio_indata_get_static_delegate;
 702
 703
 704     private delegate  void efl_threadio_indata_set_delegate(System.IntPtr obj, System.IntPtr pd,    System.IntPtr data);
 705
 706
 707     public delegate  void efl_threadio_indata_set_api_delegate(System.IntPtr obj,    System.IntPtr data);
 708     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");
 709     private static  void indata_set(System.IntPtr obj, System.IntPtr pd,   System.IntPtr data)
 710    {
 711       Eina.Log.Debug("function efl_threadio_indata_set was called");
 712       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 713       if(wrapper != null) {
 714
 715          try {
 716             ((Thread)wrapper).SetIndata( data);
 717          } catch (Exception e) {
 718             Eina.Log.Warning($"Callback error: {e.ToString()}");
 719             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 720          }
 721                         } else {
 722          efl_threadio_indata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  data);
 723       }
 724    }
 725    private static efl_threadio_indata_set_delegate efl_threadio_indata_set_static_delegate;
 726
 727
 728     private delegate  System.IntPtr efl_threadio_outdata_get_delegate(System.IntPtr obj, System.IntPtr pd);
 729
 730
 731     public delegate  System.IntPtr efl_threadio_outdata_get_api_delegate(System.IntPtr obj);
 732     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");
 733     private static  System.IntPtr outdata_get(System.IntPtr obj, System.IntPtr pd)
 734    {
 735       Eina.Log.Debug("function efl_threadio_outdata_get was called");
 736       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 737       if(wrapper != null) {
 738                    System.IntPtr _ret_var = default( System.IntPtr);
 739          try {
 740             _ret_var = ((Thread)wrapper).GetOutdata();
 741          } catch (Exception e) {
 742             Eina.Log.Warning($"Callback error: {e.ToString()}");
 743             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 744          }
 745       return _ret_var;
 746       } else {
 747          return efl_threadio_outdata_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 748       }
 749    }
 750    private static efl_threadio_outdata_get_delegate efl_threadio_outdata_get_static_delegate;
 751
 752
 753     private delegate  void efl_threadio_outdata_set_delegate(System.IntPtr obj, System.IntPtr pd,    System.IntPtr data);
 754
 755
 756     public delegate  void efl_threadio_outdata_set_api_delegate(System.IntPtr obj,    System.IntPtr data);
 757     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");
 758     private static  void outdata_set(System.IntPtr obj, System.IntPtr pd,   System.IntPtr data)
 759    {
 760       Eina.Log.Debug("function efl_threadio_outdata_set was called");
 761       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 762       if(wrapper != null) {
 763
 764          try {
 765             ((Thread)wrapper).SetOutdata( data);
 766          } catch (Exception e) {
 767             Eina.Log.Warning($"Callback error: {e.ToString()}");
 768             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 769          }
 770                         } else {
 771          efl_threadio_outdata_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  data);
 772       }
 773    }
 774    private static efl_threadio_outdata_set_delegate efl_threadio_outdata_set_static_delegate;
 775
 776
 777     private delegate  void efl_threadio_call_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 778
 779
 780     public delegate  void efl_threadio_call_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb);
 781     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");
 782     private static  void call(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallInternal func, EinaFreeCb func_free_cb)
 783    {
 784       Eina.Log.Debug("function efl_threadio_call was called");
 785       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 786       if(wrapper != null) {
 787                               EFlThreadIOCallWrapper func_wrapper = new EFlThreadIOCallWrapper(func, func_data, func_free_cb);
 788
 789          try {
 790             ((Thread)wrapper).Call( func_wrapper.ManagedCb);
 791          } catch (Exception e) {
 792             Eina.Log.Warning($"Callback error: {e.ToString()}");
 793             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 794          }
 795                         } else {
 796          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);
 797       }
 798    }
 799    private static efl_threadio_call_delegate efl_threadio_call_static_delegate;
 800
 801
 802     private delegate  System.IntPtr efl_threadio_call_sync_delegate(System.IntPtr obj, System.IntPtr pd,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
 803
 804
 805     public delegate  System.IntPtr efl_threadio_call_sync_api_delegate(System.IntPtr obj,  IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb);
 806     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");
 807     private static  System.IntPtr call_sync(System.IntPtr obj, System.IntPtr pd, IntPtr func_data, EFlThreadIOCallSyncInternal func, EinaFreeCb func_free_cb)
 808    {
 809       Eina.Log.Debug("function efl_threadio_call_sync was called");
 810       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 811       if(wrapper != null) {
 812                               EFlThreadIOCallSyncWrapper func_wrapper = new EFlThreadIOCallSyncWrapper(func, func_data, func_free_cb);
 813           System.IntPtr _ret_var = default( System.IntPtr);
 814          try {
 815             _ret_var = ((Thread)wrapper).CallSync( func_wrapper.ManagedCb);
 816          } catch (Exception e) {
 817             Eina.Log.Warning($"Callback error: {e.ToString()}");
 818             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 819          }
 820                   return _ret_var;
 821       } else {
 822          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);
 823       }
 824    }
 825    private static efl_threadio_call_sync_delegate efl_threadio_call_sync_static_delegate;
 826
 827
 828     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] private delegate  System.String efl_core_command_line_command_get_delegate(System.IntPtr obj, System.IntPtr pd);
 829
 830
 831     [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] public delegate  System.String efl_core_command_line_command_get_api_delegate(System.IntPtr obj);
 832     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");
 833     private static  System.String command_get(System.IntPtr obj, System.IntPtr pd)
 834    {
 835       Eina.Log.Debug("function efl_core_command_line_command_get was called");
 836       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 837       if(wrapper != null) {
 838                    System.String _ret_var = default( System.String);
 839          try {
 840             _ret_var = ((Thread)wrapper).GetCommand();
 841          } catch (Exception e) {
 842             Eina.Log.Warning($"Callback error: {e.ToString()}");
 843             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 844          }
 845       return _ret_var;
 846       } else {
 847          return efl_core_command_line_command_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 848       }
 849    }
 850    private static efl_core_command_line_command_get_delegate efl_core_command_line_command_get_static_delegate;
 851
 852
 853     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_core_command_line_command_array_set_delegate(System.IntPtr obj, System.IntPtr pd,    System.IntPtr array);
 854
 855
 856     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_core_command_line_command_array_set_api_delegate(System.IntPtr obj,    System.IntPtr array);
 857     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");
 858     private static bool command_array_set(System.IntPtr obj, System.IntPtr pd,   System.IntPtr array)
 859    {
 860       Eina.Log.Debug("function efl_core_command_line_command_array_set was called");
 861       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 862       if(wrapper != null) {
 863                var _in_array = new Eina.Array< System.String>(array, true, true);
 864                      bool _ret_var = default(bool);
 865          try {
 866             _ret_var = ((Thread)wrapper).SetCommandArray( _in_array);
 867          } catch (Exception e) {
 868             Eina.Log.Warning($"Callback error: {e.ToString()}");
 869             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 870          }
 871                   return _ret_var;
 872       } else {
 873          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);
 874       }
 875    }
 876    private static efl_core_command_line_command_array_set_delegate efl_core_command_line_command_array_set_static_delegate;
 877
 878
 879     [return: MarshalAs(UnmanagedType.U1)] 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);
 880
 881
 882     [return: MarshalAs(UnmanagedType.U1)] 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);
 883     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");
 884     private static bool command_string_set(System.IntPtr obj, System.IntPtr pd,   System.String str)
 885    {
 886       Eina.Log.Debug("function efl_core_command_line_command_string_set was called");
 887       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 888       if(wrapper != null) {
 889                                     bool _ret_var = default(bool);
 890          try {
 891             _ret_var = ((Thread)wrapper).SetCommandString( str);
 892          } catch (Exception e) {
 893             Eina.Log.Warning($"Callback error: {e.ToString()}");
 894             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 895          }
 896                   return _ret_var;
 897       } else {
 898          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);
 899       }
 900    }
 901    private static efl_core_command_line_command_string_set_delegate efl_core_command_line_command_string_set_static_delegate;
 902
 903
 904     private delegate  System.IntPtr efl_core_command_line_command_access_delegate(System.IntPtr obj, System.IntPtr pd);
 905
 906
 907     public delegate  System.IntPtr efl_core_command_line_command_access_api_delegate(System.IntPtr obj);
 908     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");
 909     private static  System.IntPtr command_access(System.IntPtr obj, System.IntPtr pd)
 910    {
 911       Eina.Log.Debug("function efl_core_command_line_command_access was called");
 912       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 913       if(wrapper != null) {
 914                   Eina.Accessor< System.String> _ret_var = default(Eina.Accessor< System.String>);
 915          try {
 916             _ret_var = ((Thread)wrapper).CommandAccess();
 917          } catch (Exception e) {
 918             Eina.Log.Warning($"Callback error: {e.ToString()}");
 919             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 920          }
 921       return _ret_var.Handle;
 922       } else {
 923          return efl_core_command_line_command_access_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 924       }
 925    }
 926    private static efl_core_command_line_command_access_delegate efl_core_command_line_command_access_static_delegate;
 927
 928
 929     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_closer_closed_get_delegate(System.IntPtr obj, System.IntPtr pd);
 930
 931
 932     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_closer_closed_get_api_delegate(System.IntPtr obj);
 933     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");
 934     private static bool closed_get(System.IntPtr obj, System.IntPtr pd)
 935    {
 936       Eina.Log.Debug("function efl_io_closer_closed_get was called");
 937       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 938       if(wrapper != null) {
 939                   bool _ret_var = default(bool);
 940          try {
 941             _ret_var = ((Thread)wrapper).GetClosed();
 942          } catch (Exception e) {
 943             Eina.Log.Warning($"Callback error: {e.ToString()}");
 944             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 945          }
 946       return _ret_var;
 947       } else {
 948          return efl_io_closer_closed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 949       }
 950    }
 951    private static efl_io_closer_closed_get_delegate efl_io_closer_closed_get_static_delegate;
 952
 953
 954     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_closer_close_on_exec_get_delegate(System.IntPtr obj, System.IntPtr pd);
 955
 956
 957     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_closer_close_on_exec_get_api_delegate(System.IntPtr obj);
 958     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");
 959     private static bool close_on_exec_get(System.IntPtr obj, System.IntPtr pd)
 960    {
 961       Eina.Log.Debug("function efl_io_closer_close_on_exec_get was called");
 962       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 963       if(wrapper != null) {
 964                   bool _ret_var = default(bool);
 965          try {
 966             _ret_var = ((Thread)wrapper).GetCloseOnExec();
 967          } catch (Exception e) {
 968             Eina.Log.Warning($"Callback error: {e.ToString()}");
 969             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 970          }
 971       return _ret_var;
 972       } else {
 973          return efl_io_closer_close_on_exec_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 974       }
 975    }
 976    private static efl_io_closer_close_on_exec_get_delegate efl_io_closer_close_on_exec_get_static_delegate;
 977
 978
 979     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_closer_close_on_exec_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool close_on_exec);
 980
 981
 982     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_closer_close_on_exec_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool close_on_exec);
 983     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");
 984     private static bool close_on_exec_set(System.IntPtr obj, System.IntPtr pd,  bool close_on_exec)
 985    {
 986       Eina.Log.Debug("function efl_io_closer_close_on_exec_set was called");
 987       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 988       if(wrapper != null) {
 989                                     bool _ret_var = default(bool);
 990          try {
 991             _ret_var = ((Thread)wrapper).SetCloseOnExec( close_on_exec);
 992          } catch (Exception e) {
 993             Eina.Log.Warning($"Callback error: {e.ToString()}");
 994             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 995          }
 996                   return _ret_var;
 997       } else {
 998          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);
 999       }
1000    }
1001    private static efl_io_closer_close_on_exec_set_delegate efl_io_closer_close_on_exec_set_static_delegate;
1002
1003
1004     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_closer_close_on_invalidate_get_delegate(System.IntPtr obj, System.IntPtr pd);
1005
1006
1007     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_closer_close_on_invalidate_get_api_delegate(System.IntPtr obj);
1008     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");
1009     private static bool close_on_invalidate_get(System.IntPtr obj, System.IntPtr pd)
1010    {
1011       Eina.Log.Debug("function efl_io_closer_close_on_invalidate_get was called");
1012       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1013       if(wrapper != null) {
1014                   bool _ret_var = default(bool);
1015          try {
1016             _ret_var = ((Thread)wrapper).GetCloseOnInvalidate();
1017          } catch (Exception e) {
1018             Eina.Log.Warning($"Callback error: {e.ToString()}");
1019             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1020          }
1021       return _ret_var;
1022       } else {
1023          return efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1024       }
1025    }
1026    private static efl_io_closer_close_on_invalidate_get_delegate efl_io_closer_close_on_invalidate_get_static_delegate;
1027
1028
1029     private delegate  void efl_io_closer_close_on_invalidate_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool close_on_invalidate);
1030
1031
1032     public delegate  void efl_io_closer_close_on_invalidate_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool close_on_invalidate);
1033     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");
1034     private static  void close_on_invalidate_set(System.IntPtr obj, System.IntPtr pd,  bool close_on_invalidate)
1035    {
1036       Eina.Log.Debug("function efl_io_closer_close_on_invalidate_set was called");
1037       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1038       if(wrapper != null) {
1039
1040          try {
1041             ((Thread)wrapper).SetCloseOnInvalidate( close_on_invalidate);
1042          } catch (Exception e) {
1043             Eina.Log.Warning($"Callback error: {e.ToString()}");
1044             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1045          }
1046                         } else {
1047          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);
1048       }
1049    }
1050    private static efl_io_closer_close_on_invalidate_set_delegate efl_io_closer_close_on_invalidate_set_static_delegate;
1051
1052
1053     private delegate  Eina.Error efl_io_closer_close_delegate(System.IntPtr obj, System.IntPtr pd);
1054
1055
1056     public delegate  Eina.Error efl_io_closer_close_api_delegate(System.IntPtr obj);
1057     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");
1058     private static  Eina.Error close(System.IntPtr obj, System.IntPtr pd)
1059    {
1060       Eina.Log.Debug("function efl_io_closer_close was called");
1061       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1062       if(wrapper != null) {
1063                    Eina.Error _ret_var = default( Eina.Error);
1064          try {
1065             _ret_var = ((Thread)wrapper).Close();
1066          } catch (Exception e) {
1067             Eina.Log.Warning($"Callback error: {e.ToString()}");
1068             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1069          }
1070       return _ret_var;
1071       } else {
1072          return efl_io_closer_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1073       }
1074    }
1075    private static efl_io_closer_close_delegate efl_io_closer_close_static_delegate;
1076
1077
1078     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_reader_can_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
1079
1080
1081     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_reader_can_read_get_api_delegate(System.IntPtr obj);
1082     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");
1083     private static bool can_read_get(System.IntPtr obj, System.IntPtr pd)
1084    {
1085       Eina.Log.Debug("function efl_io_reader_can_read_get was called");
1086       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1087       if(wrapper != null) {
1088                   bool _ret_var = default(bool);
1089          try {
1090             _ret_var = ((Thread)wrapper).GetCanRead();
1091          } catch (Exception e) {
1092             Eina.Log.Warning($"Callback error: {e.ToString()}");
1093             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1094          }
1095       return _ret_var;
1096       } else {
1097          return efl_io_reader_can_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1098       }
1099    }
1100    private static efl_io_reader_can_read_get_delegate efl_io_reader_can_read_get_static_delegate;
1101
1102
1103     private delegate  void efl_io_reader_can_read_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool can_read);
1104
1105
1106     public delegate  void efl_io_reader_can_read_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool can_read);
1107     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");
1108     private static  void can_read_set(System.IntPtr obj, System.IntPtr pd,  bool can_read)
1109    {
1110       Eina.Log.Debug("function efl_io_reader_can_read_set was called");
1111       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1112       if(wrapper != null) {
1113
1114          try {
1115             ((Thread)wrapper).SetCanRead( can_read);
1116          } catch (Exception e) {
1117             Eina.Log.Warning($"Callback error: {e.ToString()}");
1118             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1119          }
1120                         } else {
1121          efl_io_reader_can_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  can_read);
1122       }
1123    }
1124    private static efl_io_reader_can_read_set_delegate efl_io_reader_can_read_set_static_delegate;
1125
1126
1127     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_reader_eos_get_delegate(System.IntPtr obj, System.IntPtr pd);
1128
1129
1130     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_reader_eos_get_api_delegate(System.IntPtr obj);
1131     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");
1132     private static bool eos_get(System.IntPtr obj, System.IntPtr pd)
1133    {
1134       Eina.Log.Debug("function efl_io_reader_eos_get was called");
1135       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1136       if(wrapper != null) {
1137                   bool _ret_var = default(bool);
1138          try {
1139             _ret_var = ((Thread)wrapper).GetEos();
1140          } catch (Exception e) {
1141             Eina.Log.Warning($"Callback error: {e.ToString()}");
1142             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1143          }
1144       return _ret_var;
1145       } else {
1146          return efl_io_reader_eos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1147       }
1148    }
1149    private static efl_io_reader_eos_get_delegate efl_io_reader_eos_get_static_delegate;
1150
1151
1152     private delegate  void efl_io_reader_eos_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool is_eos);
1153
1154
1155     public delegate  void efl_io_reader_eos_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool is_eos);
1156     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");
1157     private static  void eos_set(System.IntPtr obj, System.IntPtr pd,  bool is_eos)
1158    {
1159       Eina.Log.Debug("function efl_io_reader_eos_set was called");
1160       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1161       if(wrapper != null) {
1162
1163          try {
1164             ((Thread)wrapper).SetEos( is_eos);
1165          } catch (Exception e) {
1166             Eina.Log.Warning($"Callback error: {e.ToString()}");
1167             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1168          }
1169                         } else {
1170          efl_io_reader_eos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  is_eos);
1171       }
1172    }
1173    private static efl_io_reader_eos_set_delegate efl_io_reader_eos_set_static_delegate;
1174
1175
1176     private delegate  Eina.Error efl_io_reader_read_delegate(System.IntPtr obj, System.IntPtr pd,   ref Eina.RwSlice rw_slice);
1177
1178
1179     public delegate  Eina.Error efl_io_reader_read_api_delegate(System.IntPtr obj,   ref Eina.RwSlice rw_slice);
1180     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");
1181     private static  Eina.Error read(System.IntPtr obj, System.IntPtr pd,  ref Eina.RwSlice rw_slice)
1182    {
1183       Eina.Log.Debug("function efl_io_reader_read was called");
1184       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1185       if(wrapper != null) {
1186                                      Eina.Error _ret_var = default( Eina.Error);
1187          try {
1188             _ret_var = ((Thread)wrapper).Read( ref rw_slice);
1189          } catch (Exception e) {
1190             Eina.Log.Warning($"Callback error: {e.ToString()}");
1191             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1192          }
1193                   return _ret_var;
1194       } else {
1195          return efl_io_reader_read_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  ref rw_slice);
1196       }
1197    }
1198    private static efl_io_reader_read_delegate efl_io_reader_read_static_delegate;
1199
1200
1201     [return: MarshalAs(UnmanagedType.U1)] private delegate bool efl_io_writer_can_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
1202
1203
1204     [return: MarshalAs(UnmanagedType.U1)] public delegate bool efl_io_writer_can_write_get_api_delegate(System.IntPtr obj);
1205     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");
1206     private static bool can_write_get(System.IntPtr obj, System.IntPtr pd)
1207    {
1208       Eina.Log.Debug("function efl_io_writer_can_write_get was called");
1209       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1210       if(wrapper != null) {
1211                   bool _ret_var = default(bool);
1212          try {
1213             _ret_var = ((Thread)wrapper).GetCanWrite();
1214          } catch (Exception e) {
1215             Eina.Log.Warning($"Callback error: {e.ToString()}");
1216             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1217          }
1218       return _ret_var;
1219       } else {
1220          return efl_io_writer_can_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1221       }
1222    }
1223    private static efl_io_writer_can_write_get_delegate efl_io_writer_can_write_get_static_delegate;
1224
1225
1226     private delegate  void efl_io_writer_can_write_set_delegate(System.IntPtr obj, System.IntPtr pd,  [MarshalAs(UnmanagedType.U1)]  bool can_write);
1227
1228
1229     public delegate  void efl_io_writer_can_write_set_api_delegate(System.IntPtr obj,  [MarshalAs(UnmanagedType.U1)]  bool can_write);
1230     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");
1231     private static  void can_write_set(System.IntPtr obj, System.IntPtr pd,  bool can_write)
1232    {
1233       Eina.Log.Debug("function efl_io_writer_can_write_set was called");
1234       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1235       if(wrapper != null) {
1236
1237          try {
1238             ((Thread)wrapper).SetCanWrite( can_write);
1239          } catch (Exception e) {
1240             Eina.Log.Warning($"Callback error: {e.ToString()}");
1241             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1242          }
1243                         } else {
1244          efl_io_writer_can_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  can_write);
1245       }
1246    }
1247    private static efl_io_writer_can_write_set_delegate efl_io_writer_can_write_set_static_delegate;
1248
1249
1250     private delegate  Eina.Error efl_io_writer_write_delegate(System.IntPtr obj, System.IntPtr pd,   ref Eina.Slice slice,   ref Eina.Slice remaining);
1251
1252
1253     public delegate  Eina.Error efl_io_writer_write_api_delegate(System.IntPtr obj,   ref Eina.Slice slice,   ref Eina.Slice remaining);
1254     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");
1255     private static  Eina.Error write(System.IntPtr obj, System.IntPtr pd,  ref Eina.Slice slice,  ref Eina.Slice remaining)
1256    {
1257       Eina.Log.Debug("function efl_io_writer_write was called");
1258       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
1259       if(wrapper != null) {
1260                                  remaining = default(Eina.Slice);                      Eina.Error _ret_var = default( Eina.Error);
1261          try {
1262             _ret_var = ((Thread)wrapper).Write( ref slice,  ref remaining);
1263          } catch (Exception e) {
1264             Eina.Log.Warning($"Callback error: {e.ToString()}");
1265             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1266          }
1267                               return _ret_var;
1268       } else {
1269          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);
1270       }
1271    }
1272    private static efl_io_writer_write_delegate efl_io_writer_write_static_delegate;
1273 }
1274 }