internals/src/EflSharp/EflSharp/efl/efl_io_buffer.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 namespace Io {
  11
  12 /// <summary>Generic In-memory buffer of data to be used as I/O.
  13 /// This class offers both input and output, which can be used at the same time since <see cref="Efl.Io.IReader.Read"/> and <see cref="Efl.Io.IWriter.Write"/> use different offsets/position internally.
  14 ///
  15 /// One can get temporary direct access to internal buffer with <see cref="Efl.Io.Buffer.GetSlice"/> or steal the buffer with <see cref="Efl.Io.Buffer.BinbufSteal"/>.
  16 ///
  17 /// A fixed sized buffer can be implemented by setting <see cref="Efl.Io.Buffer.Limit"/> followed by <see cref="Efl.Io.Buffer.Preallocate"/></summary>
  18 [Efl.Io.Buffer.NativeMethods]
  19 public class Buffer : Efl.Object, Efl.Eo.IWrapper,Efl.Io.ICloser,Efl.Io.IPositioner,Efl.Io.IReader,Efl.Io.ISizer,Efl.Io.IWriter
  20 {
  21     ///<summary>Pointer to the native class description.</summary>
  22     public override System.IntPtr NativeClass
  23     {
  24         get
  25         {
  26             if (((object)this).GetType() == typeof(Buffer))
  27             {
  28                 return GetEflClassStatic();
  29             }
  30             else
  31             {
  32                 return Efl.Eo.ClassRegister.klassFromType[((object)this).GetType()];
  33             }
  34         }
  35     }
  36
  37     [System.Runtime.InteropServices.DllImport(efl.Libs.Efl)] internal static extern System.IntPtr
  38         efl_io_buffer_class_get();
  39     /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.</summary>
  40     /// <param name="parent">Parent instance.</param>
  41     public Buffer(Efl.Object parent= null
  42             ) : base(efl_io_buffer_class_get(), typeof(Buffer), parent)
  43     {
  44         FinishInstantiation();
  45     }
  46
  47     /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.
  48     /// Internal usage: Constructs an instance from a native pointer. This is used when interacting with C code and should not be used directly.</summary>
  49     /// <param name="raw">The native pointer to be wrapped.</param>
  50     protected Buffer(System.IntPtr raw) : base(raw)
  51     {
  52             }
  53
  54     /// <summary>Initializes a new instance of the <see cref="Buffer"/> class.
  55     /// Internal usage: Constructor to forward the wrapper initialization to the root class that interfaces with native code. Should not be used directly.</summary>
  56     /// <param name="baseKlass">The pointer to the base native Eo class.</param>
  57     /// <param name="managedType">The managed type of the public constructor that originated this call.</param>
  58     /// <param name="parent">The Efl.Object parent of this instance.</param>
  59     protected Buffer(IntPtr baseKlass, System.Type managedType, Efl.Object parent) : base(baseKlass, managedType, parent)
  60     {
  61     }
  62
  63     /// <summary>Verifies if the given object is equal to this one.</summary>
  64     /// <param name="instance">The object to compare to.</param>
  65     /// <returns>True if both objects point to the same native object.</returns>
  66     public override bool Equals(object instance)
  67     {
  68         var other = instance as Efl.Object;
  69         if (other == null)
  70         {
  71             return false;
  72         }
  73         return this.NativeHandle == other.NativeHandle;
  74     }
  75
  76     /// <summary>Gets the hash code for this object based on the native pointer it points to.</summary>
  77     /// <returns>The value of the pointer, to be used as the hash code of this object.</returns>
  78     public override int GetHashCode()
  79     {
  80         return this.NativeHandle.ToInt32();
  81     }
  82
  83     /// <summary>Turns the native pointer into a string representation.</summary>
  84     /// <returns>A string with the type and the native pointer for this object.</returns>
  85     public override String ToString()
  86     {
  87         return $"{this.GetType().Name}@[{this.NativeHandle.ToInt32():x}]";
  88     }
  89
  90     /// <summary>Notifies <see cref="Efl.Io.Buffer.PositionRead"/> changed</summary>
  91     public event EventHandler PositionReadChangedEvt
  92     {
  93         add
  94         {
  95             lock (eventLock)
  96             {
  97                 var wRef = new WeakReference(this);
  98                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
  99                 {
 100                     var obj = wRef.Target as Efl.Eo.IWrapper;
 101                     if (obj != null)
 102                     {
 103                         EventArgs args = EventArgs.Empty;
 104                         try
 105                         {
 106                             value?.Invoke(obj, args);
 107                         }
 108                         catch (Exception e)
 109                         {
 110                             Eina.Log.Error(e.ToString());
 111                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 112                         }
 113                     }
 114                 };
 115
 116                 string key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
 117                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 118             }
 119         }
 120
 121         remove
 122         {
 123             lock (eventLock)
 124             {
 125                 string key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
 126                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 127             }
 128         }
 129     }
 130     ///<summary>Method to raise event PositionReadChangedEvt.</summary>
 131     public void OnPositionReadChangedEvt(EventArgs e)
 132     {
 133         var key = "_EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED";
 134         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 135         if (desc == IntPtr.Zero)
 136         {
 137             Eina.Log.Error($"Failed to get native event {key}");
 138             return;
 139         }
 140
 141         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 142     }
 143     /// <summary>Notifies <see cref="Efl.Io.Buffer.PositionWrite"/> changed</summary>
 144     public event EventHandler PositionWriteChangedEvt
 145     {
 146         add
 147         {
 148             lock (eventLock)
 149             {
 150                 var wRef = new WeakReference(this);
 151                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 152                 {
 153                     var obj = wRef.Target as Efl.Eo.IWrapper;
 154                     if (obj != null)
 155                     {
 156                         EventArgs args = EventArgs.Empty;
 157                         try
 158                         {
 159                             value?.Invoke(obj, args);
 160                         }
 161                         catch (Exception e)
 162                         {
 163                             Eina.Log.Error(e.ToString());
 164                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 165                         }
 166                     }
 167                 };
 168
 169                 string key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
 170                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 171             }
 172         }
 173
 174         remove
 175         {
 176             lock (eventLock)
 177             {
 178                 string key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
 179                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 180             }
 181         }
 182     }
 183     ///<summary>Method to raise event PositionWriteChangedEvt.</summary>
 184     public void OnPositionWriteChangedEvt(EventArgs e)
 185     {
 186         var key = "_EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED";
 187         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 188         if (desc == IntPtr.Zero)
 189         {
 190             Eina.Log.Error($"Failed to get native event {key}");
 191             return;
 192         }
 193
 194         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 195     }
 196     /// <summary>Notifies the internal buffer was reallocated, thus whatever was returned by <see cref="Efl.Io.Buffer.GetSlice"/> becomes invalid</summary>
 197     public event EventHandler ReallocatedEvt
 198     {
 199         add
 200         {
 201             lock (eventLock)
 202             {
 203                 var wRef = new WeakReference(this);
 204                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 205                 {
 206                     var obj = wRef.Target as Efl.Eo.IWrapper;
 207                     if (obj != null)
 208                     {
 209                         EventArgs args = EventArgs.Empty;
 210                         try
 211                         {
 212                             value?.Invoke(obj, args);
 213                         }
 214                         catch (Exception e)
 215                         {
 216                             Eina.Log.Error(e.ToString());
 217                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 218                         }
 219                     }
 220                 };
 221
 222                 string key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
 223                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 224             }
 225         }
 226
 227         remove
 228         {
 229             lock (eventLock)
 230             {
 231                 string key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
 232                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 233             }
 234         }
 235     }
 236     ///<summary>Method to raise event ReallocatedEvt.</summary>
 237     public void OnReallocatedEvt(EventArgs e)
 238     {
 239         var key = "_EFL_IO_BUFFER_EVENT_REALLOCATED";
 240         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 241         if (desc == IntPtr.Zero)
 242         {
 243             Eina.Log.Error($"Failed to get native event {key}");
 244             return;
 245         }
 246
 247         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 248     }
 249     /// <summary>Notifies closed, when property is marked as true
 250     /// (Since EFL 1.22)</summary>
 251     public event EventHandler ClosedEvt
 252     {
 253         add
 254         {
 255             lock (eventLock)
 256             {
 257                 var wRef = new WeakReference(this);
 258                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 259                 {
 260                     var obj = wRef.Target as Efl.Eo.IWrapper;
 261                     if (obj != null)
 262                     {
 263                         EventArgs args = EventArgs.Empty;
 264                         try
 265                         {
 266                             value?.Invoke(obj, args);
 267                         }
 268                         catch (Exception e)
 269                         {
 270                             Eina.Log.Error(e.ToString());
 271                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 272                         }
 273                     }
 274                 };
 275
 276                 string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
 277                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 278             }
 279         }
 280
 281         remove
 282         {
 283             lock (eventLock)
 284             {
 285                 string key = "_EFL_IO_CLOSER_EVENT_CLOSED";
 286                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 287             }
 288         }
 289     }
 290     ///<summary>Method to raise event ClosedEvt.</summary>
 291     public void OnClosedEvt(EventArgs e)
 292     {
 293         var key = "_EFL_IO_CLOSER_EVENT_CLOSED";
 294         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 295         if (desc == IntPtr.Zero)
 296         {
 297             Eina.Log.Error($"Failed to get native event {key}");
 298             return;
 299         }
 300
 301         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 302     }
 303     /// <summary>Notifies position changed</summary>
 304     public event EventHandler PositionChangedEvt
 305     {
 306         add
 307         {
 308             lock (eventLock)
 309             {
 310                 var wRef = new WeakReference(this);
 311                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 312                 {
 313                     var obj = wRef.Target as Efl.Eo.IWrapper;
 314                     if (obj != null)
 315                     {
 316                         EventArgs args = EventArgs.Empty;
 317                         try
 318                         {
 319                             value?.Invoke(obj, args);
 320                         }
 321                         catch (Exception e)
 322                         {
 323                             Eina.Log.Error(e.ToString());
 324                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 325                         }
 326                     }
 327                 };
 328
 329                 string key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
 330                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 331             }
 332         }
 333
 334         remove
 335         {
 336             lock (eventLock)
 337             {
 338                 string key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
 339                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 340             }
 341         }
 342     }
 343     ///<summary>Method to raise event PositionChangedEvt.</summary>
 344     public void OnPositionChangedEvt(EventArgs e)
 345     {
 346         var key = "_EFL_IO_POSITIONER_EVENT_POSITION_CHANGED";
 347         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 348         if (desc == IntPtr.Zero)
 349         {
 350             Eina.Log.Error($"Failed to get native event {key}");
 351             return;
 352         }
 353
 354         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 355     }
 356     /// <summary>Notifies can_read property changed.
 357     /// 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.
 358     ///
 359     /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IReader.Read"/>, thus before it returns.
 360     /// (Since EFL 1.22)</summary>
 361     public event EventHandler<Efl.Io.IReaderCanReadChangedEvt_Args> CanReadChangedEvt
 362     {
 363         add
 364         {
 365             lock (eventLock)
 366             {
 367                 var wRef = new WeakReference(this);
 368                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 369                 {
 370                     var obj = wRef.Target as Efl.Eo.IWrapper;
 371                     if (obj != null)
 372                     {
 373                                                 Efl.Io.IReaderCanReadChangedEvt_Args args = new Efl.Io.IReaderCanReadChangedEvt_Args();
 374                         args.arg = evt.Info != IntPtr.Zero;
 375                         try
 376                         {
 377                             value?.Invoke(obj, args);
 378                         }
 379                         catch (Exception e)
 380                         {
 381                             Eina.Log.Error(e.ToString());
 382                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 383                         }
 384                     }
 385                 };
 386
 387                 string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 388                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 389             }
 390         }
 391
 392         remove
 393         {
 394             lock (eventLock)
 395             {
 396                 string key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 397                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 398             }
 399         }
 400     }
 401     ///<summary>Method to raise event CanReadChangedEvt.</summary>
 402     public void OnCanReadChangedEvt(Efl.Io.IReaderCanReadChangedEvt_Args e)
 403     {
 404         var key = "_EFL_IO_READER_EVENT_CAN_READ_CHANGED";
 405         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 406         if (desc == IntPtr.Zero)
 407         {
 408             Eina.Log.Error($"Failed to get native event {key}");
 409             return;
 410         }
 411
 412         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 413         try
 414         {
 415             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 416         }
 417         finally
 418         {
 419             Marshal.FreeHGlobal(info);
 420         }
 421     }
 422     /// <summary>Notifies end of stream, when property is marked as true.
 423     /// If this is used alongside with an <see cref="Efl.Io.ICloser"/>, then it should be emitted before that call.
 424     ///
 425     /// It should be emitted only once for an object unless it implements <see cref="Efl.Io.IPositioner.Seek"/>.
 426     ///
 427     /// The property <see cref="Efl.Io.IReader.CanRead"/> should change to <c>false</c> before this event is dispatched.
 428     /// (Since EFL 1.22)</summary>
 429     public event EventHandler EosEvt
 430     {
 431         add
 432         {
 433             lock (eventLock)
 434             {
 435                 var wRef = new WeakReference(this);
 436                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 437                 {
 438                     var obj = wRef.Target as Efl.Eo.IWrapper;
 439                     if (obj != null)
 440                     {
 441                         EventArgs args = EventArgs.Empty;
 442                         try
 443                         {
 444                             value?.Invoke(obj, args);
 445                         }
 446                         catch (Exception e)
 447                         {
 448                             Eina.Log.Error(e.ToString());
 449                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 450                         }
 451                     }
 452                 };
 453
 454                 string key = "_EFL_IO_READER_EVENT_EOS";
 455                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 456             }
 457         }
 458
 459         remove
 460         {
 461             lock (eventLock)
 462             {
 463                 string key = "_EFL_IO_READER_EVENT_EOS";
 464                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 465             }
 466         }
 467     }
 468     ///<summary>Method to raise event EosEvt.</summary>
 469     public void OnEosEvt(EventArgs e)
 470     {
 471         var key = "_EFL_IO_READER_EVENT_EOS";
 472         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 473         if (desc == IntPtr.Zero)
 474         {
 475             Eina.Log.Error($"Failed to get native event {key}");
 476             return;
 477         }
 478
 479         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 480     }
 481     /// <summary>Notifies size changed</summary>
 482     public event EventHandler SizeChangedEvt
 483     {
 484         add
 485         {
 486             lock (eventLock)
 487             {
 488                 var wRef = new WeakReference(this);
 489                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 490                 {
 491                     var obj = wRef.Target as Efl.Eo.IWrapper;
 492                     if (obj != null)
 493                     {
 494                         EventArgs args = EventArgs.Empty;
 495                         try
 496                         {
 497                             value?.Invoke(obj, args);
 498                         }
 499                         catch (Exception e)
 500                         {
 501                             Eina.Log.Error(e.ToString());
 502                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 503                         }
 504                     }
 505                 };
 506
 507                 string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
 508                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 509             }
 510         }
 511
 512         remove
 513         {
 514             lock (eventLock)
 515             {
 516                 string key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
 517                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 518             }
 519         }
 520     }
 521     ///<summary>Method to raise event SizeChangedEvt.</summary>
 522     public void OnSizeChangedEvt(EventArgs e)
 523     {
 524         var key = "_EFL_IO_SIZER_EVENT_SIZE_CHANGED";
 525         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 526         if (desc == IntPtr.Zero)
 527         {
 528             Eina.Log.Error($"Failed to get native event {key}");
 529             return;
 530         }
 531
 532         Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, IntPtr.Zero);
 533     }
 534     /// <summary>Notifies can_write property changed.
 535     /// 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.
 536     ///
 537     /// Note that usually this event is dispatched from inside <see cref="Efl.Io.IWriter.Write"/>, thus before it returns.
 538     /// (Since EFL 1.22)</summary>
 539     public event EventHandler<Efl.Io.IWriterCanWriteChangedEvt_Args> CanWriteChangedEvt
 540     {
 541         add
 542         {
 543             lock (eventLock)
 544             {
 545                 var wRef = new WeakReference(this);
 546                 Efl.EventCb callerCb = (IntPtr data, ref Efl.Event.NativeStruct evt) =>
 547                 {
 548                     var obj = wRef.Target as Efl.Eo.IWrapper;
 549                     if (obj != null)
 550                     {
 551                                                 Efl.Io.IWriterCanWriteChangedEvt_Args args = new Efl.Io.IWriterCanWriteChangedEvt_Args();
 552                         args.arg = evt.Info != IntPtr.Zero;
 553                         try
 554                         {
 555                             value?.Invoke(obj, args);
 556                         }
 557                         catch (Exception e)
 558                         {
 559                             Eina.Log.Error(e.ToString());
 560                             Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
 561                         }
 562                     }
 563                 };
 564
 565                 string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 566                 AddNativeEventHandler(efl.Libs.Efl, key, callerCb, value);
 567             }
 568         }
 569
 570         remove
 571         {
 572             lock (eventLock)
 573             {
 574                 string key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 575                 RemoveNativeEventHandler(efl.Libs.Efl, key, value);
 576             }
 577         }
 578     }
 579     ///<summary>Method to raise event CanWriteChangedEvt.</summary>
 580     public void OnCanWriteChangedEvt(Efl.Io.IWriterCanWriteChangedEvt_Args e)
 581     {
 582         var key = "_EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED";
 583         IntPtr desc = Efl.EventDescription.GetNative(efl.Libs.Efl, key);
 584         if (desc == IntPtr.Zero)
 585         {
 586             Eina.Log.Error($"Failed to get native event {key}");
 587             return;
 588         }
 589
 590         IntPtr info = Eina.PrimitiveConversion.ManagedToPointerAlloc(e.arg ? (byte) 1 : (byte) 0);
 591         try
 592         {
 593             Efl.Eo.Globals.efl_event_callback_call(this.NativeHandle, desc, info);
 594         }
 595         finally
 596         {
 597             Marshal.FreeHGlobal(info);
 598         }
 599     }
 600     /// <summary>Limit how big the buffer can grow.
 601     /// This affects both <see cref="Efl.Io.Buffer.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
 602     ///
 603     /// If you want a buffer of an exact size always set the limit before any further calls that can expand it.</summary>
 604     /// <returns>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</returns>
 605     virtual public uint GetLimit() {
 606          var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_limit_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 607         Eina.Error.RaiseIfUnhandledException();
 608         return _ret_var;
 609  }
 610     /// <summary>Constructor-only property to set buffer limit. 0 is unlimited</summary>
 611     /// <param name="size">Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</param>
 612     virtual public void SetLimit(uint size) {
 613                                  Efl.Io.Buffer.NativeMethods.efl_io_buffer_limit_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
 614         Eina.Error.RaiseIfUnhandledException();
 615                          }
 616     /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
 617     /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
 618     ///
 619     /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 620     /// <returns>Position in buffer</returns>
 621     virtual public ulong GetPositionRead() {
 622          var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_read_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 623         Eina.Error.RaiseIfUnhandledException();
 624         return _ret_var;
 625  }
 626     /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
 627     /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
 628     ///
 629     /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 630     /// <param name="position">Position in buffer</param>
 631     /// <returns><c>true</c> if setting the position succeeded, <c>false</c> otherwise</returns>
 632     virtual public bool SetPositionRead(ulong position) {
 633                                  var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_read_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
 634         Eina.Error.RaiseIfUnhandledException();
 635                         return _ret_var;
 636  }
 637     /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
 638     /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
 639     ///
 640     /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 641     /// <returns>Position in buffer</returns>
 642     virtual public ulong GetPositionWrite() {
 643          var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_write_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 644         Eina.Error.RaiseIfUnhandledException();
 645         return _ret_var;
 646  }
 647     /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
 648     /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
 649     ///
 650     /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 651     /// <param name="position">Position in buffer</param>
 652     /// <returns><c>true</c> if setting the position succeeded, <c>false</c> otherwise</returns>
 653     virtual public bool SetPositionWrite(ulong position) {
 654                                  var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_position_write_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
 655         Eina.Error.RaiseIfUnhandledException();
 656                         return _ret_var;
 657  }
 658     /// <summary>Get a temporary access to buffer&apos;s internal memory.
 659     /// The memory pointed by slice may be changed by other methods of this class. The event &quot;reallocated&quot; will be called in those situations.</summary>
 660     /// <returns>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.ISizer.Resize"/> are called. It is the full slice, not a partial one starting at current position.</returns>
 661     virtual public Eina.Slice GetSlice() {
 662          var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_slice_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 663         Eina.Error.RaiseIfUnhandledException();
 664         return _ret_var;
 665  }
 666     /// <summary>Immediately pre-allocate a buffer of at least a given size.</summary>
 667     /// <param name="size">Amount of bytes to pre-allocate.</param>
 668     virtual public void Preallocate(uint size) {
 669                                  Efl.Io.Buffer.NativeMethods.efl_io_buffer_preallocate_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
 670         Eina.Error.RaiseIfUnhandledException();
 671                          }
 672     /// <summary>Adopt a read-only slice as buffer&apos;s backing store.
 673     /// The slice memory will not be copied and must remain alive during the buffer&apos;s lifetime. Usually this is guaranteed by some global static-const memory or some parent object and this buffer being a view of that -- be aware of parent memory remaining alive, such as &quot;slice,changed&quot; events.</summary>
 674     /// <param name="slice">Slice to adopt as read-only</param>
 675     virtual public void AdoptReadonly(Eina.Slice slice) {
 676                                  Efl.Io.Buffer.NativeMethods.efl_io_buffer_adopt_readonly_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),slice);
 677         Eina.Error.RaiseIfUnhandledException();
 678                          }
 679     /// <summary>Adopt a read-write slice as buffer&apos;s backing store.
 680     /// The slice memory will not be copied and must remain alive during the buffer&apos;s lifetime. Usually this is guaranteed by some global static memory or some parent object and this buffer being a view of that -- be aware of parent memory remaining alive, such as &quot;slice,changed&quot; events.
 681     ///
 682     /// The memory will be disposed using free() and reallocated using realloc().</summary>
 683     /// <param name="slice">Slice to adopt as read-write</param>
 684     virtual public void AdoptReadwrite(Eina.RwSlice slice) {
 685                                  Efl.Io.Buffer.NativeMethods.efl_io_buffer_adopt_readwrite_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),slice);
 686         Eina.Error.RaiseIfUnhandledException();
 687                          }
 688     /// <summary>Steals the internal buffer memory and returns it as a binbuf.
 689     /// The returned memory must be freed with eina_binbuf_free().
 690     ///
 691     /// On failure, for example a read-only backing store was adopted with <see cref="Efl.Io.Buffer.AdoptReadonly"/>, NULL is returned.</summary>
 692     /// <returns>Binbuf</returns>
 693     virtual public Eina.Binbuf BinbufSteal() {
 694          var _ret_var = Efl.Io.Buffer.NativeMethods.efl_io_buffer_binbuf_steal_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 695         Eina.Error.RaiseIfUnhandledException();
 696         var _binbuf_ret = new Eina.Binbuf(_ret_var, true);
 697         return _binbuf_ret;
 698  }
 699     /// <summary>If true will notify object was closed.
 700     /// (Since EFL 1.22)</summary>
 701     /// <returns><c>true</c> if closed, <c>false</c> otherwise</returns>
 702     virtual public bool GetClosed() {
 703          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));
 704         Eina.Error.RaiseIfUnhandledException();
 705         return _ret_var;
 706  }
 707     /// <summary>If true will automatically close resources on exec() calls.
 708     /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 709     /// (Since EFL 1.22)</summary>
 710     /// <returns><c>true</c> if close on exec(), <c>false</c> otherwise</returns>
 711     virtual public bool GetCloseOnExec() {
 712          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));
 713         Eina.Error.RaiseIfUnhandledException();
 714         return _ret_var;
 715  }
 716     /// <summary>If <c>true</c>, will close on exec() call.
 717     /// (Since EFL 1.22)</summary>
 718     /// <param name="close_on_exec"><c>true</c> if close on exec(), <c>false</c> otherwise</param>
 719     /// <returns><c>true</c> if could set, <c>false</c> if not supported or failed.</returns>
 720     virtual public bool SetCloseOnExec(bool close_on_exec) {
 721                                  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);
 722         Eina.Error.RaiseIfUnhandledException();
 723                         return _ret_var;
 724  }
 725     /// <summary>If true will automatically close() on object invalidate.
 726     /// 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.
 727     /// (Since EFL 1.22)</summary>
 728     /// <returns><c>true</c> if close on invalidate, <c>false</c> otherwise</returns>
 729     virtual public bool GetCloseOnInvalidate() {
 730          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));
 731         Eina.Error.RaiseIfUnhandledException();
 732         return _ret_var;
 733  }
 734     /// <summary>If true will automatically close() on object invalidate.
 735     /// 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.
 736     /// (Since EFL 1.22)</summary>
 737     /// <param name="close_on_invalidate"><c>true</c> if close on invalidate, <c>false</c> otherwise</param>
 738     virtual public void SetCloseOnInvalidate(bool close_on_invalidate) {
 739                                  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);
 740         Eina.Error.RaiseIfUnhandledException();
 741                          }
 742     /// <summary>Closes the Input/Output object.
 743     /// 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.
 744     ///
 745     /// You can understand this method as close(2) libc function.
 746     /// (Since EFL 1.22)</summary>
 747     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 748     virtual public Eina.Error Close() {
 749          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));
 750         Eina.Error.RaiseIfUnhandledException();
 751         return _ret_var;
 752  }
 753     /// <summary>Position property</summary>
 754     /// <returns>Position in file or buffer</returns>
 755     virtual public ulong GetPosition() {
 756          var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_position_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 757         Eina.Error.RaiseIfUnhandledException();
 758         return _ret_var;
 759  }
 760     /// <summary>Try to set position object, relative to start of file. See <see cref="Efl.Io.IPositioner.Seek"/></summary>
 761     /// <param name="position">Position in file or buffer</param>
 762     /// <returns><c>true</c> if could reposition, <c>false</c> if errors.</returns>
 763     virtual public bool SetPosition(ulong position) {
 764                                  var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_position_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),position);
 765         Eina.Error.RaiseIfUnhandledException();
 766                         return _ret_var;
 767  }
 768     /// <summary>Seek in data</summary>
 769     /// <param name="offset">Offset in byte relative to whence</param>
 770     /// <param name="whence">Whence</param>
 771     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 772     virtual public Eina.Error Seek(long offset, Efl.Io.PositionerWhence whence) {
 773                                                          var _ret_var = Efl.Io.IPositionerConcrete.NativeMethods.efl_io_positioner_seek_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),offset, whence);
 774         Eina.Error.RaiseIfUnhandledException();
 775                                         return _ret_var;
 776  }
 777     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 778     /// (Since EFL 1.22)</summary>
 779     /// <returns><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</returns>
 780     virtual public bool GetCanRead() {
 781          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));
 782         Eina.Error.RaiseIfUnhandledException();
 783         return _ret_var;
 784  }
 785     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 786     /// (Since EFL 1.22)</summary>
 787     /// <param name="can_read"><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</param>
 788     virtual public void SetCanRead(bool can_read) {
 789                                  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);
 790         Eina.Error.RaiseIfUnhandledException();
 791                          }
 792     /// <summary>If <c>true</c> will notify end of stream.
 793     /// (Since EFL 1.22)</summary>
 794     /// <returns><c>true</c> if end of stream, <c>false</c> otherwise</returns>
 795     virtual public bool GetEos() {
 796          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));
 797         Eina.Error.RaiseIfUnhandledException();
 798         return _ret_var;
 799  }
 800     /// <summary>If <c>true</c> will notify end of stream.
 801     /// (Since EFL 1.22)</summary>
 802     /// <param name="is_eos"><c>true</c> if end of stream, <c>false</c> otherwise</param>
 803     virtual public void SetEos(bool is_eos) {
 804                                  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);
 805         Eina.Error.RaiseIfUnhandledException();
 806                          }
 807     /// <summary>Reads data into a pre-allocated buffer.
 808     /// 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.
 809     ///
 810     /// You can understand this method as read(2) libc function.
 811     /// (Since EFL 1.22)</summary>
 812     /// <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>
 813     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 814     virtual public Eina.Error Read(ref Eina.RwSlice rw_slice) {
 815                                  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);
 816         Eina.Error.RaiseIfUnhandledException();
 817                         return _ret_var;
 818  }
 819     /// <summary>Size property</summary>
 820     /// <returns>Object size</returns>
 821     virtual public ulong GetSize() {
 822          var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_get_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle));
 823         Eina.Error.RaiseIfUnhandledException();
 824         return _ret_var;
 825  }
 826     /// <summary>Try to resize the object, check with get if the value was accepted or not.</summary>
 827     /// <param name="size">Object size</param>
 828     /// <returns><c>true</c> if could resize, <c>false</c> if errors.</returns>
 829     virtual public bool SetSize(ulong size) {
 830                                  var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_size_set_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
 831         Eina.Error.RaiseIfUnhandledException();
 832                         return _ret_var;
 833  }
 834     /// <summary>Resize object</summary>
 835     /// <param name="size">Object size</param>
 836     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 837     virtual public Eina.Error Resize(ulong size) {
 838                                  var _ret_var = Efl.Io.ISizerConcrete.NativeMethods.efl_io_sizer_resize_ptr.Value.Delegate((inherited ? Efl.Eo.Globals.efl_super(this.NativeHandle, this.NativeClass) : this.NativeHandle),size);
 839         Eina.Error.RaiseIfUnhandledException();
 840                         return _ret_var;
 841  }
 842     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 843     /// (Since EFL 1.22)</summary>
 844     /// <returns><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</returns>
 845     virtual public bool GetCanWrite() {
 846          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));
 847         Eina.Error.RaiseIfUnhandledException();
 848         return _ret_var;
 849  }
 850     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 851     /// (Since EFL 1.22)</summary>
 852     /// <param name="can_write"><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</param>
 853     virtual public void SetCanWrite(bool can_write) {
 854                                  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);
 855         Eina.Error.RaiseIfUnhandledException();
 856                          }
 857     /// <summary>Writes data from a pre-populated buffer.
 858     /// 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.
 859     ///
 860     /// You can understand this method as write(2) libc function.
 861     /// (Since EFL 1.22)</summary>
 862     /// <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>
 863     /// <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>
 864     /// <returns>0 on succeed, a mapping of errno otherwise</returns>
 865     virtual public Eina.Error Write(ref Eina.Slice slice, ref Eina.Slice remaining) {
 866                                                          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);
 867         Eina.Error.RaiseIfUnhandledException();
 868                                         return _ret_var;
 869  }
 870     /// <summary>Limit how big the buffer can grow.
 871 /// This affects both <see cref="Efl.Io.Buffer.Preallocate"/> and how buffer grows when <see cref="Efl.Io.IWriter.Write"/> is called.
 872 ///
 873 /// If you want a buffer of an exact size always set the limit before any further calls that can expand it.</summary>
 874 /// <value>Defines a maximum buffer size, or 0 to allow unlimited amount of bytes</value>
 875     public uint Limit {
 876         get { return GetLimit(); }
 877         set { SetLimit(value); }
 878     }
 879     /// <summary>The position used by <see cref="Efl.Io.IReader.Read"/>.
 880 /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionWrite"/>.
 881 ///
 882 /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 883 /// <value>Position in buffer</value>
 884     public ulong PositionRead {
 885         get { return GetPositionRead(); }
 886         set { SetPositionRead(value); }
 887     }
 888     /// <summary>The position used by <see cref="Efl.Io.IWriter.Write"/>.
 889 /// Note that <see cref="Efl.Io.IPositioner.Seek"/> or <see cref="Efl.Io.IPositioner.SetPosition"/> will affect this property and <see cref="Efl.Io.Buffer.PositionRead"/>.
 890 ///
 891 /// <see cref="Efl.Io.IPositioner.GetPosition"/> will return the greatest of <see cref="Efl.Io.Buffer.PositionRead"/> and <see cref="Efl.Io.Buffer.PositionWrite"/>.</summary>
 892 /// <value>Position in buffer</value>
 893     public ulong PositionWrite {
 894         get { return GetPositionWrite(); }
 895         set { SetPositionWrite(value); }
 896     }
 897     /// <summary>Get a temporary access to buffer&apos;s internal memory.
 898 /// The memory pointed by slice may be changed by other methods of this class. The event &quot;reallocated&quot; will be called in those situations.</summary>
 899 /// <value>Slice of the current buffer, may be invalidated if <see cref="Efl.Io.IWriter.Write"/>, <see cref="Efl.Io.ICloser.Close"/> or <see cref="Efl.Io.ISizer.Resize"/> are called. It is the full slice, not a partial one starting at current position.</value>
 900     public Eina.Slice Slice {
 901         get { return GetSlice(); }
 902     }
 903     /// <summary>If true will notify object was closed.
 904 /// (Since EFL 1.22)</summary>
 905 /// <value><c>true</c> if closed, <c>false</c> otherwise</value>
 906     public bool Closed {
 907         get { return GetClosed(); }
 908     }
 909     /// <summary>If true will automatically close resources on exec() calls.
 910 /// When using file descriptors this should set FD_CLOEXEC so they are not inherited by the processes (children or self) doing exec().
 911 /// (Since EFL 1.22)</summary>
 912 /// <value><c>true</c> if close on exec(), <c>false</c> otherwise</value>
 913     public bool CloseOnExec {
 914         get { return GetCloseOnExec(); }
 915         set { SetCloseOnExec(value); }
 916     }
 917     /// <summary>If true will automatically close() on object invalidate.
 918 /// 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.
 919 /// (Since EFL 1.22)</summary>
 920 /// <value><c>true</c> if close on invalidate, <c>false</c> otherwise</value>
 921     public bool CloseOnInvalidate {
 922         get { return GetCloseOnInvalidate(); }
 923         set { SetCloseOnInvalidate(value); }
 924     }
 925     /// <summary>Position property</summary>
 926 /// <value>Position in file or buffer</value>
 927     public ulong Position {
 928         get { return GetPosition(); }
 929         set { SetPosition(value); }
 930     }
 931     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IReader.Read"/> can be called without blocking or failing.
 932 /// (Since EFL 1.22)</summary>
 933 /// <value><c>true</c> if it can be read without blocking or failing, <c>false</c> otherwise</value>
 934     public bool CanRead {
 935         get { return GetCanRead(); }
 936         set { SetCanRead(value); }
 937     }
 938     /// <summary>If <c>true</c> will notify end of stream.
 939 /// (Since EFL 1.22)</summary>
 940 /// <value><c>true</c> if end of stream, <c>false</c> otherwise</value>
 941     public bool Eos {
 942         get { return GetEos(); }
 943         set { SetEos(value); }
 944     }
 945     /// <summary>Size property</summary>
 946 /// <value>Object size</value>
 947     public ulong Size {
 948         get { return GetSize(); }
 949         set { SetSize(value); }
 950     }
 951     /// <summary>If <c>true</c> will notify <see cref="Efl.Io.IWriter.Write"/> can be called without blocking or failing.
 952 /// (Since EFL 1.22)</summary>
 953 /// <value><c>true</c> if it can be written without blocking or failure, <c>false</c> otherwise</value>
 954     public bool CanWrite {
 955         get { return GetCanWrite(); }
 956         set { SetCanWrite(value); }
 957     }
 958     private static IntPtr GetEflClassStatic()
 959     {
 960         return Efl.Io.Buffer.efl_io_buffer_class_get();
 961     }
 962     /// <summary>Wrapper for native methods and virtual method delegates.
 963     /// For internal use by generated code only.</summary>
 964     public new class NativeMethods : Efl.Object.NativeMethods
 965     {
 966         private static Efl.Eo.NativeModule Module = new Efl.Eo.NativeModule(    efl.Libs.Efl);
 967         /// <summary>Gets the list of Eo operations to override.</summary>
 968         /// <returns>The list of Eo operations to be overload.</returns>
 969         public override System.Collections.Generic.List<Efl_Op_Description> GetEoOps(System.Type type)
 970         {
 971             var descs = new System.Collections.Generic.List<Efl_Op_Description>();
 972             var methods = Efl.Eo.Globals.GetUserMethods(type);
 973
 974             if (efl_io_buffer_limit_get_static_delegate == null)
 975             {
 976                 efl_io_buffer_limit_get_static_delegate = new efl_io_buffer_limit_get_delegate(limit_get);
 977             }
 978
 979             if (methods.FirstOrDefault(m => m.Name == "GetLimit") != null)
 980             {
 981                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_limit_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_limit_get_static_delegate) });
 982             }
 983
 984             if (efl_io_buffer_limit_set_static_delegate == null)
 985             {
 986                 efl_io_buffer_limit_set_static_delegate = new efl_io_buffer_limit_set_delegate(limit_set);
 987             }
 988
 989             if (methods.FirstOrDefault(m => m.Name == "SetLimit") != null)
 990             {
 991                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_limit_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_limit_set_static_delegate) });
 992             }
 993
 994             if (efl_io_buffer_position_read_get_static_delegate == null)
 995             {
 996                 efl_io_buffer_position_read_get_static_delegate = new efl_io_buffer_position_read_get_delegate(position_read_get);
 997             }
 998
 999             if (methods.FirstOrDefault(m => m.Name == "GetPositionRead") != null)
1000             {
1001                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_read_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_read_get_static_delegate) });
1002             }
1003
1004             if (efl_io_buffer_position_read_set_static_delegate == null)
1005             {
1006                 efl_io_buffer_position_read_set_static_delegate = new efl_io_buffer_position_read_set_delegate(position_read_set);
1007             }
1008
1009             if (methods.FirstOrDefault(m => m.Name == "SetPositionRead") != null)
1010             {
1011                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_read_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_read_set_static_delegate) });
1012             }
1013
1014             if (efl_io_buffer_position_write_get_static_delegate == null)
1015             {
1016                 efl_io_buffer_position_write_get_static_delegate = new efl_io_buffer_position_write_get_delegate(position_write_get);
1017             }
1018
1019             if (methods.FirstOrDefault(m => m.Name == "GetPositionWrite") != null)
1020             {
1021                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_write_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_write_get_static_delegate) });
1022             }
1023
1024             if (efl_io_buffer_position_write_set_static_delegate == null)
1025             {
1026                 efl_io_buffer_position_write_set_static_delegate = new efl_io_buffer_position_write_set_delegate(position_write_set);
1027             }
1028
1029             if (methods.FirstOrDefault(m => m.Name == "SetPositionWrite") != null)
1030             {
1031                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_position_write_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_position_write_set_static_delegate) });
1032             }
1033
1034             if (efl_io_buffer_slice_get_static_delegate == null)
1035             {
1036                 efl_io_buffer_slice_get_static_delegate = new efl_io_buffer_slice_get_delegate(slice_get);
1037             }
1038
1039             if (methods.FirstOrDefault(m => m.Name == "GetSlice") != null)
1040             {
1041                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_slice_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_slice_get_static_delegate) });
1042             }
1043
1044             if (efl_io_buffer_preallocate_static_delegate == null)
1045             {
1046                 efl_io_buffer_preallocate_static_delegate = new efl_io_buffer_preallocate_delegate(preallocate);
1047             }
1048
1049             if (methods.FirstOrDefault(m => m.Name == "Preallocate") != null)
1050             {
1051                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_preallocate"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_preallocate_static_delegate) });
1052             }
1053
1054             if (efl_io_buffer_adopt_readonly_static_delegate == null)
1055             {
1056                 efl_io_buffer_adopt_readonly_static_delegate = new efl_io_buffer_adopt_readonly_delegate(adopt_readonly);
1057             }
1058
1059             if (methods.FirstOrDefault(m => m.Name == "AdoptReadonly") != null)
1060             {
1061                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_adopt_readonly"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_adopt_readonly_static_delegate) });
1062             }
1063
1064             if (efl_io_buffer_adopt_readwrite_static_delegate == null)
1065             {
1066                 efl_io_buffer_adopt_readwrite_static_delegate = new efl_io_buffer_adopt_readwrite_delegate(adopt_readwrite);
1067             }
1068
1069             if (methods.FirstOrDefault(m => m.Name == "AdoptReadwrite") != null)
1070             {
1071                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_adopt_readwrite"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_adopt_readwrite_static_delegate) });
1072             }
1073
1074             if (efl_io_buffer_binbuf_steal_static_delegate == null)
1075             {
1076                 efl_io_buffer_binbuf_steal_static_delegate = new efl_io_buffer_binbuf_steal_delegate(binbuf_steal);
1077             }
1078
1079             if (methods.FirstOrDefault(m => m.Name == "BinbufSteal") != null)
1080             {
1081                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_buffer_binbuf_steal"), func = Marshal.GetFunctionPointerForDelegate(efl_io_buffer_binbuf_steal_static_delegate) });
1082             }
1083
1084             if (efl_io_closer_closed_get_static_delegate == null)
1085             {
1086                 efl_io_closer_closed_get_static_delegate = new efl_io_closer_closed_get_delegate(closed_get);
1087             }
1088
1089             if (methods.FirstOrDefault(m => m.Name == "GetClosed") != null)
1090             {
1091                 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) });
1092             }
1093
1094             if (efl_io_closer_close_on_exec_get_static_delegate == null)
1095             {
1096                 efl_io_closer_close_on_exec_get_static_delegate = new efl_io_closer_close_on_exec_get_delegate(close_on_exec_get);
1097             }
1098
1099             if (methods.FirstOrDefault(m => m.Name == "GetCloseOnExec") != null)
1100             {
1101                 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) });
1102             }
1103
1104             if (efl_io_closer_close_on_exec_set_static_delegate == null)
1105             {
1106                 efl_io_closer_close_on_exec_set_static_delegate = new efl_io_closer_close_on_exec_set_delegate(close_on_exec_set);
1107             }
1108
1109             if (methods.FirstOrDefault(m => m.Name == "SetCloseOnExec") != null)
1110             {
1111                 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) });
1112             }
1113
1114             if (efl_io_closer_close_on_invalidate_get_static_delegate == null)
1115             {
1116                 efl_io_closer_close_on_invalidate_get_static_delegate = new efl_io_closer_close_on_invalidate_get_delegate(close_on_invalidate_get);
1117             }
1118
1119             if (methods.FirstOrDefault(m => m.Name == "GetCloseOnInvalidate") != null)
1120             {
1121                 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) });
1122             }
1123
1124             if (efl_io_closer_close_on_invalidate_set_static_delegate == null)
1125             {
1126                 efl_io_closer_close_on_invalidate_set_static_delegate = new efl_io_closer_close_on_invalidate_set_delegate(close_on_invalidate_set);
1127             }
1128
1129             if (methods.FirstOrDefault(m => m.Name == "SetCloseOnInvalidate") != null)
1130             {
1131                 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) });
1132             }
1133
1134             if (efl_io_closer_close_static_delegate == null)
1135             {
1136                 efl_io_closer_close_static_delegate = new efl_io_closer_close_delegate(close);
1137             }
1138
1139             if (methods.FirstOrDefault(m => m.Name == "Close") != null)
1140             {
1141                 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) });
1142             }
1143
1144             if (efl_io_positioner_position_get_static_delegate == null)
1145             {
1146                 efl_io_positioner_position_get_static_delegate = new efl_io_positioner_position_get_delegate(position_get);
1147             }
1148
1149             if (methods.FirstOrDefault(m => m.Name == "GetPosition") != null)
1150             {
1151                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_position_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_position_get_static_delegate) });
1152             }
1153
1154             if (efl_io_positioner_position_set_static_delegate == null)
1155             {
1156                 efl_io_positioner_position_set_static_delegate = new efl_io_positioner_position_set_delegate(position_set);
1157             }
1158
1159             if (methods.FirstOrDefault(m => m.Name == "SetPosition") != null)
1160             {
1161                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_position_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_position_set_static_delegate) });
1162             }
1163
1164             if (efl_io_positioner_seek_static_delegate == null)
1165             {
1166                 efl_io_positioner_seek_static_delegate = new efl_io_positioner_seek_delegate(seek);
1167             }
1168
1169             if (methods.FirstOrDefault(m => m.Name == "Seek") != null)
1170             {
1171                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_positioner_seek"), func = Marshal.GetFunctionPointerForDelegate(efl_io_positioner_seek_static_delegate) });
1172             }
1173
1174             if (efl_io_reader_can_read_get_static_delegate == null)
1175             {
1176                 efl_io_reader_can_read_get_static_delegate = new efl_io_reader_can_read_get_delegate(can_read_get);
1177             }
1178
1179             if (methods.FirstOrDefault(m => m.Name == "GetCanRead") != null)
1180             {
1181                 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) });
1182             }
1183
1184             if (efl_io_reader_can_read_set_static_delegate == null)
1185             {
1186                 efl_io_reader_can_read_set_static_delegate = new efl_io_reader_can_read_set_delegate(can_read_set);
1187             }
1188
1189             if (methods.FirstOrDefault(m => m.Name == "SetCanRead") != null)
1190             {
1191                 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) });
1192             }
1193
1194             if (efl_io_reader_eos_get_static_delegate == null)
1195             {
1196                 efl_io_reader_eos_get_static_delegate = new efl_io_reader_eos_get_delegate(eos_get);
1197             }
1198
1199             if (methods.FirstOrDefault(m => m.Name == "GetEos") != null)
1200             {
1201                 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) });
1202             }
1203
1204             if (efl_io_reader_eos_set_static_delegate == null)
1205             {
1206                 efl_io_reader_eos_set_static_delegate = new efl_io_reader_eos_set_delegate(eos_set);
1207             }
1208
1209             if (methods.FirstOrDefault(m => m.Name == "SetEos") != null)
1210             {
1211                 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) });
1212             }
1213
1214             if (efl_io_reader_read_static_delegate == null)
1215             {
1216                 efl_io_reader_read_static_delegate = new efl_io_reader_read_delegate(read);
1217             }
1218
1219             if (methods.FirstOrDefault(m => m.Name == "Read") != null)
1220             {
1221                 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) });
1222             }
1223
1224             if (efl_io_sizer_size_get_static_delegate == null)
1225             {
1226                 efl_io_sizer_size_get_static_delegate = new efl_io_sizer_size_get_delegate(size_get);
1227             }
1228
1229             if (methods.FirstOrDefault(m => m.Name == "GetSize") != null)
1230             {
1231                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_get"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_get_static_delegate) });
1232             }
1233
1234             if (efl_io_sizer_size_set_static_delegate == null)
1235             {
1236                 efl_io_sizer_size_set_static_delegate = new efl_io_sizer_size_set_delegate(size_set);
1237             }
1238
1239             if (methods.FirstOrDefault(m => m.Name == "SetSize") != null)
1240             {
1241                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_size_set"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_size_set_static_delegate) });
1242             }
1243
1244             if (efl_io_sizer_resize_static_delegate == null)
1245             {
1246                 efl_io_sizer_resize_static_delegate = new efl_io_sizer_resize_delegate(resize);
1247             }
1248
1249             if (methods.FirstOrDefault(m => m.Name == "Resize") != null)
1250             {
1251                 descs.Add(new Efl_Op_Description() {api_func = Efl.Eo.FunctionInterop.LoadFunctionPointer(Module.Module, "efl_io_sizer_resize"), func = Marshal.GetFunctionPointerForDelegate(efl_io_sizer_resize_static_delegate) });
1252             }
1253
1254             if (efl_io_writer_can_write_get_static_delegate == null)
1255             {
1256                 efl_io_writer_can_write_get_static_delegate = new efl_io_writer_can_write_get_delegate(can_write_get);
1257             }
1258
1259             if (methods.FirstOrDefault(m => m.Name == "GetCanWrite") != null)
1260             {
1261                 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) });
1262             }
1263
1264             if (efl_io_writer_can_write_set_static_delegate == null)
1265             {
1266                 efl_io_writer_can_write_set_static_delegate = new efl_io_writer_can_write_set_delegate(can_write_set);
1267             }
1268
1269             if (methods.FirstOrDefault(m => m.Name == "SetCanWrite") != null)
1270             {
1271                 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) });
1272             }
1273
1274             if (efl_io_writer_write_static_delegate == null)
1275             {
1276                 efl_io_writer_write_static_delegate = new efl_io_writer_write_delegate(write);
1277             }
1278
1279             if (methods.FirstOrDefault(m => m.Name == "Write") != null)
1280             {
1281                 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) });
1282             }
1283
1284             descs.AddRange(base.GetEoOps(type));
1285             return descs;
1286         }
1287         /// <summary>Returns the Eo class for the native methods of this class.</summary>
1288         /// <returns>The native class pointer.</returns>
1289         public override IntPtr GetEflClass()
1290         {
1291             return Efl.Io.Buffer.efl_io_buffer_class_get();
1292         }
1293
1294         #pragma warning disable CA1707, SA1300, SA1600
1295
1296
1297         private delegate uint efl_io_buffer_limit_get_delegate(System.IntPtr obj, System.IntPtr pd);
1298
1299
1300         public delegate uint efl_io_buffer_limit_get_api_delegate(System.IntPtr obj);
1301
1302         public static Efl.Eo.FunctionWrapper<efl_io_buffer_limit_get_api_delegate> efl_io_buffer_limit_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_limit_get_api_delegate>(Module, "efl_io_buffer_limit_get");
1303
1304         private static uint limit_get(System.IntPtr obj, System.IntPtr pd)
1305         {
1306             Eina.Log.Debug("function efl_io_buffer_limit_get was called");
1307             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1308             if (wrapper != null)
1309             {
1310             uint _ret_var = default(uint);
1311                 try
1312                 {
1313                     _ret_var = ((Buffer)wrapper).GetLimit();
1314                 }
1315                 catch (Exception e)
1316                 {
1317                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1318                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1319                 }
1320
1321         return _ret_var;
1322
1323             }
1324             else
1325             {
1326                 return efl_io_buffer_limit_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1327             }
1328         }
1329
1330         private static efl_io_buffer_limit_get_delegate efl_io_buffer_limit_get_static_delegate;
1331
1332
1333         private delegate void efl_io_buffer_limit_set_delegate(System.IntPtr obj, System.IntPtr pd,  uint size);
1334
1335
1336         public delegate void efl_io_buffer_limit_set_api_delegate(System.IntPtr obj,  uint size);
1337
1338         public static Efl.Eo.FunctionWrapper<efl_io_buffer_limit_set_api_delegate> efl_io_buffer_limit_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_limit_set_api_delegate>(Module, "efl_io_buffer_limit_set");
1339
1340         private static void limit_set(System.IntPtr obj, System.IntPtr pd, uint size)
1341         {
1342             Eina.Log.Debug("function efl_io_buffer_limit_set was called");
1343             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1344             if (wrapper != null)
1345             {
1346
1347                 try
1348                 {
1349                     ((Buffer)wrapper).SetLimit(size);
1350                 }
1351                 catch (Exception e)
1352                 {
1353                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1354                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1355                 }
1356
1357
1358             }
1359             else
1360             {
1361                 efl_io_buffer_limit_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
1362             }
1363         }
1364
1365         private static efl_io_buffer_limit_set_delegate efl_io_buffer_limit_set_static_delegate;
1366
1367
1368         private delegate ulong efl_io_buffer_position_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
1369
1370
1371         public delegate ulong efl_io_buffer_position_read_get_api_delegate(System.IntPtr obj);
1372
1373         public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_get_api_delegate> efl_io_buffer_position_read_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_get_api_delegate>(Module, "efl_io_buffer_position_read_get");
1374
1375         private static ulong position_read_get(System.IntPtr obj, System.IntPtr pd)
1376         {
1377             Eina.Log.Debug("function efl_io_buffer_position_read_get was called");
1378             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1379             if (wrapper != null)
1380             {
1381             ulong _ret_var = default(ulong);
1382                 try
1383                 {
1384                     _ret_var = ((Buffer)wrapper).GetPositionRead();
1385                 }
1386                 catch (Exception e)
1387                 {
1388                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1389                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1390                 }
1391
1392         return _ret_var;
1393
1394             }
1395             else
1396             {
1397                 return efl_io_buffer_position_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1398             }
1399         }
1400
1401         private static efl_io_buffer_position_read_get_delegate efl_io_buffer_position_read_get_static_delegate;
1402
1403         [return: MarshalAs(UnmanagedType.U1)]
1404         private delegate bool efl_io_buffer_position_read_set_delegate(System.IntPtr obj, System.IntPtr pd,  ulong position);
1405
1406         [return: MarshalAs(UnmanagedType.U1)]
1407         public delegate bool efl_io_buffer_position_read_set_api_delegate(System.IntPtr obj,  ulong position);
1408
1409         public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_set_api_delegate> efl_io_buffer_position_read_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_read_set_api_delegate>(Module, "efl_io_buffer_position_read_set");
1410
1411         private static bool position_read_set(System.IntPtr obj, System.IntPtr pd, ulong position)
1412         {
1413             Eina.Log.Debug("function efl_io_buffer_position_read_set was called");
1414             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1415             if (wrapper != null)
1416             {
1417                                     bool _ret_var = default(bool);
1418                 try
1419                 {
1420                     _ret_var = ((Buffer)wrapper).SetPositionRead(position);
1421                 }
1422                 catch (Exception e)
1423                 {
1424                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1425                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1426                 }
1427
1428                         return _ret_var;
1429
1430             }
1431             else
1432             {
1433                 return efl_io_buffer_position_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
1434             }
1435         }
1436
1437         private static efl_io_buffer_position_read_set_delegate efl_io_buffer_position_read_set_static_delegate;
1438
1439
1440         private delegate ulong efl_io_buffer_position_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
1441
1442
1443         public delegate ulong efl_io_buffer_position_write_get_api_delegate(System.IntPtr obj);
1444
1445         public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_get_api_delegate> efl_io_buffer_position_write_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_get_api_delegate>(Module, "efl_io_buffer_position_write_get");
1446
1447         private static ulong position_write_get(System.IntPtr obj, System.IntPtr pd)
1448         {
1449             Eina.Log.Debug("function efl_io_buffer_position_write_get was called");
1450             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1451             if (wrapper != null)
1452             {
1453             ulong _ret_var = default(ulong);
1454                 try
1455                 {
1456                     _ret_var = ((Buffer)wrapper).GetPositionWrite();
1457                 }
1458                 catch (Exception e)
1459                 {
1460                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1461                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1462                 }
1463
1464         return _ret_var;
1465
1466             }
1467             else
1468             {
1469                 return efl_io_buffer_position_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1470             }
1471         }
1472
1473         private static efl_io_buffer_position_write_get_delegate efl_io_buffer_position_write_get_static_delegate;
1474
1475         [return: MarshalAs(UnmanagedType.U1)]
1476         private delegate bool efl_io_buffer_position_write_set_delegate(System.IntPtr obj, System.IntPtr pd,  ulong position);
1477
1478         [return: MarshalAs(UnmanagedType.U1)]
1479         public delegate bool efl_io_buffer_position_write_set_api_delegate(System.IntPtr obj,  ulong position);
1480
1481         public static Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_set_api_delegate> efl_io_buffer_position_write_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_position_write_set_api_delegate>(Module, "efl_io_buffer_position_write_set");
1482
1483         private static bool position_write_set(System.IntPtr obj, System.IntPtr pd, ulong position)
1484         {
1485             Eina.Log.Debug("function efl_io_buffer_position_write_set was called");
1486             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1487             if (wrapper != null)
1488             {
1489                                     bool _ret_var = default(bool);
1490                 try
1491                 {
1492                     _ret_var = ((Buffer)wrapper).SetPositionWrite(position);
1493                 }
1494                 catch (Exception e)
1495                 {
1496                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1497                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1498                 }
1499
1500                         return _ret_var;
1501
1502             }
1503             else
1504             {
1505                 return efl_io_buffer_position_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
1506             }
1507         }
1508
1509         private static efl_io_buffer_position_write_set_delegate efl_io_buffer_position_write_set_static_delegate;
1510
1511
1512         private delegate Eina.Slice efl_io_buffer_slice_get_delegate(System.IntPtr obj, System.IntPtr pd);
1513
1514
1515         public delegate Eina.Slice efl_io_buffer_slice_get_api_delegate(System.IntPtr obj);
1516
1517         public static Efl.Eo.FunctionWrapper<efl_io_buffer_slice_get_api_delegate> efl_io_buffer_slice_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_slice_get_api_delegate>(Module, "efl_io_buffer_slice_get");
1518
1519         private static Eina.Slice slice_get(System.IntPtr obj, System.IntPtr pd)
1520         {
1521             Eina.Log.Debug("function efl_io_buffer_slice_get was called");
1522             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1523             if (wrapper != null)
1524             {
1525             Eina.Slice _ret_var = default(Eina.Slice);
1526                 try
1527                 {
1528                     _ret_var = ((Buffer)wrapper).GetSlice();
1529                 }
1530                 catch (Exception e)
1531                 {
1532                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1533                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1534                 }
1535
1536         return _ret_var;
1537
1538             }
1539             else
1540             {
1541                 return efl_io_buffer_slice_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1542             }
1543         }
1544
1545         private static efl_io_buffer_slice_get_delegate efl_io_buffer_slice_get_static_delegate;
1546
1547
1548         private delegate void efl_io_buffer_preallocate_delegate(System.IntPtr obj, System.IntPtr pd,  uint size);
1549
1550
1551         public delegate void efl_io_buffer_preallocate_api_delegate(System.IntPtr obj,  uint size);
1552
1553         public static Efl.Eo.FunctionWrapper<efl_io_buffer_preallocate_api_delegate> efl_io_buffer_preallocate_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_preallocate_api_delegate>(Module, "efl_io_buffer_preallocate");
1554
1555         private static void preallocate(System.IntPtr obj, System.IntPtr pd, uint size)
1556         {
1557             Eina.Log.Debug("function efl_io_buffer_preallocate was called");
1558             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1559             if (wrapper != null)
1560             {
1561
1562                 try
1563                 {
1564                     ((Buffer)wrapper).Preallocate(size);
1565                 }
1566                 catch (Exception e)
1567                 {
1568                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1569                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1570                 }
1571
1572
1573             }
1574             else
1575             {
1576                 efl_io_buffer_preallocate_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
1577             }
1578         }
1579
1580         private static efl_io_buffer_preallocate_delegate efl_io_buffer_preallocate_static_delegate;
1581
1582
1583         private delegate void efl_io_buffer_adopt_readonly_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.Slice slice);
1584
1585
1586         public delegate void efl_io_buffer_adopt_readonly_api_delegate(System.IntPtr obj,  Eina.Slice slice);
1587
1588         public static Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readonly_api_delegate> efl_io_buffer_adopt_readonly_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readonly_api_delegate>(Module, "efl_io_buffer_adopt_readonly");
1589
1590         private static void adopt_readonly(System.IntPtr obj, System.IntPtr pd, Eina.Slice slice)
1591         {
1592             Eina.Log.Debug("function efl_io_buffer_adopt_readonly was called");
1593             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1594             if (wrapper != null)
1595             {
1596
1597                 try
1598                 {
1599                     ((Buffer)wrapper).AdoptReadonly(slice);
1600                 }
1601                 catch (Exception e)
1602                 {
1603                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1604                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1605                 }
1606
1607
1608             }
1609             else
1610             {
1611                 efl_io_buffer_adopt_readonly_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice);
1612             }
1613         }
1614
1615         private static efl_io_buffer_adopt_readonly_delegate efl_io_buffer_adopt_readonly_static_delegate;
1616
1617
1618         private delegate void efl_io_buffer_adopt_readwrite_delegate(System.IntPtr obj, System.IntPtr pd,  Eina.RwSlice slice);
1619
1620
1621         public delegate void efl_io_buffer_adopt_readwrite_api_delegate(System.IntPtr obj,  Eina.RwSlice slice);
1622
1623         public static Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readwrite_api_delegate> efl_io_buffer_adopt_readwrite_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_adopt_readwrite_api_delegate>(Module, "efl_io_buffer_adopt_readwrite");
1624
1625         private static void adopt_readwrite(System.IntPtr obj, System.IntPtr pd, Eina.RwSlice slice)
1626         {
1627             Eina.Log.Debug("function efl_io_buffer_adopt_readwrite was called");
1628             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1629             if (wrapper != null)
1630             {
1631
1632                 try
1633                 {
1634                     ((Buffer)wrapper).AdoptReadwrite(slice);
1635                 }
1636                 catch (Exception e)
1637                 {
1638                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1639                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1640                 }
1641
1642
1643             }
1644             else
1645             {
1646                 efl_io_buffer_adopt_readwrite_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), slice);
1647             }
1648         }
1649
1650         private static efl_io_buffer_adopt_readwrite_delegate efl_io_buffer_adopt_readwrite_static_delegate;
1651
1652
1653         private delegate System.IntPtr efl_io_buffer_binbuf_steal_delegate(System.IntPtr obj, System.IntPtr pd);
1654
1655
1656         public delegate System.IntPtr efl_io_buffer_binbuf_steal_api_delegate(System.IntPtr obj);
1657
1658         public static Efl.Eo.FunctionWrapper<efl_io_buffer_binbuf_steal_api_delegate> efl_io_buffer_binbuf_steal_ptr = new Efl.Eo.FunctionWrapper<efl_io_buffer_binbuf_steal_api_delegate>(Module, "efl_io_buffer_binbuf_steal");
1659
1660         private static System.IntPtr binbuf_steal(System.IntPtr obj, System.IntPtr pd)
1661         {
1662             Eina.Log.Debug("function efl_io_buffer_binbuf_steal was called");
1663             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1664             if (wrapper != null)
1665             {
1666             Eina.Binbuf _ret_var = default(Eina.Binbuf);
1667                 try
1668                 {
1669                     _ret_var = ((Buffer)wrapper).BinbufSteal();
1670                 }
1671                 catch (Exception e)
1672                 {
1673                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1674                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1675                 }
1676
1677         _ret_var.Own = false; return _ret_var.Handle;
1678
1679             }
1680             else
1681             {
1682                 return efl_io_buffer_binbuf_steal_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1683             }
1684         }
1685
1686         private static efl_io_buffer_binbuf_steal_delegate efl_io_buffer_binbuf_steal_static_delegate;
1687
1688         [return: MarshalAs(UnmanagedType.U1)]
1689         private delegate bool efl_io_closer_closed_get_delegate(System.IntPtr obj, System.IntPtr pd);
1690
1691         [return: MarshalAs(UnmanagedType.U1)]
1692         public delegate bool efl_io_closer_closed_get_api_delegate(System.IntPtr obj);
1693
1694         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");
1695
1696         private static bool closed_get(System.IntPtr obj, System.IntPtr pd)
1697         {
1698             Eina.Log.Debug("function efl_io_closer_closed_get was called");
1699             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1700             if (wrapper != null)
1701             {
1702             bool _ret_var = default(bool);
1703                 try
1704                 {
1705                     _ret_var = ((Buffer)wrapper).GetClosed();
1706                 }
1707                 catch (Exception e)
1708                 {
1709                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1710                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1711                 }
1712
1713         return _ret_var;
1714
1715             }
1716             else
1717             {
1718                 return efl_io_closer_closed_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1719             }
1720         }
1721
1722         private static efl_io_closer_closed_get_delegate efl_io_closer_closed_get_static_delegate;
1723
1724         [return: MarshalAs(UnmanagedType.U1)]
1725         private delegate bool efl_io_closer_close_on_exec_get_delegate(System.IntPtr obj, System.IntPtr pd);
1726
1727         [return: MarshalAs(UnmanagedType.U1)]
1728         public delegate bool efl_io_closer_close_on_exec_get_api_delegate(System.IntPtr obj);
1729
1730         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");
1731
1732         private static bool close_on_exec_get(System.IntPtr obj, System.IntPtr pd)
1733         {
1734             Eina.Log.Debug("function efl_io_closer_close_on_exec_get was called");
1735             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1736             if (wrapper != null)
1737             {
1738             bool _ret_var = default(bool);
1739                 try
1740                 {
1741                     _ret_var = ((Buffer)wrapper).GetCloseOnExec();
1742                 }
1743                 catch (Exception e)
1744                 {
1745                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1746                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1747                 }
1748
1749         return _ret_var;
1750
1751             }
1752             else
1753             {
1754                 return efl_io_closer_close_on_exec_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1755             }
1756         }
1757
1758         private static efl_io_closer_close_on_exec_get_delegate efl_io_closer_close_on_exec_get_static_delegate;
1759
1760         [return: MarshalAs(UnmanagedType.U1)]
1761         private delegate bool efl_io_closer_close_on_exec_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
1762
1763         [return: MarshalAs(UnmanagedType.U1)]
1764         public delegate bool efl_io_closer_close_on_exec_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_exec);
1765
1766         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");
1767
1768         private static bool close_on_exec_set(System.IntPtr obj, System.IntPtr pd, bool close_on_exec)
1769         {
1770             Eina.Log.Debug("function efl_io_closer_close_on_exec_set was called");
1771             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1772             if (wrapper != null)
1773             {
1774                                     bool _ret_var = default(bool);
1775                 try
1776                 {
1777                     _ret_var = ((Buffer)wrapper).SetCloseOnExec(close_on_exec);
1778                 }
1779                 catch (Exception e)
1780                 {
1781                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1782                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1783                 }
1784
1785                         return _ret_var;
1786
1787             }
1788             else
1789             {
1790                 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);
1791             }
1792         }
1793
1794         private static efl_io_closer_close_on_exec_set_delegate efl_io_closer_close_on_exec_set_static_delegate;
1795
1796         [return: MarshalAs(UnmanagedType.U1)]
1797         private delegate bool efl_io_closer_close_on_invalidate_get_delegate(System.IntPtr obj, System.IntPtr pd);
1798
1799         [return: MarshalAs(UnmanagedType.U1)]
1800         public delegate bool efl_io_closer_close_on_invalidate_get_api_delegate(System.IntPtr obj);
1801
1802         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");
1803
1804         private static bool close_on_invalidate_get(System.IntPtr obj, System.IntPtr pd)
1805         {
1806             Eina.Log.Debug("function efl_io_closer_close_on_invalidate_get was called");
1807             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1808             if (wrapper != null)
1809             {
1810             bool _ret_var = default(bool);
1811                 try
1812                 {
1813                     _ret_var = ((Buffer)wrapper).GetCloseOnInvalidate();
1814                 }
1815                 catch (Exception e)
1816                 {
1817                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1818                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1819                 }
1820
1821         return _ret_var;
1822
1823             }
1824             else
1825             {
1826                 return efl_io_closer_close_on_invalidate_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1827             }
1828         }
1829
1830         private static efl_io_closer_close_on_invalidate_get_delegate efl_io_closer_close_on_invalidate_get_static_delegate;
1831
1832
1833         private delegate void efl_io_closer_close_on_invalidate_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
1834
1835
1836         public delegate void efl_io_closer_close_on_invalidate_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool close_on_invalidate);
1837
1838         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");
1839
1840         private static void close_on_invalidate_set(System.IntPtr obj, System.IntPtr pd, bool close_on_invalidate)
1841         {
1842             Eina.Log.Debug("function efl_io_closer_close_on_invalidate_set was called");
1843             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1844             if (wrapper != null)
1845             {
1846
1847                 try
1848                 {
1849                     ((Buffer)wrapper).SetCloseOnInvalidate(close_on_invalidate);
1850                 }
1851                 catch (Exception e)
1852                 {
1853                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1854                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1855                 }
1856
1857
1858             }
1859             else
1860             {
1861                 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);
1862             }
1863         }
1864
1865         private static efl_io_closer_close_on_invalidate_set_delegate efl_io_closer_close_on_invalidate_set_static_delegate;
1866
1867
1868         private delegate Eina.Error efl_io_closer_close_delegate(System.IntPtr obj, System.IntPtr pd);
1869
1870
1871         public delegate Eina.Error efl_io_closer_close_api_delegate(System.IntPtr obj);
1872
1873         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");
1874
1875         private static Eina.Error close(System.IntPtr obj, System.IntPtr pd)
1876         {
1877             Eina.Log.Debug("function efl_io_closer_close was called");
1878             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1879             if (wrapper != null)
1880             {
1881             Eina.Error _ret_var = default(Eina.Error);
1882                 try
1883                 {
1884                     _ret_var = ((Buffer)wrapper).Close();
1885                 }
1886                 catch (Exception e)
1887                 {
1888                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1889                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1890                 }
1891
1892         return _ret_var;
1893
1894             }
1895             else
1896             {
1897                 return efl_io_closer_close_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1898             }
1899         }
1900
1901         private static efl_io_closer_close_delegate efl_io_closer_close_static_delegate;
1902
1903
1904         private delegate ulong efl_io_positioner_position_get_delegate(System.IntPtr obj, System.IntPtr pd);
1905
1906
1907         public delegate ulong efl_io_positioner_position_get_api_delegate(System.IntPtr obj);
1908
1909         public static Efl.Eo.FunctionWrapper<efl_io_positioner_position_get_api_delegate> efl_io_positioner_position_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_position_get_api_delegate>(Module, "efl_io_positioner_position_get");
1910
1911         private static ulong position_get(System.IntPtr obj, System.IntPtr pd)
1912         {
1913             Eina.Log.Debug("function efl_io_positioner_position_get was called");
1914             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1915             if (wrapper != null)
1916             {
1917             ulong _ret_var = default(ulong);
1918                 try
1919                 {
1920                     _ret_var = ((Buffer)wrapper).GetPosition();
1921                 }
1922                 catch (Exception e)
1923                 {
1924                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1925                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1926                 }
1927
1928         return _ret_var;
1929
1930             }
1931             else
1932             {
1933                 return efl_io_positioner_position_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
1934             }
1935         }
1936
1937         private static efl_io_positioner_position_get_delegate efl_io_positioner_position_get_static_delegate;
1938
1939         [return: MarshalAs(UnmanagedType.U1)]
1940         private delegate bool efl_io_positioner_position_set_delegate(System.IntPtr obj, System.IntPtr pd,  ulong position);
1941
1942         [return: MarshalAs(UnmanagedType.U1)]
1943         public delegate bool efl_io_positioner_position_set_api_delegate(System.IntPtr obj,  ulong position);
1944
1945         public static Efl.Eo.FunctionWrapper<efl_io_positioner_position_set_api_delegate> efl_io_positioner_position_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_position_set_api_delegate>(Module, "efl_io_positioner_position_set");
1946
1947         private static bool position_set(System.IntPtr obj, System.IntPtr pd, ulong position)
1948         {
1949             Eina.Log.Debug("function efl_io_positioner_position_set was called");
1950             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1951             if (wrapper != null)
1952             {
1953                                     bool _ret_var = default(bool);
1954                 try
1955                 {
1956                     _ret_var = ((Buffer)wrapper).SetPosition(position);
1957                 }
1958                 catch (Exception e)
1959                 {
1960                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1961                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1962                 }
1963
1964                         return _ret_var;
1965
1966             }
1967             else
1968             {
1969                 return efl_io_positioner_position_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), position);
1970             }
1971         }
1972
1973         private static efl_io_positioner_position_set_delegate efl_io_positioner_position_set_static_delegate;
1974
1975
1976         private delegate Eina.Error efl_io_positioner_seek_delegate(System.IntPtr obj, System.IntPtr pd,  long offset,  Efl.Io.PositionerWhence whence);
1977
1978
1979         public delegate Eina.Error efl_io_positioner_seek_api_delegate(System.IntPtr obj,  long offset,  Efl.Io.PositionerWhence whence);
1980
1981         public static Efl.Eo.FunctionWrapper<efl_io_positioner_seek_api_delegate> efl_io_positioner_seek_ptr = new Efl.Eo.FunctionWrapper<efl_io_positioner_seek_api_delegate>(Module, "efl_io_positioner_seek");
1982
1983         private static Eina.Error seek(System.IntPtr obj, System.IntPtr pd, long offset, Efl.Io.PositionerWhence whence)
1984         {
1985             Eina.Log.Debug("function efl_io_positioner_seek was called");
1986             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
1987             if (wrapper != null)
1988             {
1989                                                             Eina.Error _ret_var = default(Eina.Error);
1990                 try
1991                 {
1992                     _ret_var = ((Buffer)wrapper).Seek(offset, whence);
1993                 }
1994                 catch (Exception e)
1995                 {
1996                     Eina.Log.Warning($"Callback error: {e.ToString()}");
1997                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
1998                 }
1999
2000                                         return _ret_var;
2001
2002             }
2003             else
2004             {
2005                 return efl_io_positioner_seek_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), offset, whence);
2006             }
2007         }
2008
2009         private static efl_io_positioner_seek_delegate efl_io_positioner_seek_static_delegate;
2010
2011         [return: MarshalAs(UnmanagedType.U1)]
2012         private delegate bool efl_io_reader_can_read_get_delegate(System.IntPtr obj, System.IntPtr pd);
2013
2014         [return: MarshalAs(UnmanagedType.U1)]
2015         public delegate bool efl_io_reader_can_read_get_api_delegate(System.IntPtr obj);
2016
2017         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");
2018
2019         private static bool can_read_get(System.IntPtr obj, System.IntPtr pd)
2020         {
2021             Eina.Log.Debug("function efl_io_reader_can_read_get was called");
2022             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2023             if (wrapper != null)
2024             {
2025             bool _ret_var = default(bool);
2026                 try
2027                 {
2028                     _ret_var = ((Buffer)wrapper).GetCanRead();
2029                 }
2030                 catch (Exception e)
2031                 {
2032                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2033                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2034                 }
2035
2036         return _ret_var;
2037
2038             }
2039             else
2040             {
2041                 return efl_io_reader_can_read_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2042             }
2043         }
2044
2045         private static efl_io_reader_can_read_get_delegate efl_io_reader_can_read_get_static_delegate;
2046
2047
2048         private delegate void efl_io_reader_can_read_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_read);
2049
2050
2051         public delegate void efl_io_reader_can_read_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_read);
2052
2053         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");
2054
2055         private static void can_read_set(System.IntPtr obj, System.IntPtr pd, bool can_read)
2056         {
2057             Eina.Log.Debug("function efl_io_reader_can_read_set was called");
2058             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2059             if (wrapper != null)
2060             {
2061
2062                 try
2063                 {
2064                     ((Buffer)wrapper).SetCanRead(can_read);
2065                 }
2066                 catch (Exception e)
2067                 {
2068                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2069                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2070                 }
2071
2072
2073             }
2074             else
2075             {
2076                 efl_io_reader_can_read_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_read);
2077             }
2078         }
2079
2080         private static efl_io_reader_can_read_set_delegate efl_io_reader_can_read_set_static_delegate;
2081
2082         [return: MarshalAs(UnmanagedType.U1)]
2083         private delegate bool efl_io_reader_eos_get_delegate(System.IntPtr obj, System.IntPtr pd);
2084
2085         [return: MarshalAs(UnmanagedType.U1)]
2086         public delegate bool efl_io_reader_eos_get_api_delegate(System.IntPtr obj);
2087
2088         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");
2089
2090         private static bool eos_get(System.IntPtr obj, System.IntPtr pd)
2091         {
2092             Eina.Log.Debug("function efl_io_reader_eos_get was called");
2093             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2094             if (wrapper != null)
2095             {
2096             bool _ret_var = default(bool);
2097                 try
2098                 {
2099                     _ret_var = ((Buffer)wrapper).GetEos();
2100                 }
2101                 catch (Exception e)
2102                 {
2103                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2104                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2105                 }
2106
2107         return _ret_var;
2108
2109             }
2110             else
2111             {
2112                 return efl_io_reader_eos_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2113             }
2114         }
2115
2116         private static efl_io_reader_eos_get_delegate efl_io_reader_eos_get_static_delegate;
2117
2118
2119         private delegate void efl_io_reader_eos_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool is_eos);
2120
2121
2122         public delegate void efl_io_reader_eos_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool is_eos);
2123
2124         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");
2125
2126         private static void eos_set(System.IntPtr obj, System.IntPtr pd, bool is_eos)
2127         {
2128             Eina.Log.Debug("function efl_io_reader_eos_set was called");
2129             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2130             if (wrapper != null)
2131             {
2132
2133                 try
2134                 {
2135                     ((Buffer)wrapper).SetEos(is_eos);
2136                 }
2137                 catch (Exception e)
2138                 {
2139                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2140                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2141                 }
2142
2143
2144             }
2145             else
2146             {
2147                 efl_io_reader_eos_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), is_eos);
2148             }
2149         }
2150
2151         private static efl_io_reader_eos_set_delegate efl_io_reader_eos_set_static_delegate;
2152
2153
2154         private delegate Eina.Error efl_io_reader_read_delegate(System.IntPtr obj, System.IntPtr pd,  ref Eina.RwSlice rw_slice);
2155
2156
2157         public delegate Eina.Error efl_io_reader_read_api_delegate(System.IntPtr obj,  ref Eina.RwSlice rw_slice);
2158
2159         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");
2160
2161         private static Eina.Error read(System.IntPtr obj, System.IntPtr pd, ref Eina.RwSlice rw_slice)
2162         {
2163             Eina.Log.Debug("function efl_io_reader_read was called");
2164             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2165             if (wrapper != null)
2166             {
2167                                     Eina.Error _ret_var = default(Eina.Error);
2168                 try
2169                 {
2170                     _ret_var = ((Buffer)wrapper).Read(ref rw_slice);
2171                 }
2172                 catch (Exception e)
2173                 {
2174                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2175                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2176                 }
2177
2178                         return _ret_var;
2179
2180             }
2181             else
2182             {
2183                 return efl_io_reader_read_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), ref rw_slice);
2184             }
2185         }
2186
2187         private static efl_io_reader_read_delegate efl_io_reader_read_static_delegate;
2188
2189
2190         private delegate ulong efl_io_sizer_size_get_delegate(System.IntPtr obj, System.IntPtr pd);
2191
2192
2193         public delegate ulong efl_io_sizer_size_get_api_delegate(System.IntPtr obj);
2194
2195         public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate> efl_io_sizer_size_get_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_get_api_delegate>(Module, "efl_io_sizer_size_get");
2196
2197         private static ulong size_get(System.IntPtr obj, System.IntPtr pd)
2198         {
2199             Eina.Log.Debug("function efl_io_sizer_size_get was called");
2200             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2201             if (wrapper != null)
2202             {
2203             ulong _ret_var = default(ulong);
2204                 try
2205                 {
2206                     _ret_var = ((Buffer)wrapper).GetSize();
2207                 }
2208                 catch (Exception e)
2209                 {
2210                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2211                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2212                 }
2213
2214         return _ret_var;
2215
2216             }
2217             else
2218             {
2219                 return efl_io_sizer_size_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2220             }
2221         }
2222
2223         private static efl_io_sizer_size_get_delegate efl_io_sizer_size_get_static_delegate;
2224
2225         [return: MarshalAs(UnmanagedType.U1)]
2226         private delegate bool efl_io_sizer_size_set_delegate(System.IntPtr obj, System.IntPtr pd,  ulong size);
2227
2228         [return: MarshalAs(UnmanagedType.U1)]
2229         public delegate bool efl_io_sizer_size_set_api_delegate(System.IntPtr obj,  ulong size);
2230
2231         public static Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate> efl_io_sizer_size_set_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_size_set_api_delegate>(Module, "efl_io_sizer_size_set");
2232
2233         private static bool size_set(System.IntPtr obj, System.IntPtr pd, ulong size)
2234         {
2235             Eina.Log.Debug("function efl_io_sizer_size_set was called");
2236             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2237             if (wrapper != null)
2238             {
2239                                     bool _ret_var = default(bool);
2240                 try
2241                 {
2242                     _ret_var = ((Buffer)wrapper).SetSize(size);
2243                 }
2244                 catch (Exception e)
2245                 {
2246                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2247                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2248                 }
2249
2250                         return _ret_var;
2251
2252             }
2253             else
2254             {
2255                 return efl_io_sizer_size_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
2256             }
2257         }
2258
2259         private static efl_io_sizer_size_set_delegate efl_io_sizer_size_set_static_delegate;
2260
2261
2262         private delegate Eina.Error efl_io_sizer_resize_delegate(System.IntPtr obj, System.IntPtr pd,  ulong size);
2263
2264
2265         public delegate Eina.Error efl_io_sizer_resize_api_delegate(System.IntPtr obj,  ulong size);
2266
2267         public static Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate> efl_io_sizer_resize_ptr = new Efl.Eo.FunctionWrapper<efl_io_sizer_resize_api_delegate>(Module, "efl_io_sizer_resize");
2268
2269         private static Eina.Error resize(System.IntPtr obj, System.IntPtr pd, ulong size)
2270         {
2271             Eina.Log.Debug("function efl_io_sizer_resize was called");
2272             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2273             if (wrapper != null)
2274             {
2275                                     Eina.Error _ret_var = default(Eina.Error);
2276                 try
2277                 {
2278                     _ret_var = ((Buffer)wrapper).Resize(size);
2279                 }
2280                 catch (Exception e)
2281                 {
2282                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2283                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2284                 }
2285
2286                         return _ret_var;
2287
2288             }
2289             else
2290             {
2291                 return efl_io_sizer_resize_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), size);
2292             }
2293         }
2294
2295         private static efl_io_sizer_resize_delegate efl_io_sizer_resize_static_delegate;
2296
2297         [return: MarshalAs(UnmanagedType.U1)]
2298         private delegate bool efl_io_writer_can_write_get_delegate(System.IntPtr obj, System.IntPtr pd);
2299
2300         [return: MarshalAs(UnmanagedType.U1)]
2301         public delegate bool efl_io_writer_can_write_get_api_delegate(System.IntPtr obj);
2302
2303         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");
2304
2305         private static bool can_write_get(System.IntPtr obj, System.IntPtr pd)
2306         {
2307             Eina.Log.Debug("function efl_io_writer_can_write_get was called");
2308             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2309             if (wrapper != null)
2310             {
2311             bool _ret_var = default(bool);
2312                 try
2313                 {
2314                     _ret_var = ((Buffer)wrapper).GetCanWrite();
2315                 }
2316                 catch (Exception e)
2317                 {
2318                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2319                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2320                 }
2321
2322         return _ret_var;
2323
2324             }
2325             else
2326             {
2327                 return efl_io_writer_can_write_get_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)));
2328             }
2329         }
2330
2331         private static efl_io_writer_can_write_get_delegate efl_io_writer_can_write_get_static_delegate;
2332
2333
2334         private delegate void efl_io_writer_can_write_set_delegate(System.IntPtr obj, System.IntPtr pd, [MarshalAs(UnmanagedType.U1)] bool can_write);
2335
2336
2337         public delegate void efl_io_writer_can_write_set_api_delegate(System.IntPtr obj, [MarshalAs(UnmanagedType.U1)] bool can_write);
2338
2339         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");
2340
2341         private static void can_write_set(System.IntPtr obj, System.IntPtr pd, bool can_write)
2342         {
2343             Eina.Log.Debug("function efl_io_writer_can_write_set was called");
2344             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2345             if (wrapper != null)
2346             {
2347
2348                 try
2349                 {
2350                     ((Buffer)wrapper).SetCanWrite(can_write);
2351                 }
2352                 catch (Exception e)
2353                 {
2354                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2355                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2356                 }
2357
2358
2359             }
2360             else
2361             {
2362                 efl_io_writer_can_write_set_ptr.Value.Delegate(Efl.Eo.Globals.efl_super(obj, Efl.Eo.Globals.efl_class_get(obj)), can_write);
2363             }
2364         }
2365
2366         private static efl_io_writer_can_write_set_delegate efl_io_writer_can_write_set_static_delegate;
2367
2368
2369         private delegate Eina.Error efl_io_writer_write_delegate(System.IntPtr obj, System.IntPtr pd,  ref Eina.Slice slice,  ref Eina.Slice remaining);
2370
2371
2372         public delegate Eina.Error efl_io_writer_write_api_delegate(System.IntPtr obj,  ref Eina.Slice slice,  ref Eina.Slice remaining);
2373
2374         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");
2375
2376         private static Eina.Error write(System.IntPtr obj, System.IntPtr pd, ref Eina.Slice slice, ref Eina.Slice remaining)
2377         {
2378             Eina.Log.Debug("function efl_io_writer_write was called");
2379             Efl.Eo.IWrapper wrapper = Efl.Eo.Globals.PrivateDataGet(pd);
2380             if (wrapper != null)
2381             {
2382                                 remaining = default(Eina.Slice);                            Eina.Error _ret_var = default(Eina.Error);
2383                 try
2384                 {
2385                     _ret_var = ((Buffer)wrapper).Write(ref slice, ref remaining);
2386                 }
2387                 catch (Exception e)
2388                 {
2389                     Eina.Log.Warning($"Callback error: {e.ToString()}");
2390                     Eina.Error.Set(Eina.Error.UNHANDLED_EXCEPTION);
2391                 }
2392
2393                                         return _ret_var;
2394
2395             }
2396             else
2397             {
2398                 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);
2399             }
2400         }
2401
2402         private static efl_io_writer_write_delegate efl_io_writer_write_static_delegate;
2403
2404         #pragma warning restore CA1707, SA1300, SA1600
2405
2406 }
2407 }
2408 }
2409
2410 }
2411