private void StructureParseTypes(CSharpProject project, SDRepository sdRepository)
{
var types = project.Compilation.MainAssembly.TopLevelTypeDefinitions.ToList();
for (int j = 0; j < types.Count; j++)
{
var type = types[j];
if (types[j].Kind != TypeKind.Delegate)
{
PostParseMessage(_parserStrings.ParsingClass + ": " + string.Format("{0}.{1}", types[j].Namespace, types[j].Name));
var nameSpace = sdRepository.GetNamespaceByIdentifier(type.Namespace);
var namespaceRef = nameSpace ?? new SDNamespace(type.Namespace)
{
IsProjectStranger = true
};
var sdType = new SDType(type.GetIdentifier(), type.Name, namespaceRef)
{
Accessibility = type.GetDefinition().Accessibility.ToString().ToLower()
};
sdRepository.AddType(sdType);
EventParser.ParseMinimalFields(sdType, types[j]);
PropertyParser.ParseMinimalProperties(sdType, types[j]);
FieldParser.ParseMinimalFields(sdType, types[j]);
MethodParser.ParseMinimalConstructors(sdType, types[j]);
MethodParser.ParseMinimalMethods(sdType, types[j]);
sdRepository.AddNamespaceTypeRelation(types[j].Namespace, sdType.Identifier);
}
}
}
public void CreateApiDoc(SDRepository sdRepository, int navigationLevel)
{
foreach (var sdNamespace in sdRepository.GetAllNamespaces())
{
_namespaceBuilder.InsertNamespace(sdNamespace, navigationLevel);
}
}
private void ParseMethodCalls(CSharpSolution solution, SDRepository sdRepository)
{
var methodCallParser = new MethodCallParser(sdRepository, solution);
methodCallParser.OnItemParseStart += (n) => { ExecuteOnStepMessage(_parserStrings.ParsingMethod + ": " + n); };
methodCallParser.ParseMethodCalls();
}
public static void AddKnownNamespaces(SDRepository sdRepository)
{
sdRepository.AddNamespace(new SDNamespace("System")
{
IsProjectStranger = true
});
}
internal void ExecuteOnParseCompleted(SDRepository repository)
{
if (OnParseCompleted != null)
{
OnParseCompleted(repository);
}
}
private void ResolveUses(SDRepository sdRepository)
{
var useParser = new UseParser(sdRepository);
useParser.OnItemParseStart += (n) => { ExecuteOnStepMessage(_parserStrings.ParsingUseings + ": " + n); };
useParser.ResolveAllUses();
}
public MethodVisitor(SDRepository repository, SDMethod method, SDType type, CSharpFile file)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
public SequenceDiagram(SDRepository sdRepository)
{
_sdRepository = sdRepository;
_sequenceDiagramPngRenderer = new SequenceDiagramPngRenderer();
_sequenceDiagramSvgRenderer = new SequenceDiagramSvgRenderer();
Nodes = new List <SequenceDiagramNode>();
}
private void ParseTypes(CSharpProject project, SDRepository sdRepository, ICoreConfigSection sharpDoxConfig)
{
var typeParser = new TypeParser(sdRepository, sharpDoxConfig);
typeParser.OnItemParseStart += (n) => { PostParseMessage(_parserStrings.ParsingClass + ": " + n); };
typeParser.ParseProjectTypes(project);
}
public CSharpMethodVisitor(SDRepository repository, SDMethod method, SDType type, Document file) : base(SyntaxWalkerDepth.StructuredTrivia)
{
_repository = repository;
_method = method;
_type = type;
_file = file;
_tokenList = method.Calls;
}
public void ExportSolution(SDRepository repository)
{
_buildMessenger.ExecuteOnStepProgress(0);
_buildMessenger.ExecuteOnStepMessage(string.Empty);
RunAllExporters(repository);
_buildMessenger.ExecuteOnStepProgress(100);
}
private void ParseNamespaces(CSharpProject project, SDRepository sdRepository, ICoreConfigSection sharpDoxConfig, Dictionary <string, string> tokens)
{
var namespaceParser = new NamespaceParser(sdRepository, sharpDoxConfig, sharpDoxConfig.InputFile, tokens);
namespaceParser.OnDocLanguageFound += ExecuteOnDocLanguageFound;
namespaceParser.OnItemParseStart += (n) => { PostParseMessage(_parserStrings.ParsingNamespace + ": " + n); };
namespaceParser.ParseProjectNamespaces(project);
}
private void RemoveEmptyNamespaces(SDRepository repository)
{
foreach (var sdNamespace in repository.GetAllNamespaces())
{
if (sdNamespace.Types.Count == 0)
{
repository.RemoveNamespace(sdNamespace);
}
}
}
/// <default>
/// <summary>
/// Gets an existing <see cref="SDRepository"/> with the given target framework.
/// Or adds and returns a new one.
/// </summary>
/// <param name="targetFx">The target framework of the <see cref="SDRepository"/>.</param>
/// <returns>Existing or new <see cref="SDRepository"/> with the given target framework.</returns>
/// </default>
/// <de>
/// <summary>
/// Liefert ein neues oder bestehendes <see cref="SDRepository"/> mit dem gegebenen Framework.
/// </summary>
/// <param name="targetFx">Das Zielframework des <see cref="SDRepository"/>.</param>
/// <returns>Neues oder bestehendes <see cref="SDRepository"/>.</returns>
/// </de>
public SDRepository GetExistingOrNew(SDTargetFx targetFx)
{
var sdRepository = Repositories.SingleOrDefault(r => r.TargetFx == targetFx);
if (sdRepository == null)
{
sdRepository = new SDRepository();
sdRepository.TargetFx = targetFx;
Repositories.Add(sdRepository);
}
return(sdRepository);
}
private void StructureParseNamespaces(CSharpProject project, SDRepository sdRepository)
{
var types = project.Compilation.MainAssembly.TopLevelTypeDefinitions.ToList();
for (int j = 0; j < types.Count; j++)
{
PostParseMessage(_parserStrings.ParsingNamespace + ": " + types[j].Namespace);
var sdNamespace = new SDNamespace(types[j].Namespace);
sdRepository.AddNamespace(sdNamespace);
}
}
public SDRepository ParseStructure(CSharpSolution solution)
{
_solution = solution;
_repository = new SDRepository();
_buildMessenger.ExecuteOnStepProgress(0);
_buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.ParsingSolution);
ParseNamespaces();
ParseTypes();
_buildMessenger.ExecuteOnStepProgress(100);
return(_repository);
}
private void RunAllExporters(SDRepository repository)
{
var i = 0;
foreach (var exporter in _allExporters)
{
if (_coreConfigSection.ActivatedExporters.Contains(exporter.ExporterName))
{
_buildMessenger.ExecuteOnBuildMessage(string.Format(_sdBuildStrings.StartExporter + ": \"{0}\" ...", exporter.ExporterName));
var outputPath = GetOutputPath(_coreConfigSection.OutputPath, exporter.ExporterName);
exporter.OnStepMessage += (m) => _buildMessenger.ExecuteOnStepMessage(m);
exporter.OnStepProgress += (p) => _buildMessenger.ExecuteOnStepProgress(p);
exporter.Export(repository, outputPath);
}
}
}
private void ParseCompleted(SDRepository repository)
{
Application.Current.Dispatcher.BeginInvoke(
DispatcherPriority.Background,
new Action(() => {
TreeView = new VisibilityItemList();
if (repository != null)
{
foreach (var sdNamespace in repository.GetAllNamespaces())
{
TreeView.Add(new NamespaceViewModel(sdNamespace,
_sharpDoxConfig.ExcludedIdentifiers));
}
}
IsTreeRefreshing = false;
}));
}
public SDRepository ParseSolution(CSharpSolution solution, List <string> excludedIdentifiers)
{
_solution = solution;
_excludedIdentifiers = excludedIdentifiers ?? new List <string>();
_repository = new SDRepository();
_buildMessenger.ExecuteOnStepProgress(0);
_buildMessenger.ExecuteOnBuildMessage(_sdBuildStrings.ParsingSolution);
GetProjectInfos();
GetImages();
ParseNamespaces();
ParseTypes();
ParseArticles();
ParseMethodCalls();
ResolveUses();
_buildMessenger.ExecuteOnStepProgress(100);
return(_repository);
}
internal NamespaceParser(SDRepository repository, List <string> excludedIdentifiers, ICoreConfigSection coreConfigSection)
: base(repository, excludedIdentifiers)
{
_descriptionFiles = Directory.EnumerateFiles(Path.GetDirectoryName(coreConfigSection.InputPath), "*.sdnd", SearchOption.AllDirectories).ToList();
}
internal UseParser(SDRepository sdRepository)
{
_sdRepository = sdRepository;
}
internal MethodCallParser(SDRepository repository, CSharpSolution solution)
: base(repository)
{
_solution = solution;
}
public static void AddKnownTypes(SDRepository sdRepository)
{
var systemNamespace = sdRepository.GetNamespaceByIdentifier("System");
if (systemNamespace != null)
{
sdRepository.AddType(new SDType("dynamic", "Dynamic", systemNamespace)
{
IsProjectStranger = true, CSharpName = "dynamic"
});
sdRepository.AddType(new SDType("System.Object", "Object", systemNamespace)
{
IsProjectStranger = true, CSharpName = "object"
});
sdRepository.AddType(new SDType("System.Boolean", "Boolean", systemNamespace)
{
IsProjectStranger = true, CSharpName = "bool"
});
sdRepository.AddType(new SDType("System.Char", "Char", systemNamespace)
{
IsProjectStranger = true, CSharpName = "char"
});
sdRepository.AddType(new SDType("System.SByte", "SByte", systemNamespace)
{
IsProjectStranger = true, CSharpName = "sbyte"
});
sdRepository.AddType(new SDType("System.Byte", "Byte", systemNamespace)
{
IsProjectStranger = true, CSharpName = "byte"
});
sdRepository.AddType(new SDType("System.Int16", "Int16", systemNamespace)
{
IsProjectStranger = true, CSharpName = "short"
});
sdRepository.AddType(new SDType("System.UInt16", "UInt16", systemNamespace)
{
IsProjectStranger = true, CSharpName = "ushort"
});
sdRepository.AddType(new SDType("System.Int32", "Int32", systemNamespace)
{
IsProjectStranger = true, CSharpName = "int"
});
sdRepository.AddType(new SDType("System.UInt32", "UInt32", systemNamespace)
{
IsProjectStranger = true, CSharpName = "uint"
});
sdRepository.AddType(new SDType("System.Int64", "Int64", systemNamespace)
{
IsProjectStranger = true, CSharpName = "long"
});
sdRepository.AddType(new SDType("System.UInt64", "UInt64", systemNamespace)
{
IsProjectStranger = true, CSharpName = "ulong"
});
sdRepository.AddType(new SDType("System.Single", "Single", systemNamespace)
{
IsProjectStranger = true, CSharpName = "float"
});
sdRepository.AddType(new SDType("System.Double", "Double", systemNamespace)
{
IsProjectStranger = true, CSharpName = "double"
});
sdRepository.AddType(new SDType("System.Decimal", "Decimal", systemNamespace)
{
IsProjectStranger = true, CSharpName = "decimal"
});
sdRepository.AddType(new SDType("System.String", "String", systemNamespace)
{
IsProjectStranger = true, CSharpName = "string"
});
sdRepository.AddType(new SDType("System.Void", "Void", systemNamespace)
{
IsProjectStranger = true, CSharpName = "void"
});
}
}
internal BaseParser(SDRepository repository, List <string> excludedIdentifiers = null)
{
_repository = repository;
_excludedIdentifiers = excludedIdentifiers;
_documentationParser = new DocumentationParser(repository);
}
internal UseParser(SDRepository repository) : base(repository)
{
}
internal PropertyParser(SDRepository repository, TypeParser typeParser, List <string> excludedIdentifiers)
: base(repository, excludedIdentifiers)
{
_typeParser = typeParser;
}
internal TypeParser(SDRepository repository, ICoreConfigSection sharpDoxConfig) : base(repository, sharpDoxConfig)
{
}
internal NamespaceParser(SDRepository repository, ICoreConfigSection sharpDoxConfig, string inputFile, Dictionary <string, string> tokens) : base(repository, sharpDoxConfig)
{
_descriptionFiles = Directory.EnumerateFiles(Path.GetDirectoryName(inputFile), "*.sdnd", SearchOption.AllDirectories).ToList();
_tokens = tokens;
}
public DocumentationParser(SDRepository sdRepository)
{
_sdRepository = sdRepository;
}
/// <default>
/// <summary>
/// The constructor takes two parameters.
/// You have to create a new instance
/// for each text you want to transform.
/// </summary>
/// <param name="repository">The repository of the parsed project.</param>
/// <param name="template">The text you want to transform.</param>
/// </default>
/// <de>
/// <summary>
/// The Konstruktor akzeptiert zwei Parameter.
/// Für jeden Text der transformiert werden soll
/// muss eine neue Instanz erstellt werden.
/// </summary>
/// <param name="repository">Das Repository des eingelesenen Projekts.</param>
/// <param name="template">Der Text der transformiert werden soll.</param>
/// </de>
public Templater(SDRepository repository, string template)
{
_repository = repository;
_template = template;
}
