import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Map<String, String> getOutputStreamBatchGroups(Group g, Map<Node, String> batchGroupMap) {
    Map<String, String> ret = new HashMap();
    Set<PartitionNode> externalGroupOutputs = externalGroupOutputs(g);
    for(PartitionNode n: externalGroupOutputs) {
        ret.put(n.streamId, batchGroupMap.get(n));
    }        
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
public Stream partition(Grouping grouping) {
    if(_node instanceof PartitionNode) {
        return each(new Fields(), new TrueFilter()).partition(grouping);
    } else {
        return _topology.addSourcedNode(this, new PartitionNode(_node.streamId, _name, getOutputFields(), grouping));       
    }
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Collection<PartitionNode> uniquedSubscriptions(Set<PartitionNode> subscriptions) {
    Map<String, PartitionNode> ret = new HashMap();
    for(PartitionNode n: subscriptions) {
        PartitionNode curr = ret.get(n.streamId);
        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);
    }
    return ret.values();
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static boolean isIdentityPartition(PartitionNode n) {
    Grouping g = n.thriftGrouping;
    if(g.is_set_custom_serialized()) {
        CustomStreamGrouping csg = (CustomStreamGrouping) Utils.deserialize(g.get_custom_serialized());
        return csg instanceof IdentityGrouping;
    }
    return false;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Set<PartitionNode> externalGroupInputs(Group g) {
    Set<PartitionNode> ret = new HashSet();
    for(Node n: g.incomingNodes()) {
        if(n instanceof PartitionNode) {
            ret.add((PartitionNode) n);
        }
    }
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Set<PartitionNode> externalGroupOutputs(Group g) {
    Set<PartitionNode> ret = new HashSet();
    for(Node n: g.outgoingNodes()) {
        if(n instanceof PartitionNode) {
            ret.add((PartitionNode) n);
        }
    }
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
public Stream partition(Grouping grouping) {
    if (_node instanceof PartitionNode) {
        return each(new Fields(), new TrueFilter()).partition(grouping);
    } else {
        return _topology.addSourcedNode(this, new PartitionNode(_node.streamId, _name, getOutputFields(), grouping));
    }
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Collection<PartitionNode> uniquedSubscriptions(Set<PartitionNode> subscriptions) {
    Map<String, PartitionNode> ret = new HashMap<>();
    for(PartitionNode n: subscriptions) {
        PartitionNode curr = ret.get(n.streamId);
        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);
    }
    return ret.values();
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Map<String, String> getOutputStreamBatchGroups(Group g, Map<Node, String> batchGroupMap) {
    Map<String, String> ret = new HashMap<>();
    Set<PartitionNode> externalGroupOutputs = externalGroupOutputs(g);
    for(PartitionNode n: externalGroupOutputs) {
        ret.put(n.streamId, batchGroupMap.get(n));
    }        
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static boolean isIdentityPartition(PartitionNode n) {
    Grouping g = n.thriftGrouping;
    if(g.is_set_custom_serialized()) {
        CustomStreamGrouping csg = (CustomStreamGrouping) Utils.javaDeserialize(g.get_custom_serialized(), Serializable.class);
        return csg instanceof IdentityGrouping;
    }
    return false;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Set<PartitionNode> externalGroupInputs(Group g) {
    Set<PartitionNode> ret = new HashSet<>();
    for(Node n: g.incomingNodes()) {
        if(n instanceof PartitionNode) {
            ret.add((PartitionNode) n);
        }
    }
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static Set<PartitionNode> externalGroupOutputs(Group g) {
    Set<PartitionNode> ret = new HashSet<>();
    for(Node n: g.outgoingNodes()) {
        if(n instanceof PartitionNode) {
            ret.add((PartitionNode) n);
        }
    }
    return ret;
}
 

import storm.trident.planner.PartitionNode; //导入依赖的package包/类
private static PartitionNode makeIdentityPartition(Node basis) {
    return new PartitionNode(basis.streamId, basis.name, basis.allOutputFields,
        Grouping.custom_serialized(Utils.serialize(new IdentityGrouping())));
}