private static void SaveNamespaceDictionary()
{
foreach (KeyValuePair <string, List <T6Function> > keyValuePair in _namespaceDictionary)
{
StringBuilder internalsStringBuilder = new StringBuilder();
StringBuilder functionsStringBuilder = new StringBuilder();
foreach (T6Function t6Function in keyValuePair.Value)
{
internalsStringBuilder.Append(NativeFunctionTemplate.GetFunctionString(keyValuePair.Key, t6Function));
}
foreach (T6Function t6Function in keyValuePair.Value)
{
string internalName = keyValuePair.Key + "_" + t6Function.Name;
functionsStringBuilder.Append(FunctionTemplate.GetMethodString(internalName, t6Function));
}
Directory.CreateDirectory(_outputDir + "/Torque6/Engine/Namespaces");
StreamWriter SW = new StreamWriter(_outputDir + "/Torque6/Engine/Namespaces/" + keyValuePair.Key + ".cs");
SW.Write(NamespaceTemplate.GetClassString(keyValuePair.Key,
internalsStringBuilder.ToString().Trim(),
functionsStringBuilder.ToString().Trim(),
GetCustomForNamespace(keyValuePair.Key)));
SW.Close();
}
}
public static NamespaceTemplate AddNamespace(this FileTemplate file, string nameSpace)
{
NamespaceTemplate namespaceTemplate = new NamespaceTemplate(file, nameSpace);
file.Namespaces.Add(namespaceTemplate);
return(namespaceTemplate);
}
public static DeclareTypeTemplate AddDeclareType(this NamespaceTemplate namespaceTemplate, string name, ICodeFragment type)
{
DeclareTypeTemplate declareTypeTemplate = new DeclareTypeTemplate(name, type);
namespaceTemplate.Children.Insert(0, declareTypeTemplate);
return(declareTypeTemplate);
}
public static ClassTemplate AddClass(this NamespaceTemplate namespaceTemplate, string name, params TypeTemplate[] basedOn)
{
ClassTemplate classTemplate = new ClassTemplate(namespaceTemplate, name, basedOn);
namespaceTemplate.Children.Add(classTemplate);
return(classTemplate);
}
public static EnumTemplate AddEnum(this NamespaceTemplate namespaceTemplate, string name, TypeTemplate basedOn = null)
{
EnumTemplate enumTemplate = new EnumTemplate(namespaceTemplate, name, basedOn);
namespaceTemplate.Children.Add(enumTemplate);
return(enumTemplate);
}
public void NamespaceWriter()
{
NamespaceTemplate template = new NamespaceTemplate(null, "test");
template.AddClass("testClass");
NamespaceWriter writer = new NamespaceWriter(this.output.Language.CastTo <BaseLanguage>());
writer.Write(template, this.output);
Assert.AreEqual("namespace test\r\n{\r\n public partial class testClass\r\n {\r\n }\r\n}", this.output.ToString());
}
private void CreateApiIndexFiles()
{
foreach (var solution in StepInput.SDProject.Solutions.Values)
{
var sdRepository = solution.Repositories.SingleOrDefault(r => r.TargetFx.Identifier == StepInput.CurrentTargetFx.Identifier);
if (sdRepository != null)
{
foreach (var sdNamespace in sdRepository.GetAllNamespaces())
{
ExecuteOnStepMessage(string.Format("{0}: {1}", StepInput.ChmStrings.CreateIndexFilesFor, sdNamespace.Fullname));
var namespaceHtmlFile = Path.Combine(StepInput.TmpPath, sdNamespace.Guid + ".html");
var template = new NamespaceTemplate {
SDNamespace = sdNamespace
};
File.WriteAllText(namespaceHtmlFile, template.TransformText());
foreach (var sdType in sdNamespace.Types)
{
var fieldsIndexHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + "-Fields.html");
var fieldsTemplate = new FieldsTemplate {
SDType = sdType
};
File.WriteAllText(fieldsIndexHtmlFile, fieldsTemplate.TransformText());
var eveIndexHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + "-Events.html");
var eventsTemplate = new EventsTemplate {
SDType = sdType
};
File.WriteAllText(eveIndexHtmlFile, eventsTemplate.TransformText());
var propertiesIndexHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + "-Properties.html");
var propertiesTemplate = new PropertiesTemplate {
SDType = sdType
};
File.WriteAllText(propertiesIndexHtmlFile, propertiesTemplate.TransformText());
var constructorsIndexHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + "-Constructors.html");
var constructorsTemplate = new ConstructorsTemplate {
SDType = sdType
};
File.WriteAllText(constructorsIndexHtmlFile, constructorsTemplate.TransformText());
var methodsIndexHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + "-Methods.html");
var methodsTemplate = new MethodsTemplate {
SDType = sdType
};
File.WriteAllText(methodsIndexHtmlFile, methodsTemplate.TransformText());
}
}
}
}
}
private static KeyValuePair <string, Template> OutputNamespaceFunctions(string namespaceName,
List <TorqueFunction> functions)
{
FunctionInternalsRegionTemplate functionInternals = FunctionsToInternals(functions);
FunctionDeclarationRegionTemplate functionDecls = FunctionsToDeclarations(functions);
NamespaceTemplate nsTemplate = new NamespaceTemplate();
nsTemplate.ReplaceField("namespaceName", namespaceName);
nsTemplate.ReplaceField("functionInternals", functionInternals.Indent(2).Content);
nsTemplate.ReplaceField("functionDecls", functionDecls.Indent(2).Content);
return(new KeyValuePair <string, Template>(namespaceName, nsTemplate));
}
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 static NamespaceTemplate WithDeclareType(this NamespaceTemplate namespaceTemplate, string name, ICodeFragment type)
{
namespaceTemplate.AddDeclareType(name, type);
return(namespaceTemplate);
}
protected virtual ClassTemplate WriteClass(ModelTransferObject model, string relativePath)
{
IOptions modelOptions = this.Options.Get(model);
if (model.BasedOn != null && model.Language != null && modelOptions.Language != null)
{
this.MapType(model.Language, modelOptions.Language, model.BasedOn);
}
bool isInterface = model.IsInterface || modelOptions.PreferInterfaces;
string modelNamespace = modelOptions.SkipNamespace ? string.Empty : model.Namespace;
ClassTemplate otherClassTemplate = this.files.Where(file => file.RelativePath == relativePath &&
file.Options.Language == modelOptions.Language)
.SelectMany(file => file.Namespaces)
.SelectMany(ns => ns.Children).OfType <ClassTemplate>()
.FirstOrDefault(x => x.Namespace.Name == modelNamespace && x.Name == model.Name);
NamespaceTemplate namespaceTemplate = otherClassTemplate?.Namespace ?? this.files.AddFile(relativePath, modelOptions)
.WithName(model.FileName)
// .WithType(isInterface ? "interface" : null)
.AddNamespace(modelNamespace);
ClassTemplate classTemplate = namespaceTemplate.AddClass(model.Name, model.BasedOn?.ToTemplate())
.FormatName(modelOptions);
if (model.BasedOn != null)
{
this.AddUsing(model.BasedOn, classTemplate, modelOptions);
}
classTemplate.IsInterface = isInterface;
classTemplate.IsAbstract = model.IsAbstract;
if (model is GenericModelTransferObject generic)
{
generic.Template.Generics.Select(x => new ClassGenericTemplate(x.Alias.Name)).ForEach(classTemplate.Generics.Add);
}
foreach (TypeTransferObject interFace in model.Interfaces)
{
if (model.Language != null && modelOptions.Language != null)
{
this.MapType(model.Language, modelOptions.Language, interFace);
}
if (interFace.Name == model.Name)
{
continue;
}
classTemplate.BasedOn.Add(new BaseTypeTemplate(classTemplate, interFace.ToTemplate()));
this.AddUsing(interFace, classTemplate, modelOptions);
}
if (model is GenericModelTransferObject genericModel)
{
this.AddConstants(genericModel.Template, classTemplate);
this.AddFields(genericModel.Template, classTemplate);
this.AddProperties(genericModel.Template, classTemplate);
}
else
{
this.AddConstants(model, classTemplate);
this.AddFields(model, classTemplate);
this.AddProperties(model, classTemplate);
}
return(classTemplate);
}
