BadInteropExtensionProvider.cs

Go to the documentation of this file.

using BadScript2.Common;
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Objects;
using BadScript2.Runtime.Objects.Native;
using BadScript2.Runtime.Settings;
 
namespace BadScript2.Runtime.Interop;
 
public class BadInteropExtensionProvider
{
    private readonly List<Type> m_ActiveExtensions = new List<Type>();
 
    private readonly Dictionary<string, Func<BadObject, BadObject>> m_GlobalExtensions =
        new Dictionary<string, Func<BadObject, BadObject>>();
 
    private readonly Dictionary<Type, Dictionary<string, Func<BadObject, BadObject>>> m_ObjectExtensions =
        new Dictionary<Type, Dictionary<string, Func<BadObject, BadObject>>>();
 
    private readonly Dictionary<Type, Dictionary<string, Func<BadObject, BadObject>>> m_StaticExtensionCache =
        new Dictionary<Type, Dictionary<string, Func<BadObject, BadObject>>>();
 
    private readonly Dictionary<Type, bool> m_SupportedTypes = new Dictionary<Type, bool>();
 
    public BadInteropExtensionProvider() { }
 
    public BadInteropExtensionProvider(BadInteropExtension[] extensions)
    {
        AddExtensions(extensions);
    }
 
    public BadObject[] GetExtensionNames()
    {
        return m_GlobalExtensions.Keys.Select(x => (BadObject)x)
            .ToArray();
    }
 
    public BadObject[] GetExtensionNames(BadObject obj)
    {
        Type t = obj.GetType();
 
        List<BadObject> objs = new List<BadObject>(GetExtensionNames());
 
        if (HasTypeExtensions(t))
        {
            objs.AddRange(GetTypeExtensions(t)
                .Keys.Select(x => (BadObject)x)
            );
        }
 
        if (obj is not IBadNative native)
        {
            return objs.ToArray();
        }
 
        t = native.Type;
 
        if (HasTypeExtensions(t))
        {
            objs.AddRange(GetTypeExtensions(t)
                .Keys.Select(x => (BadObject)x)
            );
        }
 
        return objs.ToArray();
    }
 
    
    public BadTable GetExtensions(BadObject obj)
    {
        Type t = obj.GetType();
 
        Dictionary<string, BadObject> objs = new Dictionary<string, BadObject>(m_GlobalExtensions.ToDictionary(x => x.Key, x => x.Value(obj)));
 
        if (HasTypeExtensions(t))
        {
            foreach (KeyValuePair<string,Func<BadObject,BadObject>> kvp in GetTypeExtensions(t))
            {
                objs[kvp.Key] = kvp.Value(obj);
            }
        }
 
        if (obj is not IBadNative native)
        {
            return new BadTable(objs.ToDictionary(x=>x.Key, x => x.Value));
        }
 
        t = native.Type;
 
        if (HasTypeExtensions(t))
        {
            foreach (KeyValuePair<string,Func<BadObject,BadObject>> kvp in GetTypeExtensions(t))
            {
                objs[kvp.Key] = kvp.Value(obj);
            }
        }
 
        return new BadTable(objs.ToDictionary(x=>x.Key, x => x.Value));
    }
 
    private bool InnerHasTypeExtensions(Type t)
    {
        bool r = m_ObjectExtensions.Any(x => x.Key.IsAssignableFrom(t));
        m_SupportedTypes.Add(t, r);
 
        return r;
    }
 
    private bool HasTypeExtensions(Type t)
    {
        return m_SupportedTypes.TryGetValue(t, out bool r) ? r : InnerHasTypeExtensions(t);
    }
 
    private bool HasGlobalExtensions(string propName)
    {
        return m_GlobalExtensions.ContainsKey(propName);
    }
 
    private Dictionary<string, Func<BadObject, BadObject>> GetTypeExtensions(Type type)
    {
        if (m_StaticExtensionCache.TryGetValue(type, out Dictionary<string, Func<BadObject, BadObject>>? extensions))
        {
            return extensions;
        }
 
        Dictionary<string, Func<BadObject, BadObject>>
            exts = new Dictionary<string, Func<BadObject, BadObject>>();
 
        foreach (KeyValuePair<Type, Dictionary<string, Func<BadObject, BadObject>>> kvp in
                 m_ObjectExtensions.Where(x => x.Key.IsAssignableFrom(type)))
        {
            foreach (KeyValuePair<string, Func<BadObject, BadObject>> keyValuePair in kvp.Value)
            {
                exts[keyValuePair.Key] = keyValuePair.Value;
            }
        }
 
        if (BadNativeOptimizationSettings.Instance.UseStaticExtensionCaching)
        {
            m_StaticExtensionCache[type] = exts;
        }
 
        return exts;
    }
 
    public void RegisterGlobal(string propName, Func<BadObject, BadObject> func)
    {
        m_GlobalExtensions.Add(propName, func);
    }
 
    public void RegisterGlobal(string propName, BadObject obj)
    {
        RegisterGlobal(propName, _ => obj);
    }
 
    public void RegisterObject<T>(string propName, Func<T, BadObject> obj)
    {
        RegisterObject(typeof(T),
                       propName,
                       o =>
                       {
                           return o switch
                           {
                               T t => obj(t),
                               BadNative<T> nT => obj(nT.Value),
                               _ => throw new BadRuntimeException("Cannot cast object to type " + typeof(T)),
                           };
                       }
                      );
    }
 
    public void RegisterObject(Type t, string propName, BadObject obj)
    {
        RegisterObject(t, propName, _ => obj);
    }
 
    public void RegisterObject(Type t, string propName, Func<BadObject, BadObject> obj)
    {
        if (m_ObjectExtensions.TryGetValue(t, out Dictionary<string, Func<BadObject, BadObject>>? extension))
        {
            extension[propName] = obj;
        }
        else
        {
            m_ObjectExtensions[t] = new Dictionary<string, Func<BadObject, BadObject>> { { propName, obj } };
        }
    }
 
 
    public bool HasObject(Type t, string propName)
    {
        return HasGlobalExtensions(propName) ||
               (HasTypeExtensions(t) &&
                GetTypeExtensions(t)
                    .ContainsKey(propName));
    }
 
    public bool HasObject<T>(string propName)
    {
        return HasObject(typeof(T), propName);
    }
 
    public BadObjectReference GetObjectReference(Type t,
                                                 string propName,
                                                 BadObject instance,
                                                 BadScope? caller)
    {
        return BadObjectReference.Make($"{t.Name}.{propName}",
                                       (p) => GetObject(t, propName, instance, caller, p)
                                      );
    }
 
    public BadObject GetObject(Type t, string propName, BadObject instance, BadScope? caller, BadSourcePosition? pos)
    {
        Dictionary<string, Func<BadObject, BadObject>> ext = GetTypeExtensions(t);
 
        if (ext.ContainsKey(propName))
        {
            return ext[propName](instance);
        }
 
        if (HasGlobalExtensions(propName))
        {
            return m_GlobalExtensions[propName](instance);
        }
 
        throw BadRuntimeException.Create(caller, $"No property named {propName} for type {t.Name}", pos);
    }
 
 
    public BadObject GetObject<T>(string propName, BadObject instance, BadScope? caller = null, BadSourcePosition? pos = null)
    {
        return GetObject(typeof(T), propName, instance, caller, pos);
    }
 
    public void AddExtension<T>() where T : BadInteropExtension, new()
    {
        T t = new T();
        Initialize(t);
    }
 
    public void AddExtensions(params BadInteropExtension[] extensions)
    {
        foreach (BadInteropExtension extension in extensions)
        {
            AddExtension(extension);
        }
    }
 
    public void AddExtension(BadInteropExtension extension)
    {
        Initialize(extension);
    }
 
    private void Initialize(BadInteropExtension ext)
    {
        if (m_ActiveExtensions.Contains(ext.GetType()))
        {
            return;
        }
 
        m_ActiveExtensions.Add(ext.GetType());
        ext.InnerAddExtensions(this);
    }
}