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; }