@Override
public void deactivate() {
BaseNode node = this.children.get(this.currentChild);
if (node != null) {
node.deactivate();
} else {
throw new NullPointerException(
"Deactivating Sequence node no effect! There is no child attached.");
}
}
/**
* Time Complexity::O(log n),n=number of elements present.<br>
* Memory::O(log n),for traversing stack is formed<br>
* You can optimize it using user_defined stack.
*/
void insertTree(UraInstantiator uraI, BaseNode p, BaseNode root) {
if ((tmp2.nodeIndex < p.nodeIndex)) {
if (p.left != null) {
insertTree(uraI, p.left, p);
} else {
p.left = tmp2;
tmp2 = null;
}
if ((insertFlag == true) && (vMFlag == true)) {
p.nodeIndex += 1l;
p.vMFactor += 1l;
}
} else {
long tmpnode = tmp2.nodeIndex;
tmpnode -= p.vMFactor;
if (tmp2.nodeIndex == p.nodeIndex) {
insertFlag = true;
ClientData temp = p.data;
p.data = tmp2.data;
tmp2.data = temp;
p.vMFactor += 1l;
}
tmp2.nodeIndex = tmpnode;
if (p.right != null) {
insertTree(uraI, p.right, p);
} else {
p.right = tmp2;
tmp2 = null;
}
vMFlag = true;
}
uraI.getBaseStructure().checkForUnbalancing(uraI, p, root);
}
void insert1(UraInstantiator uraI, long node, ClientData data, BaseNode p) {
if (node >= 0l) {
insertFlag = false;
vMFlag = false;
tmp2 = new BaseNode();
tmp2.nodeIndex = node;
tmp2.data = data;
if (rootTREE == null) {
rootTREE = new BaseNode();
rootTREE.left = tmp2;
} else {
insertTree(uraI, rootTREE.left, rootTREE);
}
} else System.out.println(" NEGATIVE INDEX ARE NOT ACCEPTED");
}
@Override
public void write(Element element, Project project) throws CantSaveSomethingException {
super.write(element, project);
Element filterXML = new Element(FILTER);
filterXML.setAttribute(CLASS_NAME, myFilter.getClass().getName());
element.addContent(filterXML);
}
@Override
public void read(Element element, Project project) throws CantLoadSomethingException {
super.read(element, project);
Element filterXML = element.getChild(FILTER);
String filterName = filterXML.getAttribute(CLASS_NAME).getValue();
try {
Class filterClass = null;
for (Language l : project.getProjectModules(Language.class)) {
filterClass = ClassLoaderManager.getInstance().getClass(l, filterName);
if (filterClass != null) break;
}
if (filterClass == null) {
try {
filterClass = Class.forName(filterName);
} catch (ClassNotFoundException e) {
filterClass = null;
}
}
if (filterClass != null) {
myFilter = (BaseFilter) filterClass.newInstance();
} else {
throw new CantLoadSomethingException("Can't find filter class " + filterName);
}
} catch (Throwable t) {
throw new CantLoadSomethingException("Can't instantiate or read filter " + filterName, t);
}
}
/**
* Make a new cast node with a target type and an expression, which is immediately marked as
* resolved Only to be called by type adjusting, after tree was already resolved
*
* @param coords The source code coordinates.
* @param targetType The target type.
* @param expr The expression to be casted.
* @param resolveResult Resolution result (should be true)
*/
public CastNode(Coords coords, TypeNode targetType, ExprNode expr, BaseNode parent) {
this(coords, targetType, expr);
parent.becomeParent(this);
resolve();
check();
}
/** @see de.unika.ipd.grgen.ast.BaseNode#resolveLocal() */
@Override
protected boolean resolveLocal() {
boolean successfullyResolved = true;
if (typeUnresolved instanceof PackageIdentNode)
Resolver.resolveOwner((PackageIdentNode) typeUnresolved);
else fixupDefinition(typeUnresolved, typeUnresolved.getScope());
type = typeResolver.resolve(typeUnresolved, this);
successfullyResolved = type != null && successfullyResolved;
return successfullyResolved;
}
/**
* Rectify the indexes beyond currently inserted .<br>
* <br>
* Time:: O(log n)
*/
void findAndCorrect(long node, BaseNode tmp) {
if (tmp != null) {
if (node < tmp.nodeIndex) {
findAndCorrect(node, tmp.left);
if (maxFlag == true) {
tmp.nodeIndex -= 1l;
tmp.vMFactor -= 1l;
}
} else if (node == tmp.nodeIndex) {
if (tmp.right != null) {
tmp.vMFactor -= 1l;
} else {
tmp.vMFactor = 0l;
}
maxFlag = true;
} else {
findAndCorrect(node - tmp.vMFactor, tmp.right);
}
} else {
// It's a bug.'
}
}
public void addChild(BaseLeaf child) {
assert (myChildren.isEmpty());
super.addChild(child);
}
public String toString() {
return node._get_nodeid() + "." + fieldName;
}
@Override
public void addChild(BaseNode child) {
this.children.add(child);
child.setParent(this);
}
