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

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