public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Visibility MethodName(arg: Type, ...)
// Visibility (ctor) MethodName(arg: Type, ...)
// parameters
Action<IRichStringbuilder> WriteArgumentsIfExist = innerSb => {
innerSb.WriteRegular("(");
if (Arguments != null && Arguments.Count > 0)
{
for (int i = 0; i < Arguments.Count; i++)
{
var kvp = Arguments[i];
innerSb.WriteRegular(kvp.Key + ": ");
innerSb.WriteBold(kvp.Value);
if ( (i + 1) < Arguments.Count)
innerSb.WriteRegular(", ");
}
}
innerSb.WriteRegular(")");
};
Visibility.Design(richSb);
richSb.WriteRegular(" ");
if (Ctor) richSb.WriteRegular("(ctor)");
richSb.WriteRegular(Name);
WriteArgumentsIfExist(richSb);
richSb.WriteRegular(": ");
richSb.WriteBold(Ctor ? Name : ReturnType);
AppendSuffix(richSb);
AppendSuffixOverride(richSb);
return richSb;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Visibility PropertyName: ReturnType {get;set}
Visibility.Design(richSb);
richSb.WriteRegular(" ");
WriteNameHelper(richSb);
richSb.WriteRegular(": ");
richSb.WriteBold(ReturnType);
bool OpenCloseBracket = Getter || Setter;
if (OpenCloseBracket)
{
richSb.WriteRegular("{");
if (Getter) richSb.WriteRegular("get;");
if (Setter) richSb.WriteRegular("set;");
richSb.WriteRegular("}");
}
if (Abstract)
richSb.WriteItalic(" ** abstract **");
if (Virtual)
{
richSb.WriteRegular(" « ");
richSb.WriteUnderline("virtual");
richSb.WriteRegular(" »");
}
if (Overrided)
richSb.WriteBold(" !overrided");
return richSb;
}
protected static void DrawLine(IRichStringbuilder builder, int size, bool useIntercalatedSpace, char c, bool appendLineAtTheEnd = true, bool writingHeader = false)
{
Action<bool, string> internalFunc = (header, data) =>
{
if (header) { builder.WriteBold(data); }
else { builder.WriteRegular(data); }
};
if (useIntercalatedSpace)
{
for (int i = 0;
i < size;
internalFunc(writingHeader, (i % 2 == 0 ? "" + c : " ")), i++) ;
}
else
{
for (int i = 0;
i < size;
internalFunc(writingHeader, ("" + c)), i++) ;
}
if (appendLineAtTheEnd)
{
builder.WriteLine();
}
}
protected int WriteBaseTypesUML(IRichStringbuilder richSb)
{
var sbuilder = BaseTypes.Aggregate(new StringBuilder(), (sb, s) => sb.Append(s + ", "));
string baseTypes = sbuilder.Remove(sbuilder.Length - 2, 2).ToString();
richSb.WriteBold(baseTypes);
return sbuilder.Length;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
DesignHeader(richSb);
if (Values.Any())
{
StringBuilder sb2 = new StringBuilder();
foreach (var kvp in Values)
{
sb2.Append(kvp.Key);
if (!String.IsNullOrEmpty(kvp.Value))
{
sb2.Append(" = ");
sb2.Append(kvp.Value);
}
sb2.AppendLine(", ");
}
if (sb2.Capacity >= 2)
sb2.Remove(sb2.Length - 2, 2);
string str = sb2.ToString();
richSb.WriteRegular(str).WriteLine(); ;
}
return richSb;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Header
DesignHeader(richSb);
// REFERENCES
if (ReferencedTypes.Any())
{
richSb.WriteLine();
DrawLine(richSb, 50, true, '-');
WriteReferencesUML(richSb);
DrawLine(richSb, 50, true, '-');
}
// PROPERTIES
if (Properties.Any())
{
richSb.WriteLine();
richSb.WriteRegular("Properties ").WriteLine();
WritePropertiesUML(richSb);
}
// METHODS
if (Methods.Any())
{
richSb.WriteLine();
richSb.WriteRegular("Methods ").WriteLine();
WriteMethodsUML(richSb);
}
return richSb;
}
public override IRichStringbuilder Design(IRichStringbuilder richerStringBuilder)
{
// CONSTANT_NAME : constant_type = value
richerStringBuilder.WriteRegular(Name + " : ");
richerStringBuilder.WriteBold(ReturnType);
richerStringBuilder.WriteRegular(" = ");
richerStringBuilder.WriteItalic(InitialValue);
return richerStringBuilder;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Visibility MethodName(arg: Type, ...)
// Visibility (ctor) MethodName(arg: Type, ...)
// parameters
Action<IRichStringbuilder> WriteArgumentsIfExist = innerSb =>
{
innerSb.WriteRegular("(");
if (Arguments != null && Arguments.Count > 0)
{
for (int i = 0; i < Arguments.Count; i++)
{
var kvp = Arguments.ElementAt(i);
innerSb.WriteRegular(kvp.Key + ": ");
innerSb.WriteBold(kvp.Value);
if ((i + 1) < Arguments.Count)
innerSb.WriteRegular(", ");
}
}
innerSb.WriteRegular(")");
};
if( Ctor && Static )
this.Visibility = new Visibility(Enums.VisibilityMode.@public);
Visibility.Design(richSb);
richSb.WriteRegular(" ");
if (Ctor)
{
if (Static) { richSb.WriteRegular("(cctor)"); }
else { richSb.WriteRegular("(ctor)"); }
}
WriteNameHelper(richSb);
WriteArgumentsIfExist(richSb);
richSb.WriteRegular(": ");
richSb.WriteBold(Ctor ? Name : ReturnType);
if (Abstract)
richSb.WriteItalic(" ** abstract **");
if (Virtual)
{
richSb.WriteRegular(" « ");
richSb.WriteUnderline("virtual");
richSb.WriteRegular(" »");
}
if (Overrided)
richSb.WriteBold(" !overrided");
return richSb;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Visibility Name: ReturnType readonly
Visibility.Design(richSb);
richSb.WriteRegular(" " + Name + ": ");
richSb.WriteBold(ReturnType);
if (@Readonly)
richSb.WriteItalic(" readonly");
AppendSuffix(richSb);
return richSb;
}
protected void AppendSuffix(IRichStringbuilder richSb)
{
if (@Static)
richSb.WriteRegular(" [STATIC]");
if (Abstract)
richSb.WriteItalic(" ** abstract **");
if (Virtual)
{
richSb.WriteRegular(" « ");
richSb.WriteUnderline("virtual");
richSb.WriteRegular(" »");
}
}
private IRichStringbuilder DesignHeader(IRichStringbuilder richSb)
{
int LINE_CHARS_NUM = Name.Length + 5;
DrawLine(richSb, LINE_CHARS_NUM, true, '_', true, true);
richSb.WriteRegular(": ");
Visibility.Design(richSb);
richSb.WriteRegular(Name);
richSb.WriteRegular(" ");
richSb.WriteItalic(ENUM_WORD);
LINE_CHARS_NUM += ENUM_WORD.Length;
richSb.WriteLine();
DrawLine(richSb, LINE_CHARS_NUM, true, '¯', true, true);
return richSb;
}
public void DesignHeader(IRichStringbuilder richSb)
{
int LINE_CHARS_NUM = Name.Length + 5;
DrawLine(richSb, LINE_CHARS_NUM, true, '_', true, true);
richSb.WriteRegular(": ");
Visibility.Design(richSb);
richSb.WriteRegular(Name);
int charsWritten = DesignHeaderConcrete(richSb);
if (BaseTypes.Any())
{
richSb.WriteRegular(" : ");
charsWritten += (int) Math.Round((double)WriteBaseTypesUML(richSb) * 1.7d);
}
richSb.WriteLine();
DrawLine(richSb, LINE_CHARS_NUM + charsWritten, true, '¯', true, true);
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
// Visibility PropertyName: ReturnType {get;set}
Visibility.Design(richSb);
richSb.WriteRegular(" " + Name + ": ");
richSb.WriteBold(ReturnType);
bool OpenCloseBracket = Getter || Setter;
if (OpenCloseBracket)
{
richSb.WriteRegular("{");
if (Getter) richSb.WriteRegular("get;");
if (Setter) richSb.WriteRegular("set;");
richSb.WriteRegular("}");
}
AppendSuffix(richSb);
AppendSuffixOverride(richSb);
return richSb;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
Func<string> f = () => {
switch (Mode)
{
case VisibilityMode.@internal:
return "@";
case VisibilityMode.@private:
return "-";
case VisibilityMode.@protected:
return "#";
case VisibilityMode.@public:
return "+";
default:
throw new NotSupportedException();
}
};
string symbol = f();
richSb.WriteRegular(symbol);
return richSb;
}
protected override int DesignHeaderConcrete(IRichStringbuilder richSb)
{
int charsWritten = 0;
if (Abstract)
{
richSb.WriteRegular(" ");
richSb.WriteItalic(ABSTRACT_WORD);
charsWritten += ABSTRACT_WORD.Length;
}
if (Static)
{
richSb.WriteRegular(" ");
richSb.WriteItalic(STATIC_WORD);
charsWritten += STATIC_WORD.Length;
}
return charsWritten;
}
protected void AppendSuffixOverride(IRichStringbuilder richSb)
{
if (Overrided)
richSb.WriteBold(" !overrided");
}
public void DesignType(IRichStringbuilder richSb)
{
Design(richSb);
}
public bool WritePropertiesUML(IRichStringbuilder richSb)
{
Properties.ToList().ForEach(p => p.Design(richSb).WriteLine());
return Properties.Count > 0;
}
public bool WriteMethodsUML(IRichStringbuilder richSb)
{
Methods.ToList().ForEach(m => m.Design(richSb).WriteLine());
return Methods.Count > 0;
}
public IRichStringbuilder Design(IRichStringbuilder richSb)
{
string dummyTextPreparation = Name;
Func<string> annotationString = () =>
{
string s = string.Empty;
switch (Type)
{
case CLRAvailableTypeMode.@class:
if (Abstract) s = "« abstract »";
break;
case CLRAvailableTypeMode.@enum:
s = " « enum »";
break;
case CLRAvailableTypeMode.@interface:
s = " « interface »";
break;
case CLRAvailableTypeMode.@struct:
s = " « struct »";
break;
default: throw new NotSupportedException();
}
return s;
};
if (!string.IsNullOrEmpty(BaseName)) { dummyTextPreparation += " extends " + BaseName; }
string annotationText = annotationString();
dummyTextPreparation += annotationText; // append
// calc size
int numCharsOthersSeparators = (int)Math.Round(dummyTextPreparation.Length * 0.8);
int numCharsClass = (int)Math.Round((dummyTextPreparation.Length * 1.3)); // fixed value because of the caracter _
DrawLine(richSb, numCharsClass, true, '_', true, true);
richSb.WriteRegular(": ");
Visibility.Design(richSb);
richSb.WriteRegular(" " + Name);
if (!string.IsNullOrEmpty(annotationText)) { richSb.WriteItalic(annotationText); }
if (!string.IsNullOrEmpty(BaseName)) { richSb.WriteRegular(" extends ").WriteBold(BaseName); }
richSb.WriteLine();
DrawLine(richSb, numCharsClass, true, '¯', true, true);
// REFERENCES
if (ReferencedTypes.Any())
{
richSb.WriteLine();
DrawLine(richSb, numCharsOthersSeparators, true, '-');
WriteReferencesUML(richSb);
DrawLine(richSb, numCharsOthersSeparators, true, '-');
}
// CONSTANTS
if (ConstantFields.Any())
{
richSb.WriteLine();
richSb.WriteRegular("CONSTANTS ").WriteLine();
WriteConstantsUML(richSb);
}
// FIELDS
if (Fields.Any())
{
richSb.WriteLine();
richSb.WriteRegular("Fields ").WriteLine();
WriteFieldsUML(richSb);
}
// PROPERTIES
if (Properties.Any())
{
richSb.WriteLine();
richSb.WriteRegular("Properties ").WriteLine();
WritePropertiesUML(richSb);
}
// METHODS
if (Methods.Any())
{
richSb.WriteLine();
richSb.WriteRegular("Methods ").WriteLine();
WriteMethodsUML(richSb);
}
return richSb;
}
protected void WriteNameHelper(IRichStringbuilder richSb)
{
if (IsStatic) { richSb.WriteUnderline(Name); }
else { richSb.WriteRegular(Name); }
}
protected bool WriteMethodsUML(IRichStringbuilder richSb)
{
Methods.OrderByDescending(x => !x.Static).ToList().Aggregate(new List<Method>(), (l, m) => {
l.Insert((m.Ctor && m.Static) ? 0 : l.Count, m);
return l;
}).ForEach(m => m.Design(richSb).WriteLine());
return Methods.Count > 0;
}
protected bool WritePropertiesUML(IRichStringbuilder richSb)
{
Properties.OrderByDescending(x => !x.Static).ToList().ForEach(p => p.Design(richSb).WriteLine());
return Properties.Count > 0;
}
protected bool WriteConstantsUML(IRichStringbuilder richSb)
{
ConstantFields.ToList().ForEach(c => c.Design(richSb).WriteLine());
return ConstantFields.Count > 0;
}
protected abstract int DesignHeaderConcrete(IRichStringbuilder richSb);
protected bool WriteFieldsUML(IRichStringbuilder richSb)
{
Fields.OrderByDescending(x => !x.Static).ToList().ForEach(f => f.Design(richSb).WriteLine());
return Fields.Count > 0;
}
public abstract IRichStringbuilder Design(IRichStringbuilder richerStringBuilder);
protected override int DesignHeaderConcrete(IRichStringbuilder richSb)
{
richSb.WriteRegular(" ");
richSb.WriteItalic(STRUCT_WORD);
return STRUCT_WORD.Length;
}
public NRefactoryCom2(IRichStringbuilder richSb)
{
ParameterValidator.ThrowIfArgumentNull(richSb, "richSb");
m_richSb = richSb;
}
protected bool WriteReferencesUML(IRichStringbuilder richSb)
{
ReferencedTypes.ToList().ForEach(x => richSb.WriteRegular("references: " + x).WriteLine());
return ReferencedTypes.Count > 0;
}
