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 abstract string GetClassModifierString(ClassModifier modifier, bool forCode);
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());
}
