/// <summary> /// Constructs a Function node based upon the XML specification /// </summary> /// <param name="FunctionNode"></param> /// <returns></returns> private GPNode CreateFunction(XmlNode FunctionNode) { XmlNode xmlType = FunctionNode.SelectSingleNode("Function"); XmlNodeList listParams = FunctionNode.SelectNodes("GPNode"); GPNodeFunction gpFunction = null; // // See if we have an ADF if (xmlType.InnerText == "ADF") { XmlNode xmlWhichADF = FunctionNode.SelectSingleNode("WhichFunction"); int WhichADF = Convert.ToInt32(xmlWhichADF.InnerText); gpFunction = new GPNodeFunctionADF(WhichADF, (byte)listParams.Count); } else if (xmlType.InnerText == "ADL") // Check for an ADL { XmlNode xmlWhichADL = FunctionNode.SelectSingleNode("WhichFunction"); int WhichADL = Convert.ToInt32(xmlWhichADL.InnerText); gpFunction = new GPNodeFunctionADL(WhichADL, (byte)listParams.Count); } else if (xmlType.InnerText == "ADR") // Check for an ADR { XmlNode xmlWhichADR = FunctionNode.SelectSingleNode("WhichFunction"); int WhichADR = Convert.ToInt32(xmlWhichADR.InnerText); gpFunction = new GPNodeFunctionADR(WhichADR, (byte)listParams.Count); } else { // // Get the correct function node type created GPNodeFunction func = (GPNodeFunction)m_FunctionSet[xmlType.InnerText.ToUpper()]; gpFunction = (GPNodeFunction)func.Clone(); } // // Build the list of parameters to this node foreach (XmlNode ParamNode in listParams) { gpFunction.Children.Add(ReadGPNode(ParamNode)); } return(gpFunction); }
/// <summary> /// This is a simple factory function that selects from the available /// list of functions and creates a class of that type. /// </summary> /// <param name="UseADF">Select from ADFs</param> /// <param name="StartADF">Which ADF to start choosing from</param> /// <param name="UseADL">Select from ADLs</param> /// <param name="StartADL">Which ADL to start choosing from</param> /// <param name="UseADR">Select from ADRs</param> /// <param name="StartADR">Which ADR to start choosing from</param> protected GPNode CreateNodeFunction(bool UseADF, int StartADF, bool UseADL, int StartADL, bool UseADR, int StartADR) { // // Add up all the different function types that we can choose from // *"Regular" function types sent over from the client // *ADFs // *ADLs // *ADRs int Count = m_Config.FunctionSet.Count; if (UseADF) { Count += m_Branch.Parent.ADF.Count - StartADF; } if (UseADL) { Count += m_Branch.Parent.ADL.Count - StartADL; } if (UseADR) { Count += m_Branch.Parent.ADR.Count - StartADR; } // // Randomly select from the function node choices. int Function = GPUtilities.rngNextInt(Count); // // See if we chose a "regular" function if (Function < m_Config.FunctionSet.Count) { GPNodeFunction Type = (GPNodeFunction)m_Config.FunctionSet[Function]; return((GPNodeFunction)Type.Clone()); } // // See if we chose an ADF Function -= m_Config.FunctionSet.Count; if (Function < (m_Branch.Parent.ADF.Count - StartADF)) { int WhichADF = StartADF + Function; byte NumberArgs = m_Branch.Parent.ADF[WhichADF].NumberArgs; GPNodeFunctionADF adfFunc = new GPNodeFunctionADF(WhichADF, NumberArgs); return(adfFunc); } // // See if we chose an ADL Function -= m_Config.ADFSet.Count; if (Function < (m_Branch.Parent.ADL.Count - StartADL)) { int WhichADL = StartADL + Function; byte NumberArgs = m_Branch.Parent.ADL[WhichADL].NumberArgs; GPNodeFunctionADL adlFunc = new GPNodeFunctionADL(WhichADL, NumberArgs); return(adlFunc); } // // See if we chose an ADR Function -= m_Config.ADLSet.Count; if (Function < (m_Branch.Parent.ADR.Count - StartADR)) { int WhichADR = StartADR + Function; byte NumberArgs = m_Branch.Parent.ADR[WhichADR].NumberArgs; GPNodeFunctionADR adrFunc = new GPNodeFunctionADR(WhichADR, NumberArgs); return(adrFunc); } return(null); }