import storm.trident.graph.Group; //导入依赖的package包/类
private static Map<Group, String> genBoltIds(Collection<Group> groups) {
    Map<Group, String> ret = new HashMap();
    int ctr = 0;
    for(Group g: groups) {
        if(!isSpoutGroup(g)) {
            List<String> name = new ArrayList();
            name.add("b");
            name.add("" + ctr);
            String groupName = getGroupName(g);
            if(groupName!=null && !groupName.isEmpty()) {
                name.add(getGroupName(g));                
            }
            ret.put(g, Utils.join(name, "-"));
            ctr++;
        }
    }
    return ret;
}
 

import storm.trident.graph.Group; //导入依赖的package包/类
private static Integer getMaxParallelism(Set<Group> groups) {
    Integer ret = null;
    for(Group g: groups) {
        if(isSpoutGroup(g)) {
            SpoutNode n = (SpoutNode) g.nodes.iterator().next();
            Map conf = getSpoutComponentConfig(n.spout);
            if(conf==null) conf = new HashMap();
            Number maxP = (Number) conf.get(Config.TOPOLOGY_MAX_TASK_PARALLELISM);
            if(maxP!=null) {
                if(ret==null) ret = maxP.intValue();
                else ret = Math.min(ret, maxP.intValue());
            }
        }
    }
    return ret;
}
 

import storm.trident.graph.Group; //导入依赖的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.graph.Group; //导入依赖的package包/类
private static Map<Group, String> genBoltIds(Collection<Group> groups) {
    Map<Group, String> ret = new HashMap<>();
    int ctr = 0;
    for(Group g: groups) {
        if(!isSpoutGroup(g)) {
            List<String> name = new ArrayList<>();
            name.add("b");
            name.add("" + ctr);
            String groupName = getGroupName(g);
            if(groupName!=null && !groupName.isEmpty()) {
                name.add(getGroupName(g));                
            }
            ret.put(g, Utils.join(name, "-"));
            ctr++;
        }
    }
    return ret;
}
 

import storm.trident.graph.Group; //导入依赖的package包/类
private static Set<String> committerBatches(Group g, Map<Node, String> batchGroupMap) {
    Set<String> ret = new HashSet();
    for(Node n: g.nodes) {
       if(n instanceof ProcessorNode) {
           if(((ProcessorNode) n).committer) {
               ret.add(batchGroupMap.get(n));
           }
       } 
    }
    return ret;
}
 

import storm.trident.graph.Group; //导入依赖的package包/类
private static Integer getFixedParallelism(Set<Group> groups) {
    Integer ret = null;
    for(Group g: groups) {
        for(Node n: g.nodes) {
            if(n.stateInfo != null && n.stateInfo.spec.requiredNumPartitions!=null) {
                int reqPartitions = n.stateInfo.spec.requiredNumPartitions;
                if(ret!=null && ret!=reqPartitions) {
                    throw new RuntimeException("Cannot have one group have fixed parallelism of two different values");
                }
                ret = reqPartitions;
            }
        }
    }
    return ret;
}
 

import storm.trident.graph.Group; //导入依赖的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.graph.Group; //导入依赖的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;
}