import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
static void assignLabels(AnnotationProvider annotationProvider,
                         List<DefaultDomain> domains) {

    domains.stream()
           .forEach(domain -> {
               ObjectIntMap<String> wordCounts = new ObjectIntHashMap<>();

               domain.forEachAttribute(attributeIndex -> {
                   String label = annotationProvider.getAttributeLabel(attributeIndex);
                   if (label == null) {
                       return;
                   }

                   countWords(wordCounts, label);
               });

               List<String> topWords = computeTopWords(wordCounts);
               domain.name = String.join(" ", topWords);
           });
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException {
    lock = new ReentrantReadWriteLock();
    lock.writeLock().lock();
    try {
        int version = in.readInt();
        int size = in.readInt();
        entries = new ArrayList(size);
        map = new ObjectIntHashMap(size);
        for (int i = 0; i < size; i++) {
            Object o = in.readObject();
            map.put(o, i);
            entries.add(o);
        }
        growthStopped = in.readBoolean();
        entryClass = (Class) in.readObject();
        if (version > 0) { // instanced id added in version 1S
            instanceId = (VMID) in.readObject();
        }
    } finally {
        lock.writeLock().unlock();
    }
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
public static <V> ObjectIntHashMap<V> ensureNoNullKeys(int capacity, float loadFactor) {
    return new ObjectIntHashMap<V>(capacity, loadFactor) {
        @Override
        public int put(V key, int value) {
            if (key == null) {
                throw new IllegalArgumentException("Map key must not be null");
            }
            return super.put(key, value);
        }
    };
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
/**
 * Build the stats from information about each node.
 */
private OsStats(List<NodeInfo> nodeInfos, List<NodeStats> nodeStatsList) {
    this.names = new ObjectIntHashMap<>();
    int availableProcessors = 0;
    int allocatedProcessors = 0;
    for (NodeInfo nodeInfo : nodeInfos) {
        availableProcessors += nodeInfo.getOs().getAvailableProcessors();
        allocatedProcessors += nodeInfo.getOs().getAllocatedProcessors();

        if (nodeInfo.getOs().getName() != null) {
            names.addTo(nodeInfo.getOs().getName(), 1);
        }
    }
    this.availableProcessors = availableProcessors;
    this.allocatedProcessors = allocatedProcessors;

    long totalMemory = 0;
    long freeMemory = 0;
    for (NodeStats nodeStats : nodeStatsList) {
        if (nodeStats.getOs() != null) {
            long total = nodeStats.getOs().getMem().getTotal().getBytes();
            if (total > 0) {
                totalMemory += total;
            }
            long free = nodeStats.getOs().getMem().getFree().getBytes();
            if (free > 0) {
                freeMemory += free;
            }
        }
    }
    this.mem = new org.elasticsearch.monitor.os.OsStats.Mem(totalMemory, freeMemory);
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
/**
 * Build from lists of information about each node.
 */
private JvmStats(List<NodeInfo> nodeInfos, List<NodeStats> nodeStatsList) {
    this.versions = new ObjectIntHashMap<>();
    long threads = 0;
    long maxUptime = 0;
    long heapMax = 0;
    long heapUsed = 0;
    for (NodeInfo nodeInfo : nodeInfos) {
        versions.addTo(new JvmVersion(nodeInfo.getJvm()), 1);
    }

    for (NodeStats nodeStats : nodeStatsList) {
        org.elasticsearch.monitor.jvm.JvmStats js = nodeStats.getJvm();
        if (js == null) {
            continue;
        }
        if (js.getThreads() != null) {
            threads += js.getThreads().getCount();
        }
        maxUptime = Math.max(maxUptime, js.getUptime().millis());
        if (js.getMem() != null) {
            heapUsed += js.getMem().getHeapUsed().getBytes();
            heapMax += js.getMem().getHeapMax().getBytes();
        }
    }
    this.threads = threads;
    this.maxUptime = maxUptime;
    this.heapUsed = heapUsed;
    this.heapMax = heapMax;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
private String createString(String[] tokens, Map<String, List<BytesRef>> payloads, int encoding, char delimiter) {
    String resultString = "";
    ObjectIntHashMap<String> payloadCounter = new ObjectIntHashMap<>();
    for (String token : tokens) {
        if (!payloadCounter.containsKey(token)) {
            payloadCounter.putIfAbsent(token, 0);
        } else {
            payloadCounter.put(token, payloadCounter.get(token) + 1);
        }
        resultString = resultString + token;
        BytesRef payload = payloads.get(token).get(payloadCounter.get(token));
        if (payload.length > 0) {
            resultString = resultString + delimiter;
            switch (encoding) {
            case 0: {
                resultString = resultString + Float.toString(PayloadHelper.decodeFloat(payload.bytes, payload.offset));
                break;
            }
            case 1: {
                resultString = resultString + Integer.toString(PayloadHelper.decodeInt(payload.bytes, payload.offset));
                break;
            }
            case 2: {
                resultString = resultString + payload.utf8ToString();
                break;
            }
            default: {
                throw new ElasticsearchException("unsupported encoding type");
            }
            }
        }
        resultString = resultString + " ";
    }
    return resultString;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
JvmStats() {
    versions = new ObjectIntHashMap<>();
    threads = 0;
    maxUptime = 0;
    heapMax = 0;
    heapUsed = 0;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
@Override
public void readFrom(StreamInput in) throws IOException {
    int size = in.readVInt();
    versions = new ObjectIntHashMap<>(size);
    for (; size > 0; size--) {
        versions.addTo(JvmVersion.readJvmVersion(in), in.readVInt());
    }
    threads = in.readVLong();
    maxUptime = in.readVLong();
    heapUsed = in.readVLong();
    heapMax = in.readVLong();
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
/**
 * creates a mapping between concept pairs and indices used in the ILP
 * 
 * @param predictions
 */
private ObjectIntMap<CPair> initVarMap(ObjectDoubleMap<CPair> predictions) {
	ObjectIntMap<CPair> varMap = new ObjectIntHashMap<CPair>();
	int x = 0;
	for (ObjectCursor<CPair> p : predictions.keys()) {
		varMap.put(p.value, x);
		x++;
	}
	return varMap;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
public SubgraphILPFast(List<Concept> concepts, List<Proposition> propositions, int maxSize, int maxTime,
		Set<Concept> goldConcepts, double penalty) {
	super(concepts, propositions, maxSize);

	if (maxTime > 0)
		this.maxTime = maxTime;
	this.goldConcepts = goldConcepts;
	this.penalty = penalty;
	if (goldConcepts != null)
		this.withPenalty = true;

	long start = System.currentTimeMillis();
	Logger.getGlobal().log(Level.INFO, "Creating ILP");

	this.conceptIds = new ObjectIntHashMap<Concept>(concepts.size());
	for (int i = 0; i < this.concepts.size(); i++)
		this.conceptIds.put(this.concepts.get(i), i);

	Set<CPair> edges = new HashSet<CPair>();
	for (Proposition p : this.propositions) {
		edges.add(new CPair(p.sourceConcept, p.targetConcept));
		edges.add(new CPair(p.targetConcept, p.sourceConcept));
	}
	this.edges = new ArrayList<CPair>(edges);

	this.createProblem();

	double duration = (System.currentTimeMillis() - start) / 1000.0;
	Logger.getGlobal().log(Level.INFO, "- done: " + duration);
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
public SubgraphILP(List<Concept> concepts, List<Proposition> propositions, int maxSize) {
	super(concepts, propositions, maxSize);

	long start = System.currentTimeMillis();
	Logger.getGlobal().log(Level.INFO, "Creating ILP");

	this.conceptIds = new ObjectIntHashMap<Concept>(concepts.size());
	for (int i = 0; i < this.concepts.size(); i++)
		this.conceptIds.put(this.concepts.get(i), i);

	this.relations = this.propositions.stream().map(p -> new CPair(p.sourceConcept, p.targetConcept))
			.collect(Collectors.toSet());

	this.edges = new CPair[this.concepts.size() * this.concepts.size()];
	int id = 0;
	for (Concept c1 : this.concepts) {
		this.edges[id++] = new CPair(null, c1);
		for (Concept c2 : this.concepts) {
			if (c1 != c2) {
				this.edges[id++] = new CPair(c1, c2);
			}
		}
	}

	this.createProblem();

	double duration = (System.currentTimeMillis() - start) / 1000.0;
	Logger.getGlobal().log(Level.INFO, "- done: " + duration);
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
protected static double calculateInformationGain(
    ObjectIntHashMap<Double> cIn, ObjectIntHashMap<Double> cOut,
    double class_entropy,
    double total_c_in,
    double total) {
  double total_c_out = (total - total_c_in);
  return class_entropy
      - total_c_in / total * entropy(cIn, total_c_in)
      - total_c_out / total * entropy(cOut, total_c_out);
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
protected int moveElement(
    List<ValueLabel> element,
    ObjectIntHashMap<Double> cIn, ObjectIntHashMap<Double> cOut,
    int pos) {
  cIn.putOrAdd(element.get(pos).label, 1, 1);
  cOut.putOrAdd(element.get(pos).label, -1, -1);
  return 1;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
void checkIdCoverage(File file) throws IOException {
    CyNetworkView view = session.getNetworkView();
    CyNetwork network = view.getModel();
    CyTable nodeTable = network.getDefaultNodeTable();

    List<String> names = SafeUtil.getStringColumnNames(nodeTable)
                                 .collect(Collectors.toList());
    CyNodeTableVisitor visitor = new CyNodeTableVisitor(nodeTable, names);

    String path = file.getPath();
    AnalyzeAnnotationConsumer consumer = new AnalyzeAnnotationConsumer() {
        @Override
        public void accept(IdMappingResult result) {
            idMappingResult = result;
            IntIntMap coverage = result.coverage;
            int topIndex = Util.getTopKey(coverage, -1);

            columnCoverage = new ObjectIntHashMap<>();
            coverage.forEach((Consumer<? super IntIntCursor>) c -> columnCoverage.addTo(names.get(c.key), c.value));

            nodeIds.setSelectedIndex(topIndex);

            try {
                String canonicalPath = file.getCanonicalPath();
                lastAnnotationPath = canonicalPath;
                notifyListeners(file);
            } catch (IOException e) {
                fail(e, "Unexpected error");
            }
        }
    };

    SimpleTaskFactory taskFactory = new SimpleTaskFactory(() -> new AnalyzeAnnotationTask(path, visitor, consumer));
    taskManager.execute(taskFactory.createTaskIterator());
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
@SuppressWarnings("PMD.DataflowAnomalyAnalysis")
public void check() {
	int color = DEFAULT_COLOR;
	ObjectIntMap<AbstractStage> colors = new ObjectIntHashMap<AbstractStage>();
	ThreadPainter threadPainter = new ThreadPainter();
	Traverser traverser = new Traverser(threadPainter);

	for (AbstractStage threadableStage : threadableStages) {
		color++;
		colors.put(threadableStage, color);

		threadPainter.reset(colors, color, threadableStages);
		traverser.traverse(threadableStage);
	}
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
private ObjectIntMap<String> generateFeatureMap(SourceOfRandomness sourceOfRandomness) {
    ObjectIntMap<String> featureMap = new ObjectIntHashMap<>();
    int numFeatures = sourceOfRandomness.nextInt(1,15);
    for (int i = 0; i < numFeatures; i++) {
        int featureValue = sourceOfRandomness.nextInt(20);
        while (featureMap.containsKey(""+featureValue)) {
            featureValue = sourceOfRandomness.nextInt(20);
        }

        featureMap.put(""+featureValue, sourceOfRandomness.nextInt(2));
    }
    return featureMap;
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
@Override
public int test() {
    final ObjectIntHashMap<Integer> m_map = new ObjectIntHashMap<>( m_keys.length, m_fillFactor );
    for ( int i = 0; i < m_keys.length; ++i )
        m_map.put( m_keys[ i ], i );
    for ( int i = 0; i < m_keys2.length; ++i )
        m_map.put( m_keys2[ i ], i );
    return m_map.size();
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
@Test
public void objectCollectionAsIterableTest() {
  ObjectIntHashMap<String> foo = new ObjectIntHashMap<>();
  foo.put("foo", 1);
  foo.put("foo2", 2);
  foo.put("bar", 8);

  final ImmutableSet<String> reference = ImmutableSet.of("foo", "foo2", "bar");
  assertEquals(reference, ImmutableSet.copyOf(HppcUtils.asJavaIterable(foo.keys())));
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
public Alphabet (int capacity, Class entryClass)
{
	this.map = new ObjectIntHashMap (capacity);
	this.entries = new ArrayList (capacity);
	this.entryClass = entryClass;
	// someone could try to deserialize us into this image (e.g., by RMI).  Handle this.
	deserializedEntries.putIfAbsent(instanceId, this);
}
 

import com.carrotsearch.hppc.ObjectIntHashMap; //导入依赖的package包/类
public Object clone ()
{
       lock.readLock().lock();
       try {
           Alphabet ret = new Alphabet();
           ret.map = (ObjectIntHashMap) map.clone();
           ret.entries = (ArrayList) entries.clone();
           ret.growthStopped = growthStopped;
           ret.entryClass = entryClass;
           return ret;
       } finally {
           lock.readLock().unlock();
       }
}