Java ASTNode.getChildCount方法代码示例

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
/**
 * Recursive function to change time variable to t
 */
public static void setTimeToT(ASTNode node)
{
	if (node == null)
	{
		return;
	}
	if (node.getType() == ASTNode.Type.NAME_TIME)
	{
		if (node.getName()==null || !node.getName().equals("t") || !node.getName().equals("time"))
		{
			node.setName("t");
		}
	}
	else if (node.getType() == ASTNode.Type.NAME_AVOGADRO)
	{
		node.setName("avogadro");
	}
	for (int c = 0; c < node.getChildCount(); c++)
	{
		setTimeToT(node.getChild(c));
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static ASTNode removePreset(ASTNode math, String place)
{
	if (math.getType() == ASTNode.Type.LOGICAL_AND)
	{
		ASTNode rightChild = math.getRightChild();
		if (rightChild.getType() == ASTNode.Type.RELATIONAL_EQ && rightChild.getLeftChild().toFormula().equals(place))
		{
			return deepCopy(math.getLeftChild());
		}
	}
	for (int i = 0; i < math.getChildCount(); i++)
	{
		ASTNode child = removePreset(math.getChild(i), place);
		math.replaceChild(i, child);
	}
	return deepCopy(math);
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static ASTNode removeBoolean(ASTNode math, String boolVar)
{
	if (math == null)
	{
		return null;
	}
	if (math.getType() == ASTNode.Type.RELATIONAL_EQ)
	{
		if (math.getLeftChild().isSetName() && math.getLeftChild().getName().equals(boolVar))
		{
			return deepCopy(math.getLeftChild());
		}
	}
	for (int i = 0; i < math.getChildCount(); i++)
	{
		ASTNode child = removeBoolean(math.getChild(i), boolVar);
		math.replaceChild(i, child);
	}
	return deepCopy(math);
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static void replaceArgument(ASTNode formula, String bvar, ASTNode arg)
{
	int n = 0;
	for (int i = 0; i < formula.getChildCount(); i++)
	{
		ASTNode child = formula.getChild(i);
		if (child.isSetName() && child.getName().equals(bvar))
		{
			formula.replaceChild(n, deepCopy(arg));
		}
		else if (child.getChildCount() > 0)
		{
			replaceArgument(child, bvar, arg);
		}
		n++;
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
/**
 * recursively puts every astnode child into the arraylist passed in
 * 
 * @param node
 * @param nodeChildrenList
 */
protected static void getAllASTNodeChildren(ASTNode node, ArrayList<ASTNode> nodeChildrenList)
{

	for (int i = 0; i < node.getChildCount(); i++)
	{
		ASTNode child = node.getChild(i);
		if (child.getChildCount() == 0)
		{
			nodeChildrenList.add(child);
		}
		else
		{
			nodeChildrenList.add(child);
			getAllASTNodeChildren(child, nodeChildrenList);
		}
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static void getAllASTNodeChildren(ASTNode node, ArrayList<ASTNode> nodeChildrenList)
{

	ASTNode child;
	long size = node.getChildCount();

	if (node.getChildCount() == 0)
	{
		nodeChildrenList.add(node);
	}

	for (int i = 0; i < size; i++)
	{
		// TODO:check this
		child = node.getChild(i);
		nodeChildrenList.add(child);
		getAllASTNodeChildren(child, nodeChildrenList);
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static ASTNode[] splitMath(ASTNode math)
{
	ASTNode plus = new ASTNode(Type.PLUS);
	ASTNode minus = new ASTNode(Type.PLUS);
	ASTNode[] result = new ASTNode[] { plus, minus };
	List<ASTNode> nodes = RateSplitterInterpreter.parseASTNode(math);
	for (ASTNode node : nodes)
	{
		if (node.getType() == ASTNode.Type.MINUS)
		{
			minus.addChild(node.getChild(0));
		}
		else
		{
			plus.addChild(node);
		}
	}

	return plus.getChildCount() > 0 && minus.getChildCount() > 0 ? result : null;
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
/**
 * recursively puts every astnode child into the arraylist passed in
 * 
 * @param node
 * @param nodeChildrenList
 */
protected void getAllASTNodeChildren(ASTNode node, ArrayList<ASTNode> nodeChildrenList)
{

	for (ASTNode child : node.getChildren())
	{

		if (child.getChildCount() == 0)
		{
			nodeChildrenList.add(child);
		}
		else
		{
			nodeChildrenList.add(child);
			getAllASTNodeChildren(child, nodeChildrenList);
		}
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public void replaceArgument(ASTNode formula, String bvar, ASTNode arg)
{
	int n = 0;
	for (int i = 0; i < formula.getChildCount(); i++)
	{
		ASTNode child = formula.getChild(i);
		if (child.isString() && child.getName().equals(bvar))
		{
			formula.replaceChild(n, arg.clone());
		}
		else if (child.getChildCount() > 0)
		{
			replaceArgument(child, bvar, arg);
		}
		n++;
	}
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
private LinkedList<String> parseMathHelper(ASTNode astNode) {
	LinkedList<String> inputs = new LinkedList<String>();
	if (!astNode.isOperator() && !astNode.isNumber())
		inputs.add(astNode.getName());
	for (int i = 0; i < astNode.getChildCount(); i++) {
		inputs.addAll(parseMathHelper(astNode.getListOfNodes().get(i)));
	}
	return inputs;
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public ASTNode replaceParams(ASTNode formula, HashMap<String,String> parameters) {
	if (formula.getChildCount() > 0) {
		for (int i = 0; i < formula.getChildCount(); i ++) {
			formula.replaceChild(i, replaceParams(formula.getChild(i), parameters));
		}
	}
	else if (parameters.keySet().contains(formula.getName())) {
		return SBMLutilities.myParseFormula(parameters.get(formula.getName()));
	}
	return formula;
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public String removeBooleanAssign(ASTNode math) {
	if (math.getType() == ASTNode.Type.FUNCTION_PIECEWISE && math.getChildCount() > 1) {
		ASTNode result = math.getChild(1);
		for (int j = 0; j < sbml.getModel().getParameterCount(); j++) {
			Parameter parameter = sbml.getModel().getParameter(j);
			if (SBMLutilities.isBoolean(parameter)) {
				result = SBMLutilities.removeBoolean(result,parameter.getId());
			}
		}
		return SBMLutilities.myFormulaToString(result);
	}
	return SBMLutilities.myFormulaToString(math);
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static boolean isBoolean(SBMLDocument document, ASTNode node)
{
	if (node == null)
	{
		return false;
	}
	else if (node.isBoolean())
	{
		return true;
	}
	else if (node.getType() == ASTNode.Type.FUNCTION)
	{
		FunctionDefinition fd = document.getModel().getFunctionDefinition(node.getName());
		if (fd != null && fd.isSetMath())
		{
			return isBoolean(document, fd.getMath().getRightChild());
		}
		return false;
	}
	else if (node.getType() == ASTNode.Type.FUNCTION_PIECEWISE)
	{
		for (int c = 0; c < node.getChildCount(); c += 2)
		{
			if (!isBoolean(document, node.getChild(c)))
			{
				return false;
			}
		}
		return true;
	}
	return false;
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
public static String SBMLMathToBoolLPNString(ASTNode math, HashMap<String, Integer> constants, ArrayList<String> booleans)
{
	if (math.getType() == ASTNode.Type.FUNCTION_PIECEWISE && math.getChildCount() > 1)
	{
		return SBMLMathToLPNString(math.getChild(1), constants, booleans);
	}
	return SBMLMathToLPNString(math, constants, booleans);
}
 

import org.sbml.jsbml.ASTNode; //导入方法依赖的package包/类
private ASTNode replaceFunctionDefinition(ASTNode equation, ListOf<FunctionDefinition> functions) {
	if (equation.getType() == ASTNode.Type.FUNCTION) {
		FunctionDefinition fd = functions.get(equation.getName());
		ASTNode newNode = fd.getBody();
		for (int i = 0; i < fd.getArgumentCount(); i++) {
			newNode = replace(fd.getArgument(i).getName(), equation.getChild(i), newNode);
		}
		return newNode;
	}
	for (int i = 0; i < equation.getChildCount(); i++) {
		equation.replaceChild(i, replaceFunctionDefinition(equation.getChild(i), functions));
	}
	return equation;
}