gnu.trove.TIntIntHashMap Java Examples

HashLeafData(BtreeIndexNodeView _nodeView, int recordCount) {
  nodeView = _nodeView;

  final IntToIntBtree btree = _nodeView.btree;

  int offset = nodeView.myAddressInBuffer + nodeView.indexToOffset(0);
  final ByteBuffer buffer = nodeView.myBuffer;

  keys = new int[recordCount];
  values = new TIntIntHashMap(recordCount);
  int keyNumber = 0;

  for (int i = 0; i < btree.hashPageCapacity; ++i) {
    int key = buffer.getInt(offset + KEY_OFFSET);
    if (key != HASH_FREE) {
      int value = buffer.getInt(offset);

      if (keyNumber == keys.length) throw new IllegalStateException("Index corrupted");
      keys[keyNumber++] = key;
      values.put(key, value);
    }
    offset += INTERIOR_SIZE;
  }

  Arrays.sort(keys);
}
 

private static TIntIntHashMap parseHits(BufferedReader reader) throws IOException {
  TIntIntHashMap hits = new TIntIntHashMap();
  String line;
  while ((line = reader.readLine()) != null) {
    if (line.startsWith(END_OF_RECORD)) {
      return hits;
    }
    if (line.startsWith(DA)) {
      // DA:line,hits
      int comma = line.indexOf(',');
      try {
        hits.put(
            Integer.parseInt(line.substring(DA.length(), comma)),
            Integer.parseInt(line.substring(comma + 1)));
      } catch (NumberFormatException e) {
        logger.warn("Cannot parse LCOV line: " + line, e);
      }
    }
  }
  return hits;
}
 

private static TIntIntHashMap getCoverageVersionToCurrentLineMapping(Diff.Change change, int firstNLines) {
  TIntIntHashMap result = new TIntIntHashMap();
  int prevLineInFirst = 0;
  int prevLineInSecond = 0;
  while (change != null) {

    for (int l = 0; l < change.line0 - prevLineInFirst; l++) {
      result.put(prevLineInFirst + l, prevLineInSecond + l);
    }

    prevLineInFirst = change.line0 + change.deleted;
    prevLineInSecond = change.line1 + change.inserted;

    change = change.link;
  }

  for (int i = prevLineInFirst; i < firstNLines; i++) {
    result.put(i, prevLineInSecond + i - prevLineInFirst);
  }

  return result;
}
 

public TroveContentFullDB(IDocumentDB documentsDB, IFeatureDB featuresDB) {
    super();
    _documentsDB = documentsDB;
    _featuresDB = featuresDB;

    int sizeDocs = documentsDB.getDocumentsCount();
    _documentsFeatures = new Vector<TIntArrayList>(sizeDocs);
    _documentsFrequencies = new Vector<TIntArrayList>(sizeDocs);
    for (int i = 0; i < sizeDocs; ++i) {
        _documentsFeatures.add(new TIntArrayList());
        _documentsFrequencies.add(new TIntArrayList());
    }

    int sizeFeats = featuresDB.getFeaturesCount();
    _featuresDocuments = new Vector<TIntArrayList>(sizeFeats);
    _featuresFrequencies = new Vector<TIntArrayList>(sizeFeats);
    for (int i = 0; i < sizeFeats; ++i) {
        _featuresDocuments.add(new TIntArrayList());
        _featuresFrequencies.add(new TIntArrayList());
    }

    _documentLenghts = new TIntIntHashMap();

    _name = "generic";
}
 

public IContentDB cloneDB(IDocumentDB documentsDB, IFeatureDB featuresDB) {
    TroveContentILDB contentDB = new TroveContentILDB(documentsDB,
            featuresDB);
    contentDB._name = new String(_name);

    contentDB._featuresDocuments = new Vector<TIntArrayList>(
            _featuresDocuments.size());
    for (int i = 0; i < _featuresDocuments.size(); ++i)
        contentDB._featuresDocuments.add((TIntArrayList) _featuresDocuments
                .get(i).clone());

    contentDB._documentFeaturesCount = (TIntIntHashMap) _documentFeaturesCount
            .clone();
    contentDB._documentLenghts = (TIntIntHashMap) _documentLenghts.clone();

    contentDB._featuresFrequencies = new Vector<TIntArrayList>(
            _featuresFrequencies.size());
    for (int i = 0; i < _featuresFrequencies.size(); ++i)
        contentDB._featuresFrequencies
                .add((TIntArrayList) _featuresFrequencies.get(i).clone());

    return contentDB;
}
 

public TroveContentILDB(IDocumentDB documentsDB, IFeatureDB featuresDB) {
    super();
    _documentsDB = documentsDB;
    _featuresDB = featuresDB;

    int size = featuresDB.getFeaturesCount();
    _featuresDocuments = new Vector<TIntArrayList>(size);
    _featuresFrequencies = new Vector<TIntArrayList>(size);
    for (int i = 0; i < size; ++i) {
        _featuresDocuments.add(new TIntArrayList());
        _featuresFrequencies.add(new TIntArrayList());
    }

    _documentLenghts = new TIntIntHashMap();
    _documentFeaturesCount = new TIntIntHashMap();
    _name = "generic";
}
 

private TIntIntHashMap calculateMatches(final String[] propertyWords) {
  int classNameIndex = myOldClassName.length - 1;
  TIntIntHashMap matches = new TIntIntHashMap();
  for (int i = propertyWords.length - 1; i >= 0; i--) {
    final String propertyWord = propertyWords[i];
    Match match = null;
    for (int j = classNameIndex; j >= 0 && match == null; j--) {
      match = checkMatch(j, i, propertyWord);
    }
    if (match != null) {
      matches.put(match.oldClassNameIndex, i);
      classNameIndex = match.oldClassNameIndex - 1;
    }
  }
  return matches;
}
 

public IContentDB cloneDB(IDocumentDB docDB, IFeatureDB featDB) {
    TroveContentDB contentDB = new TroveContentDB(docDB, featDB);
    contentDB._name = new String(_name);

    contentDB._documentsFeatures = new Vector<TIntArrayList>(
            _documentsFeatures.size());
    for (int i = 0; i < _documentsFeatures.size(); ++i)
        contentDB._documentsFeatures.add((TIntArrayList) _documentsFeatures
                .get(i).clone());

    contentDB._documentsFrequencies = new Vector<TIntArrayList>(
            _documentsFrequencies.size());
    for (int i = 0; i < _documentsFrequencies.size(); ++i)
        contentDB._documentsFrequencies
                .add((TIntArrayList) _documentsFrequencies.get(i).clone());

    contentDB._documentLenghts = (TIntIntHashMap) _documentLenghts.clone();
    contentDB._featureDocumentsCount = (TIntIntHashMap) _featureDocumentsCount
            .clone();

    return contentDB;
}
 

public TroveContentDB(IDocumentDB documentsDB, IFeatureDB featuresDB) {
    super();
    _documentsDB = documentsDB;
    _featuresDB = featuresDB;

    int size = documentsDB.getDocumentsCount();
    _documentsFeatures = new Vector<TIntArrayList>(size);
    _documentsFrequencies = new Vector<TIntArrayList>(size);
    for (int i = 0; i < size; ++i) {
        _documentsFeatures.add(new TIntArrayList());
        _documentsFrequencies.add(new TIntArrayList());
    }

    _documentLenghts = new TIntIntHashMap();
    _featureDocumentsCount = new TIntIntHashMap();
    _name = "generic";
}
 

public String suggestName(final String propertyName) {
  if (myOldClassNameAsGiven.equals(propertyName)) return myNewClassNameAsGiven;
  final String[] propertyWords = NameUtil.splitNameIntoWords(propertyName);
  TIntIntHashMap matches = calculateMatches(propertyWords);
  if (matches.isEmpty()) return propertyName;
  TreeMap<Pair<Integer,Integer>, String> replacements = calculateReplacements(propertyWords, matches);
  if (replacements.isEmpty()) return propertyName;
  return calculateNewName(replacements, propertyWords, propertyName);
}
 

@Nonnull
private static List<IndentUsageInfo> toIndentUsageList(@Nonnull TIntIntHashMap indentToUsages) {
  List<IndentUsageInfo> indentUsageInfos = ContainerUtil.newArrayList();
  TIntIntIterator it = indentToUsages.iterator();
  while (it.hasNext()) {
    it.advance();
    indentUsageInfos.add(new IndentUsageInfo(it.key(), it.value()));
  }
  return indentUsageInfos;
}
 

public static void readIntIntMap(DataInputStream stream, TIntIntHashMap map) throws IOException {
	
	int size = stream.readInt();
	map.ensureCapacity(size);
	for(int i = 0; i < size; i++)
		map.put(stream.readInt(), stream.readInt());
	
}
 

private static void countQuotes(@Nonnull TIntIntHashMap holder, @Nonnull CharSequence text, int start, int end) {
  for (int i = end - 1; i >= start; i--) {
    char c = text.charAt(i);
    if (holder.containsKey(c)) {
      holder.put(c, holder.get(c) + 1);
    }
  }
}
 

@Nonnull
private static TIntIntHashMap getCommitsMap(@Nonnull Iterable<Integer> hashes) {
  TIntIntHashMap commits = new TIntIntHashMap();
  int row = 0;
  for (Integer commitId : hashes) {
    commits.put(commitId, row);
    row++;
  }
  return commits;
}
 

private void runLoadCommitsData(@Nonnull Iterable<Integer> hashes) {
  long taskNumber = myCurrentTaskIndex++;
  TIntIntHashMap commits = getCommitsMap(hashes);
  TIntHashSet toLoad = new TIntHashSet();

  for (int id : commits.keys()) {
    cacheCommit(id, taskNumber);
    toLoad.add(id);
  }

  myLoader.queue(new TaskDescriptor(toLoad));
}
 

private void sortCommitsByRow(@Nonnull List<T> result, @Nonnull final TIntIntHashMap rowsForCommits) {
  ContainerUtil.sort(result, (details1, details2) -> {
    int row1 = rowsForCommits.get(myHashMap.getCommitIndex(details1.getId(), details1.getRoot()));
    int row2 = rowsForCommits.get(myHashMap.getCommitIndex(details2.getId(), details2.getRoot()));
    return Comparing.compare(row1, row2);
  });
}
 

public SimpleColoredComponent() {
  myFragments = new ArrayList<String>(3);
  myAttributes = new ArrayList<SimpleTextAttributes>(3);
  myIpad = new JBInsets(1, 2, 1, 2);
  myIconTextGap = JBUI.scale(2);
  myBorder = new MyBorder();
  myFragmentPadding = new TIntIntHashMap(10);
  myFragmentAlignment = new TIntIntHashMap(10);
  setOpaque(true);

  updateUI();
}
 

@javax.annotation.Nullable
private SoftReference<TIntIntHashMap> doGetLineMapping(final long date, boolean oldToNew) {
  final VirtualFile f = getVirtualFile();
  final byte[] oldContent;
  synchronized (LOCK) {
    if (myOldContent == null) {
      if (ApplicationManager.getApplication().isDispatchThread()) return null;
      final byte[] byteContent = LocalHistory.getInstance().getByteContent(f, new FileRevisionTimestampComparator() {
        public boolean isSuitable(long revisionTimestamp) {
          return revisionTimestamp < date;
        }
      });
      myOldContent = new SoftReference<byte[]>(byteContent);
    }
    oldContent = myOldContent.get();
  }

  if (oldContent == null) return null;
  String[] coveredLines = getCoveredLines(oldContent, f);
  String[] currentLines = getUpToDateLines();

  String[] oldLines = oldToNew ? coveredLines : currentLines;
  String[] newLines = oldToNew ? currentLines : coveredLines;

  Diff.Change change = null;
  try {
    change = Diff.buildChanges(oldLines, newLines);
  }
  catch (FilesTooBigForDiffException e) {
    LOG.info(e);
    return null;
  }
  return new SoftReference<TIntIntHashMap>(getCoverageVersionToCurrentLineMapping(change, oldLines.length));
}
 

@javax.annotation.Nullable
private TIntIntHashMap getNewToOldLineMapping(final long date) {
  if (myNewToOldLines == null) {
    myNewToOldLines = doGetLineMapping(date, false);
    if (myNewToOldLines == null) return null;
  }
  return myNewToOldLines.get();
}
 

@Nullable
private TIntIntHashMap getOldToNewLineMapping(final long date) {
  if (myOldToNewLines == null) {
    myOldToNewLines = doGetLineMapping(date, true);
    if (myOldToNewLines == null) return null;
  }
  return myOldToNewLines.get();
}
 

public static void main(String[] args) throws IOException {
  PersistentHashMap<Integer, Integer> lkeys = createOrOpenMap();
  List<Integer> mapping = (List<Integer>)lkeys.getAllKeysWithExistingMapping();
  System.out.println(mapping.size());
  final TIntIntHashMap map = new TIntIntHashMap(mapping.size());
  for(Integer i:mapping) map.put(i, lkeys.get(i));

  Collections.sort(mapping, (o1, o2) -> map.get(o2) - map.get(o1));

  for(int i = 0; i < 500; ++i) {
    //System.out.println(mapping.get(i) + ",");
    System.out.println(mapping.get(i) + ":" + map.get(mapping.get(i)));
  }
  lkeys.close();
}
 

protected IIndex createEnrichedTraining(TIntIntHashMap map, IIndex testAllCats, IIndex training) {
    IIndex idx = training.cloneIndex();
    TroveMainIndexBuilder builder = new TroveMainIndexBuilder(idx);
    int numDocs = training.getDocumentDB().getDocumentsCount();

    int[] keys = map.keys();
    for (int i = 0; i < keys.length; i++) {
        int docID = keys[i];
        ArrayList<String> features = new ArrayList<String>(100);
        String docName = "" + (numDocs + (i + 1));
        IIntIterator feats = testAllCats.getContentDB().getDocumentFeatures(docID);
        while (feats.hasNext()) {
            int featID = feats.next();
            String featName = testAllCats.getFeatureDB().getFeatureName(featID);
            int count = testAllCats.getContentDB().getDocumentFeatureFrequency(docID, featID);
            for (int j = 0; j < count; j++)
                features.add(featName);
        }

        ArrayList<String> categories = new ArrayList<String>();
        IShortIterator cats = testAllCats.getClassificationDB().getDocumentCategories(docID);
        while (cats.hasNext()) {
            short catID = cats.next();
            String catName = testAllCats.getCategoryDB().getCategoryName(catID);
            categories.add(catName);
        }

        builder.addDocument(docName, features.toArray(new String[0]), categories.toArray(new String[0]));
    }

    return idx;
}
 

public static void writeIntIntMap(DataOutputStream stream, TIntIntHashMap map) throws IOException {
	
	stream.writeInt(map.size());
	for(int key : map.keys()) {
		stream.writeInt(key);
		stream.writeInt(map.get(key));
	}
	
}
 

public void removeDocuments(IIntIterator removedDocuments) {
    int shift = 0;
    int lastGoodDocument = 0;
    int totalDocuments = _documentsMap.size();
    TIntIntHashMap documentsRemap = new TIntIntHashMap();
    while (removedDocuments.hasNext()) {
        int removedDocument = removedDocuments.next();
        while (lastGoodDocument < removedDocument) {
            documentsRemap.put(lastGoodDocument, lastGoodDocument - shift);
            ++lastGoodDocument;
        }
        lastGoodDocument = removedDocument + 1;
        int removedDocumentPosition = removedDocument - shift;
        _documentsMap.remove(_documentsRMap.get(removedDocumentPosition));
        _documentsRMap.remove(removedDocumentPosition);
        ++shift;
    }

    while (lastGoodDocument < totalDocuments) {
        documentsRemap.put(lastGoodDocument, lastGoodDocument - shift);
        ++lastGoodDocument;
    }

    Iterator<Entry<String, Integer>> mapIter = _documentsMap.entrySet()
            .iterator();
    while (mapIter.hasNext()) {
        Entry<String, Integer> entry = mapIter.next();
        int value = entry.getValue();
        int newvalue = documentsRemap.get(value);
        entry.setValue(newvalue);
    }

}
 

public IContentDB cloneDB(IDocumentDB docDB, IFeatureDB featDB) {
    TroveContentFullDB contentDB = new TroveContentFullDB(docDB, featDB);
    contentDB._name = new String(_name);

    contentDB._documentsFeatures = new Vector<TIntArrayList>(
            _documentsFeatures.size());
    for (int i = 0; i < _documentsFeatures.size(); ++i)
        contentDB._documentsFeatures.add((TIntArrayList) _documentsFeatures
                .get(i).clone());

    contentDB._documentsFrequencies = new Vector<TIntArrayList>(
            _documentsFrequencies.size());
    for (int i = 0; i < _documentsFrequencies.size(); ++i)
        contentDB._documentsFrequencies
                .add((TIntArrayList) _documentsFrequencies.get(i).clone());

    contentDB._documentLenghts = (TIntIntHashMap) _documentLenghts.clone();

    contentDB._featuresDocuments = new Vector<TIntArrayList>(
            _featuresDocuments.size());
    for (int i = 0; i < _featuresDocuments.size(); ++i)
        contentDB._featuresDocuments.add((TIntArrayList) _featuresDocuments
                .get(i).clone());

    contentDB._featuresFrequencies = new Vector<TIntArrayList>(
            _featuresFrequencies.size());
    for (int i = 0; i < _featuresFrequencies.size(); ++i)
        contentDB._featuresFrequencies
                .add((TIntArrayList) _featuresFrequencies.get(i).clone());

    return contentDB;
}
 

public void removeFeatures(IIntIterator removedFeatures) {
    int shift = 0;
    int lastGoodFeature = 0;
    int totalFeatures = _featuresMap.size();
    TIntIntHashMap featuresRemap = new TIntIntHashMap();
    while (removedFeatures.hasNext()) {
        int removedFeature = removedFeatures.next();
        while (lastGoodFeature < removedFeature) {
            featuresRemap.put(lastGoodFeature, lastGoodFeature - shift);
            ++lastGoodFeature;
        }
        lastGoodFeature = removedFeature + 1;
        int removedFeaturePosition = removedFeature - shift;
        _featuresMap.remove(_featuresRMap.get(removedFeaturePosition));
        _featuresRMap.remove(removedFeaturePosition);
        ++shift;
    }

    while (lastGoodFeature < totalFeatures) {
        featuresRemap.put(lastGoodFeature, lastGoodFeature - shift);
        ++lastGoodFeature;
    }

    TObjectIntIterator<String> mapIter = _featuresMap.iterator();
    while (mapIter.hasNext()) {
        mapIter.advance();
        int value = mapIter.value();
        int newvalue = featuresRemap.get(value);
        mapIter.setValue(newvalue);
    }
}
 

private static BlazeCoverageData parse(InputStream inputStream) throws IOException {
  Map<String, FileData> map = new HashMap<>();
  BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, UTF_8));
  String line;
  while ((line = reader.readLine()) != null) {
    if (line.startsWith(SF)) {
      String source = line.substring(SF.length());
      TIntIntHashMap hits = parseHits(reader);
      if (!hits.isEmpty()) {
        map.put(source, new FileData(source, hits));
      }
    }
  }
  return new BlazeCoverageData(ImmutableMap.copyOf(map));
}
 

public MultiIconSimpleColoredComponent() {
  myFragments = new ArrayList<>(3);
  myLayouts = new ArrayList<>(3);
  myAttributes = new ArrayList<>(3);
  myIcons = new ArrayList<>(3);
  myIpad = new JBInsets(1, 2, 1, 2);
  myIconTextGap = JBUI.scale(2);
  myBorder = new MyBorder();
  myFragmentPadding = new TIntIntHashMap(10);
  myFragmentAlignment = new TIntIntHashMap(10);
  setOpaque(true);
  updateUI();
}
 

public MultiIconSimpleColoredComponent() {
  myFragments = new ArrayList<>(3);
  myLayouts = new ArrayList<>(3);
  myAttributes = new ArrayList<>(3);
  myIcons = new ArrayList<>(3);
  myIpad = new JBInsets(1, 2, 1, 2);
  myIconTextGap = JBUI.scale(2);
  myBorder = new MyBorder();
  myFragmentPadding = new TIntIntHashMap(10);
  myFragmentAlignment = new TIntIntHashMap(10);
  setOpaque(true);
  updateUI();
}
 

public static Pair<IIndex, IIndex> splitIndex(int step, IIndex index, int numValidationSteps) {
    int numPositives = index.getDocumentDB().getDocumentsCount();

    int numSteps = Math.min(numPositives, numValidationSteps);
    if (step >= numSteps)
        return null;

    TIntArrayList tr = new TIntArrayList();
    TIntArrayList va = new TIntArrayList();

    int numPositivesInValidation = numPositives / numSteps;
    int numPositivesInTraining = numPositives - numPositivesInValidation;
    int startTrainingID = (numPositives / numSteps) * step;
    int endTrainingID = (startTrainingID + numPositivesInTraining - 1);
    TIntIntHashMap map = new TIntIntHashMap();
    for (int i = startTrainingID; i <= endTrainingID; i++) {
        int v = i % numPositives;
        map.put(v, v);
    }


    int curDoc = 0;
    IIntIterator docs = index.getDocumentDB().getDocuments();
    while (docs.hasNext()) {
        int docID = docs.next();
        if (map.containsKey(curDoc)) {
            tr.add(docID);
        } else {
            va.add(docID);
        }
        curDoc++;
    }


    tr.sort();
    va.sort();


    IIndex trIndex = index.cloneIndex();
    trIndex.removeDocuments(new TIntArrayListIterator(va), false);


    IIndex vaIndex = index.cloneIndex();
    vaIndex.removeDocuments(new TIntArrayListIterator(tr), false);


    JatecsLogger.status().println("done. The training contains " + tr.size() + " document(s) and the validation contains " + va.size() + " document(s).");

    Pair<IIndex, IIndex> ret = new Pair<IIndex, IIndex>(trIndex, vaIndex);
    return ret;

}