BadInteropExtensionProvider.cs

Go to the documentation of this file.

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();
    }
 
    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}",
            () => GetObject(t, propName, instance, caller)
        );
    }
 
    public BadObject GetObject(Type t, string propName, BadObject instance, BadScope? caller)
    {
        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}");
    }
 
 
    public BadObject GetObject<T>(string propName, BadObject instance, BadScope? caller = null)
    {
        return GetObject(typeof(T), propName, instance, caller);
    }
 
    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);
    }
}