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

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