XLibrary.XNodeIn.AddFunctionCall C# (CSharp) Method

        internal void AddFunctionCall(ref SharedDictionary<FunctionCall> map, int nodeId, FunctionCall call)
        {
            if (map == null)
                map = new SharedDictionary<FunctionCall>(1);

            if (!map.Contains(nodeId))
                map.Add(nodeId, call);
        }

        public static FunctionCall CreateNewCall(int hash, int sourceID, XNodeIn dest)
        {
            var call = new FunctionCall() { ID = hash, Source = sourceID, Destination = dest.ID };
            CallMap.Add(hash, call);

            // add link to node that its been called
            dest.AddFunctionCall(ref dest.CalledIn, sourceID, call);

            var source = Nodes[sourceID];
            source.AddFunctionCall(ref source.CallsOut, dest.ID, call);

            //***** new location of create of class to class add function call

            CreateLayerCall(source, dest);

            if (Remote != null)
                foreach (var client in Remote.SyncClients)
                    lock(client.NewCalls)
                        client.NewCalls.Add(new Tuple<int, int>(sourceID, dest.ID));

            CallChange = true;

            if (!ClassTracking)
                return call;

            var srcNode = Nodes[call.Source];
            if (srcNode == null)
                return call;

            var sourceClass = GetContainingClass(srcNode) as XNodeIn;
            var destClass = GetContainingClass(dest) as XNodeIn;

            if (sourceClass == destClass)
                return call;

            if (destClass.ObjType != XObjType.Class || sourceClass.ObjType != XObjType.Class)
            {
                LogError("parent not class type, {0} and {1}", destClass.ObjType, sourceClass.ObjType);
                return call;
            }

            hash = sourceClass.ID * FunctionCount + destClass.ID;

            call.ClassCallHash = hash;

            //LogError("Adding to class map {0} -> {1} with hash {2}", sourceClass.ID, destClass.ID, hash);

            var classCall = new FunctionCall() { ID = hash, Source = sourceClass.ID, Destination = destClass.ID };
            ClassCallMap.Add(hash, classCall);

            destClass.AddFunctionCall(ref destClass.CalledIn, sourceClass.ID, classCall);
            sourceClass.AddFunctionCall(ref sourceClass.CallsOut, destClass.ID, classCall);

            return call;
        }