Java Object2ObjectOpenHashMap类代码示例

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Create a HashIndex that can be used when executing queries.
 * 
 * @param indexName the name of this index, used for statistics collection
 * @param indexedExpression the expression to index on, a function dependent on region entries
 *        individually, limited to a path expression.
 * @param fromClause expression that evaluates to the collection(s) that will be queried over,
 *        must contain one and only one region path, and only one iterator.
 * @param projectionAttributes not used
 * @param definitions the canonicalized definitions
 */
public HashIndex(String indexName, Region region, String fromClause, String indexedExpression,
    String projectionAttributes, String origFromClause, String origIndexExpr,
    String[] definitions, IndexStatistics stats) {
  super(indexName, region, fromClause, indexedExpression, projectionAttributes, origFromClause,
      origIndexExpr, definitions, stats);
  RegionAttributes ra = region.getAttributes();


  if (IndexManager.isObjectModificationInplace()) {
    entryToValuesMap = new ConcurrentHashMap(ra.getInitialCapacity(), ra.getLoadFactor(),
        ra.getConcurrencyLevel());
  } else {
    if (entryToOldKeysMap == null) {
      entryToOldKeysMap = new ThreadLocal<Object2ObjectOpenHashMap>();
    }
  }

  entriesSet = new HashIndexSet();
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * @param opCode one of OTHER_OP, BEFORE_UPDATE_OP, AFTER_UPDATE_OP.
 */
void removeMapping(RegionEntry entry, int opCode) throws IMQException {
  // logger.debug("##### In RemoveMapping: entry : "
  // + entry );
  if (opCode == BEFORE_UPDATE_OP) {
    // Either take key from reverse map OR evaluate it using IMQEvaluator.
    if (!IndexManager.isObjectModificationInplace()) {
      // It will always contain 1 element only, for this thread.
      entryToOldKeysMap.set(new Object2ObjectOpenHashMap(1));
      this.evaluator.evaluate(entry, false);
    }
  } else {
    // Need to reset the thread-local map as many puts and destroys might
    // happen in same thread.
    if (entryToOldKeysMap != null) {
      entryToOldKeysMap.remove();
    }
    this.evaluator.evaluate(entry, false);
    this.internalIndexStats.incNumUpdates();
  }
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public void writeProperties(Object2ObjectOpenHashMap<String,DataRef> props) {
    try {
        writer.writeStartObject();
        for (Object2ObjectMap.Entry<String, DataRef> entry : props.object2ObjectEntrySet()) {
            writer.writeFieldName(entry.getKey());
            if(entry.getValue() instanceof CoreRef) {
                CoreRef prop =  (CoreRef)(entry.getValue());
                prop.write(propwriter);
            }
            else
                throw new UnsupportedOperationException("Only CoreRefs are supported for encoding.");
        }

        writer.writeEndObject();
    } catch (IOException e) {
        throw new IOError(e);
    }
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Outputs on stdout the different clusters computed
 *
 * @param cluster word clusters
 */
public void printClusters( Object2ObjectOpenHashMap<String, ClusterEntry> cluster ) {
    int k = -1;
    for( ClusterEntry jj : cluster.values() ) {
        if( jj.cluster > k ) k = jj.cluster;
    }
    k++;
    for( int i = 0; i < k; i++ ) {
        for( String s : cluster.keySet() ) {
            if( cluster.get( s ).cluster == i ) {
                //if ( cluster.get( s ).score > 0.5 )
                System.out.println( s + "\t" + i + "\t" + cluster.get( s ).score );
            }
        }
    }
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * k-means of the words in the vector file
 * @param k number of clusters
 * @param map vector
 * @return clustering of the words in the vector
 */
public Object2ObjectOpenHashMap<String, ClusterEntry> cluster( final int k, final UncompressedWordVectors map ) {
    final int len = map.vectors.keySet().size();
    int[] original = new int[ len ];
    Random r = new Random();
    for( int i = 0; i < k; i++ ) {
        original[ i ] = i;
    }
    for( int i = k + 1; i < len; i++ ) {
        original[ i ] = r.nextInt( k );
    }

    String[] words = new String[ map.vectors.keySet().size() ];
    int z = 0;
    for( String s : map.vectors.keySet() ) {
        words[ z++ ] = s;
    }
    return cluster( k, map, original, words );
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Returns the closest word in the vector file
 * @param map vectors
 * @param words input words
 * @return a list of closest words to the input ones
 */
public Object2ObjectOpenHashMap<String, ClusterEntry> assignClosest( final UncompressedWordVectors map, ArrayList<String> words ) {
    final int d = map.getVectorLength();
    Object2ObjectOpenHashMap<String, ClusterEntry> assignment = new Object2ObjectOpenHashMap<String, ClusterEntry>();
    for( String w : map.vectors.keySet() ) {
        float maxSim = -1;
        int bestWord = -1;
        for( int j = 0; j < words.size(); j++ ) {
            final float s = sim( map.vectors.get( w ), map.vectors.get( words.get( j ) ), d );
            if( s > maxSim ) {
                maxSim = s;
                bestWord = j;
            }
        }
        ClusterEntry e = new ClusterEntry();
        e.cluster = bestWord;
        e.score = maxSim;
        assignment.put( w, e );
    }
    return assignment;
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public static UncompressedWordVectors read( String file ) throws IOException {
    Object2ObjectOpenHashMap<String, float[]> map = new Object2ObjectOpenHashMap<String, float[]>();
    final BufferedReader lines = new BufferedReader( new FileReader( file ) );
    String line;
    while( ( line = lines.readLine() ) != null ) {
        String parts[] = line.split( "\t" );
        float[] values = new float[ parts.length - 1 ];
        for( int i = 1; i < parts.length; i++ ) {
            values[ i - 1 ] = Float.parseFloat( parts[ i ] );
        }
        map.put( parts[ 0 ], values );
    }
    lines.close();
    UncompressedWordVectors vector = new UncompressedWordVectors();
    vector.vectors = map;
    return vector;
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public Iterable<M> getVertexMessagesImproved(I vertexId, int pId) throws IOException {

        Object2ObjectOpenHashMap<I,DataInputOutput[]> partitionMap = new_map[pId];
        DataInputOutput[] vertex_map_entry = partitionMap.get(vertexId);
        if( vertex_map_entry == null)
        {
            return EmptyIterable.get();
        }
        reentrant_locks[pId].readLock().lock();
        try {
            int current_index = getCurrentIndex(pId,vertexId);
            DataInputOutput result =  vertex_map_entry[current_index];
            resetCurrentIndex(pId,vertexId, current_index);
            ((UnsafeByteArrayOutputStream) ((ExtendedDataInputOutput)  vertex_map_entry[getCurrentIndex(pId,vertexId)]).getDataOutput()).reset();
            synchronized (has_messages_map[pId]) {
                has_messages_map[pId].remove(vertexId);
            }
            return new MessagesIterable<M>(result, messageValueFactory);
        } finally {
        reentrant_locks[pId].readLock().unlock();
        }
    }
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public Iterable<M> getVertexMessagesImproved(I vertexId, int pId) throws IOException {

        Object2ObjectOpenHashMap<I,M[]> partitionMap = new_map[pId];
        M[] vertex_map_entry = partitionMap.get(vertexId);
        if( vertex_map_entry == null)
        {
            return EmptyIterable.get();
        }

        reentrant_locks[pId].readLock().lock();
        try {
            int current_index = getCurrentIndex(pId, vertexId);
            M result = vertex_map_entry[current_index];
            resetCurrentIndex(pId, vertexId, current_index);
            vertex_map_entry[getCurrentIndex(pId, vertexId)] = messageCombiner.createInitialMessage();
            synchronized (has_messages_map[pId]) {
                has_messages_map[pId].remove(vertexId);
            }
            return Collections.singleton(result);
        } finally {
            reentrant_locks[pId].readLock().unlock();
        }

    }
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public UUIDCommodityMap(Set<UUID> allUUIDs, 
		Object2IntOpenHashMap<UUID> uuidIntMap,
		Object2ObjectOpenHashMap<UUID, Commodity[]> uuidInputMap,
		boolean makeNoMap) {
	keyMap = null;
	partIdToArrayIdMap = new int[uuidIntMap.size()];
	innerValues = new LimitedCommodityStateMap[allUUIDs.size()];
	
	Arrays.fill(partIdToArrayIdMap, -1);
	
	Iterator<UUID> it = allUUIDs.iterator();
	for (int i = 0; i < allUUIDs.size(); i++) {
		UUID curr = it.next();
		if (uuidIntMap.containsKey(curr)) {
			partIdToArrayIdMap[uuidIntMap.getInt(curr)] = i;
			innerValues[i] = new LimitedCommodityStateMap(uuidInputMap.get(curr));
		} else {
			throw new IllegalArgumentException("no mapping for specified key");
		}
	}
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public PooledDatasetChecker(GroundTruth evaluations, ImmutableGraph g, UnexpectednessScorer[] pool, Int2ObjectMap<String> id2name) throws IOException {
	this.graph = g;
	this.pool = pool;
	this.evaluations = evaluations;
	this.id2name = id2name;
	SummaryStatistics[] stats = new SummaryStatistics[pool.length];
	for (int i = 0; i < stats.length; i++)
		stats[i] = new SummaryStatistics();
	retriever2itsFraction = new Object2ObjectOpenHashMap<UnexpectednessScorer, SummaryStatistics>(pool, stats);
	for (int i = 0; i < stats.length; i++)
		stats[i] = new SummaryStatistics();
	retriever2evaluatedTopResults = new Object2ObjectOpenHashMap<UnexpectednessScorer, SummaryStatistics>(pool, stats);
	unmatchStats = new SummaryStatistics();

	System.out.println(evaluations.stats());
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Add a tag to the element.
 *
 * @param key   The key of the tag.
 * @param value The value of the tag.
 * @return      The previous value of the key, if any.
 */
public final String tag(final String key, final String value) {
  if (key == null || value == null) {
    return null;
  }

  String k = key.trim();
  String v = value.trim();

  if (k.isEmpty() || v.isEmpty()) {
    return null;
  }

  if (this.tags == null) {
    this.tags = new Object2ObjectOpenHashMap<>(INITIAL_TAG_CAPACITY);
  }

  return this.tags.put(STRING_POOL.get(k), STRING_POOL.get(v));
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Given a prefix, find all keys within the ternary search tree that contain
 * the specified prefix.
 *
 * @param prefix  The prefix to search for.
 * @return        A map of matching keys and their associated values.
 */
public final Map<String, V> search(final String prefix) {
  Map<String, V> results = new Object2ObjectOpenHashMap<>();

  if (prefix == null) {
    return results;
  }

  Node<V> root = this.get(this.root, prefix, 0);

  if (root == null) {
    return results;
  }

  if (root.value != null) {
    results.put(prefix, root.value);
  }

  this.search(root.equal, new StringBuilder(prefix), results);

  return results;
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
public Weights<T> average() {
	System.err.print("averaging (this may take a while)... ");
	Weights<T> result = new Weights<T>(opts, true);
	result.data = new Object2ObjectOpenHashMap<>();
	result.index = index;
	result.gram = gram;
	int cnt = 0;
	for (String feat : data.keySet()) {
		FeatureWeights dw = data.get(feat);
		if (dw.used > opts.minupdate) {
			cnt++;
			FeatureWeights fw = new FeatureWeights();
			for (int trans : index.indices()) {
				float averaged = dw.getAveraged(trans, i);
				if (!Float.isNaN(averaged)) {
					fw.increment(trans, averaged, 0);
				}
			}
			result.data.put(feat, fw);
		}
	}
	System.err.println("done, averaged " + cnt + " features.");
	return result;
}
 

import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap; //导入依赖的package包/类
/**
 * Initializes internal data structures for transitions.
 */
private void initTransitionsMaps() {
	if (trId2bpnMap == null) {
		trId2bpnMap = new Object2LongOpenHashMap<String>();
		trId2bpnMap.defaultReturnValue(-1L);
	}
	if (tr2InPlacesMap == null) {
		tr2InPlacesMap = new Long2ObjectOpenHashMap<>();
		tr2InPlacesMap.defaultReturnValue(null);
	}
	if (tr2OutPlacesMap == null) {
		tr2OutPlacesMap = new Long2ObjectOpenHashMap<>();
		tr2OutPlacesMap.defaultReturnValue(null);
	}
	if (tr2InAllArcsMap == null) {
		tr2InAllArcsMap = new Object2ObjectOpenHashMap<String, LongBigArrayBigList>();
		tr2InAllArcsMap.defaultReturnValue(null);
	}
	if (tr2OutAllArcsMap == null) {
		tr2OutAllArcsMap = new Object2ObjectOpenHashMap<String, LongBigArrayBigList>();
		tr2OutAllArcsMap.defaultReturnValue(null);
	}
}