return ret;
}
- /** the empty sequence (matches the empty string) */
- public static Sequence newEmptySequence() { return new Sequence.Constant.Empty(); }
+ /** create an empty sequence (matches the empty string) */
+ public static Sequence create() { return new Sequence.Constant.Empty(); }
- /** after matching the sequence, do not add anything to the output tree */
- public static Sequence newDropSequence(Element[] e) { return new Constant.Drop(e); }
+ /** create a sequence of one element */
+ public static Sequence create(Element e) { return create(new Element[] { e }, 0); }
- /** after matching the sequence, insert a constant into the output tree */
- public static Sequence newConstantSequence(Element[] e, Object o) { return new Constant(e, o); }
+ /** create a sequence which drops the result of all but one of its element */
+ public static Sequence create(Element[] e, int which) { return new Singleton(e, which); }
- /** after matching the sequence, place the result of the <tt>idx</tt>th match in the output tree */
- public static Sequence newSingletonSequence(Element[] e, int idx) { return new Singleton(e, idx); }
- public static Sequence newSingletonSequence(Element e) { return newSingletonSequence(new Element[] { e }, 0); }
+ /** create a sequence which always evaluates to a constant result */
+ public static Sequence create(Element[] e, Object result) { return new Constant(e, result); }
/**
- * after matching the sequence, create the specified output tree
- * @param tag the tag for the output tree
- * @param e the elements to match
- * @param drops only elements of <tt>e</tt> whose corresponding <tt>boolean</tt> in <tt>drops</tt>
- * is <i>false</i> will be included in the output tree
+ * create a sequence (general form)
+ * @param head the head of the output tree
+ * @param e the elements to match
+ * @param drop only elements of <tt>e</tt> whose corresponding <tt>boolean</tt> in <tt>drops</tt>
+ * is <i>false</i> will be included in the output tree
+ * @param foster if true, all children of the last child (ie
+ * grandchildren) are promoted to children of this
+ * node; this is very useful for matching repetitions
**/
- public static Sequence newRewritingSequence(Object tag, Element[] e, boolean[] drops) {
- return new RewritingSequence(tag, e, drops); }
-
- public static Sequence newUnwrapSequence(Element[] e, Object tag, boolean[] drops) { return new Unwrap(e, tag, drops); }
+ public static Sequence create(Object head, Element[] e, boolean[] drop, boolean foster) {
+ return foster
+ ? new Unwrap(e, head, drop)
+ : new RewritingSequence(head, e, drop);
+ }
////////////////////////////////////////////////////////////////////////////////