MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup (formatting)

Browse Source
This commit is contained in:
Roman Shevchenko
2019-04-16 12:32:57 +02:00
parent bb33d58802
commit 3a1e2378c7
1 changed files with 30 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
platform/util/src/com/intellij/util/containers/LimitedPool.java
+30 -43
View File
@@ -1,68 +1,55 @@
/*
* Copyright 2000-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.util.containers;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NotNull;
/*
/**
* @author max
*/
public class LimitedPool<T> {
private final int maxCapacity;
private final ObjectFactory<T> factory;
private Object[] storage;
private int index;
public LimitedPool(final int maxCapacity, @NotNull ObjectFactory<T> factory) {
this.maxCapacity = maxCapacity;
this.factory = factory;
storage = new Object[10];
public interface ObjectFactory<T> {
@NotNull T create();
default void cleanup(@NotNull T t) { }
}
public interface ObjectFactory<T> {
@NotNull
T create();
void cleanup(@NotNull T t);
private final int myCapacity;
private final ObjectFactory<T> myFactory;
private Object[] myStorage;
private int myIndex;
public LimitedPool(int capacity, @NotNull ObjectFactory<T> factory) {
myCapacity = capacity;
myFactory = factory;
myStorage = new Object[10];
}
@NotNull
public T alloc() {
if (index == 0) return factory.create();
int i = --index;
//noinspection unchecked
T result = (T)storage[i];
storage[i] = null;
if (myIndex == 0) {
return myFactory.create();
}
int i = --myIndex;
@SuppressWarnings("unchecked") T result = (T)myStorage[i];
myStorage[i] = null;
return result;
}
public void recycle(@NotNull T t) {
factory.cleanup(t);
if (index >= maxCapacity) return;
myFactory.cleanup(t);
if (myIndex >= myCapacity) {
return;
}
ensureCapacity();
storage[index++] = t;
myStorage[myIndex++] = t;
}
private void ensureCapacity() {
if (storage.length <= index) {
int newCapacity = Math.min(maxCapacity, storage.length * 3 / 2);
storage = ArrayUtil.realloc(storage, newCapacity, ArrayUtil.OBJECT_ARRAY_FACTORY);
if (myStorage.length <= myIndex) {
int newCapacity = Math.min(myCapacity, myStorage.length * 3 / 2);
myStorage = ArrayUtil.realloc(myStorage, newCapacity, ArrayUtil.OBJECT_ARRAY_FACTORY);
}
}
}
}