public boolean equals(final Object other) {
   if (!(other instanceof TIntObjectHashMap)) {
     return false;
   }
   final TIntObjectHashMap that = (TIntObjectHashMap) other;
   return that.size() == this.size() && this.forEachEntry(new EqProcedure(that));
 }
  public RefsModel(
      @NotNull Map<VirtualFile, CompressedRefs> refs,
      @NotNull Set<Integer> heads,
      @NotNull VcsLogStorage hashMap,
      @NotNull Map<VirtualFile, VcsLogProvider> providers) {
    myRefs = refs;
    myHashMap = hashMap;

    myBestRefForHead = new TIntObjectHashMap<>();
    myRootForHead = new TIntObjectHashMap<>();
    for (int head : heads) {
      CommitId commitId = myHashMap.getCommitId(head);
      if (commitId != null) {
        VirtualFile root = commitId.getRoot();
        myRootForHead.put(head, root);
        Optional<VcsRef> bestRef =
            myRefs
                .get(root)
                .refsToCommit(head)
                .stream()
                .min(providers.get(root).getReferenceManager().getBranchLayoutComparator());
        if (bestRef.isPresent()) {
          myBestRefForHead.put(head, bestRef.get());
        } else {
          LOG.warn("No references at head " + commitId);
        }
      }
    }
  }
 @Override
 protected synchronized void onError() {
   super.onError();
   for (int each : myDataMap.keys()) {
     myDataMap.get(each).remoteId = -1;
   }
 }
 @Override
 public synchronized int registerTextEditorHighlightingPass(
     @NotNull TextEditorHighlightingPassFactory factory,
     @Nullable int[] runAfterCompletionOf,
     @Nullable int[] runAfterOfStartingOf,
     boolean runIntentionsPassAfter,
     int forcedPassId) {
   assert !checkedForCycles;
   PassConfig info =
       new PassConfig(
           factory,
           runAfterCompletionOf == null || runAfterCompletionOf.length == 0
               ? ArrayUtil.EMPTY_INT_ARRAY
               : runAfterCompletionOf,
           runAfterOfStartingOf == null || runAfterOfStartingOf.length == 0
               ? ArrayUtil.EMPTY_INT_ARRAY
               : runAfterOfStartingOf);
   int passId = forcedPassId == -1 ? nextAvailableId++ : forcedPassId;
   PassConfig registered = myRegisteredPassFactories.get(passId);
   assert registered == null
       : "Pass id " + passId + " has already been registered in: " + registered.passFactory;
   myRegisteredPassFactories.put(passId, info);
   if (factory instanceof DirtyScopeTrackingHighlightingPassFactory) {
     myDirtyScopeTrackingFactories.add((DirtyScopeTrackingHighlightingPassFactory) factory);
   }
   return passId;
 }
    public void merge(final Binding b, final boolean removeObject) {
      for (final PsiTypeVariable var : b.getBoundVariables()) {
        final int index = var.getIndex();

        if (myBindings.get(index) != null) {
          LOG.error("Oops... Binding conflict...");
        } else {
          final PsiType type = b.apply(var);
          final PsiClassType javaLangObject =
              PsiType.getJavaLangObject(
                  PsiManager.getInstance(myProject), GlobalSearchScope.allScope(myProject));

          if (removeObject && javaLangObject.equals(type)) {
            final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(var.getIndex());

            if (cluster != null) {
              for (final PsiTypeVariable war : cluster) {
                final PsiType wtype = b.apply(war);

                if (!javaLangObject.equals(wtype)) {
                  myBindings.put(index, type);
                  break;
                }
              }
            }
          } else {
            myBindings.put(index, type);
          }
        }
      }
    }
Example #6
0
  public TIntObjectHashMap<TIntHashSet> resolve(
      DirectedGraph<Integer, RDFEdge> graph,
      Set<Set<Integer>> literalSubjectPairs,
      Document document,
      KnowledgeBase kb) {

    TIntObjectHashMap<TIntHashSet> resolvedSubjects = new TIntObjectHashMap<TIntHashSet>();

    TIntHashSet ham = new TIntHashSet();
    TIntHashSet spam = new TIntHashSet();

    resolvedSubjects.put(0, spam);
    resolvedSubjects.put(1, ham);

    for (Set<Integer> c : literalSubjectPairs) {
      TIntHashSet subjects = getAmbiguousURIRefs(c);

      if (subjects.size() > 1) {
        ham.add(subjects.toArray()[new Random().nextInt(subjects.size())]);
        if (resolvedSubjects.size() < subjects.size()) {
          for (int s : subjects.toArray()) {
            if (!ham.contains(s)) {
              spam.add(s);
            }
          }
        }
      }
    }
    return resolvedSubjects;
  }
  @NotNull
  public TIntObjectHashMap<T> preLoadCommitData(@NotNull TIntHashSet commits) throws VcsException {
    TIntObjectHashMap<T> result = new TIntObjectHashMap<>();
    final MultiMap<VirtualFile, String> rootsAndHashes = MultiMap.create();
    commits.forEach(
        commit -> {
          CommitId commitId = myHashMap.getCommitId(commit);
          if (commitId != null) {
            rootsAndHashes.putValue(commitId.getRoot(), commitId.getHash().asString());
          }
          return true;
        });

    for (Map.Entry<VirtualFile, Collection<String>> entry : rootsAndHashes.entrySet()) {
      VcsLogProvider logProvider = myLogProviders.get(entry.getKey());
      if (logProvider != null) {
        List<? extends T> details =
            readDetails(logProvider, entry.getKey(), ContainerUtil.newArrayList(entry.getValue()));
        for (T data : details) {
          int index = myHashMap.getCommitIndex(data.getId(), data.getRoot());
          result.put(index, data);
        }
        saveInCache(result);
      } else {
        LOG.error(
            "No log provider for root "
                + entry.getKey().getPath()
                + ". All known log providers "
                + myLogProviders);
      }
    }

    return result;
  }
 private void setDirtyScope(int passId, RangeMarker scope) {
   RangeMarker marker = dirtyScopes.get(passId);
   if (marker != scope) {
     if (marker != null) {
       marker.dispose();
     }
     dirtyScopes.put(passId, scope);
   }
 }
  public final ItemAuction[] getAuctions() {
    final ItemAuction[] auctions;

    synchronized (_auctions) {
      auctions = _auctions.getValues(new ItemAuction[_auctions.size()]);
    }

    return auctions;
  }
  public void testP2OMap() {
    // Long-long
    TLongObjectHashMap<Long> lomap = new TLongObjectHashMap<Long>();
    assertTrue(serializesCorrectly(lomap, "p2o-l-1"));
    lomap.put(0, Long.valueOf(1));
    assertTrue(serializesCorrectly(lomap, "p2o-l-2"));
    lomap.put(Long.MIN_VALUE, Long.valueOf(Long.MIN_VALUE));
    assertTrue(serializesCorrectly(lomap, "p2o-l-3"));
    lomap.put(Long.MAX_VALUE, Long.valueOf(Long.MAX_VALUE));
    assertTrue(serializesCorrectly(lomap, "p2o-l-4"));

    // Int-int
    TIntObjectHashMap<Integer> iomap = new TIntObjectHashMap<Integer>();
    assertTrue(serializesCorrectly(iomap, "p2o-i-1"));
    iomap.put(0, Integer.valueOf(1));
    assertTrue(serializesCorrectly(iomap, "p2o-i-2"));
    iomap.put(Integer.MIN_VALUE, Integer.valueOf(Integer.MIN_VALUE));
    assertTrue(serializesCorrectly(iomap, "p2o-i-3"));
    iomap.put(Integer.MAX_VALUE, Integer.valueOf(Integer.MAX_VALUE));
    assertTrue(serializesCorrectly(iomap, "p2o-i-4"));

    // Double-double
    TDoubleObjectHashMap<Double> domap = new TDoubleObjectHashMap<Double>();
    assertTrue(serializesCorrectly(domap, "p2o-d-1"));
    domap.put(0, Double.valueOf(1));
    assertTrue(serializesCorrectly(domap, "p2o-d-2"));
    domap.put(Double.MIN_VALUE, Double.valueOf(Double.MIN_VALUE));
    assertTrue(serializesCorrectly(domap, "p2o-d-3"));
    domap.put(Double.MAX_VALUE, Double.valueOf(Double.MAX_VALUE));
    assertTrue(serializesCorrectly(domap, "p2o-d-4"));
    domap.put(Double.POSITIVE_INFINITY, Double.valueOf(Double.POSITIVE_INFINITY));
    assertTrue(serializesCorrectly(domap, "p2o-d-5"));
    domap.put(Double.NEGATIVE_INFINITY, Double.valueOf(Double.NEGATIVE_INFINITY));
    assertTrue(serializesCorrectly(domap, "p2o-d-6"));
    // NOTE: trove doesn't deal well with NaN
    //        ddmap.put( Double.NaN, Double.NaN );
    //        assertTrue( serializesCorrectly( ddmap ) );

    // Float-float
    TFloatObjectHashMap<Float> fomap = new TFloatObjectHashMap<Float>();
    assertTrue(serializesCorrectly(fomap, "p2o-f-1"));
    fomap.put(0, Float.valueOf(1));
    assertTrue(serializesCorrectly(fomap, "p2o-f-2"));
    fomap.put(Float.MIN_VALUE, Float.valueOf(Float.MIN_VALUE));
    assertTrue(serializesCorrectly(fomap, "p2o-f-3"));
    fomap.put(Float.MAX_VALUE, Float.valueOf(Float.MAX_VALUE));
    assertTrue(serializesCorrectly(fomap, "p2o-f-4"));
    fomap.put(Float.POSITIVE_INFINITY, Float.valueOf(Float.POSITIVE_INFINITY));
    assertTrue(serializesCorrectly(fomap, "p2o-f-5"));
    fomap.put(Float.NEGATIVE_INFINITY, Float.valueOf(Float.NEGATIVE_INFINITY));
    assertTrue(serializesCorrectly(fomap, "p2o-f-6"));
    // NOTE: trove doesn't deal well with NaN
    //        ffmap.put( Float.NaN, Float.NaN );
    //        assertTrue( serializesCorrectly( ffmap ) );
  }
Example #11
0
 private void addToMap(int id, int index) {
   id = unwrap(myFactory.getValue(id)).getID();
   int[] classes = myIdToEqClassesIndices.get(id);
   if (classes == null) {
     classes = new int[] {index};
     myIdToEqClassesIndices.put(id, classes);
   } else {
     classes = ArrayUtil.append(classes, index);
     myIdToEqClassesIndices.put(id, classes);
   }
 }
Example #12
0
 private void removeFromMap(int id, int index) {
   id = unwrap(myFactory.getValue(id)).getID();
   int[] classes = myIdToEqClassesIndices.get(id);
   if (classes != null) {
     int i = ArrayUtil.indexOf(classes, index);
     if (i != -1) {
       classes = ArrayUtil.remove(classes, i);
       myIdToEqClassesIndices.put(id, classes);
     }
   }
 }
    BindingImpl(final int index, final PsiType type) {
      myBindings = new TIntObjectHashMap<PsiType>();
      myCyclic = type instanceof PsiTypeVariable;

      myBindings.put(index, type);

      if (type instanceof Bottom) {
        final HashSet<PsiTypeVariable> cluster = myFactory.getClusterOf(index);

        if (cluster != null) {
          for (PsiTypeVariable var : cluster) {
            myBindings.put(var.getIndex(), type);
          }
        }
      }
    }
Example #14
0
  public int registerCustomItemName(Plugin plugin, String key) {
    int id = UniqueItemStringMap.getId(key);

    itemPlugin.put(id, plugin.getDescription().getName());

    return id;
  }
Example #15
0
 void afterUnmarshal(Unmarshaller u, Object parent) {
   items = new TIntObjectHashMap<ItemTemplate>();
   for (ItemTemplate it : its) {
     items.put(it.getTemplateId(), it);
   }
   its = null;
 }
Example #16
0
  /**
   * Initialize implementation dependent properties of the RTree. Currently implemented properties
   * are:
   *
   * <ul>
   *   <li>MaxNodeEntries This specifies the maximum number of entries in a node. The default value
   *       is 10, which is used if the property is not specified, or is less than 2.
   *   <li>MinNodeEntries This specifies the minimum number of entries in a node. The default value
   *       is half of the MaxNodeEntries value (rounded down), which is used if the property is not
   *       specified or is less than 1.
   * </ul>
   *
   * @see com.infomatiq.jsi.SpatialIndex#init(Properties)
   */
  public void init(Properties props) {
    maxNodeEntries = Integer.parseInt(props.getProperty("MaxNodeEntries", "0"));
    minNodeEntries = Integer.parseInt(props.getProperty("MinNodeEntries", "0"));

    // Obviously a node with less than 2 entries cannot be split.
    // The node splitting algorithm will work with only 2 entries
    // per node, but will be inefficient.
    if (maxNodeEntries < 2) {
      log.warn(
          "Invalid MaxNodeEntries = "
              + maxNodeEntries
              + " Resetting to default value of "
              + DEFAULT_MAX_NODE_ENTRIES);
      maxNodeEntries = DEFAULT_MAX_NODE_ENTRIES;
    }

    // The MinNodeEntries must be less than or equal to (int) (MaxNodeEntries / 2)
    if (minNodeEntries < 1 || minNodeEntries > maxNodeEntries / 2) {
      log.warn("MinNodeEntries must be between 1 and MaxNodeEntries / 2");
      minNodeEntries = maxNodeEntries / 2;
    }

    entryStatus = new byte[maxNodeEntries];
    initialEntryStatus = new byte[maxNodeEntries];

    for (int i = 0; i < maxNodeEntries; i++) {
      initialEntryStatus[i] = ENTRY_STATUS_UNASSIGNED;
    }

    Node root = new Node(rootNodeId, 1, maxNodeEntries);
    nodeMap.put(rootNodeId, root);

    log.info(
        "init() " + " MaxNodeEntries = " + maxNodeEntries + ", MinNodeEntries = " + minNodeEntries);
  }
  /**
   * Iterate over the map, and ensure that if the same string is in the cache, that the entry refers
   * to the cached entry, rather than a new instance.
   *
   * @param stringMap
   */
  public void mergeStrings(TIntObjectHashMap<String> stringMap) {

    if (stringMap == null) return;
    // FIXME: Investigate using String.intern()  what's it's overhead if we
    // do it on all strings.

    // FIXME: Keep track of which integer keys (they should be 0-255) merge well and which don't,
    // by tracking successes
    for (TIntObjectIterator<String> it = stringMap.iterator(); it.hasNext(); ) {
      it.advance();
      int key = it.key();
      assert key < 256;

      // Eliminate poor merging strings
      // FIXME: should also remove existing by having sep cache per key, which
      // we can just remove once can see it's a problem.  For now, we
      // just stop after it seems that we've got no dupls
      if (strFailuresByKey[key] > 5000 && strSuccessesByKey[key] < strFailuresByKey[key]) {
        continue; // if after 5000 failures, we don't have more successes
      }

      String possDupl = it.value();
      String cachedString = stringCache.get(possDupl);
      if (cachedString != null) {
        it.setValue(cachedString); // If have one cached, use it
        strSuccessesByKey[key]++;
      } else {
        stringCache.put(possDupl, possDupl);
        strFailuresByKey[key]++;
      }
    }
  }
 /**
  * Merge equal IntegerVariable into a unique one.
  *
  * @param k number of unique variables
  * @param nbIntVars number of integer variable within the model
  * @param color array of indice of unique variables
  * @param domainByColor domain of unique variables
  */
 @Override
 protected void apply(
     final int k,
     final int nbIntVars,
     final int[] color,
     final TIntObjectHashMap<IntegerVariableMerger> domainByColor) {
   IntegerVariable vtmp;
   IntegerVariableMerger dtmp;
   final IntegerVariable[] var = new IntegerVariable[k + 1];
   for (int i = 0; i < nbIntVars; i++) {
     final int col = color[i];
     if (col != -1) {
       final IntegerVariable v = model.getIntVar(i);
       if (var[col] == null) {
         dtmp = domainByColor.get(col);
         if (dtmp.values != null) {
           vtmp = new IntegerVariable(StringUtils.randomName(), dtmp.values);
         } else {
           vtmp = new IntegerVariable(StringUtils.randomName(), dtmp.low, dtmp.upp);
         }
         vtmp.addOptions(dtmp.optionsSet);
         var[col] = vtmp;
         add(vtmp);
       }
       replaceBy(v, var[col]);
       delete(v);
     }
   }
 }
Example #19
0
 void afterUnmarshal(Unmarshaller u, Object parent) {
   wrappedItemData = new TIntObjectHashMap<WrapperItem>();
   for (WrapperItem it : list) {
     wrappedItemData.put(it.getItemId(), it);
   }
   list = null;
 }
Example #20
0
  private void executeDelete(@NotNull VirtualFile file) {
    if (!file.exists()) {
      LOG.error("Deleting a file, which does not exist: " + file.getPath());
      return;
    }
    clearIdCache();

    int id = getFileId(file);

    final VirtualFile parent = file.getParent();
    final int parentId = parent == null ? 0 : getFileId(parent);

    if (parentId == 0) {
      String rootUrl =
          normalizeRootUrl(file.getPath(), (NewVirtualFileSystem) file.getFileSystem());
      myRootsLock.writeLock().lock();
      try {
        myRoots.remove(rootUrl);
        myRootsById.remove(id);
        FSRecords.deleteRootRecord(id);
      } finally {
        myRootsLock.writeLock().unlock();
      }
    } else {
      removeIdFromParentList(parentId, id, parent, file);
      VirtualDirectoryImpl directory = (VirtualDirectoryImpl) file.getParent();
      assert directory != null : file;
      directory.removeChild(file);
    }

    FSRecords.deleteRecordRecursively(id);

    invalidateSubtree(file);
  }
 public void registerTimeoutHandler(int commandId, int timeout, Runnable onTimeout) {
   synchronized (myLock) {
     myTimeoutHandlers.put(
         commandId, new TimeoutHandler(onTimeout, System.currentTimeMillis() + timeout));
   }
   scheduleTimeoutCheck();
 }
    public Binding reduceRecursive() {
      final BindingImpl binding = (BindingImpl) create();

      for (final PsiTypeVariable var : myBoundVariables) {
        final int index = var.getIndex();
        final PsiType type = myBindings.get(index);

        if (type != null) {
          class Verifier extends PsiExtendedTypeVisitor<Void> {
            boolean myFlag = false;

            @Override
            public Void visitTypeVariable(final PsiTypeVariable var) {
              if (var.getIndex() == index) {
                myFlag = true;
              }

              return null;
            }
          }

          final Verifier verifier = new Verifier();

          type.accept(verifier);

          if (verifier.myFlag) {
            myBindings.put(index, Bottom.BOTTOM);
            binding.myBindings.put(index, Bottom.BOTTOM);
          } else {
            binding.myBindings.put(index, type);
          }
        } else {
          binding.myBindings.put(index, type);
        }
      }

      for (final PsiTypeVariable var : myBoundVariables) {
        final int index = var.getIndex();
        final PsiType type = myBindings.get(index);

        if (type != null) {
          myBindings.put(index, binding.apply(type));
        }
      }

      return this;
    }
Example #23
0
  public TIntIntHashMap rollItems(int wrapperItemId, int playerLevel, ItemRace race) {
    TIntIntHashMap itemCountMap = new TIntIntHashMap();

    final WrapperItem wrapperItem = wrappedItemData.get(wrapperItemId);
    if (wrapperItem == null) return itemCountMap;

    return wrapperItem.rollItems(playerLevel, race);
  }
 @Override
 public String getPath(int pathId) {
   String path = myAlternativePaths.get(pathId);
   if (path != null) {
     return path;
   }
   return myWrapee.getPath(pathId);
 }
 public void reset() {
   if (safeToReuse != null) {
     safeToReuse.clear();
   }
   objectsCacheOnWrite.clear();
   objectsCacheOnRead.clear();
   immutableCache.clear();
   objectIdOnCache = 0;
 }
Example #26
0
  @Nullable
  private VirtualFileSystemEntry findFileById(
      int id, boolean cachedOnly, TIntArrayList visited, int mask) {
    VirtualFileSystemEntry cached = myIdToDirCache.get(id);
    if (cached != null) return cached;

    if (visited != null
        && (visited.size() >= DEPTH_LIMIT || (mask & id) == id && visited.contains(id))) {
      @NonNls
      String sb =
          "Dead loop detected in persistent FS (id=" + id + " cached-only=" + cachedOnly + "):";
      for (int i = 0; i < visited.size(); i++) {
        int _id = visited.get(i);
        sb +=
            "\n  "
                + _id
                + " '"
                + getName(_id)
                + "' "
                + String.format("%02x", getFileAttributes(_id))
                + ' '
                + myIdToDirCache.containsKey(_id);
      }
      LOG.error(sb);
      return null;
    }

    int parentId = getParent(id);
    if (parentId >= id) {
      if (visited == null) visited = new TIntArrayList(DEPTH_LIMIT);
    }
    if (visited != null) visited.add(id);

    VirtualFileSystemEntry result;
    if (parentId == 0) {
      myRootsLock.readLock().lock();
      try {
        result = myRootsById.get(id);
      } finally {
        myRootsLock.readLock().unlock();
      }
    } else {
      VirtualFileSystemEntry parentFile = findFileById(parentId, cachedOnly, visited, mask | id);
      if (parentFile instanceof VirtualDirectoryImpl) {
        result = ((VirtualDirectoryImpl) parentFile).findChildById(id, cachedOnly);
      } else {
        result = null;
      }
    }

    if (result != null && result.isDirectory()) {
      VirtualFileSystemEntry old = myIdToDirCache.put(id, result);
      if (old != null) result = old;
    }
    return result;
  }
 public ContextRelevantStaticMethod(
     final PsiMethod psiMethod, @Nullable final TIntObjectHashMap<PsiVariable> parameters) {
   this.psiMethod = psiMethod;
   if (parameters == null) {
     this.parameters = null;
   } else {
     this.parameters = new TIntObjectHashMap<>(parameters.size());
     parameters.forEachEntry(
         new TIntObjectProcedure<PsiVariable>() {
           @SuppressWarnings("ConstantConditions")
           @Override
           public boolean execute(final int pos, final PsiVariable var) {
             ContextRelevantStaticMethod.this.parameters.put(
                 pos, new VariableSubLookupElement(var));
             return true;
           }
         });
   }
 }
 public void saveInCache(@NotNull TIntObjectHashMap<T> details) {
   UIUtil.invokeAndWaitIfNeeded(
       (Runnable)
           () ->
               details.forEachEntry(
                   (key, value) -> {
                     myCache.put(key, value);
                     return true;
                   }));
 }
  private void checkForCycles() {
    final TIntObjectHashMap<TIntHashSet> transitivePredecessors =
        new TIntObjectHashMap<TIntHashSet>();

    myRegisteredPassFactories.forEachEntry(
        new TIntObjectProcedure<PassConfig>() {
          @Override
          public boolean execute(int passId, PassConfig config) {
            TIntHashSet allPredecessors = new TIntHashSet(config.completionPredecessorIds);
            allPredecessors.addAll(config.startingPredecessorIds);
            transitivePredecessors.put(passId, allPredecessors);
            allPredecessors.forEach(
                new TIntProcedure() {
                  @Override
                  public boolean execute(int predecessorId) {
                    PassConfig predecessor = myRegisteredPassFactories.get(predecessorId);
                    if (predecessor == null) return true;
                    TIntHashSet transitives = transitivePredecessors.get(predecessorId);
                    if (transitives == null) {
                      transitives = new TIntHashSet();
                      transitivePredecessors.put(predecessorId, transitives);
                    }
                    transitives.addAll(predecessor.completionPredecessorIds);
                    transitives.addAll(predecessor.startingPredecessorIds);
                    return true;
                  }
                });
            return true;
          }
        });
    transitivePredecessors.forEachKey(
        new TIntProcedure() {
          @Override
          public boolean execute(int passId) {
            if (transitivePredecessors.get(passId).contains(passId)) {
              throw new IllegalArgumentException(
                  "There is a cycle introduced involving pass "
                      + myRegisteredPassFactories.get(passId).passFactory);
            }
            return true;
          }
        });
  }
  /** returns the postings suitable to be written into the block direct index */
  @Override
  public int[][] getPostings() {
    final int termCount = occurrences.size();
    final int[] termids = new int[termCount];
    final int[] tfs = new int[termCount];
    final int[] fields = null;
    final int[] blockfreqs = new int[termCount];
    final TIntObjectHashMap<int[]> term2blockids = new TIntObjectHashMap<int[]>();
    int blockTotal = 0; // TODO we already have blockTotal as this.blockCount, so no need to count?
    class PostingVisitor implements TObjectIntProcedure<String> {
      int i = 0;
      int blockTotal = 0;

      public boolean execute(final String a, final int b) {
        termids[i] = getTermId(a);
        tfs[i] = b;
        final TIntHashSet ids = term_blocks.get(a);
        blockfreqs[i] = ids.size();
        blockTotal += ids.size();
        final int[] bids = ids.toArray();
        Arrays.sort(bids);
        term2blockids.put(termids[i], bids);
        // System.err.println(a+": tid="+termids[i]+" tf="+tfs[i]+" bf="+blockfreqs[i] +"
        // blocks="+Arrays.toString(bids));
        i++;
        return true;
      }
    }
    PostingVisitor proc = new PostingVisitor();
    occurrences.forEachEntry(proc);
    blockTotal = proc.blockTotal;
    HeapSortInt.ascendingHeapSort(termids, tfs, blockfreqs);
    final int[] blockids = new int[blockTotal];
    int offset = 0;
    for (int termid : termids) {
      final int[] src = term2blockids.get(termid);
      final int src_l = src.length;
      System.arraycopy(src, 0, blockids, offset, src_l);
      offset += src_l;
    }
    return new int[][] {termids, tfs, fields, blockfreqs, blockids};
  }