public static FunctionDefinition CreateAutoGetter(string autoFieldName, INameReference typeName, EntityModifier modifier = null) { return(CreateGetter(typeName, Block.CreateStatement(Return.Create(NameReference.CreateThised(autoFieldName))), EntityModifier.AutoGenerated | modifier)); }
public static Property CreateIndexer(IOptions options, INameReference typeName, IEnumerable <VariableDeclaration> fields, IEnumerable <FunctionDefinition> getters, IEnumerable <FunctionDefinition> setters, EntityModifier modifier = null) { return(Create(options, NameFactory.PropertyIndexerName, typeName, fields, getters, setters, modifier)); }
public static FunctionParameter Create(string name, INameReference typeName, Variadic variadic, IExpression defaultValue, bool isNameRequired, EntityModifier modifier, ExpressionReadMode usageMode = ExpressionReadMode.ReadRequired) { return(new FunctionParameter(usageMode, name, typeName, variadic, defaultValue, modifier, isNameRequired: isNameRequired)); }
public static TypeDefinition Create(EntityModifier modifier, NameDefinition name, IEnumerable <TemplateConstraint> constraints, bool allowSlicing, IEnumerable <NameReference> parents = null, IEnumerable <INode> features = null) { return(new TypeDefinition(modifier, allowSlicing, name, constraints, parents, features, typeParameter: null, includes: null)); }
public static Property Create(IOptions options, string name, INameReference typeName, IEnumerable <VariableDeclaration> fields, IEnumerable <FunctionDefinition> getters, IEnumerable <FunctionDefinition> setters, EntityModifier modifier = null) { return(new Property(options, modifier, name, null, typeName, fields, getters, setters)); }
public TypeBuilder SetModifier(EntityModifier modifier) { if (this.build != null) { throw new InvalidOperationException(); } this.Modifier = modifier | this.Modifier; return(this); }
public ConstraintBuilder SetModifier(EntityModifier modifier) { if (this.modifier != null || this.build != null) { throw new InvalidOperationException(); } this.modifier = modifier; return(this); }
public VariableBuilder Modifier(EntityModifier modifier) { if (this.modifier != null || this.build != null) { throw new InvalidOperationException(); } this.modifier = modifier; return(this); }
public PropertyMemberBuilder Modifier(EntityModifier modifier) { if (build != null) { throw new Exception(); } this.modifier = modifier | this.modifier; return(this); }
public void Remove(EntityModifier modifier) { for (int i = modifiers.Count - 1; i >= 0; i--) { if (modifiers[i].Modifier == modifier) { modifiers.RemoveAt(i); } } }
public static FunctionDefinition CreateZeroConstructor(EntityModifier modifier, Block body) { return(new FunctionDefinition(modifier | EntityModifier.Private, NameFactory.ZeroConstructorNameDefinition(), (NameDefinition)null, null, null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), constructorChainCall: null, body: body, includes: null, friends: null)); }
public PropertyBuilder WithSetter(Block body, out FunctionDefinition setter, EntityModifier modifier = null) { if (build != null) { throw new Exception(); } setter = Property.CreateSetter(this.ValueTypeName, body, modifier); this.setters.Add(setter); return(this); }
public PropertyBuilder WithGetter(Block body, out FunctionDefinition getter, EntityModifier modifier = null) { if (build != null) { throw new Exception(); } getter = Property.CreateGetter(getTransferValueTypeName(), body, modifier); this.getters.Add(getter); return(this); }
private PropertyBuilder(IOptions options, string name, Func <NameReference> valueTypeName, EntityModifier modifier, bool referential) { this.referential = referential; this.options = options; this.name = name; this.valueTypeNameFactory = valueTypeName; this.modifier = modifier; this.fields = new List <VariableDeclaration>(); this.getters = new List <FunctionDefinition>(); this.setters = new List <FunctionDefinition>(); }
public ActionResult Delete(DisplayEnrollmentVm enrollment) { var isAdmin = EntityFetcher.FetchUserAdminStatus(Methods.GetUsernameFromCookie(HttpContext)); ViewBag.isAdmin = isAdmin; if (isAdmin == true) { EntityModifier.DeleteEnrollment(enrollment.EnrollmentId); return(Redirect(TempData["Url"].ToString())); } return(RedirectToAction("Login", "Home")); }
public void AddModifier(EntityModifier modifier, float duration = Mathf.Infinity) { Type type = modifier.GetType(); if (!modifiers.ContainsKey(type)) { ModifierList list = new ModifierList(type); modifiers.Add(type, list); } modifiers[type].Add(modifier, duration); CallEvent(type); }
internal static bool IsValidMutableName(string name, EntityModifier modifier) { modifier = modifier ?? EntityModifier.None; if (modifier.HasAccessor) { return(!NameFactory.IsMutableName(name)); } else { return(modifier.HasMutable == NameFactory.IsMutableName(name)); } }
public static FunctionDefinition CreateFunction( EntityModifier modifier, NameDefinition name, IEnumerable <TemplateConstraint> constraints, IEnumerable <FunctionParameter> parameters, ExpressionReadMode callMode, INameReference result, Block body) { return(new FunctionDefinition(modifier, name, (NameDefinition)null, constraints, parameters, callMode, result, constructorChainCall: null, body: body, includes: null, friends: null)); }
public static FunctionDefinition CreateAutoSetter(string autoFieldName, INameReference typeName, EntityModifier modifier = null) { return(FunctionDefinition.CreateFunction(EntityModifier.Mutable | EntityModifier.Accessor | modifier, NameDefinition.Create(NameFactory.PropertySetter), null, new[] { FunctionParameter.Create(NameFactory.PropertySetterValueParameter, typeName) }, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { Assignment.CreateStatement( NameReference.CreateThised(autoFieldName), NameReference.Create(NameFactory.PropertySetterValueParameter)) }))); }
public static FunctionDefinition CreateInitConstructor( EntityModifier modifier, IEnumerable <FunctionParameter> parameters, Block body, FunctionCall constructorChainCall = null) { return(new FunctionDefinition(modifier, NameFactory.InitConstructorNameDefinition(), (NameDefinition)null, null, parameters, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), constructorChainCall, body: body, includes: null, friends: null)); }
public static FunctionDefinition CreateHeapConstructor( EntityModifier modifier, IEnumerable <FunctionParameter> parameters, NameReference typeName, Block body) { return(new FunctionDefinition( modifier | EntityModifier.Static, NameFactory.NewConstructorNameDefinition(), (NameDefinition)null, null, parameters, ExpressionReadMode.ReadRequired, NameFactory.PointerNameReference(typeName), constructorChainCall: null, body: body, includes: null, friends: null)); }
private FunctionDefinition(EntityModifier modifier, NameDefinition name, NameDefinition label, IEnumerable <TemplateConstraint> constraints, IEnumerable <FunctionParameter> parameters, ExpressionReadMode callMode, INameReference result, FunctionCall constructorChainCall, Block body, IEnumerable <NameReference> includes, IEnumerable <LabelReference> friends) : base(modifier | (body == null ? EntityModifier.Abstract : EntityModifier.None), name, constraints, includes) { parameters = parameters ?? Enumerable.Empty <FunctionParameter>(); this.Label = label ?? NameDefinition.Create(name.Name); this.AccessGrants = (friends ?? Enumerable.Empty <LabelReference>()).StoreReadOnly(); this.Parameters = parameters.Indexed().StoreReadOnlyList(); setResultParameter(result); this.IsResultTypeNameInfered = result == null; if (this.IsResultTypeNameInfered) { this.resultTypeCandidates = new List <IEntityInstance>(); } this.UserBody = body; this.CallMode = callMode; // attaching zero-constructor call to the body of the function will be done when attaching entire function to a type if (constructorChainCall != null) { this.UserBody.SetConstructorChainCall(constructorChainCall); } if (this.IsLambdaInvoker) { this.LambdaTrap = new LambdaTrap(); } this.attachPostConstructor(); this.flow = Later.Create(() => ExecutionFlow.CreatePath(UserBody)); this.constructionCompleted = true; if (!IsValidMutableName(this.Name.Name, this.Modifier)) { throw new ArgumentException($"Mutable function has to be marked with name as well {this.Name}"); } }
public PropertyBuilder WithAutoSetter(out FunctionDefinition setter, EntityModifier modifier = null) { if (build != null) { throw new Exception(); } if (this.autoField == null) { throw new InvalidOperationException(); } setter = Property.CreateAutoSetter(this.autoField.Name.Name, this.getTransferValueTypeName(), modifier); this.setters.Add(setter); return(this); }
// used for creating embedded type definitions of type parameters, e.g. Tuple<T1,T2>, here we create T1 and T2 public static TypeDefinition CreateTypeParameter(TemplateParameter typeParameter) { EntityModifier modifier = typeParameter.Constraint.Modifier; if (typeParameter.Constraint.HasFunctions.Any()) { modifier |= EntityModifier.Protocol; } else { modifier |= EntityModifier.Base | EntityModifier.Interface; } return(new TypeDefinition(modifier, false, NameDefinition.Create(typeParameter.Name), null, typeParameter.Constraint.InheritsNames, typeParameter.Constraint.HasFunctions, typeParameter, includes: null)); }
public PropertyBuilder WithAutoField(IExpression initValue, EntityModifier modifier, out VariableDeclaration field) { if (build != null) { throw new Exception(); } if (this.autoField != null) { throw new ArgumentException(); } field = Property.CreateAutoField(AutoName.Instance.CreateNew(NameFactory.PropertyAutoField), this.ValueTypeName, initValue, modifier); this.autoField = field; return(this); }
public bool ContainsModifier(EntityModifier modifier) { Type type = modifier.GetType(); if (modifiers.ContainsKey(type)) { for (int i = 0; i < modifiers[type].Count; i++) { if (modifiers[type][i] == modifier) { return(true); } } } return(false); }
public static TypeBuilder WithEquatableEquals(this TypeBuilder builder, EntityModifier modifier = null) { return(builder.With(FunctionBuilder.Create(NameFactory.EqualOperator, ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(), Block.CreateStatement( IfBranch.CreateIf(IsSame.Create(NameReference.CreateThised(), NameReference.Create("cmp")), new[] { Return.Create(BoolLiteral.CreateTrue()) }), // let obj = cmp cast? Self VariableDeclaration.CreateStatement("obj", null, ExpressionFactory.CheckedSelfCast("cmp", NameFactory.ReferenceNameReference(builder.CreateTypeNameReference(TypeMutability.ReadOnly)))), // return this==obj.value Return.Create(ExpressionFactory.IsEqual(NameReference.Create(NameFactory.ThisVariableName), NameReference.Create("obj"))))) .SetModifier(EntityModifier.Override | modifier) .Parameters(FunctionParameter.Create("cmp", NameFactory.ReferenceNameReference(NameFactory.IEquatableNameReference(TypeMutability.ReadOnly)))))); }
public static TypeBuilder WithComparableCompare(this TypeBuilder builder, EntityModifier modifier = null) { return(builder.With(FunctionBuilder.Create(NameFactory.ComparableCompare, ExpressionReadMode.ReadRequired, NameFactory.OrderingNameReference(), Block.CreateStatement( IfBranch.CreateIf(IsSame.Create(NameReference.CreateThised(), NameReference.Create("cmp")), new[] { Return.Create(NameFactory.OrderingEqualReference()) }), // let obj = cmp cast? Self VariableDeclaration.CreateStatement("obj", null, ExpressionFactory.CheckedSelfCast("cmp", NameFactory.ReferenceNameReference(builder.CreateTypeNameReference(TypeMutability.ReadOnly)))), // return this.compare(obj.value) Return.Create(FunctionCall.Create(NameReference.CreateThised(NameFactory.ComparableCompare), NameReference.Create("obj"))))) .SetModifier(EntityModifier.Override | modifier) .Parameters(FunctionParameter.Create("cmp", NameFactory.ReferenceNameReference(NameFactory.IComparableNameReference(TypeMutability.ReadOnly)))))); }
private Alias(EntityModifier modifier, string name, INameReference replacement) : base(ExpressionReadMode.CannotBeRead) { if (name == null) { throw new ArgumentNullException(); } this.Modifier = (modifier ?? EntityModifier.None) | EntityModifier.Static; this.Name = NameDefinition.Create(name); this.Replacement = replacement; this.instancesCache = new EntityInstanceCache(this, () => GetInstance(TypeMutability.None, TemplateTranslation.CreateParameterless(this), Lifetime.Timeless)); this.attachPostConstructor(); }
private TypeDefinition(EntityModifier modifier, bool allowSlicing, NameDefinition name, IEnumerable <TemplateConstraint> constraints, IEnumerable <NameReference> parents, IEnumerable <INode> features, TemplateParameter typeParameter, IEnumerable <NameReference> includes) : base(modifier, name, constraints, includes) { this.AllowSlicedSubstitution = allowSlicing; this.TemplateParameter = typeParameter; this.ParentNames = (parents ?? Enumerable.Empty <NameReference>()).StoreReadOnly(); this.attachPostConstructor(); features?.ForEach(it => AddNode(it)); // all nodes have to be attached at this point setupConstructors(); }
public void AddAttackModifier(string type, EntityModifier modifier) { if (!attackModifiers.ContainsKey(type)) attackModifiers.Add(type, modifier); }
public EntityModifier(EntityModifier original) { this.competitionValue = original.competitionValue; this.MyType = original.MyType; }
public void DetachModifier(EntityModifier modifier) { attachedEntityModifiers.Remove(modifier.MyType); }
public bool AttachModifier(EntityModifier modifier) { bool attached = false; //If we don't have this type of EntityModifier attached already then simply add it in. if (!attachedEntityModifiers.ContainsKey(modifier.MyType)) { attachedEntityModifiers.Add(modifier.MyType, modifier); attached = true; } else //We have to have the new modifier compete with the old for the right to be here. { float oldCompValue, newCompValue; oldCompValue = attachedEntityModifiers[modifier.MyType].competitionValue; newCompValue = modifier.competitionValue; if (newCompValue >= oldCompValue) //Replace the old modifier with the new one. { attachedEntityModifiers[modifier.MyType].Detach(); attachedEntityModifiers[modifier.MyType] = modifier; attached = true; } } return attached; }