protected AbstractSyntaxDrawer(IInterfaceResolver interfaceResolver, ISyntaxDrawerFactory drawerFactory, StringBuilder diagramToDrawTo, string entryMethod)
 {
     _interfaceResolver = interfaceResolver;
     _diagram           = diagramToDrawTo;
     _entryMethod       = entryMethod;
     _drawerFactory     = drawerFactory;
     _logger            = new NullLogger();
 }
 public CallSyntaxStatement(IInterfaceResolver interfaceResolver,
                            StringBuilder diagram,
                            SyntaxDrawerFactory drawerFactory,
                            string entryMethod,
                            IDictionary <string, IClassStructure> analyzedClasses)
     : base(interfaceResolver, drawerFactory, diagram, entryMethod)
 {
     _analyzedClasses = analyzedClasses;
 }
        public SequenceDiagramGenerator(IDictionary <string, IClassStructure> analyzedClasses, IInterfaceResolver interfaceResolver, IDoLog logger = null)
        {
            _analyzedClasses = analyzedClasses;
            _diagram         = new StringBuilder();
            _ifaceResolver   = interfaceResolver;
            if (_logger == null)
            {
                _logger = new NullLogger();
            }

            _logger = logger;
        }
 public ForEachStatement(IInterfaceResolver interfaceResolver, ISyntaxDrawerFactory drawerFactory, StringBuilder diagram, string entryMethod)
     : base(interfaceResolver, drawerFactory, diagram, entryMethod)
 {
 }
        public AbstractSyntaxDrawer GetDrawer(SyntaxNode node, IInterfaceResolver interfaceResolver, StringBuilder diagram)
        {
            if (node is InvocationExpressionSyntax)
            {
                var drawer = new CallSyntaxStatement(interfaceResolver, diagram, this, _entryMethod, _analyzedClasses);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is ElseClauseSyntax)
            {
                var drawer = new ElseSyntaxStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is ForEachStatementSyntax)
            {
                var drawer = new ForEachStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is ForStatementSyntax)
            {
                var drawer = new ForStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is IfStatementSyntax)
            {
                var drawer = new IfStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is SwitchStatementSyntax)
            {
                var drawer = new SwitchSyntaxStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is SwitchSectionSyntax)
            {
                var drawer = new SwitchSectionStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is ObjectCreationExpressionSyntax)
            {
                var drawer = new ObjectCreationStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            if (node is ReturnStatementSyntax)
            {
                var drawer = new ReturnSyntaxStatement(interfaceResolver, this, diagram, _entryMethod);
                drawer.AppendLogger(_logger);
                return(drawer);
            }

            return(new NullDrawer(interfaceResolver, this, diagram, _entryMethod));
        }