BadTable.cs

Go to the documentation of this file.

using System.Collections;
using System.Text;
 
using BadScript2.Runtime.Error;
using BadScript2.Runtime.Interop;
using BadScript2.Runtime.Objects.Types;
 
namespace BadScript2.Runtime.Objects;
 
public class BadTable : BadObject, IBadEnumerable
{
    
    public event Action<string, BadObject, BadObject> OnChangedProperty = delegate { };
    private Func<string, BadObject, BadObject, bool>? m_OnChangeProperty;
 
    public void SetChangeInterceptor(Func<string, BadObject, BadObject, bool>? interceptor)
    {
        m_OnChangeProperty = interceptor;
    }
    
    private static BadClassPrototype? s_Prototype;
 
    private readonly Dictionary<string, BadObjectReference> m_ReferenceCache = new Dictionary<string, BadObjectReference>();
 
    public BadTable()
    {
        InnerTable = new Dictionary<string, BadObject>();
        PropertyInfos = new Dictionary<string, BadPropertyInfo>();
    }
 
    public BadTable(Dictionary<string, BadObject> table)
    {
        InnerTable = table;
        PropertyInfos = new Dictionary<string, BadPropertyInfo>();
 
        foreach (KeyValuePair<string, BadObject> kvp in InnerTable)
        {
            PropertyInfos[kvp.Key] = new BadPropertyInfo(BadAnyPrototype.Instance);
        }
    }
 
    public static BadClassPrototype Prototype => s_Prototype ??= BadNativeClassBuilder.GetNative("Table");
 
    public Dictionary<string, BadObject> InnerTable { get; }
 
    public Dictionary<string, BadPropertyInfo> PropertyInfos { get; }
 
    public IEnumerator<BadObject> GetEnumerator()
    {
        return InnerTable.Select(
                kvp => new BadTable(
                    new Dictionary<string, BadObject>
                    {
                        {
                            "Key", kvp.Key
                        },
                        {
                            "Value", kvp.Value
                        },
                    }
                )
            )
            .Cast<BadObject>()
            .GetEnumerator();
    }
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
 
 
    public override BadClassPrototype GetPrototype()
    {
        return Prototype;
    }
 
    public BadPropertyInfo GetPropertyInfo(string propName)
    {
        return PropertyInfos[propName];
    }
 
    public bool RemoveKey(string key)
    {
        PropertyInfos.Remove(key);
 
        return InnerTable.Remove(key);
    }
 
 
    public override bool HasProperty(string propName, BadScope? caller = null)
    {
        return InnerTable.ContainsKey(propName) || caller != null && caller.Provider.HasObject<BadTable>(propName);
    }
 
 
    public BadObjectReference GetProperty(string propName, bool useExtensions, BadScope? caller = null)
    {
        return !useExtensions ? GetLocalReference(propName) : GetProperty(propName, caller);
    }
    
    private bool OnChangePropertyInternal(string propName, BadObject oldValue, BadObject newValue)
    {
        if (m_OnChangeProperty != null)
        {
            return m_OnChangeProperty(propName, oldValue, newValue);
        }
 
        return false;
    }
 
    private BadObjectReference GetLocalReference(string propName)
    {
        if (m_ReferenceCache.TryGetValue(propName, out BadObjectReference reference))
        {
            return reference;
        }
 
        BadObjectReference r = BadObjectReference.Make(
            $"BadTable.{propName}",
            () => InnerTable[propName],
            (o, t, noChange) =>
            {
                if (InnerTable.TryGetValue(propName, out BadObject? propValue))
                {
                    BadPropertyInfo info = GetPropertyInfo(propName);
 
                    if (propValue != Null && info.IsReadOnly)
                    {
                        throw new BadRuntimeException($"{propName} is read-only");
                    }
 
                    if (info.Type != null && !info.Type.IsAssignableFrom(o))
                    {
                        throw new BadRuntimeException(
                            $"Cannot assign object {o.GetType().Name} to property '{propName}' of type '{info.Type.Name}'"
                        );
                    }
                    if (propValue is BadObjectReference propRef)
                    {
                        var oldValueRef = propRef.Dereference();
                        if (OnChangePropertyInternal(propName, oldValueRef, o))
                            return;
                        propRef.Set(o, t);
                        if(!noChange)
                            OnChangedProperty(propName, oldValueRef, o);
                        return;
                    }
                }
                else
                {
                    PropertyInfos[propName] = t ?? new BadPropertyInfo(BadAnyPrototype.Instance);
 
                    if (t?.Type != null && !t.Type.IsAssignableFrom(o))
                    {
                        throw new BadRuntimeException(
                            $"Cannot assign object {o.GetType().Name} to property '{propName}' of type '{t.Type.Name}'"
                        );
                    }
                }
 
                if (OnChangePropertyInternal(propName, propValue ?? Null, o))
                    return;
                InnerTable[propName] = o;
                if(!noChange)
                    OnChangedProperty(propName, propValue ?? Null, o);
            },
            () => { InnerTable.Remove(propName); }
        );
 
        m_ReferenceCache[propName] = r;
 
        return r;
    }
 
    public override BadObjectReference GetProperty(string propName, BadScope? caller = null)
    {
        if (!InnerTable.ContainsKey(propName) && caller != null && caller.Provider.HasObject<BadTable>(propName))
        {
            return caller.Provider.GetObjectReference(GetType(), propName, this, caller);
        }
 
        return GetLocalReference(propName);
    }
    
 
 
    public override string ToSafeString(List<BadObject> done)
    {
        done.Add(this);
        StringBuilder sb = new StringBuilder();
        sb.Append("{");
        sb.AppendLine();
 
        foreach (KeyValuePair<string, BadObject> kvp in InnerTable)
        {
            if (kvp.Value is BadScope)
            {
                sb.AppendLine("RECURSION_PROTECT");
 
                continue;
            }
 
            string kStr = kvp.Key;
 
            string vStr = "{...}";
 
            if (!done.Contains(kvp.Value))
            {
                vStr = kvp.Value.ToSafeString(done).Trim();
            }
 
            if (kStr.Contains("\n"))
            {
                kStr = kStr.Replace("\n", "\n\t");
            }
 
            if (vStr.Contains("\n"))
            {
                vStr = vStr.Replace("\n", "\n\t");
            }
 
            sb.AppendLine($"\t{kStr}: {vStr}");
        }
 
        sb.AppendLine("}");
 
        return sb.ToString();
    }
}