init lserp cs 5.0

2026-07-10 15:25:05 +08:00
commit 90f3fda86a
3799 changed files with 976868 additions and 0 deletions
@@ -0,0 +1,109 @@
+namespace Cef3
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Runtime.InteropServices;
+    using Cef3.Interop;
+
+    // TODO: use intptr-sized implementations ?
+
+    /// <summary>
+    /// Class representing a binary value. Can be used on any process and thread.
+    /// </summary>
+    public sealed unsafe partial class CefBinaryValue
+    {
+        /// <summary>
+        /// Creates a new object that is not owned by any other object. The specified
+        /// |data| will be copied.
+        /// </summary>
+        public static CefBinaryValue Create(byte[] data)
+        {
+            if (data == null) throw new ArgumentNullException("data");
+
+            fixed (byte* data_ptr = data)
+            {
+                var value = cef_binary_value_t.create(data_ptr, (UIntPtr)data.LongLength);
+                return CefBinaryValue.FromNative(value);
+            }
+        }
+
+        /// <summary>
+        /// Returns true if this object is valid. This object may become invalid if
+        /// the underlying data is owned by another object (e.g. list or dictionary)
+        /// and that other object is then modified or destroyed. Do not call any other
+        /// methods if this method returns false.
+        /// </summary>
+        public bool IsValid
+        {
+            get { return cef_binary_value_t.is_valid(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Returns true if this object is currently owned by another object.
+        /// </summary>
+        public bool IsOwned
+        {
+            get { return cef_binary_value_t.is_owned(_self) != 0; }
+        }
+
+        /// <summary>
+        /// Returns true if this object and |that| object have the same underlying
+        /// data.
+        /// </summary>
+        public bool IsSame(CefBinaryValue that)
+        {
+            return cef_binary_value_t.is_same(_self, that.ToNative()) != 0;
+        }
+
+        /// <summary>
+        /// Returns true if this object and |that| object have an equivalent underlying
+        /// value but are not necessarily the same object.
+        /// </summary>
+        public bool IsEqual(CefBinaryValue that)
+        {
+            return cef_binary_value_t.is_equal(_self, that.ToNative()) != 0;
+        }
+
+        /// <summary>
+        /// Returns a copy of this object. The data in this object will also be copied.
+        /// </summary>
+        public CefBinaryValue Copy()
+        {
+            var value = cef_binary_value_t.copy(_self);
+            return CefBinaryValue.FromNative(value);
+        }
+
+        /// <summary>
+        /// Returns the data size.
+        /// </summary>
+        public long Size
+        {
+            get { return (long)cef_binary_value_t.get_size(_self); }
+        }
+
+        /// <summary>
+        /// Read up to |buffer_size| number of bytes into |buffer|. Reading begins at
+        /// the specified byte |data_offset|. Returns the number of bytes read.
+        /// </summary>
+        public long GetData(byte[] buffer, long bufferSize, long dataOffset)
+        {
+            if (buffer.LongLength < dataOffset + bufferSize) throw new ArgumentOutOfRangeException("dataOffset");
+
+            fixed (byte* buffer_ptr = buffer)
+            {
+                return (long)cef_binary_value_t.get_data(_self, buffer_ptr, (UIntPtr)bufferSize, (UIntPtr)dataOffset);
+            }
+
+            // FIXME: CefBinaryValue.GetData - allow work with buffer / etc
+        }
+
+        public byte[] ToArray()
+        {
+            var value = new byte[Size];
+            var readed = GetData(value, value.Length, 0);
+            if (readed != value.Length) throw new InvalidOperationException();
+            return value;
+        }
+    }
+}