public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
BaseLanguage language = this.options.Language.CastTo <BaseLanguage>();
EnumTemplate template = (EnumTemplate)fragment;
output.Add(template.Attributes)
.Add(language.ClassScope)
.Add(" enum ")
.Add(template.Name);
if (template.BasedOn != null)
{
output.Add(" : ").Add(template.BasedOn);
}
output.StartBlock();
EnumValueTemplate last = template.Values.LastOrDefault();
foreach (EnumValueTemplate enumTemplateValue in template.Values)
{
output.Add($"{enumTemplateValue.FormattedName} = ")
.Add(enumTemplateValue.Value)
.Add(last == enumTemplateValue ? string.Empty : ",")
.BreakLine();
}
output.EndBlock();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
TypeScriptTemplate template = (TypeScriptTemplate)fragment;
output.Add(template.Code);
if (template.CloseAfter)
{
output.CloseLine();
}
if (template.BreakAfter)
{
output.BreakLine();
}
if (template.StartBlockAfter)
{
output.StartBlock();
}
if (template.EndBlockAfter)
{
output.EndBlock();
}
if (template.IndentAfter)
{
output.Indent();
}
if (template.UnindentAfter)
{
output.UnIndent();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
LambdaTemplate template = (LambdaTemplate)fragment;
output.Add("(");
if (template.Parameters != null)
{
output.Add(template.Parameters, ", ");
}
else if (template.ParameterNames?.Count == 1)
{
output.Add(template.ParameterNames[0]);
}
else if (template.ParameterNames?.Count > 1)
{
output.Add(string.Join(", ", template.ParameterNames));
}
output.Add(")")
.Add(" =>");
if (template.Code is MultilineCodeFragment)
{
output.StartBlock();
}
else
{
output.Add(" ");
}
output.Add(template.Code);
if (template.Code is MultilineCodeFragment)
{
output.EndBlock(this.options.Formatting.StartBlockInNewLine);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
LambdaTemplate template = (LambdaTemplate)fragment;
output.Add(template.ParameterName ?? "()")
.Add(" =>");
if (template.Code is MultilineCodeFragment)
{
output.StartBlock();
}
else
{
output.Add(" ");
}
output.Add(template.Code);
if (template.Code is MultilineCodeFragment)
{
output.EndBlock(output.Language.Formatting.StartBlockInNewLine);
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
NamespaceTemplate template = (NamespaceTemplate)fragment;
if (template.Children.Count == 0)
{
return;
}
bool hasNamespace = !string.IsNullOrEmpty(template.Name);
if (hasNamespace)
{
output.Add($"{this.NamespaceKeyword} {template.Name}")
.StartBlock();
}
output.Add(template.Children);
if (hasNamespace)
{
output.EndBlock();
}
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
SwitchTemplate template = (SwitchTemplate)fragment;
output.Add("switch (")
.Add(template.Expression)
.Add(")")
.StartBlock();
foreach (CaseTemplate caseTemplate in template.Cases)
{
output.Add(caseTemplate);
}
if (template.Default.Fragments.Count > 0)
{
output.Add("default:")
.Indent()
.Add(template.Default)
.Add("break").CloseLine()
.UnIndent();
}
output.EndBlock();
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
BaseLanguage language = this.options.Language.CastTo <BaseLanguage>();
ClassTemplate template = (ClassTemplate)fragment;
output.Add(template.Comment);
output.Add(template.Attributes);
output.Add(language.ClassScope).Add(" ");
if (template.IsAbstract && language.HasAbstractClasses && !template.IsInterface)
{
output.Add("abstract ");
}
if (template.IsStatic && language.HasStaticClasses)
{
output.Add("static ");
}
else if (!string.IsNullOrEmpty(language.PartialKeyword))
{
output.Add(language.PartialKeyword).Add(" ");
}
if (template.IsInterface)
{
output.Add("interface ");
}
else
{
output.Add("class ");
}
output.Add(template.Name);
if (template.Generics.Count > 0)
{
output.Add("<").Add(template.Generics.Select(x => Code.Instance.Type(x.Name)), ", ").Add(">");
}
template.BasedOn.OrderBy(x => x.ToType().IsInterface).ForEach(x => output.Add(x));
output.Add(template.Generics.Select(x => x.ToConstraints()).Where(x => x.Types.Count > 0));
output.StartBlock();
if (template.IsInterface)
{
template.Fields.ForEach(x => x.Visibility = Visibility.None);
template.Properties.ForEach(x => x.Visibility = Visibility.None);
}
bool isFirst = true;
if (template.Classes.Count > 0)
{
output.Add(template.Classes);
isFirst = false;
}
if (template.Fields.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Fields);
isFirst = false;
}
if (template.Properties.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Properties);
isFirst = false;
}
if (template.Code != null)
{
output.If(!isFirst).BreakLine().EndIf();
output.Add(template.Code);
isFirst = false;
}
if (template.Methods.Count > 0)
{
output.If(!isFirst).BreakLine().EndIf();
MethodTemplate last = template.Methods.Last();
foreach (MethodTemplate method in template.Methods)
{
output.Add(method);
if (method != last)
{
output.BreakLine();
}
}
}
if (this.options.Formatting.CollapseEmptyClasses && output.LastFragments.First().Equals(template))
{
output.UnBreakLine();
output.Add(this.options.Formatting.CollapsedClassesSpacer, true);
}
output.EndBlock();
}