C# ICirData类代码示例

        /// <summary>
        /// this will return the current CirFunction object for the signature provided or create a new CirFunction
        /// object and return it
        /// </summary>
        /// <param name="cirData"></param>
        /// <param name="functionSignature"></param>
        /// <param name="functionType"></param>
        /// <returns></returns>
        public ICirFunction getCirFunction(ICirData cirData, string functionSignature, string functionType)
        {
            try
            {
            
                if (cirData.dFunctions_bySignature.ContainsKey(functionSignature))
                    return cirData.dFunctions_bySignature[functionSignature];

                // create the function reference                
                var newCirFunction = new CirFunction(functionSignature);
                cirData.dFunctions_bySignature.Add(functionSignature, newCirFunction);

                // add it to the respective CirClas

                var cirClass = getCirClass(cirData,functionType);
                cirClass.dFunctions.Add(functionSignature, newCirFunction);

                return newCirFunction;
            }
            catch (Exception ex)
            {
                DI.log.ex(ex, "in CirFactory.getCirFunction", true);
                return null;
            }
        }

        public void mapClass(ICirClass cirClass, ICirData _cirData, bool clearPreviousList)
        {

            cirData = _cirData;
            cirRootClass = cirClass;
            mapCurrentClass(clearPreviousList);
        }

        public void Test_processTypeDefinition(ICirData cirData, ICirClass cirClass)
        {
            Assert.That(cirClass != null, "cirClass was null");
            Assert.That(cirClass.dFunctions.Count == 7, "cirClass.dFunctions.Count != 7 , it was " + cirClass.dFunctions.Count);

            // check if we can get the functions by name
            ICirFunction testMethodA = cirClass.getFunction("testMethodA()");
            Assert.IsNotNull(testMethodA, "could not get testMethodA from cirClass object");
            ICirFunction testMethodB = cirClass.getFunction("testMethodB()");
            Assert.IsNotNull(testMethodB, "could not get testMethodB from cirClass object");
            Assert.IsNotNull(cirClass.getFunction("testMethodB(System.String)"),
                             "could not get testMethodB(string) from cirClass object");
            Assert.IsNotNull(cirClass.getFunction("testMethodD(System.String,System.Type)"),
                             "could not get testMethodD(System.String,System.Type) from cirClass object");

            ICirFunction testMethodC = cirClass.getFunction("testMethodC");

            // check if we have the calls and isCalledBy
            Assert.That(testMethodA.FunctionsCalledUniqueList.Contains(testMethodB),
                        "failed on testMethodA.FunctionsCalledUniqueList.Contains(testMethodB)");
            Assert.That(testMethodA.FunctionsCalledUniqueList.Contains(testMethodC),
                        "failed on testMethodA.FunctionsCalledUniqueList.Contains(testMethodB)");
            var found = false;
            foreach (var calledByFunction in testMethodB.FunctionIsCalledBy)
                if (calledByFunction.cirFunction == testMethodA)
                    found = true;
            Assert.That(found,
                        "failed on testMethodB.FunctionIsCalledBy.Contains(testMethodA)");
        }

        public static List<String> findClassesThatImplementTheSpringMvc(ICirData fadCirData)
        {
            var lResolvedClasses = new List<String>();
            if (fadCirData == null)
            {
                DI.log.error("in findClassesThatImplementTheSpringMvc: CirData object is null");
                return lResolvedClasses;
            }

            var sSpringMvcClass = "org.springframework.web.servlet.mvc";

            var dClassesThatSuperClassSpringMVC = new Dictionary<String, ICirClass>();


            // first find which classes direcly implement a Spring MVC 
            foreach (ICirClass ccCirClass in fadCirData.dClasses_bySignature.Values)
            {
                foreach (String sSuperClass in ccCirClass.dSuperClasses.Keys)
                {
                    String sSuperClassSignature = ccCirClass.dSuperClasses[sSuperClass].Signature;
                    if (sSuperClassSignature.IndexOf(sSpringMvcClass) > -1)
                        // && ccCirClass.sSignature.IndexOf(sBaseClass) > -1)
                    {
                        String sSignatureAndSuperClass = String.Format("{0} <-- {1}", ccCirClass.Signature,
                                                                       ccCirClass.dSuperClasses[sSuperClass].Signature);
                        dClassesThatSuperClassSpringMVC.Add(sSignatureAndSuperClass, ccCirClass);
                        // DI.log.debug("{0} <-- {1}" , ccCirClass.sSignature, ccCirClass.dSuperClasses[sSuperClass].sSignature);									
                    }
                }
            }
            findAllClassesThatSuperClassProvidedList_recursive(dClassesThatSuperClassSpringMVC, lResolvedClasses);
            DI.log.debug("There are {0} classes that implement Spring MVC", lResolvedClasses.Count);
            return lResolvedClasses;
            // DI.log.debug("Loaded with {0} classes", fadCirData.dClasses_bySignature.Keys.Count);		
        }

 public static KM_CirAction setCirData(ICirData cirData)
 {
     var kmCirAction = new KM_CirAction();
     kmCirAction.CirData = cirData;
     kmCirAction.CirAction = IM_CirActions.setCirData;
     return kmCirAction;
 }

 public static KM_CirAction setCirData(ICirData cirData)
 {
     var kmCirAction = new KM_CirAction
                           {
                               CirAction = IM_CirActions.setCirData,
                               CirData = cirData
                           };
     return kmCirAction;
 }

 public static void resolveDbId(ICirData cirData)
 {
     if (cirData.lFiles.Count > 0) // && (sDbId == "" || sDbId == null))
         foreach (String sFile in cirData.lFiles)
         {
             String sResult = CirDumpsUtils.fromFileExtension_get_DbId(Path.GetExtension(sFile));
             if (!string.IsNullOrEmpty(sResult))
             {
                 cirData.sDbId = sResult;
                 return;
             }
         }
 }

        public static List<IO2Finding> mapInterfaces(List<IO2Finding> o2Findings, List<IO2Finding> sourcesMappedToInterfaces, ICirData cirData)
        {
            if (o2Findings == null || cirData == null)
                return null;
            //var sourcesMappedToInterfaces = getSourcesMappedToInterfaces(o2Findings, cirData);
            var sources = getSources(sourcesMappedToInterfaces);
            var lostSinks = getLostSinks(o2Findings);//o2Assessment.o2Findings);
            //var sources = getSources(o2Assessment.o2Findings);

            DI.log.info("There are {0} unique Lost Sinks", lostSinks.Count);
            DI.log.info("There are {0} unique Sources", sources.Count);
            var joinedFindings = mapSinksToSources(lostSinks, sources);
            return joinedFindings;
        }

 private ICirFunction processMemberReference(ICirData cirData, IMemberReference memberDefinition, SequencePoint sequencePoint)
 {
     switch (memberDefinition.GetType().Name)
     {
         case "MethodReference":
             return processMethodReference(cirData, (MethodReference)memberDefinition, sequencePoint);
         case "MethodDefinition":
             return processMethodDefinition(cirData, (MethodDefinition)memberDefinition, sequencePoint);
         default:
             DI.log.error("in CirFactory.processMethodMember, unsupported MethodMember: {0}", memberDefinition.GetType().Name);
             break;
     }
     return null;
 }

        public static List<TreeNode> createListOfNormalizedTraces(
            string textFilter, Dictionary<String, O2TraceBlock_OunceV6> dRawData,
            ICirData cdCirData, Dictionary<String, O2TraceBlock_OunceV6> dO2TraceBlock, 
            bool bOnlyProcessTracesWithNoCallers)
        {
            //var tvCreatedTraces_NormalizedTracesView = new TreeView();
            var normalizedTracesView = analyzer.ResolveNormalizeTraceFor(textFilter, dRawData,
                                                                         cdCirData, dO2TraceBlock,
                                                                         bOnlyProcessTracesWithNoCallers);


            DI.log.info("getListOfNormalizedTraces");
            List<TreeNode> ltnNormalizedTraces = analyzer.getListOfNormalizedTraces(normalizedTracesView);
            return ltnNormalizedTraces;
        }

 /// <summary>
 /// this will return the current CirClass object for the signature provided or create a new CirClass
 /// object and return it 
 /// </summary>
 /// <param name="cirData"></param>
 /// <param name="classSignature"></param>
 /// <returns></returns>
 private static ICirClass getCirClass(ICirData cirData, string classSignature)
 {
     try
     {
         if (cirData.dClasses_bySignature.ContainsKey(classSignature))
             return cirData.dClasses_bySignature[classSignature];
         var newCirClass = new CirClass(classSignature);
         cirData.dClasses_bySignature.Add(classSignature, newCirClass);
         return newCirClass;
     }
     catch (Exception ex)
     {
         DI.log.ex(ex, "in CirFactory.getCirClass", true);
         return null;
     }
 }

        public static TreeNode getTreeNodeWithAutoWiredObject(ICirData cirData, string targetFunction, SpringMvcParameter springMvcParameter, int parameterIndex)
        {
            try
            {

                if (cirData != null && cirData.dFunctions_bySignature.ContainsKey(targetFunction))
                {
                    var cirFunction = cirData.dFunctions_bySignature[targetFunction];
                    if (cirFunction.FunctionParameters.Count <= parameterIndex)
                    {
                        var filteredSignature = new FilteredSignature(targetFunction);
                        if (filteredSignature.lsParameters_Parsed.Count > parameterIndex)
                            springMvcParameter.className = filteredSignature.lsParameters_Parsed[parameterIndex];
                        else
                            DI.log.error("in getTreeNodeWithAutoWiredObject, requested parameter index not found in function: {0}", targetFunction);
                    }
                    else
                    {
                        var functionParameter = cirFunction.FunctionParameters[parameterIndex];
                        springMvcParameter.className = functionParameter.ParameterType.Replace("&", "");
                    }
                    if (springMvcParameter.className != "")
                    {

                        // Hack to handle int Java mappings 
                        if (springMvcParameter.className == "int")
                            springMvcParameter.className = "java.lang.Integer";
                        if (cirData.dClasses_bySignature.ContainsKey(springMvcParameter.className))
                        {
                            var childNodeText = string.Format("{0} - {1} - {2}", springMvcParameter.autoWiredMethodUsed, springMvcParameter.name, springMvcParameter.className);
                            return O2Forms.newTreeNode(childNodeText, childNodeText, 0, cirData.dClasses_bySignature[springMvcParameter.className]);
                        }

                        DI.log.error("in getTreeNodeWithAutoWiredObject, parameter type not found in cirData class list:{0}", springMvcParameter.className);
                    }
                }
                else
                    DI.log.error("in getTreeNodeWithAutoWiredObject, loaded cirData did not contained signature :{0}", targetFunction);
            }
            catch (Exception ex)
            {
                DI.log.error("in getTreeNodeWithAutoWiredObject:", ex.Message);
            }
            return new TreeNode();
        }

        public static void addIsCalledByMappings(ICirData cirData, ICirData fcdO2CirDataToProcess)
        {
            DI.log.debug("in addIsCalledByMappings");

            foreach (CirFunction cfCirFunction in fcdO2CirDataToProcess.dFunctions_bySignature.Values)
                foreach (ICirFunctionCall cirFunctionCalled in cfCirFunction.FunctionsCalled)
                {
                    if (cirData.dFunctions_bySignature.ContainsKey(cirFunctionCalled.cirFunction.FunctionSignature))
                    {
                        if (cirData.dFunctions_bySignature[cirFunctionCalled.cirFunction.FunctionSignature].HasControlFlowGraph)            // not sure about this
                        {
                           /* DI.log.info("Added isCalledByMapping: {0} is called by {1}",
                                        cirData.dFunctions_bySignature[cirFunctionCalled.FunctionSignature].FunctionSignature, cfCirFunction.FunctionSignature);*/
                            cirData.dFunctions_bySignature[cirFunctionCalled.cirFunction.FunctionSignature].FunctionIsCalledBy.Add(cirFunctionCalled);
                        }
                    }
                }
        }

 private static void fixFunctionsCalledXRefs(ICirData cirData)
 {
     if (cirData != null && cirData.dFunctions_bySignature != null)
     {
         var timer = new O2Timer("fixFunctionsCalledXRefs").start();
         foreach (CirFunction cirFunction in cirData.dFunctions_bySignature.Values)
         {
             if (cirFunction.FunctionName == null)
             {
                 var filteredSignature = new FilteredSignature(cirFunction.FunctionSignature);
                 cirFunction.FunctionName = filteredSignature.sFunctionName;
                 cirFunction.FunctionNameAndParameters = filteredSignature.sFunctionNameAndParams;
                 cirFunction.ClassNameFunctionNameAndParameters = filteredSignature.sFunctionClass + "." +
                                                                  filteredSignature.sFunctionNameAndParams;
             }
         }
         timer.stop();
     }
 }

        // this doesn't seem to be working since when I save this back into disk, the size of the .CirData file increases!
/*        public static void removeClassesWithNoControlFlowGraphs(ICirData cirData)
        {
            cirData.dClasses_bySymbolDef.Clear();
            cirData.dFunctions_bySymbolDef.Clear();
            cirData.dSymbols.Clear();
            var signaturesToRemove = new List<String>();
            int originalSignatureCount = cirData.dClasses_bySignature.Keys.Count;
            // remove CirClasses with no ControlFlowGraphs
            foreach (CirClass cirClass in cirData.dClasses_bySignature.Values)
                if (false == cirClass.bClassHasMethodsWithControlFlowGraphs)
                    signaturesToRemove.Add(cirClass.Signature);
            foreach (string signature in signaturesToRemove)
                cirData.dClasses_bySignature.Remove(signature);
            DI.log.info(
                "Originally there were {0} CirClass Objects in CirData file and now there are {1} ({2} were deleted)",
                originalSignatureCount, cirData.dClasses_bySignature.Keys.Count,
                originalSignatureCount - cirData.dClasses_bySignature.Keys.Count);

            // remove CirFunctions with no ControlFlowGraphs
            signaturesToRemove.Clear();
            originalSignatureCount = cirData.dFunctions_bySignature.Values.Count;
            foreach (CirFunction cirFunction in cirData.dFunctions_bySignature.Values)
                if (false == cirFunction.HasControlFlowGraph)
                    signaturesToRemove.Add(cirFunction.FunctionSignature);
            foreach (string signature in signaturesToRemove)
                cirData.dFunctions_bySignature.Remove(signature);
            DI.log.info(
                "Originally there were {0} CirFunction Objects in CirData file and now there are {1} ({2} were deleted)",
                originalSignatureCount, cirData.dFunctions_bySignature.Keys.Count,
                originalSignatureCount - cirData.dFunctions_bySignature.Keys.Count);
        }*/

        public static void saveSerializedO2CirDataObjectToFile(ICirData cirData, String sTargetFile)
        {
            if (cirData == null)
                return;

            if (sTargetFile == "")
                sTargetFile = DI.config.TempFileNameInTempDirectory + ".xml";

            try
            {
                var bfBinaryFormatter = new BinaryFormatter();

                var fsFileStream = new FileStream(sTargetFile, FileMode.Create);
                bfBinaryFormatter.Serialize(fsFileStream, cirData);
                fsFileStream.Close();
                DI.log.debug("Serialized O2CirData Saved to: {0}", sTargetFile);
            }
            catch (Exception ex)
            {
                DI.log.error("In saveSerializedO2CirDataObjectToFile: {0}", ex.Message);
            }
        }