felipealmeida pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=33f5167089402c0ff52f13619e648ff267a07f42
commit 33f5167089402c0ff52f13619e648ff267a07f42 Author: Bruno da Silva Belo <brunodasilvab...@gmail.com> Date: Mon Sep 30 23:14:46 2019 -0300 mono_docs:adding and updating eina_binbuf.cs. Summary: Generating docs and setting to 1.23. Reviewers: lauromoura, felipealmeida Reviewed By: felipealmeida Subscribers: cedric, #reviewers, #committers Tags: #efl Maniphest Tasks: T8293 Differential Revision: https://phab.enlightenment.org/D10252 --- src/bindings/mono/eina_mono/eina_binbuf.cs | 106 +++++++++++++++++++++++++++++ 1 file changed, 106 insertions(+) diff --git a/src/bindings/mono/eina_mono/eina_binbuf.cs b/src/bindings/mono/eina_mono/eina_binbuf.cs index e5dc817085..3dcda65bf8 100644 --- a/src/bindings/mono/eina_mono/eina_binbuf.cs +++ b/src/bindings/mono/eina_mono/eina_binbuf.cs @@ -6,6 +6,9 @@ using System.Runtime.InteropServices; namespace Eina { +/// <summary> +/// A Generic buffer designed to be a mutable string (SINCE EFL 1.23). +/// </summary> public class Binbuf : IDisposable { [DllImport(efl.Libs.Eina)] public static extern IntPtr @@ -39,9 +42,12 @@ public class Binbuf : IDisposable [DllImport(efl.Libs.Eina)] public static extern Eina.Slice eina_binbuf_slice_get(IntPtr buf); + /// <summary>Pointer to the native buffer.</summary> public IntPtr Handle {get;set;} = IntPtr.Zero; + ///<summary>Whether this wrapper owns the native buffer.</summary> public bool Own {get;set;} + /// <summary> Length of the buffer.</summary> public int Length { get { return (int)GetLength(); } @@ -57,6 +63,9 @@ public class Binbuf : IDisposable } } + /// <summary> + /// Create a new buffer. + /// </summary> public Binbuf() { InitNew(); @@ -76,6 +85,10 @@ public class Binbuf : IDisposable } } + /// <summary> + /// Create a new buffer with elements. + /// </summary> + ///// <param name="bb">Elements to initialize the new buffer.</param> public Binbuf(Binbuf bb) { InitNew(); @@ -86,6 +99,11 @@ public class Binbuf : IDisposable } } + /// <summary> + /// Create a new buffer. + /// </summary> + ///// <param name="handle">The native handle to be wrapped.</param> + ///// <param name="own">Whether this wrapper owns the native handle.</param> public Binbuf(IntPtr handle, bool own) { Handle = handle; @@ -97,6 +115,9 @@ public class Binbuf : IDisposable Dispose(false); } + /// <summary>Disposes of this wrapper, releasing the native buffer if owned.</summary> + /// <param name="disposing">True if this was called from <see cref="Dispose()"/> public method. False if + /// called from the C# finalizer.</param> protected virtual void Dispose(bool disposing) { IntPtr h = Handle; @@ -114,17 +135,23 @@ public class Binbuf : IDisposable } } + /// <summary>Releases the native resources held by this instance.</summary> public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } + /// <summary>Releases the native resources held by this instance.</summary> public void Free() { Dispose(); } + /// <summary> + /// Releases the native buffer. + /// </summary> + /// <returns>The native buffer.</returns> public IntPtr Release() { IntPtr h = Handle; @@ -132,61 +159,127 @@ public class Binbuf : IDisposable return h; } + /// <summary> + /// Resets the buffer. + /// </summary> public void Reset() { eina_binbuf_reset(Handle); } + /// <summary> + /// Appends a string of inputed buffer's length to the buffer, reallocating as necessary. + /// </summary> + ///// <param name="str">The string buffer.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Append(byte[] str) { return 0 != eina_binbuf_append_length(Handle, str, (UIntPtr)(str.Length)); } + /// <summary> + /// Appends a string of exact length to the buffer, reallocating as necessary. + /// </summary> + ///// <param name="str">The string buffer.</param> + ///// <param name="length">The exact length to use.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Append(byte[] str, uint length) { return 0 != eina_binbuf_append_length(Handle, str, (UIntPtr)length); } + /// <summary> + /// Appends a Binbuf to the buffer. + /// </summary> + ///// <param name="bb">The buffer to be appended.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Append(Binbuf bb) { return 0 != eina_binbuf_append_buffer(Handle, bb.Handle); } + /// <summary> + /// Appends a character to the buffer, reallocating as necessary. + /// </summary> + ///// <param name="c">The char to appended.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Append(byte c) { return 0 != eina_binbuf_append_char(Handle, c); } + /// <summary> + /// Appends a slice to the buffer, reallocating as necessary. + /// </summary> + ///// <param name="slice">The slice to appended.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Append(Eina.Slice slice) { return 0 != eina_binbuf_append_slice(Handle, slice); } + /// <summary> + /// Inserts a string of inputed buffer's length into the buffer, reallocating as necessary. + /// </summary> + ///// <param name="str">The string buffer.</param> + ///// <param name="pos">The position to insert the string.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Insert(byte[] str, uint pos) { return 0 != eina_binbuf_insert_length(Handle, str, (UIntPtr)(str.Length), (UIntPtr)pos); } + /// <summary> + /// Inserts a string of exact length into the buffer, reallocating as necessary. + /// </summary> + ///// <param name="str">The string buffer.</param> + ///// <param name="length">The exact length to use.</param> + ///// <param name="pos">The position to insert the string.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Insert(byte[] str, uint length, uint pos) { return 0 != eina_binbuf_insert_length(Handle, str, (UIntPtr)length, (UIntPtr)pos); } + /// <summary> + /// Inserts a character into the buffer, reallocating as necessary. + /// </summary> + ///// <param name="c">The char to appended.</param> + ///// <param name="pos">The position to insert the string.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Insert(byte c, uint pos) { return 0 != eina_binbuf_insert_char(Handle, c, (UIntPtr)pos); } + /// <summary> + /// Inserts a slice into the buffer, reallocating as necessary. + /// </summary> + ///// <param name="slice">The slice to appended.</param> + ///// <param name="pos">The position to insert the string.</param> + /// <returns>true on success, false if data could not be appended.</returns> public bool Insert(Eina.Slice slice, uint pos) { return 0 != eina_binbuf_insert_slice(Handle, slice, (UIntPtr)pos); } + /// <summary> + /// Removes a slice of the buffer. + /// </summary> + ///// <param name="start">The initial (inclusive) slice position to start + ///// removing, in bytes.</param> + ///// <param name="end">The final (non-inclusive) slice position to finish + ///// removing, in bytes..</param> + /// <returns>true on success, false on failure.</returns> public bool Remove(uint start, uint end) { return 0 != eina_binbuf_remove(Handle, (UIntPtr)start, (UIntPtr)end); } + /// <summary> + /// Retrieves a string to the contents of the buffer. + /// </summary> + /// <returns>The string that is contained in buffer.</returns> public byte[] GetBytes() { var ptr = eina_binbuf_string_get(Handle); @@ -201,21 +294,34 @@ public class Binbuf : IDisposable return mArray; } + /// <summary> + /// Retrieves a string to the contents of the buffer. + /// </summary> + /// <returns>The string that is contained in buffer.</returns> public IntPtr GetStringNative() { return eina_binbuf_string_get(Handle); } + /// <summary> + /// Frees the buffer. + /// </summary> public void FreeString() { eina_binbuf_string_free(Handle); } + /// <summary> + /// Retrieves the length of the buffer's contents. + /// </summary> public UIntPtr GetLength() { return eina_binbuf_length_get(Handle); } + /// <summary> + /// Gets a slice of the buffer's contents. + /// </summary> Eina.Slice GetSlice() { return eina_binbuf_slice_get(Handle); --