(61d00a474) v0.9.7.1

Libraries/GameAnalytics/GA-SDK-MONO-SHARED/Foundation/Tasks/TaskTResult.cs

@@ -0,0 +1,173 @@
+#if UNITY
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace Foundation.Tasks
+{
+    /// <summary>
+    /// A task encapsulates future work that may be waited on.
+    /// - Support running actions in background threads 
+    /// - Supports running coroutines with return results
+    /// - Use the WaitForRoutine method to wait for the task in a coroutine
+    /// </summary>
+    /// <example>
+    /// <code>
+    ///     var task = Task.Run(() =>
+    ///     {
+    ///        //Debug.Log does not work in
+    ///        Debug.Log("Sleeping...");
+    ///        Task.Delay(2000);
+    ///        Debug.Log("Slept");
+    ///    });
+    ///    // wait for it
+    ///    yield return task;
+    ///
+    ///    // check exceptions
+    ///    if(task.IsFaulted)
+    ///        Debug.LogException(task.Exception)
+    ///</code>
+    ///</example>
+    public class AsyncTask<TResult> : AsyncTask
+    {
+#region public fields
+
+        /// <summary>
+        /// get the result of the task. Blocking. It is recommended you yield on the wait before accessing this value
+        /// </summary>
+        public TResult Result;
+#endregion
+
+#region ctor
+
+        Func<TResult> _function;
+
+        public AsyncTask()
+        {
+
+        }
+
+        /// <summary>
+        /// Returns the task in the Success state.
+        /// </summary>
+        /// <param name="result"></param>
+        public AsyncTask(TResult result)
+            : this()
+        {
+            Status = TaskStatus.Success;
+            Strategy = TaskStrategy.Custom;
+            Result = result;
+        }
+
+        /// <summary>
+        /// Creates a new background Task strategy
+        /// </summary>
+        /// <param name="function"></param>
+        public AsyncTask(Func<TResult> function)
+            : this()
+        {
+            if (function == null)
+                throw new ArgumentNullException("function");
+
+            _function = function;
+        }
+
+        /// <summary>
+        /// Creates a new task with a specific strategy
+        /// </summary>
+        public AsyncTask(Func<TResult> function, TaskStrategy mode)
+            : this()
+        {
+            if (function == null)
+                throw new ArgumentNullException("function");
+
+            if (mode == TaskStrategy.Coroutine)
+                throw new ArgumentException("Mode can not be coroutine");
+
+            _function = function;
+            Strategy = mode;
+        }
+
+        /// <summary>
+        /// Creates a new Coroutine  task
+        /// </summary>
+        public AsyncTask(IEnumerator routine)
+        {
+            if (routine == null)
+                throw new ArgumentNullException("routine");
+
+
+            _routine = routine;
+            Strategy = TaskStrategy.Coroutine;
+        }
+
+        /// <summary>
+        /// Creates a new Task in a Faulted state
+        /// </summary>
+        /// <param name="ex"></param>
+        public AsyncTask(Exception ex)
+        {
+            Exception = ex;
+            Strategy = TaskStrategy.Custom;
+            Status = TaskStatus.Faulted;
+        }
+
+        /// <summary>
+        /// Creates a new task
+        /// </summary>
+        public AsyncTask(TaskStrategy mode)
+            : this()
+        {
+            Strategy = mode;
+        }
+#endregion
+
+#region protected methods
+
+        /// <summary>
+        /// Runs complete logic, for custom tasks
+        /// </summary>
+        public override void Complete(Exception ex = null)
+        {
+            Result = default(TResult);
+            base.Complete(ex);
+        }
+
+        /// <summary>
+        /// Runs complete logic, for custom tasks
+        /// </summary>
+        public void Complete(TResult result)
+        {
+            Result = result;
+            base.Complete();
+        }
+
+        public override void Start()
+        {
+            Result = default(TResult);
+            base.Start();
+        }
+
+        protected override void Execute()
+        {
+            try
+            {
+                if (_function != null)
+                {
+                    Result = _function();
+                }
+                Status = TaskStatus.Success;
+                OnTaskComplete();
+            }
+            catch (Exception ex)
+            {
+                Exception = ex;
+                Status = TaskStatus.Faulted;
+                if (LogErrors)
+                    Debug.LogException(ex);
+            }
+        }
+#endregion
+    }
+}
+#endif