gnu.trove.map.hash.TIntObjectHashMap Java Examples

void afterUnmarshal(Unmarshaller u, Object parent) {
	itemUpgradeSets = new TIntObjectHashMap<ItemUpgradeTemplate>();
	ResultItemMap = new FastMap<Integer, FastMap<Integer, UpgradeResultItem>>();

	for (ItemUpgradeTemplate set : ItemUpgradeTemplates) {
		itemUpgradeSets.put(set.getUpgrade_base_item_id(), set);

		ResultItemMap.put(set.getUpgrade_base_item_id(), new FastMap<Integer, UpgradeResultItem>());

		if (!set.getUpgrade_result_item().isEmpty()) {
			for (UpgradeResultItem resultItem : set.getUpgrade_result_item()) {
				ResultItemMap.get(set.getUpgrade_base_item_id()).put(resultItem.getItem_id(), resultItem);
			}
		}
	}
	ItemUpgradeTemplates = null;
}
 

@Override public TIntObjectHashMap<int[]> getInlinkNeighbors(Entities entities) throws EntityLinkingDataAccessException {
  TIntObjectHashMap<int[]> inlinks = new TIntObjectHashMap<int[]>();

  for (Entity e : entities) {
    inlinks.put(e.getId(), new int[0]);
  }

  for (String[] entityInlinks : allInlinks) {
    int eId = DataAccess.getInternalIdForKBEntity(getTestKBEntity(entityInlinks[0]));
    int[] inlinkIds = new int[entityInlinks.length - 1];
    for (int i = 1; i < entityInlinks.length; ++i) {
      inlinkIds[i - 1] = DataAccess.getInternalIdForKBEntity(getTestKBEntity(entityInlinks[i]));
    }
    Arrays.sort(inlinkIds);
    inlinks.put(eId, inlinkIds);
  }

  return inlinks;
}
 

private void setupEntities(Entities entities) throws Exception {
  logger.debug("Initializing MilneWittenEntityEntitySimilarity for " + entities.size() + " entities");

  collectionSize = DataAccess.getCollectionSize();

  TIntObjectHashMap<int[]> entityInlinks = DataAccess.getInlinkNeighbors(entities);

  // inlinks are assumed to be pre-sorted.
  entity2vector = new TIntObjectHashMap<>();

  for (TIntObjectIterator<int[]> itr = entityInlinks.iterator(); itr.hasNext(); ) {
    itr.advance();
    int entity = itr.key();
    int[] inLinks = itr.value();

    RoaringBitmap bs = new RoaringBitmap();
    for (int l : inLinks) {
      bs.add(l);
    }
    entity2vector.put(entity, bs);
  }

  logger.debug("Done initializing MilneWittenEntityEntitySimilarity for " + entities.size() + " entities");
}
 

public void addPartition(EquivalenceManagedPartition partition) {
	if (!this.observedPartitions.contains(partition.getIndices()) && !this.containsSimilarPartition(partition)) {
		this.observedPartitions.add(partition.getIndices());
		long hashNumber = partition.getHashNumber();
		System.out.println(String.format("Partition[%s]\t%d\tSize: %d", partition.getIndices(), Long.valueOf(hashNumber), Integer.valueOf(partition.size())));
		partitionHashes.putIfAbsent(hashNumber, new TIntObjectHashMap<THashSet<EquivalenceManagedPartition>>());
		partitionHashes.get(hashNumber).putIfAbsent(partition.size(), new THashSet<EquivalenceManagedPartition>());
		THashSet<EquivalenceManagedPartition> partitionGroup = partitionHashes.get(hashNumber).get(partition.size());

		if (partitionGroup.isEmpty()) {
			partitionGroup.add(partition);
		} else {
			// then there is at least one element in the partitionGroup
			checkPossibleEquivalences(partitionGroup, partition);
		}
	}
}
 

void afterUnmarshal(Unmarshaller u, Object parent) {
	lunaData = new TIntObjectHashMap<LunaTemplate>();
	elyos = FastList.newInstance();
	asmos = FastList.newInstance();
	any = FastList.newInstance();
	for (LunaTemplate lt : list) {
		lunaData.put(lt.getId(), lt);
		switch (lt.getRace()) {
			case ASMODIANS:
				asmos.add(lt);
				break;
			case ELYOS:
				elyos.add(lt);
				break;
			case PC_ALL:
				any.add(lt);
				break;
			default:
				break;
		}
	}
	list = null;
}
 

public void run() throws Exception {
  logger.info("STARTING");
  logger.info("Reading Link Graph");
  Entities entities = DataAccess.getAllEntities();
  TIntObjectHashMap<int[]> linkFrom = DataAccess.getAllInlinks();
  TIntObjectHashMap<int[]> linkTo = transformInlinksToOutlinks(linkFrom);
  logger.info("Creating Count Dictionaries");
  TIntObjectHashMap<TIntIntHashMap> superdocKeyphraseCounts = createAllSuperdocKeyphraseDictionaries();
  logger.info("Counting Keyphrase Occurrences");
  fillSuperdocKeyphraseCounts(linkTo, superdocKeyphraseCounts);
  logger.info("Writing to file");
  writeToFile(superdocKeyphraseCounts);
  // Flush global writer.
  writer.flush();
  writer.close();
  logger.info("DONE");
}
 

public static byte[] transform(WatchedEntity entity, byte[] data) throws IOException {
    if (entity == null) {
        return data;
    }
    TIntObjectMap<DataWatcherObject> objects = DataWatcherSerializer.decodeData(data);
    TIntObjectMap<DataWatcherObject> newobjects = new TIntObjectHashMap<DataWatcherObject>();
    //copy entity
    moveDWData(objects, newobjects, 0, 0); //flags
    moveDWData(objects, newobjects, 1, 1); //air
    moveDWData(objects, newobjects, 2, 2); //nametag
    moveDWData(objects, newobjects, 3, 3); //nametagvisible
    //copy specific types
    for (RemappingEntry entry : entity.getType().getRemaps()) {
        moveDWData(objects, newobjects, entry.getFrom(), entry.getTo());
    }
    return DataWatcherSerializer.encodeData(newobjects);
}
 

private void writeToFile(TIntObjectHashMap<TIntIntHashMap> superdocKeyphraseCounts) throws IOException, SQLException {
  int eCount = 0;

  logger.info("Writing entity-keyphrase pairs for " + superdocKeyphraseCounts.size() + " entities");

  for (int eid : superdocKeyphraseCounts.keys()) {

    if ((++eCount % 100000) == 0) {
      double percent = (double) eCount / (double) superdocKeyphraseCounts.size();

      logger.info("Wrote " + eCount + " entities (" + new DecimalFormat("#.##").format(percent) + ")");
    }

    TIntIntHashMap keyphraseCounts = superdocKeyphraseCounts.get(eid);

    for (int kid : keyphraseCounts.keys()) {
      int count = keyphraseCounts.get(kid);

      writer.write(eid + "\t" + kid + "\t" + String.valueOf(count));
      writer.newLine();
    }
  }
}
 

public TIntObjectHashMap<TIntIntHashMap> getEntityKeyphraseIntersectionCount(Entities entities) throws EntityLinkingDataAccessException {
  TIntObjectHashMap<TIntIntHashMap> isec = new TIntObjectHashMap<TIntIntHashMap>();
  for (String[] eKps : allEntityKeyphrases) {
    int entity = DataAccess.getInternalIdForKBEntity(getTestKBEntity(eKps[0]));
    TIntIntHashMap counts = new TIntIntHashMap();
    isec.put(entity, counts);

    if (eKps.length > 1) {
      int currentKp = -1;
      for (int i = 1; i < eKps.length; ++i) {
        if (i % 2 == 1) {
          currentKp = DataAccess.getIdForWord(eKps[i]);
        } else {
          int count = Integer.parseInt(eKps[i]);
          counts.put(currentKp, count);
        }
      }
    }
  }
  return isec;
}
 

/**
 * Create a new mapping.
 */
@SuppressWarnings("unchecked")
public DefaultMapping() {

    nodeState = new Set[2];
    nodeState[ONLINE_STATE] = new THashSet<>();
    nodeState[OFFLINE_STATE] = new THashSet<>();

    vmReady = new THashSet<>();

    place = new TIntObjectHashMap<>();

    host = new TIntObjectHashMap[2];
    host[RUNNING_STATE] = new TIntObjectHashMap<>();
    host[SLEEPING_STATE] = new TIntObjectHashMap<>();

    st = new TIntIntHashMap(100, 0.5f, -1, -1);
}
 

public KeytermEntityEntityMeasureTracer(String name, double weight, Map<Integer, Double> keyphraseWeights, Map<Integer, TermTracer> matches,
    TIntObjectHashMap<int[]> keyphraseTokens) throws EntityLinkingDataAccessException {
  super(name, weight);

  this.terms = keyphraseWeights;
  this.matchedTerms = matches;
  this.keyphraseTokens = keyphraseTokens;

  synchronized (id2word) {
    if (id2word.size() == 0) {
      logger.debug("Reading all word ids for tracing.");
      id2word = getAllWordIds();
      logger.debug("Reading all word ids for tracing done.");
    }
  }
}
 

@Override
public boolean inject(Parameters ps, ReconfigurationProblem rp) throws SchedulerException {
    powerStarts = new TIntObjectHashMap<>(rp.getNodes().size());
    powerEnds = new TIntObjectHashMap<>(rp.getNodes().size());

    for (Node n : rp.getNodes()) {
        NodeTransition na = rp.getNodeAction(n);
        if (na instanceof ShutdownableNode) {
            powerStarts.put(rp.getNode(n), rp.getStart());
            IntVar powerEnd = rp.makeUnboundedDuration("NodeActionType(", n, ").Pe");
            TaskMonitor.build(na.getHostingEnd(), na.getDuration(), powerEnd);
            powerEnds.put(rp.getNode(n), powerEnd);
            rp.getModel().post(rp.getModel().arithm(powerEnd, "<=", rp.getEnd()));
        } else if (na instanceof BootableNode) {
            powerStarts.put(rp.getNode(n), na.getStart());
            powerEnds.put(rp.getNode(n), rp.getEnd());
        }
    }
    return true;
}
 

private void setupEntities(Entities entities) throws Exception {
  if (entities.size() == 0) {
    logger.debug("Skipping initialization of InlinkEntityEntitySimilarity for " + entities.size() + " entities");
    return;
  }

  logger.debug("Initializing InlinkEntityEntitySimilarity for " + entities.size() + " entities");

  entity2vector = new TIntObjectHashMap<>();

  TIntObjectHashMap<int[]> entityInlinks = DataAccess.getInlinkNeighbors(entities);

  for (TIntObjectIterator<int[]> itr = entityInlinks.iterator(); itr.hasNext(); ) {
    itr.advance();
    int entity = itr.key();
    int[] inLinks = itr.value();

    RoaringBitmap bs = new RoaringBitmap();
    for (int l : inLinks) {
      bs.add(l);
    }
    entity2vector.put(entity, bs);
  }

  logger.debug("Done initializing InlinkEntityEntitySimilarity");
}
 

public void init(){
    TIntObjectHashMap<Class<?>> requestHandlerClassMap = ServiceHelper.getRequestHandlerMap();
    requestHandlerClassMap.forEachEntry(new TIntObjectProcedure<Class<?>>(){
        @Override
        public boolean execute(int i, Class<?> aClass) {
            handlerMap.put(i, (RequestHandler)BeanHelper.getServiceBean(aClass));
            timeMap.put(i,new ConcurrentLinkedDeque<>());
            return true;
        }
    });
    // 命令
    List<Class<?>> cmdClasses = ClassHelper.getClassListEndWith("com.myFruit.cmd","Cmd");
    for (Class<?> cls:cmdClasses) {

        Field[] fields = cls.getFields();
        for(Field field : fields){
            try {
                opcodeNames.put(field.getInt(null),field.getName());
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

}
 

public static Map<KBIdentifiedEntity, EntityMetaData> getEntitiesMetaData(Set<KBIdentifiedEntity> entities)
    throws EntityLinkingDataAccessException {
  TObjectIntHashMap<KBIdentifiedEntity> ids = getInternalIdsForKBEntities(entities);
  TIntObjectHashMap<EntityMetaData> metadata = getEntitiesMetaData(ids.values());
  Map<KBIdentifiedEntity, EntityMetaData> result = new HashMap<KBIdentifiedEntity, EntityMetaData>();
  for (TObjectIntIterator<KBIdentifiedEntity> itr = ids.iterator(); itr.hasNext(); ) {
    itr.advance();
    int id = itr.value();
    result.put(itr.key(), metadata.get(id));
  }
  return result;
}
 

@Override
public void clearAllVMs() {
    place.clear();
    st.clear();
    vmReady.clear();
    for (TIntObjectHashMap<Set<VM>> h : host) {
        h.clear();
    }
}
 

private synchronized void addToEntityKeyphrasesCache(String querySignature, TIntObjectHashMap<List<EntityKeyphraseData>> entityKeyphrases) {
  CachingHashMap<Integer, List<EntityKeyphraseData>> queryCache = entityKeyphrasesCaches.get(querySignature);
  if (queryCache == null) {
    int maxEntities = EntityLinkingConfig.getAsInt(EntityLinkingConfig.ENTITIES_CACHE_SIZE);
    queryCache = new CachingHashMap<Integer, List<EntityKeyphraseData>>(maxEntities);
    entityKeyphrasesCaches.put(querySignature, queryCache);
  }

  for (TIntObjectIterator<List<EntityKeyphraseData>> itr = entityKeyphrases.iterator(); itr.hasNext(); ) {
    itr.advance();
    int entityId = itr.key();
    List<EntityKeyphraseData> keyphrases = itr.value();
    queryCache.put(entityId, keyphrases);
  }
}
 

private static Collection<String> getLanguageSpecificMentionsForEntities(TIntObjectHashMap<EntityMetaData> entitiesMetaData) throws EntityLinkingDataAccessException {
    int[] collect = entitiesMetaData
            .valueCollection()
.stream()
.mapToInt(e -> e.getId())
.toArray();
    return DataAccess.getEntityMentionsforLanguageAndEntities(collect, Language.getLanguageForString(language)).keySet();
}
 

private Map<Integer, Map<Integer, Double>> computeConfidence(Graph g, TIntObjectHashMap<TIntIntHashMap> mentionEntityCounts) {
  Map<Integer, Map<Integer, Double>> confidences = new HashMap<Integer, Map<Integer, Double>>();
  // Fill with 0 confidences
  for (int mentionId : solution_.keySet()) {
    Map<Integer, Double> mentionConfidences = new HashMap<Integer, Double>();
    confidences.put(mentionId, mentionConfidences);
    int[] candidateEntities = g.getNode(mentionId).getSuccessors().keys();
    for (int entity : candidateEntities) {
      mentionConfidences.put(entity, 0.0);
    }
  }

  for (TIntObjectIterator<TIntIntHashMap> itr = mentionEntityCounts.iterator(); itr.hasNext(); ) {
    itr.advance();
    int mentionId = itr.key();
    // Get total count for mention.
    int totalCount = 0;
    for (TIntIntIterator innerItr = itr.value().iterator(); innerItr.hasNext(); ) {
      innerItr.advance();
      totalCount += innerItr.value();
    }
    // Compute confidences (by normalizing).
    Map<Integer, Double> entityConfidences = confidences.get(mentionId);
    if (entityConfidences.size() == 1) {
      entityConfidences.put(entityConfidences.keySet().iterator().next(), SINGLE_CANDIDATE_CONFIDENCE);
    } else {
      TIntIntHashMap entityCounts = itr.value();
      for (TIntIntIterator innerItr = entityCounts.iterator(); innerItr.hasNext(); ) {
        innerItr.advance();
        int entityId = innerItr.key();
        double entityConfidence = (double) innerItr.value() / (double) totalCount;
        assert entityConfidence <= 1.0001;
        assert entityConfidence >= -0.0001;
        entityConfidences.put(entityId, entityConfidence);
      }
    }
    confidences.put(mentionId, entityConfidences);
  }
  return confidences;
}
 

@Override public TIntObjectHashMap<TIntIntHashMap> getEntityUnitIntersectionCount(Entities entities, UnitType unitType)
    throws EntityLinkingDataAccessException {
  switch (unitType) {
    case KEYWORD:
    case BIGRAM:
      return getEntityUnitIntersectionCountInternal(entities, unitType);
    default:
      return null;
  }
}
 

@Override public Entities getEntitiesForInternalIds(int[] ids) throws EntityLinkingDataAccessException {
  Entities entities = new Entities();
  TIntObjectHashMap<KBIdentifiedEntity> yagoEntityIds = getKnowlegebaseEntitiesForInternalIds(ids);
  if (yagoEntityIds.isEmpty()) {
    return entities;
  }
  for (int id : ids) {
    KBIdentifiedEntity kbi = yagoEntityIds.get(id);
    entities.add(new Entity(kbi, id));
  }
  return entities;
}
 

public TIntObjectHashMap<int[]> getTypesIdsForEntitiesIds(int[] entitiesIds) throws EntityLinkingDataAccessException {
  if (entitiesIds.length == 0) {
    return new TIntObjectHashMap<>();
  }

  TIntObjectHashMap<int[]> typesIds = new TIntObjectHashMap<>(getCapacity(entitiesIds.length), troveLoadFactor);
  try {
    DatabaseKeyValueStore db = DatabaseKeyValueStore.ENTITY_TYPES_ENTITY;
    if(db.getPartitions() != 1) {
      throw new IllegalArgumentException("Multiple partitions not supported for this key-value store");
    }
    Codec entityTypesCodec = DataAccessKeyValueStoreHandler.singleton().getCodec(db);
    KeyValueStore<byte[], byte[]> keyValueStore = DataAccessKeyValueStoreHandler.singleton().getKeyValueStore(db);

    List<byte[]> encodedKeys = new ArrayList<>();
    for (int id : entitiesIds) {
      encodedKeys.add(entityTypesCodec.encodeKey(id));
    }
    Map<byte[], byte[]> keyValueMap = keyValueStore.getAll(encodedKeys);

    if (keyValueMap.size() != entitiesIds.length) {
      for (int entitiesId : entitiesIds) {
        typesIds.put(entitiesId, new int[0]);
      }
    }

    for (Map.Entry<byte[], byte[]> entry : keyValueMap.entrySet()) {
      if (entry.getKey() == null || entry.getValue() == null) continue;
      int entity = (int) entityTypesCodec.decodeKey(entry.getKey());
      int[] curTypesIds = (int[]) entityTypesCodec.decodeValue(entry.getValue());
      typesIds.put(entity, curTypesIds);
    }
  } catch (Exception e) {
    throw new EntityLinkingDataAccessException(e);
  }
  return typesIds;
}
 

/**
 * Utility method to copy the contents of a ClassifierResult.
 * 
 * @return  a copy of this {@code ClassifierResult} which will not be affected
 * by changes to the original.
 */
public Classification<T> copy() {
    Classification<T> retVal = new Classification<T>();
    retVal.actualValues = Arrays.copyOf(actualValues, actualValues.length);
    retVal.probabilities = new TIntObjectHashMap<double[]>(probabilities);
    
    return retVal;
}
 

@Override
protected void loadFromDisk() throws IOException {
  File cacheFile = getCacheFile();
  DataInputStream in = new DataInputStream(new BufferedInputStream(new GZIPInputStream(new FileInputStream(cacheFile))));
  int size = in.readInt();
  data_ = new TIntObjectHashMap<>((int) (size / Constants.DEFAULT_LOAD_FACTOR));
  for (int i = 0; i < size; ++i) {
    int entityId = in.readInt();
    int entityClass = in.readInt();
    data_.put(entityId, EntityType.getNameforDBId(entityClass));
  }
  in.close();
}
 

@Override
public TIntObjectHashMap<EntityType> getEntityClasses(Entities entities) throws EntityLinkingDataAccessException {
  TIntObjectHashMap<EntityType> entityClasses = new TIntObjectHashMap<>();
  for (Entity e : entities) {
    entityClasses.put(e.getId(), EntityType.NAMED_ENTITY);
  }
  return entityClasses;
}
 

private TIntObjectHashMap<TIntIntHashMap> createHashMap() {
  TIntObjectHashMap<TIntIntHashMap> overallMap = new TIntObjectHashMap<TIntIntHashMap>();
  TIntIntHashMap map1 = new TIntIntHashMap();
  overallMap.put(1, map1);

  TIntIntHashMap map2 = new TIntIntHashMap();
  map2.put(21, 100);
  map2.put(22, 101);
  map2.put(23, 102);
  overallMap.put(2, map2);

  TIntIntHashMap map3 = new TIntIntHashMap();
  map3.put(31, 103);
  map3.put(32, 104);
  map3.put(33, 105);
  overallMap.put(3, map3);

  TIntIntHashMap map4 = new TIntIntHashMap();
  overallMap.put(4, map4);

  TIntIntHashMap map5 = new TIntIntHashMap();
  map5.put(51, 106);
  map5.put(52, 107);
  map5.put(53, 108);
  overallMap.put(5, map5);

  TIntIntHashMap map6 = new TIntIntHashMap();
  overallMap.put(6, map6);

  TIntIntHashMap map7 = new TIntIntHashMap();
  overallMap.put(7, map7);

  return overallMap;
}
 

void afterUnmarshal(Unmarshaller u, Object parent) {
	titles = new TIntObjectHashMap<TitleTemplate>();
	for (TitleTemplate tt : tts) {
		titles.put(tt.getTitleId(), tt);
	}
	tts = null;
}
 

public TIntObjectHashMap<Cluster> refineBy(int column, int[][] values) {
	TIntObjectHashMap<Cluster> map = new TIntObjectHashMap<>();
	for (TIntIterator iter = array.iterator(); iter.hasNext();) {
		int line = iter.next();
		int c = values[line][column];
		if (map.containsKey(c)) {
			map.get(c).add(line);
		} else {
			Cluster p = new Cluster(line);
			map.put(c, p);
		}
	}
	return map;
}
 

private static TIntObjectHashMap<String> getUsedWords(TIntSet usedTokens, TIntObjectHashMap<String> idsWords) {
  TIntObjectHashMap<String> usedWords = new TIntObjectHashMap<>();
  for (TIntIterator itr = usedTokens.iterator(); itr.hasNext(); ) {
    int usedToken = itr.next();
    usedWords.put(usedToken, idsWords.get(usedToken));
  }
  return usedWords;
}
 

public static Entities getAidaEntitiesForInternalIds(int[] internalIds) throws EntityLinkingDataAccessException {
  TIntObjectHashMap<KBIdentifiedEntity> kbEntities = DataAccess.getKnowlegebaseEntitiesForInternalIds(internalIds);
  Entities entities = new Entities();
  for (TIntObjectIterator<KBIdentifiedEntity> itr = kbEntities.iterator(); itr.hasNext(); ) {
    itr.advance();
    entities.add(new Entity(itr.value(), itr.key()));
  }
  return entities;
}