public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
if (nodes[opIndex] is IndexerNode ix)
{
if (ix.Nodes.Count == 0 && nodes[opIndex - 1].Is <IdentifierNode>().Or <ITypeIdentifier>(out bool isType))
{
ITypeIdentifier arrayedType = isType ? nodes[opIndex - 1] as ITypeIdentifier : new TypeIdentifierNode(nodes[opIndex - 1] as IdentifierNode);
TypeArrayIdentifierNode lookup = new TypeArrayIdentifierNode(arrayedType, nodes[opIndex - 1].Pos);
nodes[opIndex - 1] = lookup;
nodes.RemoveAt(opIndex);
}
else
{
LookupNode lookup = new LookupNode(nodes[opIndex - 1] as IExpr, nodes[opIndex] as IndexerNode, nodes[opIndex - 1].Pos);
caller.Invoke(lookup.Index.Nodes); // Invoke on sub-elements
nodes[opIndex - 1] = lookup;
nodes.RemoveAt(opIndex);
}
return(true);
}
else
{
return(false);
}
}
public ProxyBuilder(Type proxiedType, ITypeIdentifier identifier, Guid creationContext)
{
this.identifier = identifier;
Model = ModelBuilder.New();
Proxy = RuntimeProxyBuilder.BuildDynamicProxy(proxiedType, creationContext);
ProxiedType = proxiedType;
}
private void AddName(string type_name)
{
if (name == null)
{
name = ParsedTypeIdentifier(type_name);
}
else
{
if (nested == null)
{
nested = new List <ITypeIdentifier>();
}
nested.Add(ParsedTypeIdentifier(type_name));
}
}
public EnumBuilder DefineEnum(string name, TypeAttributes visibility, Type underlyingType)
{
ITypeIdentifier ident = TypeIdentifiers.FromInternal(name);
if (name_cache.ContainsKey(ident))
{
throw new ArgumentException("Duplicate type name within an assembly.");
}
EnumBuilder eb = new EnumBuilder(this, name, visibility, underlyingType);
TypeBuilder res = eb.GetTypeBuilder();
AddType(res);
name_cache.Add(ident, res);
return(eb);
}
private TypeBuilder DefineType(string name, TypeAttributes attr, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type?parent, Type[]?interfaces, PackingSize packingSize, int typesize)
{
ArgumentNullException.ThrowIfNull(name, "fullname");
ITypeIdentifier ident = TypeIdentifiers.FromInternal(name);
if (name_cache.ContainsKey(ident))
{
throw new ArgumentException("Duplicate type name within an assembly.");
}
TypeBuilder res = new TypeBuilder(this, name, attr, parent, interfaces, packingSize, typesize, null);
AddType(res);
name_cache.Add(ident, res);
return(res);
}
public ProxyFactory(ITypeIdentifier identifier, Guid creationContext)
{
this.identifier = identifier;
this.creationContext = creationContext;
foreach (var item in identifier.GetAvailableTypesAndTheirSerializableParents().ToList())
{
if (item.IsGenericTypeDefinition)
{
continue;
}
builders.Add(item, new ProxyBuilder(item, identifier, creationContext));
}
foreach (var item in builders.ToList())
{
var proxy = item.Value.Build(builders.Select(x => x.Value).ToList());
proxies.Add(item.Value.ProxiedType, proxy);
}
}
public static void IncludeParents(this RuntimeTypeModel model, ITypeIdentifier typeIdentifier, MetaType type)
{
if (type.Type.BaseType == typeof(object) || type.Type.BaseType == null)
{
return;
}
var metaBase = model.Add(type.Type.BaseType, true);
model.IncludeParents(typeIdentifier, metaBase);
if (IsRegisteredType(typeIdentifier, type) || IsRegisteredGenericType(typeIdentifier, type))
{
foreach (var field in metaBase.GetFields())
{
if (!type.GetFields().Select(x => x.FieldNumber).Contains(field.FieldNumber))
{
type.AddField(field.FieldNumber, field.Member.Name);
}
}
}
}
public Serializer(ITypeIdentifier identifier)
{
Id = Guid.NewGuid();
proteusTypeModel = new ProteusRuntimeTypeModel(identifier);
this.identifier = identifier;
protobufTypeModel = ModelBuilder.New();
List<Type> builtProxies = new List<Type>();
var factory = new ProxyFactory(this.identifier, Id);
foreach (var item in identifier.GetAvailableTypesAndTheirSerializableParents())
{
if (item.IsGenericTypeDefinition)
continue;
var proxy = factory.GetProxy(item);
var metaType = protobufTypeModel.Add(item, false);
protobufTypeModel.IncludeParents(identifier, metaType);
metaType.SetSurrogate(proxy);
builtProxies.Add(proxy);
}
// builtProxies.Add(px);
}
private static bool IsRegisteredGenericType(ITypeIdentifier typeIdentifier, MetaType type)
{
return(type.Type.BaseType.IsGenericType && typeIdentifier.AvailableTypes.Contains(type.Type.BaseType.GetGenericTypeDefinition()));
}
public VarDeclNode(SourcePosition pos, ITypeIdentifier varTypeNode, string identifier) : base(pos, "=", LexTokenType.None)
{
this.TypeExpr = varTypeNode;
this.VarName = identifier;
this.AssignToExpr = null;
}
public VarDeclNode(SourcePosition pos, ITypeIdentifier varTypeNode, AssignmentNode assignNode) : base(pos, "=", LexTokenType.None)
{
this.TypeExpr = varTypeNode;
this.VarName = assignNode.Left.Content;
this.AssignToExpr = assignNode.Right;
}
public static IEnumerable <Type> GetAvailableTypesAndTheirSerializableParents(this ITypeIdentifier identifier)
{
var search = identifier.AvailableTypes.ToList();
var returned = new List <Type>();
foreach (var item in identifier.AvailableTypes.ToList())
{
if (!returned.Contains(item))
{
returned.Add(item);
yield return(item);
}
var props = item.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var pr in props)
{
if (search.Any(x => pr.PropertyType.IsAssignableFrom(x)))
{
if (!returned.Contains(pr.PropertyType))
{
returned.Add(pr.PropertyType);
yield return(pr.PropertyType);
}
}
}
}
}
public NewObjectNode(ITypeIdentifier typeIdentifier, ExpressionNode ctorArgs, SourcePosition position) : base(position, "new", LexTokenType.None)
{
this.Type = typeIdentifier;
this.CtorArguments = new ArgumentsNode(ctorArgs);
}
public ProteusRuntimeTypeModel(ITypeIdentifier identifier)
{
this.identifier = identifier;
}
public override ITypeName NestedName(ITypeIdentifier innerName)
{
return(TypeNames.FromDisplay(DisplayName + "+" + innerName.DisplayName));
}
internal static ITypeIdentifier FromInternal(string internalNameSpace, ITypeIdentifier typeName)
{
return(new Internal(internalNameSpace, typeName));
}
private static bool IsRegisteredType(ITypeIdentifier typeIdentifier, MetaType type)
{
return(typeIdentifier.AvailableTypes.Contains(type.Type.BaseType));
}
public TypeArrayIdentifierNode(ITypeIdentifier encapsulatedType, SourcePosition position) : base(position, string.Empty, LexTokenType.None)
{
this.EncapsulatedType = encapsulatedType;
}
internal Internal(string nameSpaceInternal, ITypeIdentifier typeName)
{
this.internalName = nameSpaceInternal + "." + typeName.InternalName;
}
public NewArrayNode(ITypeIdentifier type, IndexerNode indexer, SourcePosition position) : base(position, string.Empty, LexTokenType.None)
{
this.Type = type;
this.Indexer = indexer;
}
public abstract ITypeName NestedName(ITypeIdentifier innerName);
public void AddType(ITypeIdentifier identifier) => this.InheritanceNodes.Add(identifier);
