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
{
    private static BadClassPrototype? s_Prototype;
 
    private readonly Dictionary<string, BadObjectReference> m_ReferenceCache =
        new Dictionary<string, BadObjectReference>();
 
    private Func<string, BadObject, BadObject, bool>? m_OnChangeProperty;
 
    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; }
 
#region IBadEnumerable Members
 
    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();
    }
 
#endregion
 
    public event Action<string, BadObject, BadObject> OnChangedProperty = delegate { };
 
    public void SetChangeInterceptor(Func<string, BadObject, BadObject, bool>? interceptor)
    {
        m_OnChangeProperty = interceptor;
    }
 
 
    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}",
            (p) =>
            {
                if (InnerTable.TryGetValue(propName, out var result))
                {
                    return result;
                }
                throw BadRuntimeException.Create(null, $"Property '{propName}' not found", p);
            },
                                                       (o, p, t, noChange) =>
                                                       {
                                                           if (InnerTable.TryGetValue(propName,
                                                                    out BadObject? propValue
                                                                   ))
                                                           {
                                                               BadPropertyInfo info = GetPropertyInfo(propName);
 
                                                               if (propValue != Null && info.IsReadOnly)
                                                               {
                                                                   throw
                                                                       BadRuntimeException.Create(null,$"{propName} is read-only", p);
                                                               }
 
                                                               if (info.Type != null && !info.Type.IsAssignableFrom(o))
                                                               {
                                                                   throw BadRuntimeException.Create(null,$"Cannot assign object {o.GetType().Name} to property '{propName}' of type '{info.Type.Name}'", p);
                                                               }
 
                                                               if (propValue is BadObjectReference propRef)
                                                               {
                                                                   BadObject? oldValueRef = propRef.Dereference(p);
 
                                                                   if (OnChangePropertyInternal(propName,
                                                                            oldValueRef,
                                                                            o
                                                                           ))
                                                                   {
                                                                       return;
                                                                   }
 
                                                                   propRef.Set(o, p, 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 BadRuntimeException.Create(null,$"Cannot assign object {o.GetType().Name} to property '{propName}' of type '{t.Type.Name}'", p);
                                                               }
                                                           }
 
                                                           if (OnChangePropertyInternal(propName, propValue ?? Null, o))
                                                           {
                                                               return;
                                                           }
 
                                                           InnerTable[propName] = o;
 
                                                           if (!noChange)
                                                           {
                                                               OnChangedProperty(propName, propValue ?? Null, o);
                                                           }
                                                       },
                                                       (p) => { 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();
    }
}