Exemplo n.º 1
0
        public void ParseAndWrite(PARSE_TYPE type, string inputText)
        {
            // parse through framework
            SyntaxTree tree = new N.CSharpParser().Parse(inputText);

            // dispatch to visitor
            var defaultVisitor = new NRefactoryVisitor();
            tree.AcceptVisitor(defaultVisitor);

            IEnumerable<CLRType> CLRTypesDetected = defaultVisitor.CLRTypes;
            switch (type)
            {
                case PARSE_TYPE.FIELDS:
                    CLRTypesDetected.ToList().ForEach(clrType => clrType.WriteFieldsUML(m_richSb));
                    break;

                case PARSE_TYPE.PROPERTIES:
                    CLRTypesDetected.ToList().ForEach(clrType => clrType.WritePropertiesUML(m_richSb));
                    break;

                case PARSE_TYPE.METHODS:
                    CLRTypesDetected.ToList().ForEach(clrType => clrType.WriteMethodsUML(m_richSb));
                    break;

                case PARSE_TYPE.ALL:
                    CLRTypesDetected.ToList().ForEach(clrType => clrType.Design(m_richSb));
                    break;

                default:
                    throw new NotSupportedException();

            }
        }
        public string Parse(PARSE_TYPE type, string inputText)
        {
            // parse through framework
            SyntaxTree tree = new N.CSharpParser().Parse(inputText);

            // dispatch to visitor
            var defaultVisitor = new NRefactoryVisitor();
            tree.AcceptVisitor(defaultVisitor);

            IEnumerable<CLRType> inputTextTypes = defaultVisitor.CLRTypes;
            switch (type)
            {
                case PARSE_TYPE.FIELDS:
                    return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetFieldsUML())).ToString();

                case PARSE_TYPE.PROPERTIES:
                    return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetPropertiesUML())).ToString();

                case PARSE_TYPE.METHODS:
                    return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.GetMethodsUML())).ToString();

                case PARSE_TYPE.ALL:
                    return inputTextTypes.Aggregate(new StringBuilder(), (sb, clr) => sb.AppendLine(clr.Design())).ToString();

                default:
                    throw new NotSupportedException();

            }
        }
        public static (Type, int) ConvertType(string text)
        {
            Match match = PARSE_TYPE.Match(text);

            if (!match.Success)
            {
                throw new Exception($"Could not parse SQL type '{text}'");
            }

            string typeText = match.Groups["type"].Value;

            Type type;

            if (typeText.StartsWith("CHARACTER", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(string);
            }
            else if (typeText.Equals("INTEGER", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(long);
            }
            else if (typeText.Equals("BIGINT", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(long);
            }
            else if (typeText.Equals("REAL", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(float);
            }
            else if (typeText.Equals("DOUBLE PRECISION", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(double);
            }
            else if (typeText.StartsWith("TIMESTAMP", StringComparison.OrdinalIgnoreCase))
            {
                type = typeof(DateTime);
            }
            else
            {
                throw new Exception($"Unknown field type '{text}'");
            }

            string maxLengthText = match.Groups["maxLengthWithParens"].Value.Replace("(", "").Replace(")", "");

            if (!int.TryParse(maxLengthText, out int maxLength))
            {
                maxLength = -1;
            }

            return(type, maxLength);
        }
Exemplo n.º 4
0
        public void ParseAndWrite(PARSE_TYPE type, string inputText)
        {
            // parse through framework
            SyntaxTree tree = new N.CSharpParser().Parse(inputText);

            // dispatch to visitor
            var defaultVisitor = new NRefactoryVisitorV2();
            tree.AcceptVisitor(defaultVisitor);

            IEnumerable<Declaration> CLRDeclarations = defaultVisitor.Declarations;
            switch (type)
            {
                case PARSE_TYPE.FIELDS:
                    CLRDeclarations.OfType<ClassesAndStructs>().ToList().ForEach(cs =>
                        cs.Fields.OrderByDescending(x => !x.Static).ToList().ForEach(f => f.Design(m_richSb).WriteLine()));
                    break;

                case PARSE_TYPE.PROPERTIES:
                    CLRDeclarations.OfType<ClassesAndStructsAndInterfaces>().ToList().ForEach(csi => csi.Properties.OrderByDescending(x => !x.Static).ToList().ForEach(p => p.Design(m_richSb).WriteLine()));
                    break;

                case PARSE_TYPE.METHODS:
                    CLRDeclarations.OfType<ClassesAndStructsAndInterfaces>().ToList().ForEach(csi =>
                        csi.Methods.OrderByDescending(x => !x.Static).ToList().Aggregate(new List<Method>(), (l, m) =>
                        {
                            l.Insert((m.Ctor && m.Static) ? 0 : l.Count, m);
                            return l;
                        })
                        .ForEach(m => m.Design(m_richSb).WriteLine())
                     );
                    break;

                case PARSE_TYPE.ALL:
                    CLRDeclarations.OfType<ITypeDeclaration>().ToList().ForEach(clrType => clrType.DesignType(m_richSb));
                    break;

                default:
                    throw new NotSupportedException();

            }
        }