Added SDK

include/Ultralight/platform/Thread.h

@@ -0,0 +1,93 @@
+/**************************************************************************************************
+ *  This file is a part of Ultralight.                                                            *
+ *                                                                                                *
+ *  See <https://ultralig.ht> for licensing and more.                                             *
+ *                                                                                                *
+ *  (C) 2024 Ultralight, Inc.                                                                     *
+ **************************************************************************************************/
+#pragma once
+#include <Ultralight/Defines.h>
+
+namespace ultralight {
+
+///
+/// Unique id of the thread, used for referencing the created thread later.
+///   * on Windows this should match the thread identifier returned by either _beginthreadex() 
+///     or GetCurrentThreadId()
+///   * on POSIX this can be whatever unique id you want
+///
+typedef uint32_t ThreadId;
+
+///
+/// Platform-specific handle
+///   * on Windows this is HANDLE
+///   * on POSIX this is pthread_t
+///
+typedef uint64_t ThreadHandle;
+
+///
+/// Entry point for the thread, this function should be called by the thread once it is active
+/// and should be passed entry_point_data as the argument.
+///
+typedef void (*ThreadEntryPoint)(void*);
+
+///
+/// The type of thread, you can choose to optionally handle these for better performance.
+///
+enum class ThreadType : uint8_t {
+  Unknown = 0,
+  JavaScript,
+  Compiler,
+  GarbageCollection,
+  Network,
+  Graphics,
+  Audio,
+};
+
+///
+/// Result of creating a new thread.
+///
+/// This struct is used to return the id and handle of the created thread.
+///
+struct UExport CreateThreadResult {
+  ThreadId id;         ///< The unique id of the thread. @see ThreadId
+  ThreadHandle handle; ///< The platform-specific handle of the thread. @see ThreadHandle
+};
+
+///
+/// User-defined factory for creating new threads.
+///
+/// You can implement this interface so that the library will use your own implementation for
+/// creating threads (useful for tracking thread creation, setting thread names, etc).
+///
+/// ## Default Implementation
+///
+/// When no factory is defined, the library will create threads using the default platform-specific
+/// thread creation functions (eg, `_beginthreadex()` on Windows, `pthread_create()` on POSIX).
+///
+/// ## Setting the Thread Factory
+///
+/// To provide your own custom ThreadFactory implementation, you should inherit from this class,
+/// handle the virtual member functions, and then pass an instance to
+/// Platform::set_thread_factory().
+///
+class UExport ThreadFactory {
+ public:
+  virtual ~ThreadFactory() = default;
+
+  ///
+  /// Create a new thread.
+  ///
+  /// @param  name               The name of the thread (can be nullptr).
+  /// @param  type               The type of thread.
+  /// @param  entry_point        The entry point for the thread.
+  /// @param  entry_point_data   The data to pass to the entry point.
+  /// @param  result             The resulting id and handle of the thread creation.
+  ///
+  /// @return Returns whether or not the thread was created successfully.
+  ///
+  virtual bool CreateThread(const char* name, ThreadType type, ThreadEntryPoint entry_point,
+                            void* entry_point_data, CreateThreadResult& result) = 0;
+};
+
+} // namespace ultralight