public static string GetModifier(AccessModifier? access, ClassModifier? modifier) { if (modifier == null) return access.ToString().ToLower(); else return string.Format("{0} {1}", access.ToString().ToLower(), modifier.ToString().ToLower()); }
protected override void CopyFrom(TypeBase type) { base.CopyFrom(type); var classType = (ClassType)type; modifier = classType.modifier; }
public override string GetClassModifierString(ClassModifier modifier, bool forCode) { if (validClassModifiers.ContainsKey(modifier)) { if (forCode) { return(validClassModifiers[modifier].ToLower()); } else { return(validClassModifiers[modifier]); } } else { if (modifier == ClassModifier.None) { return(Strings.None); } else { return(string.Empty); } } }
/// <summary> /// Returns a readable string containing the <see cref="ClassModifier"/>. /// </summary> /// <param name="classModifier">The <see cref="ClassModifier"/> to convert to a string.</param> /// <returns>The converted <see cref="ClassModifier"/></returns> private static string ToString(ClassModifier classModifier) { if (classModifier == ClassModifier.None) { return(""); } return(classModifier.ToString().ToLower() + " "); }
public static string AsString(this ClassModifier modifier) { if (modifier == ClassModifier.None) { return(string.Empty); } return(EnumToLower(modifier)); }
protected override void CopyFrom(TypeBase type) { base.CopyFrom(type); ClassType classType = (ClassType)type; modifier = classType.modifier; Stereotype = classType.Stereotype; }
/// <summary> /// Create a class header line. Does not include brackets. /// </summary> public static string ClassHeader(int depth, AccessModifier scope, ClassModifier modifier, string @class, List <string> argumentNames) { // Set non string types to strings var header = string.Empty; string _modifier = modifier.ToString(); string _scope = scope.ToString(); // Add white spaces to types such as ProtectedInternal to Protected Internal and set all of it lowercase to match C# construct _scope = _scope.AddLowerUpperNeighboringSpaces(); _scope = _scope.ToLower(); // Do the same as with scope, except we may get addition white spaces for some reason. Remove them here. if (modifier != ClassModifier.None) { _modifier = _modifier.AddLowerUpperNeighboringSpaces(); if (char.IsWhiteSpace(_modifier[_modifier.Length - 1])) { _modifier.Remove(_modifier.Length - 1, 1); } _modifier = _modifier.ToString().ToLower(); } else { _modifier = string.Empty; } // Remove initial white spaces, we will do this ourselves where necessary if (char.IsWhiteSpace(@class[0])) { @class.Remove(0, 1); } header += Indent(depth) + _scope.ToLower() + " class " + _modifier + @class; // We dynamically create the Generics Arguments by manually creating all but the names, which are fed through this method. if (argumentNames != null) { if (argumentNames.Count > 0) { header += "<"; for (int i = 0; i < argumentNames.Count; i++) { header += argumentNames[i]; if (i < argumentNames.Count - 1) { header += ", "; } } header += ">"; } } return(header); }
protected override void CopyFrom(TypeBase type) { base.CopyFrom(type); ClassType classType = (ClassType)type; modifier = classType.modifier; Stereotype = classType.Stereotype; NHMTableName = classType.NHMTableName; IdGenerator = classType.IdGenerator; }
/// <summary> /// Create a root class generator based on required parameters. /// </summary> public static ClassGenerator Class(RootAccessModifier scope, ClassModifier modifier, string name, string inherits) { var @class = new ClassGenerator(); @class.scope = scope; @class.modifier = modifier; @class.name = name; @class.stringInherits = inherits; @class.isNested = false; return(@class); }
/// <summary> /// Create a nested class generator based on required parameters. /// </summary> public static ClassGenerator Class(AccessModifier nestedScope, ClassModifier modifier, string name, Type inherits) { var @class = new ClassGenerator(); @class.nestedScope = nestedScope; @class.modifier = modifier; @class.name = name; @class.inherits = inherits == null ? typeof(object) : inherits; @class.isNested = true; return(@class); }
public ClassElement ClassModifiers(params Func <ClassModifier, string>[] classModifierFuncs) { _classModifiers = ""; var classModifier = new ClassModifier(); foreach (var classModifierFunc in classModifierFuncs) { _classModifiers += classModifierFunc(classModifier) + " "; } return(this); }
public override string GetClassModifierString(ClassModifier modifier, bool forCode) { if (!forCode) { return(modifier.ToString()); } if (modifier == ClassModifier.None) { return(""); } return(modifier.ToString().ToLower()); }
protected virtual SpecificationDefinition GetSpecificationDefinition(ClassModifier classModifier) { switch (classModifier) { case ClassModifier.Sealed: return(SpecificationDefinition.Sealed); case ClassModifier.Abstract: return(SpecificationDefinition.Abstract); default: throw new ArgumentOutOfRangeException("classModifier"); } }
/// <summary> /// Create a root class generator based on required parameters. /// </summary> public static ClassGenerator Class(RootAccessModifier scope, ClassModifier modifier, string name, string inherits, string inheritsNamespace, List <string> usings = null) { var @class = new ClassGenerator(); @class.scope = scope; @class.modifier = modifier; @class.name = name; @class.assemblyQualifiedInheritanceNamespace = inheritsNamespace; @class.assemblyQualifiedInheritanceType = inherits; @class.isNested = false; @class.usings = usings; @class.useAssemblyQualifiedNameForInheritance = true; return(@class); }
private void SetModifierLabel(ClassModifier modifier) { ClassModifier[] modifierOrder = modifierOrders[project.Language]; for (int i = 0; i < modifierOrder.Length; i++) { if (modifierOrder[i] == modifier) { cboModifier.SelectedIndex = i; return; } } cboModifier.SelectedIndex = 0; }
public void AssertClass(string className, ClassModifier modifier = ClassModifier.DontCare) { TypeDefinition type; Assert.IsTrue(types.TryGetValue(className, out type), "Class " + className + " not found"); switch (modifier) { case ClassModifier.Public: Assert.True((type.Attributes & (TypeAttributes.Public | TypeAttributes.NestedPublic)) != 0, className + " should be public"); break; case ClassModifier.Internal: Assert.True((type.Attributes & (TypeAttributes.Public | TypeAttributes.NestedPublic)) == 0, className + " should not be public"); break; } }
public static string Declaration(int indent, RootAccessModifier scope, ClassModifier modifier, string typeName, string inherits, List <Interface> interfaces, string attributes, string parameters, List <Variable> variables, string customVariables, string constructors, Methods methods, bool isLive) { var output = string.Empty; output += attributes + (string.IsNullOrEmpty(attributes) ? string.Empty : "\n"); output += CodeBuilder.Indent(indent) + CodeBuilder.Scope(scope) + ((modifier == ClassModifier.None) ? string.Empty : " " + Patcher.AddLowerUpperNeighboringSpaces(modifier.ToString()).ToLower()) + " " + Patcher.ObjectTypeName(ObjectKind.Class) + " " + typeName + CodeBuilder.TryAddBaseTypeSeperator(inherits, interfaces) + inherits + CodeBuilder.Interfaces(interfaces, inherits, (interfaces.Count > 0) ? true : false); output += "\n"; output += CodeBuilder.Indent(indent) + "{"; output += "\n"; output += CodeBuilder.Variables(variables, indent + 1); output += customVariables; output += (string.IsNullOrEmpty(customVariables) ? string.Empty : "\n"); output += (!(string.IsNullOrEmpty(customVariables)) && string.IsNullOrEmpty(constructors) ? string.Empty : "\n"); output += constructors; output += MethodBuilder.Methods(indent + 1, methods, isLive); output += CodeBuilder.Indent(indent) + "}"; return(output); }
/// <summary> /// Gets the <see cref="ClassModifier" /> as a C# string. /// </summary> /// <param name="modifier">The <see cref="ClassModifier" /> to convert.</param> /// <returns>The <see cref="ClassModifier" /> as a string.</returns> public static string Declaration(this ClassModifier modifier) { switch (modifier) { case ClassModifier.None: return(""); case ClassModifier.Abstract: return("abstract"); case ClassModifier.Sealed: return("sealed"); case ClassModifier.Static: return("static"); default: return(""); } }
private void ChangeModifier(ClassModifier modifier) { if (ValidateName()) { var classType = shape.CompositeType as ClassType; if (classType != null) { try { classType.Modifier = modifier; RefreshValues(); } catch (BadSyntaxException ex) { RefreshValues(); SetError(ex.Message); } } } }
internal bool HasModifier(ClassModifier modifier) { switch (modifier) { case ClassModifier.Private: return this.classSymbol.DeclaredAccessibility == Accessibility.Private; case ClassModifier.Protected: return this.classSymbol.DeclaredAccessibility == Accessibility.Protected; case ClassModifier.Public: return this.classSymbol.DeclaredAccessibility == Accessibility.Public; case ClassModifier.Internal: return this.classSymbol.DeclaredAccessibility == Accessibility.Internal; case ClassModifier.Static: return this.classSymbol.IsStatic; case ClassModifier.Sealed: return this.classSymbol.IsSealed; case ClassModifier.Abstract: return this.classSymbol.IsAbstract; default: throw new NotImplementedException(string.Format("Modifier {0} is unknown", modifier)); } }
/// <summary> /// write auto part of code /// </summary> /// <param name="writer">stream</param> public void Write(System.IO.StreamWriter writer) { CommentWriter.Write(writer, Comment); for (int i = 0; i < _Attributes.Count; i++) // write attributes { writer.WriteLine(string.Format("[{0}]", _Attributes[i])); } writer.Write(Modifier.ToString().ToLower()); writer.Write(" "); if (ClassModifier != ClassModifiers.None) { writer.Write(ClassModifier.ToString().ToLower()); writer.Write(" "); } if (IsPartial) { writer.Write("partial "); } writer.Write(string.Format("{0} {1}", IsStruct ? "struct" : "class", Name)); if (_InheritClasses.Count > 0) { writer.Write(" : "); for (int i = 0; i < _InheritClasses.Count; i++) { writer.Write(_InheritClasses[i]); if (i < _InheritClasses.Count - 1) { writer.Write(", "); } } } writer.WriteLine(); writer.WriteLine("{"); if (_Enums.Count > 0) { writer.WriteLine(); writer.WriteLine("// Internal Enumurators"); foreach (var e in _Enums) { e.Write(writer); } } if (_Classes.Count > 0) { writer.WriteLine(); writer.WriteLine("// Internal class"); foreach (var cl in _Classes) { cl.Write(writer); } } writer.WriteLine(); writer.WriteLine("// Variables"); foreach (var v in _Variables) { v.Write(writer); } writer.WriteLine(); writer.WriteLine("// Properties"); foreach (var p in _Properties) { p.Write(writer); } writer.WriteLine(); writer.WriteLine("// Methods"); foreach (var m in _Methods) { if (!m.IsPartial) { m.Write(writer); } } writer.WriteLine(); writer.WriteLine("}"); }
public void SetModifiers(ClassModifier modifiers) { Modifiers = modifiers; }
public override string GetClassModifierString(ClassModifier modifier, bool forCode) { throw new NotImplementedException(); }
public override string GetClassModifierString(ClassModifier modifier, bool forCode) { if (!forCode) return modifier.ToString(); else if (modifier == ClassModifier.None) return ""; else return modifier.ToString().ToLower(); }
public string GetClassModifierString(ClassModifier modifier) { return GetClassModifierString(modifier, false); }
public abstract string GetClassModifierString(ClassModifier modifier, bool forCode);
protected override void CopyFrom(TypeBase type) { base.CopyFrom(type); ClassType classType = (ClassType) type; modifier = classType.modifier; }
public override string GetClassModifierString(ClassModifier modifier, bool forCode) { if (validClassModifiers.ContainsKey(modifier)) { if (forCode) return validClassModifiers[modifier].ToLower(); else return validClassModifiers[modifier]; } else { if (modifier == ClassModifier.None) return Strings.None; else return string.Empty; } }
public NormalClassDeclaration(ClassModifier classmodifier, Identifier identifier, ClassBody classbody) { this.classModifier = classmodifier; this.identifier = identifier; this.classBody = classbody; }
public static string GetVisualBasicModifier(AccessModifier? access, ClassModifier? modifier) { return !modifier.HasValue ? GetVisualBasicModifier(access.ToString()) : String.Format("{0} {1}", GetVisualBasicModifier(access.ToString()), modifier); }
public string GetClassModifierString(ClassModifier modifier) { return(GetClassModifierString(modifier, false)); }
private void ChangeModifier(ClassModifier modifier) { if (ValidateName()) { ClassType classType = shape.CompositeType as ClassType; if (classType != null) { try { classType.Modifier = modifier; RefreshValues(); } catch (BadSyntaxException ex) { RefreshValues(); SetError(ex.Message); } } } }
public static string GetModifier(AccessModifier? access, ClassModifier? modifier) { return !modifier.HasValue ? access.ToString().ToLower() : String.Format("{0} {1}", access.ToString().ToLower(), modifier.ToString().ToLower()); }