public Stream partition(Grouping grouping) {

        if(_node instanceof PartitionNode) {

            return each(new Fields(), new TrueFilter()).partition(grouping);

        } else {

        }

    }

    public Stream partition(Grouping grouping) {

        if(_node instanceof PartitionNode) {

            return each(new Fields(), new TrueFilter()).partition(grouping);

        } else {

        }

    }

                if(g1==null && !(e.source instanceof SpoutNode))

                    throw new RuntimeException("Planner exception: Null source group must indicate a spout node at this phase of planning");

                if(g1==null || !g1.equals(g2)) {

                    graph.removeEdge(e);

                    graph.addVertex(pNode);

                    graph.addEdge(e.source, pNode, new IndexedEdge(e.source, pNode, 0));

                    graph.addEdge(pNode, e.target, new IndexedEdge(pNode, e.target, e.index));                   

                }

            }

        }

        // if one group subscribes to the same stream with same partitioning multiple times,

        // merge those together (otherwise can end up with many output streams created for that partitioning

        // if need to split into multiple output streams because of same input having different

        // partitioning to the group)

       

        // this is because can't currently merge splitting logic into a spout

        // not the most kosher algorithm here, since the grouper indexes are being trounced via the adding of nodes to random groups, but it

        // works out

        List<Node> forNewGroups = new ArrayList<Node>();

        for(Group g: mergedGroups) {

            for(PartitionNode n: extraPartitionInputs(g)) {

                Node idNode = makeIdentityNode(n.allOutputFields);

                Node parentNode = TridentUtils.getParent(graph, n);

                Set<IndexedEdge> outgoing = graph.outgoingEdgesOf(n);

                graph.removeVertex(n);

               

                graph.addVertex(idNode);

   

    private static Collection<PartitionNode> uniquedSubscriptions(Set<PartitionNode> subscriptions) {

        Map<String, PartitionNode> ret = new HashMap();

        for(PartitionNode n: subscriptions) {

            if(curr!=null && !curr.thriftGrouping.equals(n.thriftGrouping)) {

                throw new RuntimeException("Multiple subscriptions to the same stream with different groupings. Should be impossible since that is explicitly guarded against.");

            }

            ret.put(n.streamId, n);

        }

            }

            grouped.get(n.streamId).add(n);

        }

        for(List<PartitionNode> group: grouped.values()) {

            for(int i=1; i<group.size(); i++) {

                if(!n.thriftGrouping.equals(anchor.thriftGrouping)) {

                    ret.add(n);

                }

            }

        }

        return ret;

    }   

   

    private static PartitionNode makeIdentityPartition(Node basis) {

            Grouping.custom_serialized(Utils.serialize(new IdentityGrouping())));

    }

                if(g1==null && !(e.source instanceof SpoutNode))

                    throw new RuntimeException("Planner exception: Null source group must indicate a spout node at this phase of planning");

                if(g1==null || !g1.equals(g2)) {

                    graph.removeEdge(e);

                    graph.addVertex(pNode);

                    graph.addEdge(e.source, pNode, new IndexedEdge(e.source, pNode, 0));

                    graph.addEdge(pNode, e.target, new IndexedEdge(pNode, e.target, e.index));                   

                }

            }

        }

        // if one group subscribes to the same stream with same partitioning multiple times,

        // merge those together (otherwise can end up with many output streams created for that partitioning

        // if need to split into multiple output streams because of same input having different

        // partitioning to the group)

       

        // this is because can't currently merge splitting logic into a spout

        // not the most kosher algorithm here, since the grouper indexes are being trounced via the adding of nodes to random groups, but it

        // works out

        List<Node> forNewGroups = new ArrayList<Node>();

        for(Group g: mergedGroups) {

            for(PartitionNode n: extraPartitionInputs(g)) {

                Node idNode = makeIdentityNode(n.allOutputFields);

                Node parentNode = TridentUtils.getParent(graph, n);

                Set<IndexedEdge> outgoing = graph.outgoingEdgesOf(n);

                graph.removeVertex(n);

               

                graph.addVertex(idNode);

   

    private static Collection<PartitionNode> uniquedSubscriptions(Set<PartitionNode> subscriptions) {

        Map<String, PartitionNode> ret = new HashMap();

        for(PartitionNode n: subscriptions) {

            if(curr!=null && !curr.thriftGrouping.equals(n.thriftGrouping)) {

                throw new RuntimeException("Multiple subscriptions to the same stream with different groupings. Should be impossible since that is explicitly guarded against.");

            }

            ret.put(n.streamId, n);

        }

            }

            grouped.get(n.streamId).add(n);

        }

        for(List<PartitionNode> group: grouped.values()) {

            for(int i=1; i<group.size(); i++) {

                if(!n.thriftGrouping.equals(anchor.thriftGrouping)) {

                    ret.add(n);

                }

            }

        }

        return ret;

    }   

   

    private static PartitionNode makeIdentityPartition(Node basis) {

            Grouping.custom_serialized(Utils.serialize(new IdentityGrouping())));

    }