/// <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 showDataForSignature(String sSignature)
        {
            // check if this function is on the current list (if not this is an edge)
            if (false == cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignature))
            // this case do a hack by adding this edge as a function
            {
                var lsFunctionsThatCallSignature = new List <ICirFunctionCall>();
                // first find everybody that calls into it
                foreach (ICirFunction ccFunction in cirDataAnalysis.dCirFunction_bySignature.Values)
                {
                    if (cirDataAnalysis.dCirFunction_bySignature.ContainsKey(sSignature))
                    {
                        if (ccFunction.FunctionsCalledUniqueList.Contains(cirDataAnalysis.dCirFunction_bySignature[sSignature]))
                        {
                            lsFunctionsThatCallSignature.Add(new CirFunctionCall(ccFunction));
                        }
                    }
                }

                var ccNewCirFunction = new CirFunction
                {
                    FunctionSignature  = sSignature,
                    FunctionIsCalledBy = lsFunctionsThatCallSignature
                };
                cirDataAnalysis.dCirFunction_bySignature.Add(sSignature, ccNewCirFunction);
            }
            var          tvTraces          = new TreeView();
            var          lFunctionsCalled  = new List <string>();
            const string sFilter_Signature = "";
            const string sFilter_Parameter = "";

            if (cbSearchMode.SelectedItem.ToString() == SearchModes.CalledFunctions.ToString())
            {
                TraceAnalysis.calculateAllTracesFromFunction(sSignature, tvTraces.Nodes, lFunctionsCalled,
                                                             sFilter_Signature, sFilter_Parameter, false,
                                                             cirDataAnalysis);
            }
            else
            {
                TraceAnalysis.calculateAllTracesFromFunction(sSignature, tvTraces.Nodes, lFunctionsCalled,
                                                             sFilter_Signature, sFilter_Parameter, true, cirDataAnalysis);
            }
            if (cbViewMode.SelectedItem.ToString() == ViewModes.List.ToString())
            {
                afv_Functions.showSignatures(lFunctionsCalled);
            }
            else
            {
                replaceTreeView(this, ref tvTreeView, tvTraces);
                if (cbSearchMode.SelectedItem.ToString() == SearchModes.IsCalledBy.ToString())
                {
                    tvTreeView.ExpandAll();
                }
            }
        }