private static Op simplify(Op op) { return Transformer.transform(simplify, op) ; }
protected Op transformation(ApplyTransformVisitor transformApply, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { if ( op == null ) { Log.warn(this, "Attempt to transform a null Op - ignored") ; return op ; } return applyTransformation(transformApply, op, beforeVisitor, afterVisitor) ; }
/** Transformation with specific Transform and default ExprTransform (apply transform inside pattern expressions like NOT EXISTS) */ public static Op transform(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { return get().transformation(transform, op, beforeVisitor, afterVisitor) ; }
/** Transform an algebra expression except skip (leave alone) any OpService nodes */ public static Op transformSkipService(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { // Skip SERVICE if ( true ) { // Simplest way but still walks the OpService subtree (and throws away the transformation). transform = new TransformSkipService(transform) ; return Transformer.transform(transform, op, beforeVisitor, afterVisitor) ; } else { // Don't transform OpService and don't walk the sub-op ApplyTransformVisitorServiceAsLeaf v = new ApplyTransformVisitorServiceAsLeaf(transform) ; WalkerVisitorSkipService walker = new WalkerVisitorSkipService(v, beforeVisitor, afterVisitor) ; OpWalker.walk(walker, op, v) ; return v.result() ; } }
/** Transform an algebra expression except skip (leave alone) any OpService nodes */ public static Op transformSkipService(Transform transform, Op op) { return transformSkipService(transform, op, null, null) ; }
protected Op transformation(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { ApplyTransformVisitor v = new ApplyTransformVisitor(transform) ; return transformation(v, op, beforeVisitor, afterVisitor) ; }
/** Transform an algebra expression except skip (leave alone) any OpService nodes */ public static Op transformSkipService(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { // Skip SERVICE if ( true ) { // Simplest way but still walks the OpService subtree (and throws away the transformation). Transform walker = new TransformSkipService(transform) ; return Transformer.transform(walker, op, beforeVisitor, afterVisitor) ; } else { // Don't transform OpService and don't walk the sub-op ExprTransform exprTransform = new ExprTransformApplyTransform(transform, beforeVisitor, afterVisitor) ; ApplyTransformVisitorServiceAsLeaf v = new ApplyTransformVisitorServiceAsLeaf(transform, exprTransform) ; WalkerVisitorSkipService walker = new WalkerVisitorSkipService(v, beforeVisitor, afterVisitor) ; OpWalker.walk(walker, op) ; return v.result() ; } }
Op op2 = Transformer.transformSkipService(transform, op) ;
protected Op transformation(Transform transform, ExprTransform exprTransform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { ApplyTransformVisitor v = new ApplyTransformVisitor(transform, exprTransform) ; return transformation(v, op, beforeVisitor, afterVisitor) ; }
protected static Op simplify(Op op) { return Transformer.transform(simplify, op) ; }
/** Transformation with specific Transform and ExprTransform applied */ public static Op transform(Transform transform, ExprTransform exprTransform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { return get().transformation(transform, exprTransform, op, beforeVisitor, afterVisitor) ; }
Op op2 = Transformer.transformSkipService(transform, op) ;
protected Op transformation(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { ExprTransform exprTransform = new ExprTransformApplyTransform(transform, beforeVisitor, afterVisitor) ; return transformation(transform, exprTransform, op, beforeVisitor, afterVisitor) ; }
protected Op transformation(ApplyTransformVisitor transformApply, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { if ( op == null ) { Log.warn(this, "Attempt to transform a null Op - ignored") ; return op ; } return applyTransformation(transformApply, op, beforeVisitor, afterVisitor) ; }
@Override protected Op modifyOp(Op op) { // Just property functions Transform t = new TransformPropertyFunction(context) ; op = Transformer.transform(t, op) ; return op ; }
public static Op transform(Transform transform, Op op, OpVisitor beforeVisitor, OpVisitor afterVisitor) { return get().transformation(transform, op, beforeVisitor, afterVisitor) ; }
public static Op quadize(Op op) { final Stack<Node> stack = new Stack<Node>() ; stack.push(Quad.defaultGraphNodeGenerated) ; // Starting condition OpVisitor before = new Pusher(stack) ; OpVisitor after = new Popper(stack) ; TransformQuadGraph qg = new TransformQuadGraph(stack) ; return Transformer.transformSkipService(qg, op, before, after) ; }
/** Do a node->node conversion of an Op - return original BGP for "no change" */ public static Op transform(NodeTransform nodeTransform, Op op) { Transform opTransform = new NodeTransformOp(nodeTransform) ; return Transformer.transform(opTransform, null, op) ; // No expr transform - we do it ourselves. }
/** Transform an algebra expression */ public static Op transform(Transform transform, Op op) { return get().transformation(transform, op, null, null) ; }
public static Op quadize(Op op) { final Deque<QuadSlot> stack = new ArrayDeque<QuadSlot>() ; QuadSlot qSlot = new QuadSlot(Quad.defaultGraphNodeGenerated, Quad.defaultGraphNodeGenerated) ; stack.push(qSlot) ; // Starting condition OpVisitor before = new Pusher(stack) ; OpVisitor after = new Popper(stack) ; TransformQuadGraph qg = new TransformQuadGraph(stack) ; return Transformer.transformSkipService(qg, op, before, after) ; }