private Interface TraverseInterface(InterfaceBlockSyntax ibs)
        {
            Interface retInterface = new Interface();

            /*
            Encapsulation = new List<Encapsulation>();
            Qualifiers = new List<Qualifiers>();
            Attributes = new List<Variables>();
            Methods = new List<Method>();
            InheritsStrings = new List<string>();
            InheritsInterfaces = new List<Interface>();
            */

            InterfaceStatementSyntax iss = ibs.Begin;

            foreach (SyntaxToken st in iss.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retInterface.Encapsulation.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retInterface.Qualifiers.Add(qual);
                }
            }

            retInterface.Name = iss.Identifier.ValueText;

            foreach(InheritsStatementSyntax inherits in ibs.Inherits){
                foreach (SyntaxNode sn in inherits.ChildNodes())
                {
                    if (sn is IdentifierNameSyntax)
                    {
                        retInterface.InheritsStrings.Add((sn as IdentifierNameSyntax).Identifier.ValueText);
                    }
                }
            }

            List<MethodBlockSyntax> methods = new List<MethodBlockSyntax>();
            List<FieldDeclarationSyntax> Fields = new List<FieldDeclarationSyntax>();
            List<PropertyBlockSyntax> properties = new List<PropertyBlockSyntax>();

            foreach (SyntaxNode sn in ibs.ChildNodes())
            {
                if (sn is MethodBlockSyntax)
                {
                    methods.Add(sn as MethodBlockSyntax);
                }
                else if (sn is FieldDeclarationSyntax)
                {
                    Fields.Add(sn as FieldDeclarationSyntax);
                }
                else if (sn is PropertyBlockSyntax)
                {
                    properties.Add(sn as PropertyBlockSyntax);
                }
            }

            foreach (MethodBlockSyntax mbs in methods)
            {
                bool isConstructor = false;
                retInterface.Methods.Add(TraverseMethod(mbs, ref isConstructor));
            }

            foreach (FieldDeclarationSyntax fds in Fields)
            {
                retInterface.Fields.Add(TraverseField(fds));
            }

            foreach (PropertyBlockSyntax pbs in properties)
            {
                retInterface.Properties.Add(TraverseProperties(pbs));
            }

            return retInterface;
        }
        private Interface TraverseInterface(InterfaceDeclarationSyntax ids)
        {
            Interface retInterface = new Interface();

            if (ids.HasLeadingTrivia)
            {
                SetOuterComments(retInterface, ids.GetLeadingTrivia().ToFullString());
            }

            if (ids.HasTrailingTrivia)
            {
                SetInnerComments(retInterface, ids.GetTrailingTrivia().ToFullString());
            }

            foreach (SyntaxToken st in ids.Modifiers)
            {
                string modifier = System.Threading.Thread.CurrentThread.CurrentCulture.TextInfo.ToTitleCase(st.ValueText);
                Encapsulation encap;
                Qualifiers qual;
                if (System.Enum.TryParse<Encapsulation>(modifier, out encap))
                {
                    retInterface.Encapsulation.Add(encap);
                }
                else if (System.Enum.TryParse<Qualifiers>(modifier, out qual))
                {
                    retInterface.Qualifiers.Add(qual);
                }
            }
            var accessVarsDecl = from aAccessVarsDecl in ids.ChildNodes().OfType<LocalDeclarationStatementSyntax>() select aAccessVarsDecl;
            foreach (LocalDeclarationStatementSyntax ldss in accessVarsDecl)
            {
                Method tempMethod = TransverseAccessVars(ldss);
                retInterface.Fields.AddRange(tempMethod.AccessedVariables);
                //retInterface.Methods.AddRange(tempMethod.InvokedMethods);
            }
            var interfaces = from aInterface in ids.ChildNodes().OfType<InterfaceDeclarationSyntax>() select aInterface;
            foreach (InterfaceDeclarationSyntax ids2 in interfaces)
            {
                Interface tempInterface = TraverseInterface(ids2);
                retInterface.InheritsInterfaces.Add(tempInterface);
            }
            retInterface.Name = ids.Identifier.ValueText;
            var methods = from aMethod in ids.ChildNodes().OfType<MethodDeclarationSyntax>() select aMethod;
            foreach (MethodDeclarationSyntax mds in methods)
            {
                Method tempMethod = TransverseMethods(mds);
                retInterface.Fields.AddRange(tempMethod.AccessedVariables);
                retInterface.Methods.Add(tempMethod);
            }
            //public List<string> InheritsStrings { get; set; }
            //public List<Property> Properties { get; set; }
            return retInterface;
        }