public Event(Controller controller, BaseConstruct parentObject, CodeLanguage language, int nodeIndex) : base(controller) { ParentObject = parentObject; Language = language; Index = nodeIndex; }
public Function(Controller controller, BaseConstruct parentObject, int nodeIndex) : base(controller) { ParentObject = parentObject; Language = CodeLanguage.CSharp; Index = nodeIndex; }
public Parameter(Controller controller, BaseConstruct parentObject, string name, string dataType, CodeLanguage language) : this(controller) { ParentObject = parentObject; Name = name; DataType = dataType; Language = language; }
public PropertyAccessor(Controller controller, BaseConstruct parentObject, AccessorTypes accessorType, string text, CodeLanguage language) : base(controller) { ParentObject = parentObject; AccessorType = accessorType; Text = text; Language = language; }
public Namespace(Controller controller, BaseConstruct parentObject, string name, CodeRoot parentCodeRoot, CodeLanguage language, int nodeIndex) : this(controller) { ParentObject = parentObject; Name = name; ParentCodeRoot = parentCodeRoot; Language = language; Index = nodeIndex; }
public Enumeration(Controller controller, string name, List<string> modifiers, string enumBase, BaseConstruct parentObject, CodeLanguage language, int nodeIndex) : base(controller) { Name = name; EnumBase = enumBase; Modifiers = modifiers; ParentObject = parentObject; Language = language; Index = nodeIndex; }
public Interface(Controller controller, string name, List<string> modifiers, string interfaceBase, CodeLanguage language, BaseConstruct parentObject, int nodeIndex) : base(controller) { Name = name; InterfaceBase = interfaceBase; Language = language; Modifiers = modifiers; ParentObject = parentObject; Index = nodeIndex; }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { Destructor userCon = (Destructor)user, newgenCon = (Destructor)newgen, prevgenCon = (Destructor)prevgen; // IsExtern if (Utility.MergeSingleItem(ref isExtern, userCon.IsExtern, newgenCon.IsExtern, prevgenCon.IsExtern) == false) return false; IsExtern = isExtern; // Triggers the replacement of BodyText if needed. return true; }
protected override void AddChildInternal(BaseConstruct childBC) { if (childBC is Region) { regions.Add(childBC as Region); } else { throw new ArgumentException("Cannot add child of type " + childBC.GetType() + "to a " + GetType()); } }
/// <summary> /// Adds a new child to this IBaseConstruct. /// </summary> /// <param name="childBC"></param> protected override void AddChildInternal(BaseConstruct childBC) { if (childBC == null) throw new InvalidOperationException("Cannot add null child"); if (childBC is Attribute) { singleAttributes.Add((Attribute)childBC); } else throw new InvalidOperationException("Cannot add child of type " + childBC.GetType()); }
protected Property(Controller controller, BaseConstruct parentObject, string name, DotNet.DataType dataType, List<string> modifiers, PropertyAccessor getAccessor, PropertyAccessor setAccessor, CodeLanguage language, int nodeIndex) : base(controller) { ParentObject = parentObject; Name = name; DataType = dataType; Modifiers = modifiers; GetAccessor = getAccessor; SetAccessor = setAccessor; Language = language; Index = nodeIndex; }
public Delegate(Controller controller, string name, List<string> modifiers, string genericType, IEnumerable<Parameter> parameters, DataType returnType, BaseConstruct.CodeLanguage language, BaseConstruct parentObject, int nodeIndex) : base(controller) { Name = name; ReturnType = returnType; GenericType = genericType ?? ""; if (parameters != null) Parameters.AddRange(parameters); Language = language; Modifiers = modifiers; ParentObject = parentObject; Index = nodeIndex; }
public Indexer(Controller controller, BaseConstruct parentObject, DataType dataType, IEnumerable<Parameter> parameters, PropertyAccessor getAccessor, PropertyAccessor setAccessor, CodeLanguage language, int nodeIndex) : base(controller) { ParentObject = parentObject; DataType = dataType; Parameters.Clear(); if (parameters != null) Parameters.AddRange(parameters); GetAccessor = getAccessor; SetAccessor = setAccessor; Language = language; Index = nodeIndex; Name = "this"; }
/// <summary> /// Adds a new child to this IBaseConstruct. /// </summary> /// <param name="childBC"></param> protected override void AddChildInternal(BaseConstruct childBC) { if (childBC == null) { throw new InvalidOperationException("Cannot add null child"); } if (childBC is Attribute) { singleAttributes.Add((Attribute)childBC); } else { throw new InvalidOperationException("Cannot add child of type " + childBC.GetType()); } }
public Field(Controller controller, BaseConstruct parentObject, CodeLanguage language) : base(controller) { ParentObject = parentObject; Language = language; }
public RenameBaseConstructAction(BaseConstruct propertyToChange, string newName) { PropertyToChange = propertyToChange; NewName = newName; }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { Field userBC = (Field)user, newgenBC = (Field)newgen, prevgenBC = (Field)prevgen; // DataType if (!Utility.MergeDataType(ref DataType, userBC.DataType, newgenBC.DataType, prevgenBC.DataType)) return false; // Modifiers if (!Utility.MergeModifiers(this, userBC, newgenBC, prevgenBC)) return false; // InitialValue if (!Utility.MergeSingleItem(ref InitialValue, userBC.InitialValue, newgenBC.InitialValue, prevgenBC.InitialValue)) return false; return true; }
protected abstract bool CustomMergeStepParameterInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen);
public override bool IsTheSame(BaseConstruct comparisonStruct) { return IsTheSame(comparisonStruct as Event); }
public VBEnumeration(BaseController controller, string name, List <string> modifiers, string enumBase, BaseConstruct parentObject, CodeLanguage language, int nodeIndex) : base(controller, name, modifiers, enumBase, parentObject, language, nodeIndex) { }
public override bool IsTheSame(BaseConstruct comparisonStruct, ComparisonDepth depth) { return(IsTheSame(comparisonStruct as AttributeSection, depth)); }
public VBBaseConstructPrinter(BaseConstruct obj) { this.obj = obj; }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { return(true); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { return(Utility.MergeSingleItem(ref Target, ((AttributeSection)user).Target, ((AttributeSection)newgen).Target, ((AttributeSection)prevgen).Target)); }
public override bool IsTheSame(BaseConstruct comparisonStruct, ComparisonDepth depth) { return IsTheSame(comparisonStruct as AttributeSection, depth); }
public override bool IsTheSame(BaseConstruct comparisonStruct) { return IsTheSame(comparisonStruct as AttributeSection); }
/// <summary> /// Adds a new child to this IBaseConstruct. /// </summary> /// <param name="childBC">The child object to add</param> protected override void AddChildInternal(BaseConstruct childBC) { throw new InvalidOperationException("Cannot add child nodes to an InterfaceMethod"); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { Event userBC = (Event)user, newgenBC = (Event)newgen, prevgenBC = (Event)prevgen; // DataType; if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.MergeDataType(ref DataType, userBC.DataType, newgenBC.DataType, prevgenBC.DataType)) return false; // Modifiers if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.MergeModifiers(this, userBC, newgenBC, prevgenBC)) return false; // AddAccessorText if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.MergeSingleItem(ref AddAccessorText, userBC.AddAccessorText, newgenBC.AddAccessorText, prevgenBC.AddAccessorText)) return false; // RemoveAccessorText if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.MergeSingleItem(ref RemoveAccessorText, userBC.RemoveAccessorText, newgenBC.RemoveAccessorText, prevgenBC.RemoveAccessorText)) return false; // InitialValue if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.MergeSingleItem(ref InitialValue, userBC.InitialValue, newgenBC.InitialValue, prevgenBC.InitialValue)) return false; return true; }
protected override void RemoveChildObjectInternal(BaseConstruct childBC) { if (childBC == null) throw new InvalidOperationException("Cannot remove null child"); if (childBC is PropertyAccessor) { PropertyAccessor accessor = (PropertyAccessor)childBC; if (accessor == GetAccessor) GetAccessor = null; else if (accessor == SetAccessor) SetAccessor = null; else throw new InvalidOperationException("The accessor does not belong to this Property"); } else throw new InvalidOperationException("Cannot remove child of type " + childBC.GetType()); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { // Handle Parameters in here, leave other customisations to CustomMergeStepParameterInternal ParameterBase userBC = (ParameterBase)user, newgenBC = (ParameterBase)newgen, prevgenBC = (ParameterBase)prevgen; if (userBC.Parameters.Count != prevgenBC.Parameters.Count && newgenBC.Parameters.Count != prevgenBC.Parameters.Count) { // We can't merge if there are additional parameters in user and newgen. return(false); } if (userBC.Parameters.Count != prevgenBC.Parameters.Count) { // the user has a different number of parameters. Check to see if the // newgen has changed, if it has then we can't merge. if (prevgenBC.ParametersAreTheSame(newgenBC, ComparisonDepth.Complete) == false) { return(false); } // User has changed, newgen hasn't. CloneParameters(userBC); return(true); } if (newgenBC.Parameters.Count != prevgenBC.Parameters.Count) { // the newgen has a different number of parameters. Check to see if the // user has changed, if it has then we can't merge. if (prevgenBC.ParametersAreTheSame(userBC, ComparisonDepth.Complete) == false) { return(false); } // Template has changed, newgen hasn't. CloneParameters(newgenBC); return(true); } Parameters.Clear(); // Check each parameter individually for (int i = 0; i < prevgenBC.Parameters.Count; i++) { bool userChange = prevgenBC.Parameters[i].IsTheSame(userBC.Parameters[i], ComparisonDepth.Complete) == false; bool templateChange = prevgenBC.Parameters[i].IsTheSame(newgenBC.Parameters[i], ComparisonDepth.Complete) == false; if (userBC.Parameters[i].IsTheSame(newgenBC.Parameters[i], ComparisonDepth.Complete)) { userChange = true; templateChange = false; } if (templateChange && userChange) { return(false); } if (userChange) { Parameters.Add((Parameter)userBC.Parameters[i].Clone()); } else if (templateChange) { Parameters.Add((Parameter)newgenBC.Parameters[i].Clone()); } else { Parameters.Add((Parameter)userBC.Parameters[i].Clone()); } } return(CustomMergeStepParameterInternal(user, newgen, prevgen)); }
public VBOperator(VBController controller, BaseConstruct parentObject, CodeLanguage language, int nodeIndex) : base(controller, parentObject, language, nodeIndex) { }
public override bool IsTheSame(BaseConstruct comparisonStruct, ComparisonDepth depth) { return IsTheSame(comparisonStruct as Event, depth); }
public override bool IsTheSame(BaseConstruct comparisonStruct) { return IsTheSame(comparisonStruct as Property); }
/// <summary> /// Adds a new child to this IBaseConstruct. /// </summary> /// <param name="childBC">The child object to add</param> protected override void AddChildInternal(BaseConstruct childBC) { throw new InvalidOperationException("Cannot add child nodes to a Destructor"); }
public override bool IsTheSame(BaseConstruct comparisonObject, ComparisonDepth depth) { return IsTheSame(comparisonObject as RegionStart, depth); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { // Handle Parameters in here, leave other customisations to CustomMergeStepParameterInternal ParameterBase userBC = (ParameterBase)user, newgenBC = (ParameterBase)newgen, prevgenBC = (ParameterBase)prevgen; if (userBC.Parameters.Count != prevgenBC.Parameters.Count && newgenBC.Parameters.Count != prevgenBC.Parameters.Count) { // We can't merge if there are additional parameters in user and newgen. return false; } if (userBC.Parameters.Count != prevgenBC.Parameters.Count) { // the user has a different number of parameters. Check to see if the // newgen has changed, if it has then we can't merge. if (prevgenBC.ParametersAreTheSame(newgenBC, ComparisonDepth.Complete) == false) return false; // User has changed, newgen hasn't. CloneParameters(userBC); return true; } if (newgenBC.Parameters.Count != prevgenBC.Parameters.Count) { // the newgen has a different number of parameters. Check to see if the // user has changed, if it has then we can't merge. if (prevgenBC.ParametersAreTheSame(userBC, ComparisonDepth.Complete) == false) return false; // Template has changed, newgen hasn't. CloneParameters(newgenBC); return true; } Parameters.Clear(); // Check each parameter individually for (int i = 0; i < prevgenBC.Parameters.Count; i++) { bool userChange = prevgenBC.Parameters[i].IsTheSame(userBC.Parameters[i], ComparisonDepth.Complete) == false; bool templateChange = prevgenBC.Parameters[i].IsTheSame(newgenBC.Parameters[i], ComparisonDepth.Complete) == false; if (userBC.Parameters[i].IsTheSame(newgenBC.Parameters[i], ComparisonDepth.Complete)) { userChange = true; templateChange = false; } Parameter clone; if (templateChange && userChange) { return false; } if (userChange) { clone = (Parameter)userBC.Parameters[i].Clone(); } else if (templateChange) { clone = (Parameter)newgenBC.Parameters[i].Clone(); } else { clone = (Parameter)userBC.Parameters[i].Clone(); } clone.ParentObject = this; Parameters.Add(clone); } return CustomMergeStepParameterInternal(user, newgen, prevgen); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { return true; }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { return Utility.MergeSingleItem(ref Target, ((AttributeSection)user).Target, ((AttributeSection)newgen).Target, ((AttributeSection)prevgen).Target); }
public override bool IsTheSame(BaseConstruct comparisonObject, ComparisonDepth depth) { return(comparisonObject is EmptyPlaceholder); }
public override bool IsTheSame(BaseConstruct comparisonStruct) { return(IsTheSame(comparisonStruct as AttributeSection)); }
/// <summary> /// Adds a new child to this IBaseConstruct. /// </summary> /// <param name="childBC"></param> protected override void AddChildInternal(BaseConstruct childBC) { if (childBC == null) throw new InvalidOperationException("Cannot add null child"); if (childBC is PropertyAccessor) { PropertyAccessor newAccessor = (PropertyAccessor)childBC; if (newAccessor.AccessorType == PropertyAccessor.AccessorTypes.Get) GetAccessor = newAccessor; else SetAccessor = newAccessor; } else throw new InvalidOperationException("Cannot add child of type " + childBC.GetType()); }
protected override bool CustomMergeStepInternal(BaseConstruct user, BaseConstruct newgen, BaseConstruct prevgen) { Property userBC = (Property)user, newgenBC = (Property)newgen, prevgenBC = (Property)prevgen; // DataType if (!Utility.MergeDataType(ref DataType, userBC.DataType, newgenBC.DataType, prevgenBC.DataType)) return false; // Modifiers if (!Utility.MergeModifiers(this, userBC, newgenBC, prevgenBC)) return false; return true; }