Java Code Examples for com.intellij.util.ArrayUtil#realloc()

@Override
protected void updateEditorLayout() {
    int currentColumnCount = this.getTableModel().getColumnCount();
    int[] columnWidths = getFileEditorState().getColumnWidths();
    int prevColumnCount = columnWidths.length;
    if (prevColumnCount != currentColumnCount) {
        columnWidths = ArrayUtil.realloc(columnWidths, currentColumnCount);
        if (prevColumnCount < currentColumnCount) {
            Arrays.fill(columnWidths, prevColumnCount, currentColumnCount, CsvEditorSettings.getInstance().getTableDefaultColumnWidth());
        }
        getFileEditorState().setColumnWidths(columnWidths);
    }

    float zoomFactor = getZoomFactor();
    for (int i = 0; i < currentColumnCount; ++i) {
        TableColumn column = this.tblEditor.getColumnModel().getColumn(i);
        column.setPreferredWidth(Math.round(columnWidths[i] * zoomFactor));
        column.setWidth(Math.round(columnWidths[i] * zoomFactor));
    }

    this.updateRowHeights(null);
    panelInfo.setVisible(getFileEditorState().showInfoPanel());
}
 

protected IElementType(@Nonnull @NonNls String debugName, @Nullable Language language, boolean register) {
  myDebugName = debugName;
  myLanguage = language == null ? Language.ANY : language;
  if (register) {
    synchronized (lock) {
      myIndex = size++;
      LOG.assertTrue(myIndex < MAX_INDEXED_TYPES, "Too many element types registered. Out of (short) range.");
      IElementType[] newRegistry = myIndex >= ourRegistry.length ? ArrayUtil.realloc(ourRegistry, ourRegistry.length * 3 / 2 + 1, ARRAY_FACTORY) : ourRegistry;
      newRegistry[myIndex] = this;
      ourRegistry = newRegistry;
    }
  }
  else {
    myIndex = -1;
  }
}
 

@Override
@Nonnull
public byte[] readBytes(@Nullable ProgressIndicator indicator) throws IOException {
  int contentLength = getConnection().getContentLength();
  BufferExposingByteArrayOutputStream out = new BufferExposingByteArrayOutputStream(contentLength > 0 ? contentLength : BLOCK_SIZE);
  NetUtils.copyStreamContent(indicator, getInputStream(), out, contentLength);
  return ArrayUtil.realloc(out.getInternalBuffer(), out.size());
}
 

@Nonnull
private static byte[] archiveState(@Nonnull Element state) {
  BufferExposingByteArrayOutputStream byteOut = new BufferExposingByteArrayOutputStream();
  try {
    try (OutputStreamWriter writer = new OutputStreamWriter(new SnappyOutputStream(byteOut), CharsetToolkit.UTF8_CHARSET)) {
      XMLOutputter xmlOutputter = JDOMUtil.newXmlOutputter();
      xmlOutputter.setFormat(XML_FORMAT);
      xmlOutputter.output(state, writer);
    }
  }
  catch (IOException e) {
    throw new StateStorageException(e);
  }
  return ArrayUtil.realloc(byteOut.getInternalBuffer(), byteOut.size());
}
 

@Override
public void setData(int segmentIndex, int data) {
  if (segmentIndex >= myData.length) {
    myData = ArrayUtil.realloc(myData, calcCapacity(myData.length, segmentIndex));
  }
  myData[segmentIndex] = (short)data;
}
 

@Override
public void occurrence(@Nonnull final StubIndexKey indexKey, @Nonnull final Object value) {
  Map<Object, int[]> map = myResult.get(indexKey);
  if (map == null) {
    map = new THashMap<>((TObjectHashingStrategy<Object>)myHashingStrategyFunction.fun(indexKey));
    myResult.put(indexKey, map);
  }

  int[] list = map.get(value);
  if (list == null) {
    map.put(value, new int[]{myStubIdx});
  }
  else {
    int lastNonZero = ArrayUtil.lastIndexOfNot(list, 0);
    if (lastNonZero >= 0 && list[lastNonZero] == myStubIdx) {
      // second and subsequent occurrence calls for the same value are no op
      return;
    }
    int lastZero = lastNonZero + 1;

    if (lastZero == list.length) {
      list = ArrayUtil.realloc(list, Math.max(4, list.length << 1));
      map.put(value, list);
    }
    list[lastZero] = myStubIdx;
  }
}
 

@Override
public boolean execute(Object a, int[] b) {
  if (b.length == 1) return true;
  int firstZero = ArrayUtil.indexOf(b, 0);
  if (firstZero != -1) {
    int[] shorterList = ArrayUtil.realloc(b, firstZero);
    myProcessingMap.put(a, shorterList);
  }
  return true;
}
 

@Override
public byte[] getBlock(final int start, final int length) throws IOException {
  myStream.seek(start);
  final byte[] bytes = new byte[length];
  final int read = myStream.read(bytes);
  return ArrayUtil.realloc(bytes, read);
}
 

@Override
public byte[] getBlock(final long start, final int length) throws IOException {
  myStream.seek(start);
  final byte[] bytes = new byte[length];
  final int read = myStream.read(bytes);
  return ArrayUtil.realloc(bytes, read);
}
 

@Nonnull
private static MappedRange[] reallocateArray(@Nonnull MappedRange[] array, int index) {
  if (index < array.length) return array;
  return ArrayUtil.realloc(array, SegmentArray.calcCapacity(array.length, index), MappedRange[]::new);
}
 

public void trimToSize() {
  if (mySize < myData.length){
    myData = ArrayUtil.realloc(myData, mySize);
  }
}
 

public void push(boolean t) {
  if (size >= data.length) {
    data = ArrayUtil.realloc(data, data.length * 3 / 2);
  }
  data[size++] = t;
}
 

@Nonnull
private static short[] reallocShortTable(short[] table) {
  return ArrayUtil.realloc(table, Math.max(table.length * 8 / 5, table.length + 1));
}
 

@Nonnull
protected static int[] reallocateArray(@Nonnull int[] array, int index) {
  if (index < array.length) return array;
  return ArrayUtil.realloc(array, calcCapacity(array.length, index));
}
 

@Nonnull
protected static short[] reallocateArray(@Nonnull short[] array, int index) {
  if (index < array.length) return array;
  return ArrayUtil.realloc(array, calcCapacity(array.length, index));
}
 

@Nonnull
private static int[] reallocateArray(@Nonnull int[] array, int index) {
  if (index < array.length) return array;
  return ArrayUtil.realloc(array, calcCapacity(array.length, index));
}