BadTask.cs

Go to the documentation of this file.

using System.Text;
 
using BadScript2.Runtime;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop.Functions;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Functions;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Interop.Common.Task;
 
public class BadTask : BadObject
{
    public static readonly BadClassPrototype Prototype = new BadNativeClassPrototype<BadTask>("Task",
                                                                                              (ctx, args) =>
                                                                                              {
                                                                                                  if (args.Length != 2)
                                                                                                  {
                                                                                                      throw new BadRuntimeException("Task constructor takes 2 arguments");
                                                                                                  }
 
                                                                                                  if (args[0] is not IBadString name)
                                                                                                  {
                                                                                                      throw new BadRuntimeException("Task constructor takes a string as first argument");
                                                                                                  }
 
                                                                                                  if (args[1] is not BadFunction f)
                                                                                                  {
                                                                                                      throw new BadRuntimeException("Task constructor takes a function as second argument");
                                                                                                  }
 
                                                                                                  return new BadTask(BadRunnable.Create(f, ctx), name.Value);
                                                                                              },
                                                                                              null
                                                                                             );
 
    private readonly List<BadTask> m_ContinuationTasks = new List<BadTask>();
 
    private readonly Dictionary<string, BadObjectReference> m_Properties =
        new Dictionary<string, BadObjectReference>();
 
    public BadTask(BadRunnable runnable, string name)
    {
        Name = name;
        Runnable = runnable;
 
        m_Properties.Add("Name",
                         BadObjectReference.Make("Task.Name",
                                                 (p) => Name,
                                                 (o, _, _) => Name = o is IBadString s ? s.Value : Name
                                                )
                        );
        m_Properties.Add("IsCompleted", BadObjectReference.Make("Task.IsCompleted", (p) => IsFinished));
        m_Properties.Add("IsInactive", BadObjectReference.Make("Task.IsInactive", (p) => IsInactive));
        m_Properties.Add("IsPaused", BadObjectReference.Make("Task.IsPaused", (p) => IsPaused));
        m_Properties.Add("IsRunning", BadObjectReference.Make("Task.IsRunning", (p) => IsRunning));
 
        BadFunction continueFunc =
            new BadDynamicInteropFunction<BadTask>("ContinueWith", (_, t) => ContinueWith(t), BadAnyPrototype.Instance, new BadFunctionParameter("task", false, true, false, null, Prototype));
        BadFunction pauseFunc = new BadDynamicInteropFunction("Pause", Pause, BadAnyPrototype.Instance);
        BadFunction resumeFunc = new BadDynamicInteropFunction("Resume", Resume, BadAnyPrototype.Instance);
        BadFunction cancelFunc = new BadDynamicInteropFunction("Cancel", Cancel, BadAnyPrototype.Instance);
        m_Properties.Add("ContinueWith", BadObjectReference.Make("Task.ContinueWith", (p) => continueFunc));
        m_Properties.Add("Pause", BadObjectReference.Make("Task.Pause", (p) => pauseFunc));
        m_Properties.Add("Resume", BadObjectReference.Make("Task.Resume", (p) => resumeFunc));
        m_Properties.Add("Cancel", BadObjectReference.Make("Task.Cancel", (p) => cancelFunc));
 
        m_Properties.Add("RunSynchronously",
                         BadObjectReference.Make("Task.RunSynchronously",
                                                 (p) => new BadEnumerableInteropFunction("RunSynchronously",
                                                      (_, _) => Enumerate(runnable),
                                                      false,
                                                      BadAnyPrototype.Instance
                                                     )
                                                )
                        );
 
        m_Properties.Add("Run",
                         BadObjectReference.Make("Task.Run",
                                                 (p) => new BadDynamicInteropFunction("Run",
                                                      Run,
                                                      BadAnyPrototype.Instance
                                                     )
                                                )
                        );
    }
 
 
    public BadRunnable Runnable { get; }
 
    public IEnumerable<BadTask> ContinuationTasks => m_ContinuationTasks;
 
    public BadTask? Creator { get; private set; }
 
    public string Name { get; set; }
 
    public bool IsInactive => !IsRunning && !IsFinished && !IsPaused;
 
    public bool IsRunning { get; private set; }
 
    public bool IsFinished { get; private set; }
 
    public bool IsPaused { get; private set; }
 
    private void Run(BadExecutionContext context)
    {
        if (IsFinished)
        {
            throw BadRuntimeException.Create(context.Scope, "Task is already finished");
        }
 
        if (IsRunning)
        {
            throw BadRuntimeException.Create(context.Scope, "Task is already running");
        }
 
        BadTaskRunner runner = context.Scope.GetSingleton<BadTaskRunner>() ??
                               throw BadRuntimeException.Create(context.Scope, "Task Runner not found");
 
        if (IsPaused)
        {
            IsPaused = false;
        }
 
        if (!runner.IsTaskAdded(this))
        {
            runner.AddTask(this, true);
        }
    }
 
    private IEnumerable<BadObject> Enumerate(BadRunnable runnable)
    {
        IEnumerator<BadObject> e = runnable.Enumerator;
 
        while (e.MoveNext())
        {
            yield return e.Current ?? Null;
        }
    }
 
    public void AddContinuation(BadTask task)
    {
        m_ContinuationTasks.Add(task);
    }
 
    public void SetCreator(BadTask? task)
    {
        Creator = task;
    }
 
    public void Start()
    {
        IsRunning = true;
    }
 
    public void Stop()
    {
        IsFinished = true;
        IsRunning = false;
        IsPaused = false;
    }
 
    public void Cancel()
    {
        if (!IsRunning)
        {
            throw new BadRuntimeException("Task is not running");
        }
 
        IsPaused = false;
        IsFinished = true;
    }
 
 
    public void Resume()
    {
        if (!IsRunning)
        {
            throw new BadRuntimeException("Task is not running");
        }
 
        if (!IsPaused)
        {
            throw new BadRuntimeException("Task is not paused");
        }
 
        IsPaused = false;
    }
 
 
    public void Pause()
    {
        if (!IsRunning)
        {
            throw new BadRuntimeException("Task is not running");
        }
 
        if (IsPaused)
        {
            throw new BadRuntimeException("Task is already paused");
        }
 
        IsPaused = true;
    }
 
 
    private BadObject ContinueWith(BadTask task)
    {
        if (IsFinished)
        {
            throw new BadRuntimeException("Task is already finished");
        }
 
        AddContinuation(task);
 
        return Null;
    }
 
    public static BadTask Create(BadFunction f, BadExecutionContext caller, string? name, params BadObject[] args)
    {
        return new BadTask(BadRunnable.Create(f, caller, args), name ?? f.ToString());
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        return m_Properties.TryGetValue(propName, out BadObjectReference? property)
                   ? property
                   : base.GetProperty(propName, caller);
    }
 
    public override string ToSafeString(List<BadObject> done)
    {
        StringBuilder sb = new StringBuilder();
        sb.AppendLine("{");
 
        foreach (KeyValuePair<string, BadObjectReference> props in m_Properties)
        {
            sb.AppendLine($"\t{props.Key}: {props.Value.Dereference(null)}");
        }
 
        sb.AppendLine("}");
 
        return sb.ToString();
    }
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return m_Properties.ContainsKey(propName) ||
               base.HasProperty(propName, caller);
    }
}