@Override
public int compare(Object o1, Object o2) {
if (WEIGHTS.containsKey(o1) && WEIGHTS.containsKey(o2)) {
return WEIGHTS.get(o1) - WEIGHTS.get(o2);
} else if (WEIGHTS.containsKey(o1) && !WEIGHTS.containsKey(o2)) {
return -1;
} else if (!WEIGHTS.containsKey(o1) && WEIGHTS.containsKey(o2)) {
return 1;
} else {
return o1.hashCode() - o2.hashCode();
}
}
@Nullable
private PsiElement findAnchor(String name) {
final int myPriority = PRIORITY.get(name);
final PsiElement[] modifiers = getModifiers();
PsiElement anchor = null;
for (int i = modifiers.length - 1; i >= 0; i--) {
PsiElement modifier = modifiers[i];
if (PRIORITY.get(modifier.getText()) <= myPriority) {
anchor = modifier;
break;
}
}
return anchor;
}
/**
* Reads events from <tt>eventStream</tt> into a linked list. The predicates associated with each
* event are counted and any which occur at least <tt>cutoff</tt> times are added to the
* <tt>predicatesInOut</tt> map along with a unique integer index.
*
* @param eventStream an <code>EventStream</code> value
* @param eventStore a writer to which the events are written to for later processing.
* @param predicatesInOut a <code>TObjectIntHashMap</code> value
* @param cutoff an <code>int</code> value
*/
private int computeEventCounts(
EventStream eventStream, Writer eventStore, TObjectIntHashMap predicatesInOut, int cutoff)
throws IOException {
TObjectIntHashMap counter = new TObjectIntHashMap();
int predicateIndex = 0;
int eventCount = 0;
while (eventStream.hasNext()) {
Event ev = eventStream.nextEvent();
eventCount++;
eventStore.write(FileEventStream.toLine(ev));
String[] ec = ev.getContext();
for (int j = 0; j < ec.length; j++) {
if (!predicatesInOut.containsKey(ec[j])) {
if (counter.increment(ec[j])) {
} else {
counter.put(ec[j], 1);
}
if (counter.get(ec[j]) >= cutoff) {
predicatesInOut.put(ec[j], predicateIndex++);
counter.remove(ec[j]);
}
}
}
}
predicatesInOut.trimToSize();
eventStore.close();
return eventCount;
}
public int findIdInCacheWrite(final Object obj, boolean immutable) {
if (immutable) {
return findProperImmutableCache(obj.getClass()).get(obj);
} else {
return objectsCacheOnWrite.get(obj);
}
}
@SuppressWarnings({"HardCodedStringLiteral"})
public void dumpStatistics() {
System.out.println("Statistics:");
final TObjectIntHashMap<Object> map = new TObjectIntHashMap<Object>();
final PsiElementVisitor psiRecursiveElementVisitor =
new XmlRecursiveElementVisitor() {
@NonNls private static final String TOKENS_KEY = "Tokens";
@NonNls private static final String ELEMENTS_KEY = "Elements";
@Override
public void visitXmlToken(XmlToken token) {
inc(TOKENS_KEY);
}
@Override
public void visitElement(PsiElement element) {
inc(ELEMENTS_KEY);
super.visitElement(element);
}
private void inc(final String key) {
map.put(key, map.get(key) + 1);
}
};
accept(psiRecursiveElementVisitor);
final Object[] keys = map.keys();
for (final Object key : keys) {
System.out.println(key + ": " + map.get(key));
}
}
public boolean hasExplicitModifier(@NotNull @NonNls String name) {
final GrModifierListStub stub = getStub();
if (stub != null) {
final int flag = NAME_TO_MODIFIER_FLAG_MAP.get(name);
return (stub.getModifiersFlags() & flag) != 0;
}
if (name.equals(GrModifier.PUBLIC)) return findChildByType(GroovyElementTypes.kPUBLIC) != null;
if (name.equals(GrModifier.ABSTRACT))
return findChildByType(GroovyElementTypes.kABSTRACT) != null;
if (name.equals(GrModifier.NATIVE)) return findChildByType(GroovyElementTypes.kNATIVE) != null;
if (name.equals(GrModifier.PRIVATE))
return findChildByType(GroovyElementTypes.kPRIVATE) != null;
if (name.equals(GrModifier.PROTECTED))
return findChildByType(GroovyElementTypes.kPROTECTED) != null;
if (name.equals(GrModifier.SYNCHRONIZED))
return findChildByType(GroovyElementTypes.kSYNCHRONIZED) != null;
if (name.equals(GrModifier.STRICTFP))
return findChildByType(GroovyElementTypes.kSTRICTFP) != null;
if (name.equals(GrModifier.STATIC)) return findChildByType(GroovyElementTypes.kSTATIC) != null;
if (name.equals(GrModifier.FINAL)) return findChildByType(GroovyElementTypes.kFINAL) != null;
if (name.equals(GrModifier.TRANSIENT))
return findChildByType(GroovyElementTypes.kTRANSIENT) != null;
if (name.equals(GrModifier.NATIVE)) return findChildByType(GroovyElementTypes.kNATIVE) != null;
if (name.equals(GrModifier.DEF)) return findChildByType(GroovyTokenTypes.kDEF) != null;
return name.equals(GrModifier.VOLATILE)
&& findChildByType(GroovyElementTypes.kVOLATILE) != null;
}
private TIntArrayList getParametersToRemove() {
TIntArrayList list = new TIntArrayList();
for (Object o : toRemoveCBs.keys()) {
if (((JCheckBox) o).isSelected()) {
list.add(toRemoveCBs.get((JCheckBox) o));
}
}
return list;
}
public int leave(DeclarationDescriptor descriptor) {
int size = myVarSizes.get(descriptor);
myMaxIndex -= size;
myVarSizes.remove(descriptor);
int oldIndex = myVarIndex.remove(descriptor);
if (oldIndex != myMaxIndex) {
throw new IllegalStateException("Descriptor can be left only if it is last: " + descriptor);
}
return oldIndex;
}
private static int getAttributeId(String attId) throws IOException {
if (myAttributeIds.containsKey(attId)) {
return myAttributeIds.get(attId);
}
int id = myNames.enumerate(attId);
myAttributeIds.put(attId, id);
return id;
}
private List index(int numEvents, EventStream es, TObjectIntHashMap predicateIndex) {
TObjectIntHashMap omap = new TObjectIntHashMap();
int outcomeCount = 0;
List eventsToCompare = new ArrayList(numEvents);
TIntArrayList indexedContext = new TIntArrayList();
while (es.hasNext()) {
Event ev = es.nextEvent();
String[] econtext = ev.getContext();
ComparableEvent ce;
int ocID;
String oc = ev.getOutcome();
if (omap.containsKey(oc)) {
ocID = omap.get(oc);
} else {
ocID = outcomeCount++;
omap.put(oc, ocID);
}
for (int i = 0; i < econtext.length; i++) {
String pred = econtext[i];
if (predicateIndex.containsKey(pred)) {
indexedContext.add(predicateIndex.get(pred));
}
}
// drop events with no active features
if (indexedContext.size() > 0) {
ce = new ComparableEvent(ocID, indexedContext.toNativeArray());
eventsToCompare.add(ce);
} else {
System.err.println(
"Dropped event " + ev.getOutcome() + ":" + Arrays.asList(ev.getContext()));
}
// recycle the TIntArrayList
indexedContext.resetQuick();
}
outcomeLabels = toIndexedStringArray(omap);
predLabels = toIndexedStringArray(predicateIndex);
return eventsToCompare;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
if (myVarIndex.size() != myVarSizes.size()) {
return "inconsistent";
}
List<Trinity<DeclarationDescriptor, Integer, Integer>> descriptors = Lists.newArrayList();
for (Object descriptor0 : myVarIndex.keys()) {
DeclarationDescriptor descriptor = (DeclarationDescriptor) descriptor0;
int varIndex = myVarIndex.get(descriptor);
int varSize = myVarSizes.get(descriptor);
descriptors.add(Trinity.create(descriptor, varIndex, varSize));
}
Collections.sort(
descriptors,
new Comparator<Trinity<DeclarationDescriptor, Integer, Integer>>() {
@Override
public int compare(
Trinity<DeclarationDescriptor, Integer, Integer> left,
Trinity<DeclarationDescriptor, Integer, Integer> right) {
return left.second - right.second;
}
});
sb.append("size=").append(myMaxIndex);
boolean first = true;
for (Trinity<DeclarationDescriptor, Integer, Integer> t : descriptors) {
if (!first) {
sb.append(", ");
}
first = false;
sb.append(t.first).append(",i=").append(t.second).append(",s=").append(t.third);
}
return sb.toString();
}
@Override
public void dispose() {
synchronized (ourInstances) {
ourInstances.remove(myParent);
for (Object o : myCounts.keys()) {
VirtualFilePointerImpl pointer = (VirtualFilePointerImpl) o;
int disposeCount = myCounts.get(pointer);
int after = pointer.myNode.incrementUsageCount(-disposeCount + 1);
LOG.assertTrue(after > 0, after);
pointer.dispose();
}
}
}
public int storeSafe(Object obj) {
if (safeClone.isSafeToReuse(obj)) {
int description = safeToReuse.get(obj);
if (description == 0) {
safeToReuse.put(obj, safeToReuse.size() + 1);
description = safeToReuse.size();
reuse.add(obj);
}
return description;
} else {
return 0;
}
}
/**
* Returns a list of edge attributes stored in String-String-tuples. The returned list contains
* two entries:
*
* <ul>
* <li>{@link GraphML#SOURCE_ATTR} - <tt>vertexIdx</tt>
* <li>{@link GraphML#TARGET_ATTR} - <tt>vertexIdx</tt>
* </ul>
*
* @param e the edge the attributes are to be returned.
* @return a list of edge attributes.
*/
protected List<Tuple<String, String>> getEdgeAttributes(Edge e) {
List<Tuple<String, String>> attrs = new LinkedList<Tuple<String, String>>();
Vertex v1 = e.getVertices().getFirst();
Vertex v2 = e.getVertices().getSecond();
int idx1 = vertexTmpIds.get(v1);
int idx2 = vertexTmpIds.get(v2);
if (idx1 > 0 && idx2 > 0) {
attrs.add(createTuple(GraphML.SOURCE_ATTR, idx1));
attrs.add(createTuple(GraphML.TARGET_ATTR, idx2));
} else {
throw new IllegalArgumentException("Orphaned edges are not allowed!");
}
return attrs;
}
@Test
public void testTermCodesPut() {
TermCodes.reset();
final int termsLength = terms.length;
TObjectIntHashMap<String> check = new TObjectIntHashMap<String>();
for (int i = 0; i < termsLength; i++) {
TermCodes.setTermCode(terms[i], i);
check.put(terms[i], i);
}
for (int j = 0; j < 1000000; j++) {
for (int i = 0; i < termsLength; i++) {
int code = TermCodes.getCode(terms[i]);
assertEquals(check.get(terms[i]), code);
}
}
}
@Test
public void testTermCodes() {
TermCodes.reset();
TObjectIntHashMap<String> check = new TObjectIntHashMap<String>();
final int termsLength = terms.length;
for (int i = 0; i < termsLength; i++) {
int id = TermCodes.getCode(terms[i]);
check.put(terms[i], id);
}
int code;
for (int j = 0; j < 1000000; j++) {
for (int i = 0; i < termsLength; i++) {
code = TermCodes.getCode(terms[i]);
assertEquals(check.get(terms[i]), code);
}
}
// TODO: get a new term, then check that the new id is unique
}
public GrIntroduceParameterDialog(IntroduceParameterInfo info) {
super(info.getProject(), true);
myInfo = info;
myProject = info.getProject();
myCanIntroduceSimpleParameter =
GroovyIntroduceParameterUtil.findExpr(myInfo) != null
|| GroovyIntroduceParameterUtil.findVar(myInfo) != null
|| findStringPart() != null;
TObjectIntHashMap<GrParameter> parametersToRemove =
GroovyIntroduceParameterUtil.findParametersToRemove(info);
toRemoveCBs = new TObjectIntHashMap<JCheckBox>(parametersToRemove.size());
for (Object p : parametersToRemove.keys()) {
JCheckBox cb =
new JCheckBox(
GroovyRefactoringBundle.message(
"remove.parameter.0.no.longer.used", ((GrParameter) p).getName()));
toRemoveCBs.put(cb, parametersToRemove.get((GrParameter) p));
cb.setSelected(true);
}
init();
}
/**
* Returns the public identifer.
*
* @return the public identifer.
*/
public final int getID() {
if (id > 0) return mapHashcodeToID.get(this);
return hashCode();
}
private void loadSociogramData(Collection<VertexRecord> records, SQLDumpReader sqlData) {
logger.info("Loading sociogram data...");
Map<String, VertexRecord> map = sqlData.getFullAlterKeyMappping(records);
TObjectIntHashMap<Vertex> rawDegrees = new TObjectIntHashMap<Vertex>();
for (Vertex v : proj.getVertices()) {
rawDegrees.put(v, v.getNeighbours().size());
}
int edgecnt = 0;
int doublecnt = 0;
int egoEdge = 0;
Set<Vertex> notOkVertices = new HashSet<Vertex>();
Set<Vertex> okVertices = new HashSet<Vertex>();
DescriptiveStatistics notOkStats = new DescriptiveStatistics();
DescriptiveStatistics okStats = new DescriptiveStatistics();
DescriptiveStatistics numDistr = new DescriptiveStatistics();
DescriptiveStatistics numDistrNoZero = new DescriptiveStatistics();
DescriptiveStatistics sizeDistr = new DescriptiveStatistics();
TDoubleArrayList sizeValues = new TDoubleArrayList();
TDoubleArrayList kSizeValues = new TDoubleArrayList();
TDoubleArrayList numValues = new TDoubleArrayList();
TDoubleArrayList numValues2 = new TDoubleArrayList();
TDoubleArrayList kNumValues = new TDoubleArrayList();
for (VertexRecord record : records) {
if (record.isEgo) {
List<Set<String>> cliques = sqlData.getCliques(record);
numDistr.addValue(cliques.size());
Vertex v = idMap.get(record.id);
numValues.add(cliques.size());
kNumValues.add(v.getNeighbours().size());
if (!cliques.isEmpty()) numDistrNoZero.addValue(cliques.size());
for (Set<String> clique : cliques) {
sizeDistr.addValue(clique.size());
sizeValues.add(clique.size());
kSizeValues.add(rawDegrees.get(projMap.get(v)));
numValues2.add(cliques.size());
List<SocialSparseVertex> vertices = new ArrayList<SocialSparseVertex>(clique.size());
for (String alter : clique) {
VertexRecord r = map.get(record.egoSQLId + alter);
if (r != null) {
SocialSparseVertex vertex = idMap.get(r.id);
if (vertex != null) {
vertices.add(vertex);
} else {
logger.warn("Vertex not found.");
}
} else {
logger.warn("Record not found.");
}
}
for (int i = 0; i < vertices.size(); i++) {
for (int j = i + 1; j < vertices.size(); j++) {
SampledVertexDecorator<SocialSparseVertex> vProj1 = projMap.get(vertices.get(i));
SampledVertexDecorator<SocialSparseVertex> vProj2 = projMap.get(vertices.get(j));
if (!vProj1.isSampled() && !vProj2.isSampled()) {
if (Math.random() < 0.62) {
SocialSparseEdge socialEdge =
builder.addEdge(graph, vertices.get(i), vertices.get(j));
if (socialEdge != null) {
projBuilder.addEdge(proj, vProj1, vProj2, socialEdge);
edgecnt++;
if (vProj1.isSampled() || vProj2.isSampled()) {
egoEdge++;
if (vProj1.isSampled()) notOkVertices.add(vProj1);
else notOkVertices.add(vProj2);
}
} else {
doublecnt++;
if (vProj1.isSampled()) okVertices.add(vProj1);
else if (vProj2.isSampled()) okVertices.add(vProj2);
}
}
}
}
}
}
}
}
for (Vertex v : okVertices) okStats.addValue(rawDegrees.get(v));
for (Vertex v : notOkVertices) notOkStats.addValue(rawDegrees.get(v));
try {
TDoubleDoubleHashMap hist =
Histogram.createHistogram(okStats, new LinearDiscretizer(1), false);
StatsWriter.writeHistogram(
hist,
"k",
"n",
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_ok.txt");
TDoubleDoubleHashMap hist2 =
Histogram.createHistogram(notOkStats, new LinearDiscretizer(1), false);
StatsWriter.writeHistogram(
hist2,
"k",
"n",
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_notok.txt");
TDoubleDoubleHashMap ratio = new TDoubleDoubleHashMap();
double[] keys = hist.keys();
for (double k : keys) {
double val1 = hist2.get(k);
double val2 = hist.get(k);
ratio.put(k, val1 / (val2 + val1));
}
StatsWriter.writeHistogram(
ratio,
"k",
"p",
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/k_ratio.txt");
logger.info("Mean num of cliques: " + numDistrNoZero.getMean());
logger.info("Mean size: " + sizeDistr.getMean());
logger.info("Median num of cliques: " + StatUtils.percentile(numDistrNoZero.getValues(), 50));
logger.info("Median size: " + StatUtils.percentile(sizeDistr.getValues(), 50));
TDoubleDoubleHashMap histNum =
Histogram.createHistogram(
numDistrNoZero,
FixedSampleSizeDiscretizer.create(numDistrNoZero.getValues(), 2, 20),
true);
Histogram.normalize(histNum);
StatsWriter.writeHistogram(
histNum,
"num",
"freq",
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/numCliques.txt");
TDoubleDoubleHashMap histSize =
Histogram.createHistogram(
sizeDistr, FixedSampleSizeDiscretizer.create(sizeDistr.getValues(), 2, 20), true);
Histogram.normalize(histSize);
StatsWriter.writeHistogram(
histSize,
"size",
"freq",
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/numPersons.txt");
Discretizer discretizer =
FixedSampleSizeDiscretizer.create(kSizeValues.toNativeArray(), 20, 20);
TDoubleArrayList valuesX = new TDoubleArrayList();
for (int i = 0; i < kSizeValues.size(); i++) {
valuesX.add(discretizer.discretize(kSizeValues.get(i)));
}
Correlations.writeToFile(
Correlations.mean(valuesX.toNativeArray(), sizeValues.toNativeArray()),
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/size_k.txt",
"k",
"size");
discretizer = FixedSampleSizeDiscretizer.create(kNumValues.toNativeArray(), 20, 20);
valuesX = new TDoubleArrayList();
for (int i = 0; i < kNumValues.size(); i++) {
valuesX.add(discretizer.discretize(kNumValues.get(i)));
}
Correlations.writeToFile(
Correlations.mean(valuesX.toNativeArray(), numValues.toNativeArray()),
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/num_k.txt",
"k",
"n");
Correlations.writeToFile(
Correlations.mean(numValues2.toNativeArray(), sizeValues.toNativeArray()),
"/Users/jillenberger/Work/socialnets/data/ivt2009/11-2011/augmented/size_num.txt",
"num",
"size");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
logger.info(
String.format("Inserted %1$s edges, %2$s edges already present.", edgecnt, doublecnt));
logger.info(String.format("Inserted %1$s edges between at least one ego.", egoEdge));
}
public int getIndex(DeclarationDescriptor descriptor) {
return myVarIndex.contains(descriptor) ? myVarIndex.get(descriptor) : -1;
}
public PsiImportList prepareOptimizeImportsResult(@NotNull final PsiJavaFile file) {
CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(file.getProject());
final Set<String> namesToImportStaticly = new THashSet<String>();
String[] names =
collectNamesToImport(
file,
namesToImportStaticly); // Note: this array may contain "<packageOrClassName>.*" for
// unresolved imports!
Arrays.sort(names);
ArrayList<String> namesList = new ArrayList<String>();
ImportLayoutTable table = mySettings.IMPORT_LAYOUT_TABLE;
if (table != null) {
int[] entriesForName = ArrayUtil.newIntArray(names.length);
for (int i = 0; i < names.length; i++) {
entriesForName[i] = findEntryIndex(names[i]);
}
Entry[] entries = table.getEntries();
for (int i = 0; i < entries.length; i++) {
Entry entry = entries[i];
if (entry instanceof PackageEntry) {
for (int j = 0; j < names.length; j++) {
if (entriesForName[j] == i) {
namesList.add(names[j]);
names[j] = null;
}
}
}
}
}
for (String name : names) {
if (name != null) namesList.add(name);
}
names = ArrayUtil.toStringArray(namesList);
TObjectIntHashMap<String> packageToCountMap = new TObjectIntHashMap<String>();
TObjectIntHashMap<String> classToCountMap = new TObjectIntHashMap<String>();
for (String name : names) {
String packageOrClassName = getPackageOrClassName(name);
if (packageOrClassName.length() == 0) continue;
if (namesToImportStaticly.contains(name)) {
int count = classToCountMap.get(packageOrClassName);
classToCountMap.put(packageOrClassName, count + 1);
} else {
int count = packageToCountMap.get(packageOrClassName);
packageToCountMap.put(packageOrClassName, count + 1);
}
}
final Set<String> classesOrPackagesToImportOnDemand = new THashSet<String>();
class MyVisitorProcedure implements TObjectIntProcedure<String> {
private final boolean myIsVisitingPackages;
MyVisitorProcedure(boolean isVisitingPackages) {
myIsVisitingPackages = isVisitingPackages;
}
public boolean execute(final String packageOrClassName, final int count) {
if (isToUseImportOnDemand(packageOrClassName, count, !myIsVisitingPackages)) {
classesOrPackagesToImportOnDemand.add(packageOrClassName);
}
return true;
}
}
classToCountMap.forEachEntry(new MyVisitorProcedure(false));
packageToCountMap.forEachEntry(new MyVisitorProcedure(true));
Set<String> classesToUseSingle =
findSingleImports(file, names, classesOrPackagesToImportOnDemand, namesToImportStaticly);
try {
final String text =
buildImportListText(
names, classesOrPackagesToImportOnDemand, classesToUseSingle, namesToImportStaticly);
String ext = StdFileTypes.JAVA.getDefaultExtension();
final PsiJavaFile dummyFile =
(PsiJavaFile)
PsiFileFactory.getInstance(file.getProject())
.createFileFromText("_Dummy_." + ext, StdFileTypes.JAVA, text);
codeStyleManager.reformat(dummyFile);
PsiImportList resultList = dummyFile.getImportList();
PsiImportList oldList = file.getImportList();
if (oldList.isReplaceEquivalent(resultList)) return null;
return resultList;
} catch (IncorrectOperationException e) {
LOG.error(e);
return null;
}
}
private static void findReadsBeforeWrites(
Instruction[] flow,
TIntHashSet[] definitelyAssigned,
List<ReadWriteVariableInstruction> result,
TObjectIntHashMap<String> namesIndex,
int[] postorder,
int[] invpostorder,
boolean onlyFirstRead) {
// skip instructions that are not reachable from the start
int start = ArrayUtil.find(invpostorder, 0);
for (int i = start; i < flow.length; i++) {
int j = invpostorder[i];
Instruction curr = flow[j];
if (curr instanceof ReadWriteVariableInstruction) {
ReadWriteVariableInstruction rw = (ReadWriteVariableInstruction) curr;
int name = namesIndex.get(rw.getVariableName());
TIntHashSet vars = definitelyAssigned[j];
if (rw.isWrite()) {
if (vars == null) {
vars = new TIntHashSet();
definitelyAssigned[j] = vars;
}
vars.add(name);
} else {
if (vars == null || !vars.contains(name)) {
result.add(rw);
if (onlyFirstRead) {
if (vars == null) {
vars = new TIntHashSet();
definitelyAssigned[j] = vars;
}
vars.add(name);
}
}
}
}
for (Instruction succ : curr.allSuccessors()) {
if (postorder[succ.num()] > postorder[curr.num()]) {
TIntHashSet currDefinitelyAssigned = definitelyAssigned[curr.num()];
TIntHashSet succDefinitelyAssigned = definitelyAssigned[succ.num()];
if (currDefinitelyAssigned != null) {
int[] currArray = currDefinitelyAssigned.toArray();
if (succDefinitelyAssigned == null) {
succDefinitelyAssigned = new TIntHashSet();
succDefinitelyAssigned.addAll(currArray);
definitelyAssigned[succ.num()] = succDefinitelyAssigned;
} else {
succDefinitelyAssigned.retainAll(currArray);
}
} else {
if (succDefinitelyAssigned != null) {
succDefinitelyAssigned.clear();
} else {
succDefinitelyAssigned = new TIntHashSet();
definitelyAssigned[succ.num()] = succDefinitelyAssigned;
}
}
}
}
}
}
