public void copyItemsetNode(TreeElement copyNode, TreeReference destRef, FormDef f)
{
TreeElement templateNode = getTemplate(destRef);
TreeElement newNode = this.copyNode(templateNode, destRef);
newNode.populateTemplate(copyNode, f);
}
//very similar to parent(), but assumes contextRef refers to a singular, existing node in the model
//this means we can do '/a/b/c + ../../d/e/f = /a/d/e/f', which we couldn't do in parent()
//return null if context ref is not absolute, or we parent up past the root node
//NOTE: this function still works even when contextRef contains INDEX_UNBOUND multiplicites... conditions depend on this behavior,
// even though it's slightly icky
public TreeReference anchor(TreeReference contextRef)
{
if (isAbsolute())
{
return(this.clone());
}
else if (!contextRef.isAbsolute())
{
return(null);
}
else
{
TreeReference newRef = contextRef.clone();
int contextSize = contextRef.size();
if (refLevel > contextSize)
{
return(null); //tried to do '/..'
}
else
{
for (int i = 0; i < refLevel; i++)
{
newRef.removeLastLevel();
}
for (int i = 0; i < size(); i++)
{
newRef.add(this.getName(i), this.getMultiplicity(i));
}
return(newRef);
}
}
}
//return a new reference that is this reference anchored to a passed-in parent reference
//if this reference is absolute, return self
//if this ref has 'parent' steps (..), it can only be anchored if the parent ref is a relative ref consisting only of other 'parent' steps
//return null in these invalid situations
public TreeReference parent(TreeReference parentRef)
{
if (isAbsolute())
{
return(this);
}
else
{
TreeReference newRef = parentRef.clone();
if (refLevel > 0)
{
if (!parentRef.isAbsolute() && parentRef.size() == 0)
{
parentRef.refLevel += refLevel;
}
else
{
return(null);
}
}
for (int i = 0; i < names.Count; i++)
{
newRef.add(this.getName(i), this.getMultiplicity(i));
}
return(newRef);
}
}
public TreeElement getTemplatePath(TreeReference ref_)
{
if (!ref_.isAbsolute())
{
return(null);
}
TreeElement node = root;
for (int i = 0; i < ref_.size(); i++)
{
String name = ref_.getName(i);
if (ref_.getMultiplicity(i) == TreeReference.INDEX_ATTRIBUTE)
{
node = node.getAttribute(null, name);
}
else
{
TreeElement newNode = node.getChild(name, TreeReference.INDEX_TEMPLATE);
if (newNode == null)
{
newNode = node.getChild(name, 0);
}
if (newNode == null)
{
return(null);
}
node = newNode;
}
}
return(node);
}
//TODO: merge anchor() and parent()
public TreeReference contextualize(TreeReference contextRef)
{
if (!contextRef.isAbsolute())
{
return(null);
}
TreeReference newRef = anchor(contextRef);
for (int i = 0; i < contextRef.size() && i < newRef.size(); i++)
{
//If the the contextRef can provide a definition for a wildcard, do so
if (TreeReference.NAME_WILDCARD.Equals(newRef.getName(i)) && !TreeReference.NAME_WILDCARD.Equals(contextRef.getName(i)))
{
newRef.names[i] = contextRef.getName(i);
}
if (contextRef.getName(i).Equals(newRef.getName(i)))
{
newRef.setMultiplicity(i, contextRef.getMultiplicity(i));
}
else
{
break;
}
}
return(newRef);
}
//returns true if 'this' is parent of 'child'
//return true if 'this' equals 'child' only if properParent is false
public Boolean isParentOf(TreeReference child, Boolean properParent)
{
if (refLevel != child.refLevel)
{
return(false);
}
if (child.size() < size() + (properParent ? 1 : 0))
{
return(false);
}
for (int i = 0; i < size(); i++)
{
if (!this.getName(i).Equals(child.getName(i)))
{
return(false);
}
int parMult = this.getMultiplicity(i);
int childMult = child.getMultiplicity(i);
if (parMult != INDEX_UNBOUND && parMult != childMult && !(i == 0 && parMult == 0 && childMult == INDEX_UNBOUND))
{
return(false);
}
}
return(true);
}
private ArrayList multiplicity; //ArrayList<Integer>
public static TreeReference rootRef()
{
TreeReference root = new TreeReference();
root.refLevel = REF_ABSOLUTE;
return(root);
}
//return a new reference that is this reference anchored to a passed-in parent reference
//if this reference is absolute, return self
//if this ref has 'parent' steps (..), it can only be anchored if the parent ref is a relative ref consisting only of other 'parent' steps
//return null in these invalid situations
public virtual TreeReference parent(TreeReference parentRef)
{
if (Absolute)
{
return(this);
}
else
{
TreeReference newRef = parentRef.Clone();
if (refLevel > 0)
{
if (!parentRef.Absolute && parentRef.size() == 0)
{
parentRef.refLevel += refLevel;
}
else
{
return(null);
}
}
for (TreeReferenceLevel l: data)
{
newRef.add(l.shallowCopy());
}
return(newRef);
}
}
public static TreeReference selfRef()
{
TreeReference self = new TreeReference();
self.refLevel = 0;
return(self);
}
public static TreeReference selfRef()
{
TreeReference self = new TreeReference();
self.refLevel = 0;
self.contextType = CONTEXT_INHERITED;
return(self);
}
public static TreeReference rootRef()
{
TreeReference root = new TreeReference();
root.refLevel = REF_ABSOLUTE;
root.contextType = CONTEXT_ABSOLUTE;
return(root);
}
/**
* clone and extend a reference by one level
* @param ref
* @param name
* @param mult
* @return
*/
public TreeReference extendRef(String name, int mult)
{
//TODO: Shouldn't work for this if this is an attribute ref;
TreeReference childRef = this.clone();
childRef.add(name, mult);
return(childRef);
}
/// <summary>Intersect this tree reference with another, returning a new tree reference
/// which contains all of the common elements, starting with the root element.
///
/// Note that relative references by their nature can't share steps, so intersecting
/// any (or by any) relative ref will result in the root ref. Additionally, if the
/// two references don't share any steps, the intersection will consist of the root
/// reference.
///
/// </summary>
/// <param name="b">The tree reference to intersect
/// </param>
/// <returns> The tree reference containing the common basis of this ref and b
/// </returns>
public virtual TreeReference intersect(TreeReference b)
{
if (!this.Absolute || !b.Absolute)
{
return(TreeReference.rootRef());
}
if (this.Equals(b))
{
return(this);
}
TreeReference a;
//A should always be bigger if one ref is larger than the other
if (this.size() < b.size())
{
a = b.Clone(); b = this.Clone();
}
else
{
a = this.Clone(); b = b.Clone();
}
//Now, trim the refs to the same length.
int diff = a.size() - b.size();
for (int i = 0; i < diff; ++i)
{
a.removeLastLevel();
}
int aSize = a.size();
//easy, but requires a lot of re-evaluation.
for (int i = 0; i <= aSize; ++i)
{
if (a.Equals(b))
{
return(a);
}
else if (a.size() == 0)
{
return(TreeReference.rootRef());
}
else
{
if (!a.removeLastLevel() || !b.removeLastLevel())
{
//I don't think it should be possible for us to get here, so flip if we do
throw new System.SystemException("Dug too deply into TreeReference during intersection");
}
}
}
//The only way to get here is if a's size is -1
throw new System.SystemException("Impossible state");
}
// same as resolveReference but return a vector containing all interstitial
// nodes: top-level instance data node first, and target node last
// returns null in all the same situations as resolveReference EXCEPT ref
// '/' will instead return empty vector
public ArrayList explodeReference(TreeReference ref_)
{
if (!ref_.isAbsolute())
{
return(null);
}
ArrayList nodes = new ArrayList();
TreeElement cur = root;
for (int i = 0; i < ref_.size(); i++)
{
String name = ref_.getName(i);
int mult = ref_.getMultiplicity(i);
//If the next node down the line is an attribute
if (mult == TreeReference.INDEX_ATTRIBUTE)
{
//This is not the attribute we're testing
if (cur != root)
{
//Add the current node
nodes.Add(cur);
}
cur = cur.getAttribute(null, name);
}
//Otherwise, it's another child element
else
{
if (mult == TreeReference.INDEX_UNBOUND)
{
if (cur.getChildMultiplicity(name) == 1)
{
mult = 0;
}
else
{
// reference is not unambiguous
return(null);
}
}
if (cur != root)
{
nodes.Add(cur);
}
cur = cur.getChild(name, mult);
if (cur == null)
{
return(null);
}
}
}
return(nodes);
}
//turn unambiguous ref into a generic ref
public TreeReference genericize()
{
TreeReference genericRef = clone();
for (int i = 0; i < genericRef.size(); i++)
{
genericRef.setMultiplicity(i, INDEX_UNBOUND);
}
return(genericRef);
}
public void templateData(FormInstance dm, TreeReference parentRef)
{
RestoreUtils.applyDataType(dm, "name", parentRef, typeof(String));
RestoreUtils.applyDataType(dm, "form-id", parentRef, typeof(int));
RestoreUtils.applyDataType(dm, "saved-on", parentRef,
Constants.DATATYPE_DATE_TIME);
RestoreUtils.applyDataType(dm, "schema", parentRef, typeof(String));
RestoreUtils.applyDataType(dm, "sent", parentRef, typeof(Boolean));
// don't touch data for now
}
public virtual TreeReference removePredicates()
{
TreeReference predicateless = Clone();
for (int i = 0; i < predicateless.data.size(); ++i)
{
predicateless.data.setElementAt(predicateless.data.elementAt(i).setPredicates(null), i);
}
return(predicateless);
}
//return a copy of the ref
public TreeReference clone()
{
TreeReference newRef = new TreeReference();
newRef.setRefLevel(this.refLevel);
for (int i = 0; i < this.size(); i++)
{
newRef.add(this.getName(i), this.getMultiplicity(i));
}
return(newRef);
}
// take in a potentially-ambiguous ref, and return a vector of refs for all nodes that match the passed-in ref
// meaning, search out all repeated nodes that match the pattern of the passed-in ref
// every ref in the returned vector will be unambiguous (no index will ever be INDEX_UNBOUND)
// does not return template nodes when matching INDEX_UNBOUND, but will match templates when INDEX_TEMPLATE is explicitly set
// return null if ref is relative, otherwise return vector of refs (but vector will be empty is no refs match)
// '/' returns {'/'}
// can handle sub-repetitions (e.g., {/a[1]/b[1], /a[1]/b[2], /a[2]/b[1]})
public List <TreeReference> expandReference(TreeReference ref_, Boolean includeTemplates)
{
if (!ref_.isAbsolute())
{
return(null);
}
List <TreeReference> v = new List <TreeReference>();
expandReference(ref_, root, v, includeTemplates);
return(v);
}
//turn unambiguous ref into a generic ref
public virtual TreeReference genericize()
{
TreeReference genericRef = Clone();
for (int i = 0; i < genericRef.size(); i++)
{
//TODO: It's not super clear whether template refs should get
//genericized or not
genericRef.setMultiplicity(i, INDEX_UNBOUND);
}
return(genericRef);
}
public TreeReference addNode(TreeReference ambigRef)
{
TreeReference ref_ = ambigRef.clone();
if (createNode(ref_) != null)
{
return(ref_);
}
else
{
return(null);
}
}
public TreeReference getParentRef()
{
//TODO: level
TreeReference ref_ = this.clone();
if (ref_.removeLastLevel())
{
return(ref_);
}
else
{
return(null);
}
}
public TreeReference relativize(TreeReference parent)
{
if (parent.isParentOf(this, false))
{
TreeReference relRef = selfRef();
for (int i = parent.size(); i < this.size(); i++)
{
relRef.add(this.getName(i), INDEX_UNBOUND);
}
return(relRef);
}
else
{
return(null);
}
}
public TreeReference copyNode(TreeReference from, TreeReference to)
{
if (!from.isAbsolute())
{
throw new InvalidReferenceException("Source reference must be absolute for copying", from);
}
TreeElement src = resolveReference(from);
if (src == null)
{
throw new InvalidReferenceException("Null Source reference while attempting to copy node", from);
}
return(copyNode(src, to).getRef());
}
public Boolean Equals(Object o)
{
if (this == o)
{
return(true);
}
else if (o is TreeReference)
{
TreeReference ref_ = (TreeReference)o;
if (this.refLevel == ref_.refLevel && this.size() == ref_.size())
{
for (int i = 0; i < this.size(); i++)
{
String nameA = this.getName(i);
String nameB = ref_.getName(i);
int multA = this.getMultiplicity(i);
int multB = ref_.getMultiplicity(i);
if (!nameA.Equals(nameB))
{
return(false);
}
else if (multA != multB)
{
if (i == 0 && (multA == 0 || multA == INDEX_UNBOUND) && (multB == 0 || multB == INDEX_UNBOUND))
{
// /data and /data[0] are functionally the same
}
else
{
return(false);
}
}
}
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
//return a copy of the ref
//UPGRADE_ISSUE: The equivalent in .NET for method 'java.lang.Object.clone' returns a different type. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1224'"
public virtual System.Object Clone()
{
TreeReference newRef = new TreeReference();
newRef.RefLevel = this.refLevel;
for (TreeReferenceLevel l: data)
{
newRef.add(l.shallowCopy());
}
//copy instances
newRef.InstanceName = instanceName;
newRef.Context = this.contextType;
return(newRef);
}
//TODO: merge anchor() and parent()
public virtual TreeReference contextualize(TreeReference contextRef)
{
//TODO: Technically we should possibly be modifying context stuff here
//instead of in the xpath stuff;
if (!contextRef.Absolute)
{
return(null);
}
// I think contextualizing of absolute nodes still needs to be done.
// They may contain predicates that need to be contextualized.
TreeReference newRef = anchor(contextRef);
// unclear...
newRef.Context = contextRef.Context;
//apply multiplicites and fill in wildcards as necessary based on the context ref
for (int i = 0; i < contextRef.size() && i < newRef.size(); i++)
{
//If the the contextRef can provide a definition for a wildcard, do so
if (TreeReference.NAME_WILDCARD.Equals(newRef.getName(i)) && !TreeReference.NAME_WILDCARD.Equals(contextRef.getName(i)))
{
newRef.data.setElementAt(newRef.data.elementAt(i).setName(contextRef.getName(i)), i);
}
if (contextRef.getName(i).Equals(newRef.getName(i)))
{
//We can't actually merge nodes if the newRef has predicates or filters
//on this expression, since those reset any existing resolutions which
//may have been done.
if (newRef.getPredicate(i) == null)
{
newRef.setMultiplicity(i, contextRef.getMultiplicity(i));
}
}
else
{
break;
}
}
return(newRef);
}
// take a ref that unambiguously refers to a single node and return that node
// return null if ref is ambiguous, node does not exist, ref is relative, or ref is '/'
// can be used to retrieve template nodes
public TreeElement resolveReference(TreeReference ref_)
{
if (!ref_.isAbsolute())
{
return(null);
}
TreeElement node = root;
for (int i = 0; i < ref_.size(); i++)
{
String name = ref_.getName(i);
int mult = ref_.getMultiplicity(i);
if (mult == TreeReference.INDEX_ATTRIBUTE)
{
//Should we possibly just return here?
//I guess technically we could step back...
node = node.getAttribute(null, name);
continue;
}
if (mult == TreeReference.INDEX_UNBOUND)
{
if (node.getChildMultiplicity(name) == 1)
{
mult = 0;
}
else
{
// reference is not unambiguous
node = null;
break;
}
}
node = node.getChild(name, mult);
if (node == null)
{
break;
}
}
return(node == root ? null : node); // never return a reference to '/'
}
public TreeReference addNode(TreeReference ambigRef, IAnswerData data, int dataType)
{
TreeReference ref_ = ambigRef.clone();
TreeElement node = createNode(ref_);
if (node != null)
{
if (dataType >= 0)
{
node.dataType = dataType;
}
node.setValue(data);
return(ref_);
}
else
{
return(null);
}
}
/// <summary> Returns the subreference of this reference up to the level specified.
///
/// Used to identify the reference context for a predicate at the same level
///
/// Must be an absolute reference, otherwise will throw IllegalArgumentException
///
/// </summary>
/// <param name="level">
/// </param>
/// <returns>
/// </returns>
public virtual TreeReference getSubReference(int level)
{
if (!this.Absolute)
{
throw new System.ArgumentException("Cannot subreference a non-absolute ref");
}
//Copy construct
TreeReference ret = new TreeReference();
ret.refLevel = this.refLevel;
ret.contextType = this.contextType;
ret.instanceName = this.instanceName;
ret.data = new List <TreeReferenceLevel>();
for (int i = 0; i <= level; ++i)
{
ret.data.addElement(this.data.elementAt(i));
}
return(ret);
}
