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;
}
