import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public static ObjectObjectHashMap<String, CollectionStatistics> readFieldStats(StreamInput in, ObjectObjectHashMap<String, CollectionStatistics> fieldStatistics) throws IOException {
    final int numFieldStatistics = in.readVInt();
    if (fieldStatistics == null) {
        fieldStatistics = HppcMaps.newNoNullKeysMap(numFieldStatistics);
    }
    for (int i = 0; i < numFieldStatistics; i++) {
        final String field = in.readString();
        assert field != null;
        final long maxDoc = in.readVLong();
        final long docCount = subOne(in.readVLong());
        final long sumTotalTermFreq = subOne(in.readVLong());
        final long sumDocFreq = subOne(in.readVLong());
        CollectionStatistics stats = new CollectionStatistics(field, maxDoc, docCount, sumTotalTermFreq, sumDocFreq);
        fieldStatistics.put(field, stats);
    }
    return fieldStatistics;
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
@Override
public synchronized void copyContextFrom(HasContext other) {
    if (other == null) {
        return;
    }

    synchronized (other) {
        ImmutableOpenMap<Object, Object> otherContext = other.getContext();
        if (otherContext == null) {
            return;
        }
        if (context == null) {
            ObjectObjectHashMap<Object, Object> map = new ObjectObjectHashMap<>(other.getContext().size());
            map.putAll(otherContext);
            this.context = map;
        } else {
            context.putAll(otherContext);
        }
    }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public Record (String name, LabeledSpans spans) {
  this.name = name;
  fieldMap = new ObjectObjectHashMap ();
  for (int i = 0; i < spans.size(); i++) {
    LabeledSpan span = spans.getLabeledSpan (i);
    if (!span.isBackground()) {
      Label tag = span.getLabel ();
      Field field = (Field) fieldMap.get (tag);
      if (field == null) {
        field = new Field (span);
        fieldMap.put (tag, field);
      } else {
        field.addFiller (span);
      }
    }
  }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public static void writeFieldStats(StreamOutput out, ObjectObjectHashMap<String, CollectionStatistics> fieldStatistics) throws IOException {
    out.writeVInt(fieldStatistics.size());

    for (ObjectObjectCursor<String, CollectionStatistics> c : fieldStatistics) {
        out.writeString(c.key);
        CollectionStatistics statistics = c.value;
        assert statistics.maxDoc() >= 0;
        out.writeVLong(statistics.maxDoc());
        out.writeVLong(addOne(statistics.docCount()));
        out.writeVLong(addOne(statistics.sumTotalTermFreq()));
        out.writeVLong(addOne(statistics.sumDocFreq()));
    }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
/** Add fields so that they can later be fetched using {@link #getByKey(Object)}. */
public void addWithKey(Object key, IndexableField field) {
    if (keyedFields == null) {
        keyedFields = new ObjectObjectHashMap<>();
    } else if (keyedFields.containsKey(key)) {
        throw new IllegalStateException("Only one field can be stored per key");
    }
    keyedFields.put(key, field);
    add(field);
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
/**
 * Wraps the given map and prevent adding of <code>null</code> keys.
 * 
 * @param expectedElements
 *          The expected number of elements guaranteed not to cause buffer
 *          expansion (inclusive).
 */
public static <K, V> ObjectObjectHashMap<K, V> ensureNoNullKeys(int expectedElements) {
    return new ObjectObjectHashMap<K, V>(expectedElements) {
        @Override
        public V put(K key, V value) {
            if (key == null) {
                throw new IllegalArgumentException("Map key must not be null");
            }
            return super.put(key, value);
        }
    };
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public ClusterStatsIndices(List<ClusterStatsNodeResponse> nodeResponses) {
    ObjectObjectHashMap<String, ShardStats> countsPerIndex = new ObjectObjectHashMap<>();

    this.docs = new DocsStats();
    this.store = new StoreStats();
    this.fieldData = new FieldDataStats();
    this.queryCache = new QueryCacheStats();
    this.completion = new CompletionStats();
    this.segments = new SegmentsStats();

    for (ClusterStatsNodeResponse r : nodeResponses) {
        for (org.elasticsearch.action.admin.indices.stats.ShardStats shardStats : r.shardsStats()) {
            ShardStats indexShardStats = countsPerIndex.get(shardStats.getShardRouting().getIndexName());
            if (indexShardStats == null) {
                indexShardStats = new ShardStats();
                countsPerIndex.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
            }

            indexShardStats.total++;

            CommonStats shardCommonStats = shardStats.getStats();

            if (shardStats.getShardRouting().primary()) {
                indexShardStats.primaries++;
                docs.add(shardCommonStats.docs);
            }
            store.add(shardCommonStats.store);
            fieldData.add(shardCommonStats.fieldData);
            queryCache.add(shardCommonStats.queryCache);
            completion.add(shardCommonStats.completion);
            segments.add(shardCommonStats.segments);
        }
    }

    shards = new ShardStats();
    indexCount = countsPerIndex.size();
    for (ObjectObjectCursor<String, ShardStats> indexCountsCursor : countsPerIndex) {
        shards.addIndexShardCount(indexCountsCursor.value);
    }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public final synchronized <V> V putInContext(Object key, Object value) {
    if (context == null) {
        context = new ObjectObjectHashMap<>(2);
    }
    return (V) context.put(key, value);
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
@Override
public final synchronized void putAllInContext(ObjectObjectAssociativeContainer<Object, Object> map) {
    if (map == null) {
        return;
    }
    if (context == null) {
        context = new ObjectObjectHashMap<>(map);
    } else {
        context.putAll(map);
    }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
protected void initMatrix(
    final ObjectObjectHashMap<Double, IntFloatHashMap> matrix,
    final Set<Double> uniqueLabels,
    final BagOfPattern[] bag) {
  for (Double label : uniqueLabels) {
    IntFloatHashMap stat = matrix.get(label);
    if (stat == null) {
      matrix.put(label, new IntFloatHashMap(bag[0].bag.size() * bag.length));
    } else {
      stat.clear();
    }
  }
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
@Override
public void setup(final int[] keys, final float fillFactor, final int oneFailureOutOf ) {
    super.setup( keys, fillFactor, oneFailureOutOf );
    m_map = new ObjectObjectHashMap<>( keys.length, fillFactor );
    for (Integer key : m_keys)
        m_map.put(new Integer( key % oneFailureOutOf == 0 ? key + 1 : key ), key);
}
 

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

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public Element toXmlDocument (String rootEltName, Object ns) {
	ArrayList orderedByStart = new ArrayList (extractedSpans);
	Collections.sort (orderedByStart, new Comparator () {
			public int compare (Object o, Object o1)
			{
				int start1 = ((Span)o).getStartIdx ();
				int start2 = ((Span)o1).getStartIdx ();
				return Double.compare (start1, start2);
			}
		} );

	ArrayList roots = new ArrayList (orderedByStart);
	ObjectObjectHashMap children = new ObjectObjectHashMap ();
	for (int i = 0; i < orderedByStart.size(); i++) {
		LabeledSpan child = (LabeledSpan) orderedByStart.get (i);
		for (int j = i-1; j >= 0; j--) {
			LabeledSpan parent = (LabeledSpan) orderedByStart.get (j);
			if (parent.isSubspan (child)) {
				List childList = (List) children.get (parent);
				if (childList == null) {
					childList = new ArrayList ();
					children.put (parent, childList);
				}
				roots.remove (child);
				childList.add (child);
				break;
			}
		}
	}

	CharSequence doc = (CharSequence) document;
	Span wholeDoc = new StringSpan (doc, 0, doc.length ());

	return generateElement (rootEltName, wholeDoc, roots, children);
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
private Element generateElement (String parentName, Span span, List childSpans, ObjectObjectHashMap tree) {
	Element parentElt = new Element (parentName);
	if (childSpans == null || childSpans.isEmpty ()) {
		parentElt.setContent (new Text (span.getText ()));
	} else {
		List childElts = new ArrayList (childSpans.size());
		int start = span.getStartIdx ();
		int current = 0;
		for (int i = 0; i < childSpans.size(); i++) {
			LabeledSpan childSpan = (LabeledSpan) childSpans.get (i);
			Label childLabel = childSpan.getLabel();

			int childStart = childSpan.getStartIdx () - start;
			if (childStart > current) {
				childElts.add (new Text (span.getText().substring (current, childStart)));
			}

			if (childLabel == backgroundTag) {
				childElts.add (new Text (childSpan.getText()));
			} else {
				String name = childLabel.getEntry ().toString();
				List grandchildren = (List) tree.get (childSpan);
				childElts.add (generateElement (name, childSpan, grandchildren, tree));
			}

			current = childSpan.getEndIdx () - start;
		}

		if (current < span.getEndIdx ())
			childElts.add (new Text (span.getText().substring (current)));

		parentElt.addContent (childElts);
	}

	return parentElt;
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public AggregatedDfs(ObjectObjectHashMap<Term, TermStatistics> termStatistics, ObjectObjectHashMap<String, CollectionStatistics> fieldStatistics, long maxDoc) {
    this.termStatistics = termStatistics;
    this.fieldStatistics = fieldStatistics;
    this.maxDoc = maxDoc;
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public ObjectObjectHashMap<Term, TermStatistics> termStatistics() {
    return termStatistics;
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
public ObjectObjectHashMap<String, CollectionStatistics> fieldStatistics() {
    return fieldStatistics;
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
/**
 * Returns a new map with a default initial capacity.
 */
public static <K, V> ObjectObjectHashMap<K, V> newMap() {
    return newMap(16);
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
/**
 * Returns a map like {@link #newMap()} that does not accept <code>null</code> keys
 */
public static <K, V> ObjectObjectHashMap<K, V> newNoNullKeysMap() {
    return ensureNoNullKeys(16);
}
 

import com.carrotsearch.hppc.ObjectObjectHashMap; //导入依赖的package包/类
private ImmutableOpenMap(ObjectObjectHashMap<KType, VType> map) {
    this.map = map;
}