internals/src/EflSharp/EflSharp/efl/efl_file.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 /// <summary>Efl file interface
  11 /// (Since EFL 1.22)</summary>
  12 [Efl.IFileConcrete.NativeMethods]
  13 public interface IFile :
  14     Efl.Eo.IWrapper, IDisposable
  15 {
  16     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  17 /// (Since EFL 1.22)</summary>
  18 /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
  19 Eina.File GetMmap();
  20     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  21 /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
  22 /// (Since EFL 1.22)</summary>
  23 /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
  24 /// <returns>0 on success, error code otherwise</returns>
  25 Eina.Error SetMmap(Eina.File f);
  26     /// <summary>Retrieve the file path from where an object is to fetch the data.
  27 /// You must not modify the strings on the returned pointers.
  28 /// (Since EFL 1.22)</summary>
  29 /// <returns>The file path.</returns>
  30 System.String GetFile();
  31     /// <summary>Set the file path from where an object will fetch the data.
  32 /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
  33 /// (Since EFL 1.22)</summary>
  34 /// <param name="file">The file path.</param>
  35 /// <returns>0 on success, error code otherwise</returns>
  36 Eina.Error SetFile(System.String file);
  37     /// <summary>Get the previously-set key which corresponds to the target data within a file.
  38 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
  39 ///
  40 /// You must not modify the strings on the returned pointers.
  41 /// (Since EFL 1.22)</summary>
  42 /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
  43 System.String GetKey();
  44     /// <summary>Set the key which corresponds to the target data within a file.
  45 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
  46 /// (Since EFL 1.22)</summary>
  47 /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
  48 void SetKey(System.String key);
  49     /// <summary>Get the load state of the object.
  50 /// (Since EFL 1.22)</summary>
  51 /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
  52 bool GetLoaded();
  53     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
  54 /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
  55 ///
  56 /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
  57 /// (Since EFL 1.22)</summary>
  58 /// <returns>0 on success, error code otherwise</returns>
  59 Eina.Error Load();
  60     /// <summary>Perform all necessary operations to unload file data from the object.
  61 /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
  62 ///
  63 /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
  64 /// (Since EFL 1.22)</summary>
  65 void Unload();
  66                                         /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
  67 /// (Since EFL 1.22)</summary>
  68 /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
  69     Eina.File Mmap {
  70         get ;
  71         set ;
  72     }
  73     /// <summary>Retrieve the file path from where an object is to fetch the data.
  74 /// You must not modify the strings on the returned pointers.
  75 /// (Since EFL 1.22)</summary>
  76 /// <value>The file path.</value>
  77     System.String File {
  78         get ;
  79         set ;
  80     }
  81     /// <summary>Get the previously-set key which corresponds to the target data within a file.
  82 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
  83 ///
  84 /// You must not modify the strings on the returned pointers.
  85 /// (Since EFL 1.22)</summary>
  86 /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
  87     System.String Key {
  88         get ;
  89         set ;
  90     }
  91     /// <summary>Get the load state of the object.
  92 /// (Since EFL 1.22)</summary>
  93 /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
  94     bool Loaded {
  95         get ;
  96     }
  97 }
  98 /// <summary>Efl file interface
  99 /// (Since EFL 1.22)</summary>
 100 sealed public class IFileConcrete :
 101
 102 IFile
 103
 104 {
 105     ///<summary>Pointer to the native class description.</summary>
 106     public System.IntPtr NativeClass
 107     {
 108         get
 109         {
 110             if (((object)this).GetType() == typeof(IFileConcrete))
 111             {
 112                 return GetEflClassStatic();
 113             }
 114             else
 115             {
 116                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
 117             }
 118         }
 119     }
 120
 121     private  System.IntPtr handle;
 122     ///<summary>Pointer to the native instance.</summary>
 123     public System.IntPtr NativeHandle
 124     {
 125         get { return handle; }
 126     }
 127
 128     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
 129         efl_file_mixin_get();
 130     /// <summary>Initializes a new instance of the <see cref="IFile"/> class.
 131     /// Internal usage: This is used when interacting with C code and should not be used directly.</summary>
 132     private IFileConcrete(System.IntPtr raw)
 133     {
 134         handle = raw;
 135     }
 136     ///<summary>Destructor.</summary>
 137     ~IFileConcrete()
 138     {
 139         Dispose(false);
 140     }
 141
 142     ///<summary>Releases the underlying native instance.</summary>
 143     private void Dispose(bool disposing)
 144     {
 145         if (handle != System.IntPtr.Zero)
 146         {
 147             IntPtr h = handle;
 148             handle = IntPtr.Zero;
 149
 150             IntPtr gcHandlePtr = IntPtr.Zero;
 151             if (disposing)
 152             {
 153                 Efl.Eo.Globals.efl_mono_native_dispose(h, gcHandlePtr);
 154             }
 155             else
 156             {
 157                 Monitor.Enter(Efl.All.InitLock);
 158                 if (Efl.All.MainLoopInitialized)
 159                 {
 160                     Efl.Eo.Globals.efl_mono_thread_safe_native_dispose(h, gcHandlePtr);
 161                 }
 162
 163                 Monitor.Exit(Efl.All.InitLock);
 164             }
 165         }
 166
 167     }
 168
 169     ///<summary>Releases the underlying native instance.</summary>
 170     public void Dispose()
 171     {
 172         Dispose(true);
 173         GC.SuppressFinalize(this);
 174     }
 175
 176     /// <summary>Verifies if the given object is equal to this one.</summary>
 177     /// <param name="instance">The object to compare to.</param>
 178     /// <returns>True if both objects point to the same native object.</returns>
 179     public override bool Equals(object instance)
 180     {
 181         var other = instance as Efl.Object;
 182         if (other == null)
 183         {
 184             return false;
 185         }
 186         return this.NativeHandle == other.NativeHandle;
 187     }
 188
 189     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
 190     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
 191     public override int GetHashCode()
 192     {
 193         return this.NativeHandle.ToInt32();
 194     }
 195
 196     /// <summary>Turns the native pointer into a string representation.</summary>
 197     /// <returns>A string with the type and the native pointer for this object.</returns>
 198     public override String ToString()
 199     {
 200         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
 201     }
 202
 203     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 204     /// (Since EFL 1.22)</summary>
 205     /// <returns>The handle to the <see cref="Eina.File"/> that will be used</returns>
 206     public Eina.File GetMmap() {
 207          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_get_ptr.Value.Delegate(this.NativeHandle);
 208         Eina.Error.RaiseIfUnhandledException();
 209         return _ret_var;
 210  }
 211     /// <summary>Set the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 212     /// If mmap is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 213     /// (Since EFL 1.22)</summary>
 214     /// <param name="f">The handle to the <see cref="Eina.File"/> that will be used</param>
 215     /// <returns>0 on success, error code otherwise</returns>
 216     public Eina.Error SetMmap(Eina.File f) {
 217                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_mmap_set_ptr.Value.Delegate(this.NativeHandle,f);
 218         Eina.Error.RaiseIfUnhandledException();
 219                         return _ret_var;
 220  }
 221     /// <summary>Retrieve the file path from where an object is to fetch the data.
 222     /// You must not modify the strings on the returned pointers.
 223     /// (Since EFL 1.22)</summary>
 224     /// <returns>The file path.</returns>
 225     public System.String GetFile() {
 226          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_get_ptr.Value.Delegate(this.NativeHandle);
 227         Eina.Error.RaiseIfUnhandledException();
 228         return _ret_var;
 229  }
 230     /// <summary>Set the file path from where an object will fetch the data.
 231     /// If file is set during object construction, the object will automatically call <see cref="Efl.IFile.Load"/> during the finalize phase of construction.
 232     /// (Since EFL 1.22)</summary>
 233     /// <param name="file">The file path.</param>
 234     /// <returns>0 on success, error code otherwise</returns>
 235     public Eina.Error SetFile(System.String file) {
 236                                  var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_set_ptr.Value.Delegate(this.NativeHandle,file);
 237         Eina.Error.RaiseIfUnhandledException();
 238                         return _ret_var;
 239  }
 240     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 241     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 242     ///
 243     /// You must not modify the strings on the returned pointers.
 244     /// (Since EFL 1.22)</summary>
 245     /// <returns>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</returns>
 246     public System.String GetKey() {
 247          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_key_get_ptr.Value.Delegate(this.NativeHandle);
 248         Eina.Error.RaiseIfUnhandledException();
 249         return _ret_var;
 250  }
 251     /// <summary>Set the key which corresponds to the target data within a file.
 252     /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases.
 253     /// (Since EFL 1.22)</summary>
 254     /// <param name="key">The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</param>
 255     public void SetKey(System.String key) {
 256                                  Efl.IFileConcrete.NativeMethods.efl_file_key_set_ptr.Value.Delegate(this.NativeHandle,key);
 257         Eina.Error.RaiseIfUnhandledException();
 258                          }
 259     /// <summary>Get the load state of the object.
 260     /// (Since EFL 1.22)</summary>
 261     /// <returns><c>true</c> if the object is loaded, <c>false</c> otherwise.</returns>
 262     public bool GetLoaded() {
 263          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_loaded_get_ptr.Value.Delegate(this.NativeHandle);
 264         Eina.Error.RaiseIfUnhandledException();
 265         return _ret_var;
 266  }
 267     /// <summary>Perform all necessary operations to open and load file data into the object using the <see cref="Efl.IFile.File"/> (or <see cref="Efl.IFile.Mmap"/>) and <see cref="Efl.IFile.Key"/> properties.
 268     /// In the case where <see cref="Efl.IFile.SetFile"/> has been called on an object, this will internally open the file and call <see cref="Efl.IFile.SetMmap"/> on the object using the opened file handle.
 269     ///
 270     /// Calling <see cref="Efl.IFile.Load"/> on an object which has already performed file operations based on the currently set properties will have no effect.
 271     /// (Since EFL 1.22)</summary>
 272     /// <returns>0 on success, error code otherwise</returns>
 273     public Eina.Error Load() {
 274          var _ret_var = Efl.IFileConcrete.NativeMethods.efl_file_load_ptr.Value.Delegate(this.NativeHandle);
 275         Eina.Error.RaiseIfUnhandledException();
 276         return _ret_var;
 277  }
 278     /// <summary>Perform all necessary operations to unload file data from the object.
 279     /// In the case where <see cref="Efl.IFile.SetMmap"/> has been externally called on an object, the file handle stored in the object will be preserved.
 280     ///
 281     /// Calling <see cref="Efl.IFile.Unload"/> on an object which is not currently loaded will have no effect.
 282     /// (Since EFL 1.22)</summary>
 283     public void Unload() {
 284          Efl.IFileConcrete.NativeMethods.efl_file_unload_ptr.Value.Delegate(this.NativeHandle);
 285         Eina.Error.RaiseIfUnhandledException();
 286          }
 287     /// <summary>Get the mmaped file from where an object will fetch the real data (it must be an <see cref="Eina.File"/>).
 288 /// (Since EFL 1.22)</summary>
 289 /// <value>The handle to the <see cref="Eina.File"/> that will be used</value>
 290     public Eina.File Mmap {
 291         get { return GetMmap(); }
 292         set { SetMmap(value); }
 293     }
 294     /// <summary>Retrieve the file path from where an object is to fetch the data.
 295 /// You must not modify the strings on the returned pointers.
 296 /// (Since EFL 1.22)</summary>
 297 /// <value>The file path.</value>
 298     public System.String File {
 299         get { return GetFile(); }
 300         set { SetFile(value); }
 301     }
 302     /// <summary>Get the previously-set key which corresponds to the target data within a file.
 303 /// Some filetypes can contain multiple data streams which are indexed by a key. Use this property for such cases (See for example <see cref="Efl.Ui.Image"/> or <see cref="Efl.Ui.Layout"/>).
 304 ///
 305 /// You must not modify the strings on the returned pointers.
 306 /// (Since EFL 1.22)</summary>
 307 /// <value>The group that the data belongs to. See the class documentation for particular implementations of this interface to see how this property is used.</value>
 308     public System.String Key {
 309         get { return GetKey(); }
 310         set { SetKey(value); }
 311     }
 312     /// <summary>Get the load state of the object.
 313 /// (Since EFL 1.22)</summary>
 314 /// <value><c>true</c> if the object is loaded, <c>false</c> otherwise.</value>
 315     public bool Loaded {
 316         get { return GetLoaded(); }
 317     }
 318     private static IntPtr GetEflClassStatic()
 319     {
 320         return Efl.IFileConcrete.efl_file_mixin_get();
 321     }
 322     /// <summary>Wrapper for native methods and virtual method delegates.
 323     /// For internal use by generated code only.</summary>
 324     public class NativeMethods  : Efl.Eo.NativeClass
 325     {
 326         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 327         /// <summary>Gets the list of Eo operations to override.</summary>
 328         /// <returns>The list of Eo operations to be overload.</returns>
 329         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 330         {
 331             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 332             var methods = Efl.Eo.Globals.GetUserMethods(type);
 333
 334             if (efl_file_mmap_get_static_delegate == null)
 335             {
 336                 efl_file_mmap_get_static_delegate = new efl_file_mmap_get_delegate(mmap_get);
 337             }
 338
 339             if (methods.FirstOrDefault(m => m.Name == "GetMmap") != null)
 340             {
 341                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_get_static_delegate) });
 342             }
 343
 344             if (efl_file_mmap_set_static_delegate == null)
 345             {
 346                 efl_file_mmap_set_static_delegate = new efl_file_mmap_set_delegate(mmap_set);
 347             }
 348
 349             if (methods.FirstOrDefault(m => m.Name == "SetMmap") != null)
 350             {
 351                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_mmap_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_mmap_set_static_delegate) });
 352             }
 353
 354             if (efl_file_get_static_delegate == null)
 355             {
 356                 efl_file_get_static_delegate = new efl_file_get_delegate(file_get);
 357             }
 358
 359             if (methods.FirstOrDefault(m => m.Name == "GetFile") != null)
 360             {
 361                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_get_static_delegate) });
 362             }
 363
 364             if (efl_file_set_static_delegate == null)
 365             {
 366                 efl_file_set_static_delegate = new efl_file_set_delegate(file_set);
 367             }
 368
 369             if (methods.FirstOrDefault(m => m.Name == "SetFile") != null)
 370             {
 371                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_set_static_delegate) });
 372             }
 373
 374             if (efl_file_key_get_static_delegate == null)
 375             {
 376                 efl_file_key_get_static_delegate = new efl_file_key_get_delegate(key_get);
 377             }
 378
 379             if (methods.FirstOrDefault(m => m.Name == "GetKey") != null)
 380             {
 381                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_get_static_delegate) });
 382             }
 383
 384             if (efl_file_key_set_static_delegate == null)
 385             {
 386                 efl_file_key_set_static_delegate = new efl_file_key_set_delegate(key_set);
 387             }
 388
 389             if (methods.FirstOrDefault(m => m.Name == "SetKey") != null)
 390             {
 391                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_key_set"), func = Marshal.GetFunctionPointerForDelegate(efl_file_key_set_static_delegate) });
 392             }
 393
 394             if (efl_file_loaded_get_static_delegate == null)
 395             {
 396                 efl_file_loaded_get_static_delegate = new efl_file_loaded_get_delegate(loaded_get);
 397             }
 398
 399             if (methods.FirstOrDefault(m => m.Name == "GetLoaded") != null)
 400             {
 401                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_loaded_get"), func = Marshal.GetFunctionPointerForDelegate(efl_file_loaded_get_static_delegate) });
 402             }
 403
 404             if (efl_file_load_static_delegate == null)
 405             {
 406                 efl_file_load_static_delegate = new efl_file_load_delegate(load);
 407             }
 408
 409             if (methods.FirstOrDefault(m => m.Name == "Load") != null)
 410             {
 411                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_load"), func = Marshal.GetFunctionPointerForDelegate(efl_file_load_static_delegate) });
 412             }
 413
 414             if (efl_file_unload_static_delegate == null)
 415             {
 416                 efl_file_unload_static_delegate = new efl_file_unload_delegate(unload);
 417             }
 418
 419             if (methods.FirstOrDefault(m => m.Name == "Unload") != null)
 420             {
 421                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_file_unload"), func = Marshal.GetFunctionPointerForDelegate(efl_file_unload_static_delegate) });
 422             }
 423
 424             return descs;
 425         }
 426         /// <summary>Returns the Eo class for the native methods of this class.</summary>
 427         /// <returns>The native class pointer.</returns>
 428         public override IntPtr GetEflClass()
 429         {
 430             return Efl.IFileConcrete.efl_file_mixin_get();
 431         }
 432
 433         #pragma warning disable CA1707, SA1300, SA1600
 434
 435
 436         private delegate Eina.File efl_file_mmap_get_delegate(System.IntPtr obj, System.IntPtr pd);
 437
 438
 439         public delegate Eina.File efl_file_mmap_get_api_delegate(System.IntPtr obj);
 440
 441         public static Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate> efl_file_mmap_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_get_api_delegate>(Module, "efl_file_mmap_get");
 442
 443         private static Eina.File mmap_get(System.IntPtr obj, System.IntPtr pd)
 444         {
 445             Eina.Log.Debug("function efl_file_mmap_get was called");
 446             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 447             if (wrapper != null)
 448             {
 449             Eina.File _ret_var = default(Eina.File);
 450                 try
 451                 {
 452                     _ret_var = ((IFileConcrete)wrapper).GetMmap();
 453                 }
 454                 catch (Exception e)
 455                 {
 456                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 457                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 458                 }
 459
 460         return _ret_var;
 461
 462             }
 463             else
 464             {
 465                 return efl_file_mmap_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 466             }
 467         }
 468
 469         private static efl_file_mmap_get_delegate efl_file_mmap_get_static_delegate;
 470
 471
 472         private delegate Eina.Error efl_file_mmap_set_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.File f);
 473
 474
 475         public delegate Eina.Error efl_file_mmap_set_api_delegate(System.IntPtr obj,  Eina.File f);
 476
 477         public static Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate> efl_file_mmap_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_mmap_set_api_delegate>(Module, "efl_file_mmap_set");
 478
 479         private static Eina.Error mmap_set(System.IntPtr obj, System.IntPtr pd, Eina.File f)
 480         {
 481             Eina.Log.Debug("function efl_file_mmap_set was called");
 482             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 483             if (wrapper != null)
 484             {
 485                                     Eina.Error _ret_var = default(Eina.Error);
 486                 try
 487                 {
 488                     _ret_var = ((IFileConcrete)wrapper).SetMmap(f);
 489                 }
 490                 catch (Exception e)
 491                 {
 492                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 493                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 494                 }
 495
 496                         return _ret_var;
 497
 498             }
 499             else
 500             {
 501                 return efl_file_mmap_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), f);
 502             }
 503         }
 504
 505         private static efl_file_mmap_set_delegate efl_file_mmap_set_static_delegate;
 506
 507         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 508         private delegate System.String efl_file_get_delegate(System.IntPtr obj, System.IntPtr pd);
 509
 510         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 511         public delegate System.String efl_file_get_api_delegate(System.IntPtr obj);
 512
 513         public static Efl.Eo.FunctionWrapper<efl_file_get_api_delegate> efl_file_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_get_api_delegate>(Module, "efl_file_get");
 514
 515         private static System.String file_get(System.IntPtr obj, System.IntPtr pd)
 516         {
 517             Eina.Log.Debug("function efl_file_get was called");
 518             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 519             if (wrapper != null)
 520             {
 521             System.String _ret_var = default(System.String);
 522                 try
 523                 {
 524                     _ret_var = ((IFileConcrete)wrapper).GetFile();
 525                 }
 526                 catch (Exception e)
 527                 {
 528                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 529                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 530                 }
 531
 532         return _ret_var;
 533
 534             }
 535             else
 536             {
 537                 return efl_file_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 538             }
 539         }
 540
 541         private static efl_file_get_delegate efl_file_get_static_delegate;
 542
 543
 544         private delegate Eina.Error efl_file_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
 545
 546
 547         public delegate Eina.Error efl_file_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String file);
 548
 549         public static Efl.Eo.FunctionWrapper<efl_file_set_api_delegate> efl_file_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_set_api_delegate>(Module, "efl_file_set");
 550
 551         private static Eina.Error file_set(System.IntPtr obj, System.IntPtr pd, System.String file)
 552         {
 553             Eina.Log.Debug("function efl_file_set was called");
 554             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 555             if (wrapper != null)
 556             {
 557                                     Eina.Error _ret_var = default(Eina.Error);
 558                 try
 559                 {
 560                     _ret_var = ((IFileConcrete)wrapper).SetFile(file);
 561                 }
 562                 catch (Exception e)
 563                 {
 564                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 565                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 566                 }
 567
 568                         return _ret_var;
 569
 570             }
 571             else
 572             {
 573                 return efl_file_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), file);
 574             }
 575         }
 576
 577         private static efl_file_set_delegate efl_file_set_static_delegate;
 578
 579         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 580         private delegate System.String efl_file_key_get_delegate(System.IntPtr obj, System.IntPtr pd);
 581
 582         [return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))]
 583         public delegate System.String efl_file_key_get_api_delegate(System.IntPtr obj);
 584
 585         public static Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate> efl_file_key_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_get_api_delegate>(Module, "efl_file_key_get");
 586
 587         private static System.String key_get(System.IntPtr obj, System.IntPtr pd)
 588         {
 589             Eina.Log.Debug("function efl_file_key_get was called");
 590             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 591             if (wrapper != null)
 592             {
 593             System.String _ret_var = default(System.String);
 594                 try
 595                 {
 596                     _ret_var = ((IFileConcrete)wrapper).GetKey();
 597                 }
 598                 catch (Exception e)
 599                 {
 600                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 601                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 602                 }
 603
 604         return _ret_var;
 605
 606             }
 607             else
 608             {
 609                 return efl_file_key_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 610             }
 611         }
 612
 613         private static efl_file_key_get_delegate efl_file_key_get_static_delegate;
 614
 615
 616         private delegate void efl_file_key_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
 617
 618
 619         public delegate void efl_file_key_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(Efl.Eo.StringKeepOwnershipMarshaler))] System.String key);
 620
 621         public static Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate> efl_file_key_set_ptr = new Efl.Eo.FunctionWrapper<efl_file_key_set_api_delegate>(Module, "efl_file_key_set");
 622
 623         private static void key_set(System.IntPtr obj, System.IntPtr pd, System.String key)
 624         {
 625             Eina.Log.Debug("function efl_file_key_set was called");
 626             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 627             if (wrapper != null)
 628             {
 629
 630                 try
 631                 {
 632                     ((IFileConcrete)wrapper).SetKey(key);
 633                 }
 634                 catch (Exception e)
 635                 {
 636                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 637                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 638                 }
 639
 640
 641             }
 642             else
 643             {
 644                 efl_file_key_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), key);
 645             }
 646         }
 647
 648         private static efl_file_key_set_delegate efl_file_key_set_static_delegate;
 649
 650         [return: MarshalAs(UnmanagedType.U1)]
 651         private delegate bool efl_file_loaded_get_delegate(System.IntPtr obj, System.IntPtr pd);
 652
 653         [return: MarshalAs(UnmanagedType.U1)]
 654         public delegate bool efl_file_loaded_get_api_delegate(System.IntPtr obj);
 655
 656         public static Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate> efl_file_loaded_get_ptr = new Efl.Eo.FunctionWrapper<efl_file_loaded_get_api_delegate>(Module, "efl_file_loaded_get");
 657
 658         private static bool loaded_get(System.IntPtr obj, System.IntPtr pd)
 659         {
 660             Eina.Log.Debug("function efl_file_loaded_get was called");
 661             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 662             if (wrapper != null)
 663             {
 664             bool _ret_var = default(bool);
 665                 try
 666                 {
 667                     _ret_var = ((IFileConcrete)wrapper).GetLoaded();
 668                 }
 669                 catch (Exception e)
 670                 {
 671                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 672                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 673                 }
 674
 675         return _ret_var;
 676
 677             }
 678             else
 679             {
 680                 return efl_file_loaded_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 681             }
 682         }
 683
 684         private static efl_file_loaded_get_delegate efl_file_loaded_get_static_delegate;
 685
 686
 687         private delegate Eina.Error efl_file_load_delegate(System.IntPtr obj, System.IntPtr pd);
 688
 689
 690         public delegate Eina.Error efl_file_load_api_delegate(System.IntPtr obj);
 691
 692         public static Efl.Eo.FunctionWrapper<efl_file_load_api_delegate> efl_file_load_ptr = new Efl.Eo.FunctionWrapper<efl_file_load_api_delegate>(Module, "efl_file_load");
 693
 694         private static Eina.Error load(System.IntPtr obj, System.IntPtr pd)
 695         {
 696             Eina.Log.Debug("function efl_file_load was called");
 697             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 698             if (wrapper != null)
 699             {
 700             Eina.Error _ret_var = default(Eina.Error);
 701                 try
 702                 {
 703                     _ret_var = ((IFileConcrete)wrapper).Load();
 704                 }
 705                 catch (Exception e)
 706                 {
 707                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 708                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 709                 }
 710
 711         return _ret_var;
 712
 713             }
 714             else
 715             {
 716                 return efl_file_load_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 717             }
 718         }
 719
 720         private static efl_file_load_delegate efl_file_load_static_delegate;
 721
 722
 723         private delegate void efl_file_unload_delegate(System.IntPtr obj, System.IntPtr pd);
 724
 725
 726         public delegate void efl_file_unload_api_delegate(System.IntPtr obj);
 727
 728         public static Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate> efl_file_unload_ptr = new Efl.Eo.FunctionWrapper<efl_file_unload_api_delegate>(Module, "efl_file_unload");
 729
 730         private static void unload(System.IntPtr obj, System.IntPtr pd)
 731         {
 732             Eina.Log.Debug("function efl_file_unload was called");
 733             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
 734             if (wrapper != null)
 735             {
 736
 737                 try
 738                 {
 739                     ((IFileConcrete)wrapper).Unload();
 740                 }
 741                 catch (Exception e)
 742                 {
 743                     Eina.Log.Warning($"Callback error: {e.ToString()}");
 744                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 745                 }
 746
 747
 748             }
 749             else
 750             {
 751                 efl_file_unload_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
 752             }
 753         }
 754
 755         private static efl_file_unload_delegate efl_file_unload_static_delegate;
 756
 757         #pragma warning restore CA1707, SA1300, SA1600
 758
 759 }
 760 }
 761 }
 762