Example #1
0
        public static Coroutine_ StartCoroutine1(MonoBehaviour b, IEnumerator <object> coroutine, object mutex = null)
        {
            var _coroutine = new Coroutine_(coroutine, mutex);

            _coroutine.StartWith(b);
            return(_coroutine);
        }
Example #2
0
 static void SetInUseBy(object mutex, Coroutine_ cr)
 {
     if (inUseBy == null)
     {
         inUseBy = new Dictionary <object, Coroutine_>();
     }
     if (!inUseBy.ContainsKey(mutex))
     {
         inUseBy.Add(mutex, cr);
     }
     else
     {
         inUseBy[mutex] = cr;
     }
 }
Example #3
0
        public static Coroutine_ StartCoroutineSingle(MonoBehaviour b, IEnumerator <object> coroutine, object mutex)
        {
            if (mutex == null)
            {
                Debug.LogWarning("Mutex is null. Consider using StartCoroutine1 instead.");
                return(StartCoroutine1(b, coroutine));
            }

            if (!CoroutineMonitor.TryEnter(mutex))
            {
                return(GetInUseBy(mutex));
            }

            var _coroutine = new Coroutine_(coroutine, mutex, true);

            _coroutine.StartWith(b);
            return(_coroutine);
        }
Example #4
0
 /// <summary>
 /// Attempts to start a coroutine in single mode. The difference in execution order between
 /// this and the StartCoroutine1 with a mutex is that the mutex lock is acquired before the
 /// coroutine is started. If a lock on the mutex cannot be acquired, the previous coroutine
 /// that acquired the lock will be returned.
 ///
 /// The started coroutine allows for suspending, interrupting and resuming. The started
 /// coroutine is not awaitable like a Unity Coroutine. Instead, use Coroutine_.GetAwaiter()
 /// if you want to wait for the coroutine to complete similar to Unity's coroutines.
 ///
 /// This function works on disposable coroutines. So the finally block in the coroutine is
 /// guaranteed to execute.
 /// </summary>
 /// <param name="b">The MonoBehaviour that starts the coroutine.</param>
 /// <param name="coroutine">The Coroutine in question.</param>
 /// <param name="mutex">A mutex that should not be null. A warning will be issued if it is
 /// null and the coroutine will be started normally.</param>
 /// <returns></returns>
 public static Coroutine_ StartCoroutineSingle(this MonoBehaviour b, IEnumerator <object> coroutine, object mutex = null)
 {
     return(Coroutine_.StartCoroutineSingle(b, coroutine, mutex));
 }
Example #5
0
 /// <summary>
 /// Starts a coroutine that allows for suspending, interrupting and resuming. The started
 /// coroutine is not awaitable like a Unity Coroutine. Instead, use Coroutine_.GetAwaiter()
 /// if you want to wait for the coroutine to complete similar to Unity's coroutines.
 ///
 /// This function works on disposable coroutines. So the finally block in the coroutine is
 /// guaranteed to execute.
 /// </summary>
 /// <param name="b">The MonoBehaviour that starts the coroutine.</param>
 /// <param name="coroutine">The Coroutine in question.</param>
 /// <param name="mutex">A mutex. If supplied, this mutex will be used and the coroutine is
 /// started in chained mode. If null, the coroutine is started normally.</param>
 /// <returns>A interruptable coroutine.</returns>
 public static Coroutine_ StartCoroutine1(this MonoBehaviour b, IEnumerable <object> coroutine, object mutex = null)
 {
     return(Coroutine_.StartCoroutine1(b, coroutine.GetEnumerator(), mutex));
 }