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