Seriously implemented all the threading for item and subset saving/loading/filtering/sorting

This commit is contained in:
Chicken-Bomes committed 2014-07-23 21:03:40 +10:00
1 parent 46c842337a
commit a6746d80a2
5 files changed
+292 -218

No files matched your search

+61 -80
View File
@@ -98,12 +98,8 @@ public class ItemList
return filters;
}
private static class ThreadLoadItems extends Thread
public static final RestartableTask loadItems = new RestartableTask("NEI Item Loading")
{
public ThreadLoadItems() {
super("NEI Item Loading");
}
private void damageSearch(Item item, List<ItemStack> permutations) {
HashSet<String> damageIconSet = new HashSet<String>();
for (int damage = 0; damage < 16; damage++)
@@ -126,99 +122,84 @@ public class ItemList
}
@Override
public void run() {
ThreadOperationTimer timer = ThreadOperationTimer.start(this, 500);
restart:
do {
reload = false;
LinkedList<ItemStack> items = new LinkedList<ItemStack>();
LinkedList<ItemStack> permutations = new LinkedList<ItemStack>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
public void execute() {
ThreadOperationTimer timer = getTimer(500);
timer.setLimit(500);
for (Item item : (Iterable<Item>) Item.itemRegistry) {
if (reload)
continue restart;
LinkedList<ItemStack> items = new LinkedList<ItemStack>();
LinkedList<ItemStack> permutations = new LinkedList<ItemStack>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
if (item == null || erroredItems.contains(item))
continue;
timer.setLimit(500);
for (Item item : (Iterable<Item>) Item.itemRegistry) {
if (interrupted()) return;
try {
timer.reset(item);
if (item == null || erroredItems.contains(item))
continue;
permutations.clear();
permutations.addAll(ItemInfo.getItemOverrides(item));
if (permutations.isEmpty())
item.getSubItems(item, null, permutations);
try {
timer.reset(item);
if (permutations.isEmpty())
damageSearch(item, permutations);
permutations.clear();
permutations.addAll(ItemInfo.getItemOverrides(item));
if (permutations.isEmpty())
item.getSubItems(item, null, permutations);
timer.reset();
if (permutations.isEmpty())
damageSearch(item, permutations);
items.addAll(permutations);
itemMap.putAll(item, permutations);
} catch (Throwable t) {
NEIServerConfig.logger.error("Removing item: " + item + " from list.", t);
erroredItems.add(item);
}
timer.reset();
items.addAll(permutations);
itemMap.putAll(item, permutations);
} catch (Throwable t) {
NEIServerConfig.logger.error("Removing item: " + item + " from list.", t);
erroredItems.add(item);
}
ItemList.items = items;
ItemList.itemMap = itemMap;
for(ItemsLoadedCallback callback : loadCallbacks)
callback.itemsLoaded();
updateFilter();
}
while (reload);
loading = false;
}
}
public static class ThreadFilterItems extends Thread {
public ThreadFilterItems() {
super("NEI Item Filtering");
}
if(interrupted()) return;
ItemList.items = items;
ItemList.itemMap = itemMap;
for(ItemsLoadedCallback callback : loadCallbacks)
callback.itemsLoaded();
updateFilter.restart();
}
};
public static final RestartableTask updateFilter = new RestartableTask("NEI Item Filtering")
{
@Override
public void run() {
restart:
do {
refilter = false;
ArrayList<ItemStack> filtered = new ArrayList<ItemStack>();
List<ItemFilter> filters = getItemFilters();
for(ItemStack item : items) {
if(refilter)
continue restart;
public void execute() {
ArrayList<ItemStack> filtered = new ArrayList<ItemStack>();
List<ItemFilter> filters = getItemFilters();
for(ItemStack item : items) {
if (interrupted()) return;
if(itemMatches(item, filters))
filtered.add(item);
}
ItemSorter.sort(filtered);
ItemPanel.updateItemList(filtered);
if(itemMatches(item, filters))
filtered.add(item);
}
while(refilter);
filtering = false;
}
}
if(interrupted()) return;
ItemSorter.sort(filtered);
if(interrupted()) return;
ItemPanel.updateItemList(filtered);
}
};
/**
* @deprecated Use updateFilter.restart()
*/
@Deprecated
public static void updateFilter() {
if (filtering)
refilter = true;
else {
filtering = true;
new ThreadFilterItems().start();
}
updateFilter.restart();
}
/**
* @deprecated Use loadItems.restart()
*/
@Deprecated
public static void loadItems() {
if (loading)
reload = true;
else {
loading = true;
new ThreadLoadItems().start();
}
loadItems.restart();
}
}
+1 -1
View File
@@ -564,7 +564,7 @@ public class LayoutManager implements IContainerInputHandler, IContainerTooltipH
if (isEnabled()) {
setInputFocused(null);
ItemList.loadItems();
ItemList.loadItems.restart();
overlayRenderer = null;
getLayoutStyle().init();
+75
View File
@@ -0,0 +1,75 @@
package codechicken.nei;
public abstract class RestartableTask
{
public final String name;
private Thread thread;
private volatile boolean restart;
private volatile boolean stopped;
private ThreadOperationTimer timer;
public RestartableTask(String name) {
this.name = name;
}
private void start() {
thread = new Thread(name) {
@Override
public void run() {
do {
while(stopped)
try { Thread.sleep(1); } catch (InterruptedException ignored) {}
if(!restart)
execute();
} while(!finish());
}
};
thread.start();
}
private synchronized boolean finish() {
if(restart) {
restart = false;
return false;
} else {
clearTasks();
return true;
}
}
public void clearTasks() {
thread = null;
timer = null;
}
public synchronized void restart() {
if(thread != null) {
stopped = false;
restart = true;
}
else
start();
}
/**
* Stops execution until restart is called. If a thread is running, the restart flag will be set, and the thread will be paused once the execute method exits.
*/
public synchronized void stop() {
if(thread != null) {
stopped = true;
restart = true;
}
}
public boolean interrupted() {
return restart;
}
public synchronized ThreadOperationTimer getTimer(int timeout) {
if (timer == null) timer = ThreadOperationTimer.start(thread, timeout);
return timer;
}
public abstract void execute();
}
+1 -1
View File
@@ -66,7 +66,7 @@ public class SearchField extends TextField implements ItemFilterProvider
@Override
public void onTextChange(String oldText) {
NEIClientConfig.setSearchExpression(text());
ItemList.updateFilter();
ItemList.updateFilter.restart();
}
@Override
+154 -136
View File
@@ -2,7 +2,6 @@ package codechicken.nei;
import codechicken.core.gui.GuiScrollSlot;
import codechicken.lib.gui.GuiDraw;
import codechicken.lib.inventory.InventoryUtils;
import codechicken.lib.vec.Rectangle4i;
import codechicken.nei.ItemList.ItemsLoadedCallback;
import codechicken.nei.ItemList.NothingItemFilter;
@@ -20,6 +19,7 @@ import net.minecraft.util.EnumChatFormatting;
import java.awt.*;
import java.util.*;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoadedCallback, ISearchProvider
{
@@ -373,7 +373,7 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
* All operations on this variable should be synchronised.
*/
private static final ItemStackSet hiddenItems = new ItemStackSet();
private static boolean hiddenItemsDirty = false;
private static final AtomicReference<NBTTagList> dirtyHiddenItems = new AtomicReference<NBTTagList>();
public static SubsetState getState(SubsetTag tag) {
SubsetState state = subsetState.get(tag.fullname);
@@ -381,9 +381,10 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
}
public static void addTag(SubsetTag tag) {
updateState.stop();
synchronized (root) {
root.addTag(tag);
updateState(true);
updateState.reallocate();
}
}
@@ -409,7 +410,6 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
hiddenItems.add(item);
else
hiddenItems.remove(item);
hiddenItemsDirty = true;
}
public static void showOnly(SubsetTag tag) {
@@ -423,22 +423,167 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
public static void setHidden(SubsetTag tag, boolean hidden) {
synchronized (hiddenItems) {
_setHidden(tag, hidden);
updateState(false);
updateHiddenItems();
}
}
public static void setHidden(ItemStack item, boolean hidden) {
synchronized (hiddenItems) {
_setHidden(item, hidden);
updateState(false);
updateHiddenItems();
}
}
public static void unhideAll() {
synchronized (hiddenItems) {
hiddenItems.clear();
hiddenItemsDirty = true;
updateState(false);
updateHiddenItems();
}
}
private static void updateHiddenItems() {
prepareDirtyHiddenItems.restart();
updateState.restart();
}
public static void loadHidden() {
synchronized (hiddenItems) {
hiddenItems.clear();
}
List<ItemStack> itemList = new LinkedList<ItemStack>();
try {
NBTTagList list = NEIClientConfig.world.nbt.getTagList("hiddenItems", 10);
for(int i = 0; i < list.tagCount(); i++)
itemList.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i)));
}
catch (Exception e) {
NEIClientConfig.logger.error("Error loading hiddenItems", e);
return;
}
synchronized (hiddenItems) {
for(ItemStack item : itemList)
hiddenItems.add(item);
}
updateState.restart();
}
private static void saveHidden() {
NBTTagList list = dirtyHiddenItems.getAndSet(null);
if(list != null) {
NEIClientConfig.world.nbt.setTag("hiddenItems", list);
NEIClientConfig.world.saveNBT();
}
}
private static final RestartableTask prepareDirtyHiddenItems = new RestartableTask("NEI Subset Save Thread")
{
private List<ItemStack> getList() {
synchronized (hiddenItems) {
return hiddenItems.values();
}
}
@Override
public void execute() {
NBTTagList list = new NBTTagList();
for(ItemStack item : getList()) {
if(interrupted()) return;
NBTTagCompound tag = new NBTTagCompound();
item.writeToNBT(tag);
list.appendTag(tag);
}
dirtyHiddenItems.set(list);
}
};
private static final UpdateStateTask updateState = new UpdateStateTask();
private static class UpdateStateTask extends RestartableTask
{
private volatile boolean reallocate;
public UpdateStateTask() {
super("NEI Subset Item Allocation");
}
@Override
public void clearTasks() {
super.clearTasks();
reallocate = false;
}
public synchronized void reallocate() {
reallocate = true;
restart();
}
@Override
public void execute() {
HashMap<String, SubsetState> state = new HashMap<String, SubsetState>();
List<SubsetTag> tags = new LinkedList<SubsetTag>();
synchronized (root) {
cloneStates(root, tags, state);
if(interrupted()) return;
}
if(reallocate) {
for (ItemStack item : ItemList.items) {
if(interrupted()) return;
for (SubsetTag tag : tags)
if (tag.filter.matches(item))
state.get(tag.fullname).items.add(item);
}
}
synchronized (root) {
calculateVisibility(root, state);
if(interrupted()) return;
}
subsetState = state;
ItemList.updateFilter.restart();
}
private void cloneStates(SubsetTag tag, List<SubsetTag> tags, HashMap<String, SubsetState> state) {
for(SubsetTag child : tag.sorted) {
if(interrupted()) return;
cloneStates(child, tags, state);
}
tags.add(tag);
SubsetState sstate = new SubsetState();
if(!reallocate)
sstate.items = SubsetWidget.getState(tag).items;
state.put(tag.fullname, sstate);
}
private void calculateVisibility(SubsetTag tag, Map<String, SubsetState> state) {
SubsetState sstate = state.get(tag.fullname);
int hidden = 0;
for(SubsetTag child : tag.sorted) {
if(interrupted()) return;
calculateVisibility(child, state);
int cstate = state.get(child.fullname).state;
if(cstate == 1)
sstate.state = 1;
else if(cstate == 0)
hidden++;
}
if(sstate.state == 1) return;
List<ItemStack> items = sstate.items;
for(ItemStack item : items) {
if(interrupted()) return;
if (isHidden(item))
hidden++;
}
if(hidden == tag.sorted.size()+items.size())
sstate.state = 0;
else if(hidden > 0)
sstate.state = 1;
}
}
@@ -568,133 +713,6 @@ public class SubsetWidget extends Button implements ItemFilterProvider, ItemsLoa
@Override
public void itemsLoaded() {
updateState(true);
}
private static boolean updatingState;
private static boolean reupdate;
private static boolean reallocate;
private static class ThreadSubsetItems extends Thread
{
public ThreadSubsetItems() {
super("NEI Subset Item Allocation");
}
@Override
public void run() {
restart:
do {
reupdate = false;
HashMap<String, SubsetState> state = new HashMap<String, SubsetState>();
List<SubsetTag> tags = new LinkedList<SubsetTag>();
synchronized (root) {
cloneStates(root, tags, state);
}
if(reallocate) {
for (ItemStack item : ItemList.items) {
if (reupdate)
continue restart;
for (SubsetTag tag : tags)
if (tag.filter.matches(item))
state.get(tag.fullname).items.add(item);
}
}
synchronized (root) {
if (reupdate)
continue;
reallocate = false;
calculateVisibility(root, state);
}
subsetState = state;
}
while(reupdate);
updatingState = false;
}
private void cloneStates(SubsetTag tag, List<SubsetTag> tags, HashMap<String, SubsetState> state) {
for(SubsetTag child : tag.sorted)
cloneStates(child, tags, state);
tags.add(tag);
SubsetState sstate = new SubsetState();
if(!reallocate)
sstate.items = SubsetWidget.getState(tag).items;
state.put(tag.fullname, sstate);
}
private void calculateVisibility(SubsetTag tag, Map<String, SubsetState> state) {
SubsetState sstate = state.get(tag.fullname);
int hidden = 0;
for(SubsetTag child : tag.sorted) {
calculateVisibility(child, state);
int cstate = state.get(child.fullname).state;
if(cstate == 1)
sstate.state = 1;
else if(cstate == 0)
hidden++;
}
if(sstate.state == 1)
return;
List<ItemStack> items = sstate.items;
for(ItemStack item : items)
if(isHidden(item))
hidden++;
if(hidden == tag.sorted.size()+items.size())
sstate.state = 0;
else if(hidden > 0)
sstate.state = 1;
}
}
public static void updateState(boolean reallocate) {
SubsetWidget.reallocate = reallocate;
if (updatingState)
reupdate = true;
else {
updatingState = true;
new ThreadSubsetItems().start();
}
ItemList.updateFilter();
}
public static void loadHidden() {
synchronized (hiddenItems) {
hiddenItems.clear();
try {
NBTTagList list = NEIClientConfig.world.nbt.getTagList("hiddenItems", 10);
for(int i = 0; i < list.tagCount(); i++)
hiddenItems.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i)));
}
catch (Exception e) {
hiddenItems.clear();
NEIClientConfig.logger.error("Error loading hiddenItems", e);
}
}
}
private static void saveHidden() {
if(!hiddenItemsDirty)
return;
synchronized (hiddenItems) {
NBTTagList list = new NBTTagList();
for(ItemStack item : hiddenItems.values()) {
NBTTagCompound tag = new NBTTagCompound();
item.writeToNBT(tag);
list.appendTag(tag);
}
NEIClientConfig.world.nbt.setTag("hiddenItems", list);
NEIClientConfig.world.saveNBT();
hiddenItemsDirty = false;
}
updateState.reallocate();
}
}