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

        public void processAssemblyDefinition(ICirData cirData, AssemblyDefinition assemblyDefinition, string assemblyPath, bool decompileCodeIfNoPdb)
        {
            var tempSourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" + assemblyDefinition.Name.Name);
            if (cirData != null && assemblyDefinition != null)
            {                
                var typesInAssembly = CecilUtils.getTypes(assemblyDefinition);
                loadAndMapSymbols(assemblyDefinition, assemblyPath, decompileCodeIfNoPdb, tempSourceCodeFolder);
                // first map all types
                foreach (var typeInAssembly in typesInAssembly)
                    processTypeDefinition(cirData, typeInAssembly);

                //then map their interfaces
                foreach (var typeInAssembly in typesInAssembly)
                {
                    mapTypeInterfaces(cirData, typeInAssembly);                    
                }

                // finally decompile the code if needed
                /*if (decompileCodeIfNoPdb)
                {
                    var sourceCodeFolder = DI.config.getTempFolderInTempDirectory("_O2_DecompiledDotNet_" +assemblyDefinition.Name.Name);
                    foreach (var cirClass in cirData.dClasses_bySignature.Values)
                        if(cirClass.
                        new CecilDecompiler().decompile(typeInAssembly, sourceCodeFolder)
                }*/
            }
            else
                DI.log.error("in processAssemblyDefinition, either cirData or assemblyDefinition was null");
        }

 public void showClass(ICirClass cirClass, ICirData _cirData)
 {
     mapClass(cirClass, _cirData);
 }

        public ICirFunction processMethodReference(ICirData cirData, MethodReference methodReference, SequencePoint sequencePoint)
        {
            try
            {                
                var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodReference);
                var functionType = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType);
                var cirFunction = getCirFunction(cirData, functionSignature, functionType);

                cirFunction.CecilSignature = methodReference.ToString();
                cirFunction.ReturnType = methodReference.ReturnType.ReturnType.FullName;
                cirFunction.ParentClass = getCirClass(cirData, CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodReference.DeclaringType));
                cirFunction.ParentClassFullName = methodReference.DeclaringType.FullName;
                cirFunction.ParentClassName = methodReference.DeclaringType.Name;
                //
                cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Assembly.ToString() : "[NullModule]";
                //cirFunction.Module = (methodReference.DeclaringType.Module != null) ? methodReference.DeclaringType.Module.Name : "[NullModule]";
                cirFunction.FunctionName = methodReference.Name;
                cirFunction.FunctionNameAndParameters = CecilUtils.getMethodNameAndParameters(methodReference);                

                cirFunction.ClassNameFunctionNameAndParameters = string.Format("{0}.{1}",
                                                                               cirFunction.ParentClassFullName,
                                                                               cirFunction.FunctionNameAndParameters);
                cirFunction.SymbolDef = Guid.NewGuid().ToString();
                /*if (sequencePoint != null)
                {
                    if (string.IsNullOrEmpty(cirFunction.File) == false)
                    { 
                    }
                    cirFunction.File = sequencePoint.Document.Url;
                    cirFunction.FileLine = sequencePoint.StartColumn.ToString();
                }*/
                
               
                //methodReference.ReturnType  // to implement since we need to add reference to a CirClass
                return cirFunction;
            }
            catch (Exception ex)
            {
                DI.log.ex(ex, "in CirFactory.processMethodReference", true);
                return null;
            }

        }

        public ICirFunction processMethodDefinition(ICirData cirData, MethodDefinition methodDefinition, SequencePoint sequencePoint)
        {
            try
            {
                //var functionSignature = methodDefinition.ToString();
                var functionSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(methodDefinition);
                var functionClass = CirFactoryUtils.getTypeUniqueSignatureFromTypeReference(methodDefinition.DeclaringType);
                var cirFunction = getCirFunction(cirData, functionSignature, functionClass);
                if (false == cirFunction.HasBeenProcessedByCirFactory)
                {
                    if (methodDefinition.CustomAttributes != null && methodDefinition.CustomAttributes.Count > 0)
                    {
                        foreach (CustomAttribute customAttribute in methodDefinition.CustomAttributes)
                        {
                            var constructorSignature = CirFactoryUtils.getFunctionUniqueSignatureFromMethodReference(customAttribute.Constructor);
                            var cirAttribute = new CirAttribute(constructorSignature);
                            foreach (var constructorParameter in customAttribute.ConstructorParameters)
                            {
                                var type = constructorParameter.GetType().FullName;
                            }
                            if (customAttribute.Fields.Count > 0 || customAttribute.Properties.Count > 0)
                            {
                            }
                           // PublicDI.log.debug("Added attribute {0} to {1}", customAttribute.Constructor.Name, cirFunction.FunctionName);
                            cirFunction.FunctionAttributes.Add(cirAttribute);
                        }
                    }
                    

                    // map the common values with MethodReference
                    processMethodReference(cirData, methodDefinition, sequencePoint);

                    cirFunction.HasBeenProcessedByCirFactory = true;  // we need to put this in here or we will have an infinite loop on recursive functions
                    cirFunction.HasControlFlowGraph = true;           // ControlFlowGraph is use by the Viewers to determine if we have more than just a reference to this method
                    cirFunction.ParentClass.bClassHasMethodsWithControlFlowGraphs = true;  // also mark the parent class

                    cirFunction.IsStatic = methodDefinition.IsStatic;
                    cirFunction.IsUnmanaged = methodDefinition.IsUnmanaged;
                    cirFunction.IsUnmanagedExport = methodDefinition.IsUnmanagedExport;
                    cirFunction.IsVirtual = methodDefinition.IsVirtual;
                    cirFunction.IsSetter = methodDefinition.IsSetter;
                    cirFunction.IsGetter = methodDefinition.IsGetter;
                    cirFunction.IsRuntime = methodDefinition.IsRuntime;
                    cirFunction.IsPublic = methodDefinition.IsPublic;
                    cirFunction.IsPrivate = methodDefinition.IsPrivate;
                    cirFunction.IsPInvokeImpl = methodDefinition.IsPInvokeImpl;
                    cirFunction.IsNative = methodDefinition.IsNative;
                    cirFunction.IsManaged = methodDefinition.IsManaged;
                    cirFunction.IsInternalCall = methodDefinition.IsInternalCall;
                    cirFunction.IsIL = methodDefinition.IsIL;
                    cirFunction.IsConstructor = methodDefinition.IsConstructor;
                    cirFunction.IsAbstract = methodDefinition.IsAbstract;
                    cirFunction.HasSecurity = methodDefinition.HasSecurity;
                    cirFunction.HasBody = methodDefinition.HasBody;

                    // try to find the location of the current method by going for the first line of the first method
                    if (methodDefinition.HasBody)
                        foreach (Instruction instruction in methodDefinition.Body.Instructions)
                            if (instruction.SequencePoint != null )
                            {
                                cirFunction.File = instruction.SequencePoint.Document.Url;
                                if (instruction.SequencePoint.StartLine == 16707566) // means there is no source code ref                                
                                    cirFunction.FileLine = "0";
                                else
                                    cirFunction.FileLine = instruction.SequencePoint.StartLine.ToString();
                                break;
                            }
                    
                    // map method parameters (this could be on the MethodReference but if so we would have to check for doing it more than once:
                    foreach (ParameterDefinition parameter in methodDefinition.Parameters)
                    {
                        ICirFunctionParameter functionParameter = new CirFunctionParameter
                        {
                            ParameterName = parameter.ToString(),
                            ParameterType = parameter.ParameterType.FullName,
                            Constant = (parameter.Constant != null) ? parameter.Constant.ToString() : "",
                            HasConstant = parameter.HasConstant,
                            HasDefault = parameter.HasDefault,
                            Method = parameter.Method.ToString()
                        };

                        cirFunction.FunctionParameters.Add(functionParameter);
                    }

                    // map the calls made and the IsCalledBy                   
                    foreach (var methodCalled in CecilUtils.getMethodsCalledInsideMethod(methodDefinition))
                    {
                        ICirFunction cirCalledFunction = processMemberReference(cirData, methodCalled.memberReference, methodCalled.sequencePoint);

                        if (cirCalledFunction != null)
                        {
                            // store the fucntion called sequence
                            cirFunction.FunctionsCalled.Add(new CirFunctionCall(cirCalledFunction,methodCalled.sequencePoint)); 
                            // store the unique list of funcions called
                            if (false == cirFunction.FunctionsCalledUniqueList.Contains(cirCalledFunction))
                                cirFunction.FunctionsCalledUniqueList.Add(cirCalledFunction);

                            // map the FunctionCalled and FunctionIsCalledBy

                            var cirFunctionCall = new CirFunctionCall(cirCalledFunction, sequencePoint);
//.........这里部分代码省略.........

 internal string processAssemblyAndSaveAsCirDataFile(ICirData cirData, string fileToProcess, string directoryToSaveCirDataFile, bool decompileCodeIfNoPdb)
 {
     processAssemblyDefinition(cirData, fileToProcess, decompileCodeIfNoPdb);
     if (cirData.dClasses_bySignature.Count == 0)
         DI.log.error("There were no classes in created cirData file, so canceling save");
     else
     {
         Files.checkIfDirectoryExistsAndCreateIfNot(directoryToSaveCirDataFile);
         var savedFileName = Path.Combine(directoryToSaveCirDataFile,Path.GetFileName(fileToProcess) + ".CirData");
         CirDataUtils.saveSerializedO2CirDataObjectToFile(cirData, savedFileName);
         return savedFileName;
     }
     return "";
 }