internals/src/EflSharp/EflSharp/efl_task.eo.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.ComponentModel;
   7 namespace Efl {
   8 /// <summary>No description supplied.</summary>
   9 [TaskNativeInherit]
  10 public class Task : Efl.LoopConsumer, Efl.Eo.IWrapper
  11 {
  12    public new static System.IntPtr klass = System.IntPtr.Zero;
  13    public new static Efl.TaskNativeInherit nativeInherit = new Efl.TaskNativeInherit();
  14    ///<summary>Pointer to the native class description.</summary>
  15    public override System.IntPtr NativeClass {
  16       get {
  17          if (((object)this).GetType() == typeof (Task))
  18             return Efl.TaskNativeInherit.GetEflClassStatic();
  19          else
  20             return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  21       }
  22    }
  23    [System.Runtime.InteropServices.DllImport(efl.Libs.Ecore)] internal static extern System.IntPtr
  24       efl_task_class_get();
  25    ///<summary>Creates a new instance.</summary>
  26    ///<param name="parent">Parent instance.</param>
  27    public Task(Efl.Object parent= null
  28          ) :
  29       base(efl_task_class_get(), typeof(Task), parent)
  30    {
  31       FinishInstantiation();
  32    }
  33    ///<summary>Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  34    public Task(System.IntPtr raw) : base(raw)
  35    {
  36             register_event_proxies();
  37    }
  38    ///<summary>Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  39    protected Task(IntPtr base_klass, System.Type managed_type, Efl.Object parent) : base(base_klass, managed_type, parent) {}
  40    ///<summary>Casts obj into an instance of this type.</summary>
  41    public new static Task static_cast(Efl.Object obj)
  42    {
  43       if (obj == null)
  44          throw new System.ArgumentNullException("obj");
  45       return new Task(obj.NativeHandle);
  46    }
  47    ///<summary>Verifies if the given object is equal to this one.</summary>
  48    public override bool Equals(object obj)
  49    {
  50       var other = obj as Efl.Object;
  51       if (other == null)
  52          return false;
  53       return this.NativeHandle == other.NativeHandle;
  54    }
  55    ///<summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  56    public override int GetHashCode()
  57    {
  58       return this.NativeHandle.ToInt32();
  59    }
  60    ///<summary>Turns the native pointer into a string representation.</summary>
  61    public override String ToString()
  62    {
  63       return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  64    }
  65    protected override void register_event_proxies()
  66    {
  67       base.register_event_proxies();
  68    }
  69    /// <summary>The priority of this task.</summary>
  70    /// <returns>No description supplied.</returns>
  71    virtual public Efl.TaskPriority GetPriority() {
  72        var _ret_var = Efl.TaskNativeInherit.efl_task_priority_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  73       Eina.Error.RaiseIfUnhandledException();
  74       return _ret_var;
  75  }
  76    /// <summary>The priority of this task.</summary>
  77    /// <param name="priority">No description supplied.</param>
  78    /// <returns></returns>
  79    virtual public  void SetPriority( Efl.TaskPriority priority) {
  80                          Efl.TaskNativeInherit.efl_task_priority_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), priority);
  81       Eina.Error.RaiseIfUnhandledException();
  82                    }
  83    /// <summary>The final exit code of this task.</summary>
  84    /// <returns>No description supplied.</returns>
  85    virtual public  int GetExitCode() {
  86        var _ret_var = Efl.TaskNativeInherit.efl_task_exit_code_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  87       Eina.Error.RaiseIfUnhandledException();
  88       return _ret_var;
  89  }
  90    /// <summary></summary>
  91    /// <returns>No description supplied.</returns>
  92    virtual public Efl.TaskFlags GetFlags() {
  93        var _ret_var = Efl.TaskNativeInherit.efl_task_flags_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
  94       Eina.Error.RaiseIfUnhandledException();
  95       return _ret_var;
  96  }
  97    /// <summary></summary>
  98    /// <param name="flags">No description supplied.</param>
  99    /// <returns></returns>
 100    virtual public  void SetFlags( Efl.TaskFlags flags) {
 101                          Efl.TaskNativeInherit.efl_task_flags_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle), flags);
 102       Eina.Error.RaiseIfUnhandledException();
 103                    }
 104    /// <summary>Actually run the task</summary>
 105    /// <returns>A future triggered when task exits and is passed int exit code</returns>
 106    virtual public  Eina.Future Run() {
 107        var _ret_var = Efl.TaskNativeInherit.efl_task_run_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 108       Eina.Error.RaiseIfUnhandledException();
 109       return _ret_var;
 110  }
 111    /// <summary>Request the task end (may send a signal or interrupt signal resulting in a terminate event being tiggered in the target task loop)</summary>
 112    /// <returns></returns>
 113    virtual public  void End() {
 114        Efl.TaskNativeInherit.efl_task_end_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 115       Eina.Error.RaiseIfUnhandledException();
 116        }
 117    public System.Threading.Tasks.Task<Eina.Value> RunAsync( System.Threading.CancellationToken token=default(System.Threading.CancellationToken))
 118    {
 119       Eina.Future future = Run();
 120       return Efl.Eo.Globals.WrapAsync(future, token);
 121    }
 122    /// <summary>The priority of this task.</summary>
 123 /// <value>No description supplied.</value>
 124    public Efl.TaskPriority Priority {
 125       get { return GetPriority(); }
 126       set { SetPriority( value); }
 127    }
 128    /// <summary>The final exit code of this task.</summary>
 129 /// <value>No description supplied.</value>
 130    public  int ExitCode {
 131       get { return GetExitCode(); }
 132    }
 133    /// <summary></summary>
 134 /// <value>No description supplied.</value>
 135    public Efl.TaskFlags Flags {
 136       get { return GetFlags(); }
 137       set { SetFlags( value); }
 138    }
 139    private static new  IntPtr GetEflClassStatic()
 140    {
 141       return Efl.Task.efl_task_class_get();
 142    }
 143 }
 144 public class TaskNativeInherit : Efl.LoopConsumerNativeInherit{
 145    public new  static Efl.Eo.NativeModule _Module = new Efl.Eo.NativeModule(efl.Libs.Ecore);
 146    public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 147    {
 148       var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 149       if (efl_task_priority_get_static_delegate == null)
 150       efl_task_priority_get_static_delegate = new efl_task_priority_get_delegate(priority_get);
 151       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_priority_get"), func = Marshal.GetFunctionPointerForDelegate(efl_task_priority_get_static_delegate)});
 152       if (efl_task_priority_set_static_delegate == null)
 153       efl_task_priority_set_static_delegate = new efl_task_priority_set_delegate(priority_set);
 154       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_priority_set"), func = Marshal.GetFunctionPointerForDelegate(efl_task_priority_set_static_delegate)});
 155       if (efl_task_exit_code_get_static_delegate == null)
 156       efl_task_exit_code_get_static_delegate = new efl_task_exit_code_get_delegate(exit_code_get);
 157       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_exit_code_get"), func = Marshal.GetFunctionPointerForDelegate(efl_task_exit_code_get_static_delegate)});
 158       if (efl_task_flags_get_static_delegate == null)
 159       efl_task_flags_get_static_delegate = new efl_task_flags_get_delegate(flags_get);
 160       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_flags_get"), func = Marshal.GetFunctionPointerForDelegate(efl_task_flags_get_static_delegate)});
 161       if (efl_task_flags_set_static_delegate == null)
 162       efl_task_flags_set_static_delegate = new efl_task_flags_set_delegate(flags_set);
 163       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_flags_set"), func = Marshal.GetFunctionPointerForDelegate(efl_task_flags_set_static_delegate)});
 164       if (efl_task_run_static_delegate == null)
 165       efl_task_run_static_delegate = new efl_task_run_delegate(run);
 166       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_run"), func = Marshal.GetFunctionPointerForDelegate(efl_task_run_static_delegate)});
 167       if (efl_task_end_static_delegate == null)
 168       efl_task_end_static_delegate = new efl_task_end_delegate(end);
 169       descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(_Module.Module, "efl_task_end"), func = Marshal.GetFunctionPointerForDelegate(efl_task_end_static_delegate)});
 170       descs.AddRange(base.GetEoOps(type));
 171       return descs;
 172    }
 173    public override IntPtr GetEflClass()
 174    {
 175       return Efl.Task.efl_task_class_get();
 176    }
 177    public static new  IntPtr GetEflClassStatic()
 178    {
 179       return Efl.Task.efl_task_class_get();
 180    }
 181
 182
 183     private delegate Efl.TaskPriority efl_task_priority_get_delegate(System.IntPtr obj, System.IntPtr pd);
 184
 185
 186     public delegate Efl.TaskPriority efl_task_priority_get_api_delegate(System.IntPtr obj);
 187     public static Efl.Eo.FunctionWrapper<efl_task_priority_get_api_delegate> efl_task_priority_get_ptr = new Efl.Eo.FunctionWrapper<efl_task_priority_get_api_delegate>(_Module, "efl_task_priority_get");
 188     private static Efl.TaskPriority priority_get(System.IntPtr obj, System.IntPtr pd)
 189    {
 190       Eina.Log.Debug("function efl_task_priority_get was called");
 191       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 192       if(wrapper != null) {
 193                   Efl.TaskPriority _ret_var = default(Efl.TaskPriority);
 194          try {
 195             _ret_var = ((Task)wrapper).GetPriority();
 196          } catch (Exception e) {
 197             Eina.Log.Warning($"Callback error: {e.ToString()}");
 198             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 199          }
 200       return _ret_var;
 201       } else {
 202          return efl_task_priority_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 203       }
 204    }
 205    private static efl_task_priority_get_delegate efl_task_priority_get_static_delegate;
 206
 207
 208     private delegate  void efl_task_priority_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TaskPriority priority);
 209
 210
 211     public delegate  void efl_task_priority_set_api_delegate(System.IntPtr obj,   Efl.TaskPriority priority);
 212     public static Efl.Eo.FunctionWrapper<efl_task_priority_set_api_delegate> efl_task_priority_set_ptr = new Efl.Eo.FunctionWrapper<efl_task_priority_set_api_delegate>(_Module, "efl_task_priority_set");
 213     private static  void priority_set(System.IntPtr obj, System.IntPtr pd,  Efl.TaskPriority priority)
 214    {
 215       Eina.Log.Debug("function efl_task_priority_set was called");
 216       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 217       if(wrapper != null) {
 218
 219          try {
 220             ((Task)wrapper).SetPriority( priority);
 221          } catch (Exception e) {
 222             Eina.Log.Warning($"Callback error: {e.ToString()}");
 223             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 224          }
 225                         } else {
 226          efl_task_priority_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  priority);
 227       }
 228    }
 229    private static efl_task_priority_set_delegate efl_task_priority_set_static_delegate;
 230
 231
 232     private delegate  int efl_task_exit_code_get_delegate(System.IntPtr obj, System.IntPtr pd);
 233
 234
 235     public delegate  int efl_task_exit_code_get_api_delegate(System.IntPtr obj);
 236     public static Efl.Eo.FunctionWrapper<efl_task_exit_code_get_api_delegate> efl_task_exit_code_get_ptr = new Efl.Eo.FunctionWrapper<efl_task_exit_code_get_api_delegate>(_Module, "efl_task_exit_code_get");
 237     private static  int exit_code_get(System.IntPtr obj, System.IntPtr pd)
 238    {
 239       Eina.Log.Debug("function efl_task_exit_code_get was called");
 240       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 241       if(wrapper != null) {
 242                    int _ret_var = default( int);
 243          try {
 244             _ret_var = ((Task)wrapper).GetExitCode();
 245          } catch (Exception e) {
 246             Eina.Log.Warning($"Callback error: {e.ToString()}");
 247             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 248          }
 249       return _ret_var;
 250       } else {
 251          return efl_task_exit_code_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 252       }
 253    }
 254    private static efl_task_exit_code_get_delegate efl_task_exit_code_get_static_delegate;
 255
 256
 257     private delegate Efl.TaskFlags efl_task_flags_get_delegate(System.IntPtr obj, System.IntPtr pd);
 258
 259
 260     public delegate Efl.TaskFlags efl_task_flags_get_api_delegate(System.IntPtr obj);
 261     public static Efl.Eo.FunctionWrapper<efl_task_flags_get_api_delegate> efl_task_flags_get_ptr = new Efl.Eo.FunctionWrapper<efl_task_flags_get_api_delegate>(_Module, "efl_task_flags_get");
 262     private static Efl.TaskFlags flags_get(System.IntPtr obj, System.IntPtr pd)
 263    {
 264       Eina.Log.Debug("function efl_task_flags_get was called");
 265       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 266       if(wrapper != null) {
 267                   Efl.TaskFlags _ret_var = default(Efl.TaskFlags);
 268          try {
 269             _ret_var = ((Task)wrapper).GetFlags();
 270          } catch (Exception e) {
 271             Eina.Log.Warning($"Callback error: {e.ToString()}");
 272             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 273          }
 274       return _ret_var;
 275       } else {
 276          return efl_task_flags_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 277       }
 278    }
 279    private static efl_task_flags_get_delegate efl_task_flags_get_static_delegate;
 280
 281
 282     private delegate  void efl_task_flags_set_delegate(System.IntPtr obj, System.IntPtr pd,   Efl.TaskFlags flags);
 283
 284
 285     public delegate  void efl_task_flags_set_api_delegate(System.IntPtr obj,   Efl.TaskFlags flags);
 286     public static Efl.Eo.FunctionWrapper<efl_task_flags_set_api_delegate> efl_task_flags_set_ptr = new Efl.Eo.FunctionWrapper<efl_task_flags_set_api_delegate>(_Module, "efl_task_flags_set");
 287     private static  void flags_set(System.IntPtr obj, System.IntPtr pd,  Efl.TaskFlags flags)
 288    {
 289       Eina.Log.Debug("function efl_task_flags_set was called");
 290       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 291       if(wrapper != null) {
 292
 293          try {
 294             ((Task)wrapper).SetFlags( flags);
 295          } catch (Exception e) {
 296             Eina.Log.Warning($"Callback error: {e.ToString()}");
 297             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 298          }
 299                         } else {
 300          efl_task_flags_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)),  flags);
 301       }
 302    }
 303    private static efl_task_flags_set_delegate efl_task_flags_set_static_delegate;
 304
 305
 306    [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))] private delegate  Eina.Future efl_task_run_delegate(System.IntPtr obj, System.IntPtr pd);
 307
 308
 309    [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Eina.FutureMarshaler))] public delegate  Eina.Future efl_task_run_api_delegate(System.IntPtr obj);
 310     public static Efl.Eo.FunctionWrapper<efl_task_run_api_delegate> efl_task_run_ptr = new Efl.Eo.FunctionWrapper<efl_task_run_api_delegate>(_Module, "efl_task_run");
 311     private static  Eina.Future run(System.IntPtr obj, System.IntPtr pd)
 312    {
 313       Eina.Log.Debug("function efl_task_run was called");
 314       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 315       if(wrapper != null) {
 316                    Eina.Future _ret_var = default( Eina.Future);
 317          try {
 318             _ret_var = ((Task)wrapper).Run();
 319          } catch (Exception e) {
 320             Eina.Log.Warning($"Callback error: {e.ToString()}");
 321             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 322          }
 323       return _ret_var;
 324       } else {
 325          return efl_task_run_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 326       }
 327    }
 328    private static efl_task_run_delegate efl_task_run_static_delegate;
 329
 330
 331     private delegate  void efl_task_end_delegate(System.IntPtr obj, System.IntPtr pd);
 332
 333
 334     public delegate  void efl_task_end_api_delegate(System.IntPtr obj);
 335     public static Efl.Eo.FunctionWrapper<efl_task_end_api_delegate> efl_task_end_ptr = new Efl.Eo.FunctionWrapper<efl_task_end_api_delegate>(_Module, "efl_task_end");
 336     private static  void end(System.IntPtr obj, System.IntPtr pd)
 337    {
 338       Eina.Log.Debug("function efl_task_end was called");
 339       Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.data_get(pd);
 340       if(wrapper != null) {
 341
 342          try {
 343             ((Task)wrapper).End();
 344          } catch (Exception e) {
 345             Eina.Log.Warning($"Callback error: {e.ToString()}");
 346             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 347          }
 348             } else {
 349          efl_task_end_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 350       }
 351    }
 352    private static efl_task_end_delegate efl_task_end_static_delegate;
 353 }
 354 }
 355 namespace Efl {
 356 /// <summary>No description supplied.</summary>
 357 public enum TaskPriority
 358 {
 359 /// <summary></summary>
 360 Normal = 0,
 361 /// <summary></summary>
 362 Background = 1,
 363 /// <summary></summary>
 364 Low = 2,
 365 /// <summary></summary>
 366 High = 3,
 367 /// <summary></summary>
 368 Ultra = 4,
 369 }
 370 }
 371 namespace Efl {
 372 /// <summary>No description supplied.</summary>
 373 public enum TaskFlags
 374 {
 375 /// <summary></summary>
 376 None = 0,
 377 /// <summary></summary>
 378 UseStdin = 1,
 379 /// <summary></summary>
 380 UseStdout = 2,
 381 /// <summary></summary>
 382 NoExitCodeError = 4,
 383 }
 384 }