tilera
/
Applied-Energistics-2-tilera-Edition
1
1
Fork 0
Code Issues 7 Pull Requests Releases 1 Wiki Activity

Merge pull request #2032 from yueh/feature-cached-networkmonitor 

Changed NetworkMonitor to update its cache.
This commit is contained in:
yueh 2015-12-10 16:34:24 +01:00
parent 71a9687b01 0696662254
commit 919faefb15
3 changed files with 293 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/main/java/appeng/me/cache/GridStorageCache.java vendored
View File

@ -239,8 +239,8 @@ public class GridStorageCache implements IStorageGrid
}
}
this.itemMonitor.forceUpdate();
this.fluidMonitor.forceUpdate();
this.itemMonitor.forceUpdate( false );
this.fluidMonitor.forceUpdate( false );
tracker.applyChanges();
}

365
src/main/java/appeng/me/cache/NetworkMonitor.java vendored
View File

@ -21,41 +21,321 @@ package appeng.me.cache;
import java.util.Collection;
import java.util.Deque;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import com.google.common.collect.ImmutableList;
import appeng.api.config.AccessRestriction;
import appeng.api.config.Actionable;
import appeng.api.networking.events.MENetworkStorageEvent;
import appeng.api.networking.security.BaseActionSource;
import appeng.api.storage.IMEInventoryHandler;
import appeng.api.storage.IMEMonitor;
import appeng.api.storage.IMEMonitorHandlerReceiver;
import appeng.api.storage.MEMonitorHandler;
import appeng.api.storage.StorageChannel;
import appeng.api.storage.data.IAEStack;
import appeng.api.storage.data.IItemList;
import appeng.me.storage.ItemWatcher;
public class NetworkMonitor<T extends IAEStack<T>> extends MEMonitorHandler<T>
public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
{
@Nonnull
private static final Deque<NetworkMonitor<?>> GLOBAL_DEPTH = new LinkedList<NetworkMonitor<?>>();
private static final Deque<NetworkMonitor<?>> DEPTH = new LinkedList<NetworkMonitor<?>>();
@Nonnull
private final GridStorageCache myGridCache;
@Nonnull
private final StorageChannel myChannel;
@Nonnull
private final IItemList<T> cachedList;
@Nonnull
private final Map<IMEMonitorHandlerReceiver<T>, Object> listeners = new HashMap<IMEMonitorHandlerReceiver<T>, Object>();
private boolean sendEvent = false;
private boolean hasChanged = false;
private int localDepthSemaphore = 0;
public NetworkMonitor( final GridStorageCache cache, final StorageChannel chan )
{
super( null, chan );
this.myGridCache = cache;
this.myChannel = chan;
this.cachedList = (IItemList<T>) chan.createList();
}
void forceUpdate()
@Override
public void addListener( final IMEMonitorHandlerReceiver<T> l, final Object verificationToken )
{
this.hasChanged = true;
this.listeners.put( l, verificationToken );
}
@Override
public boolean canAccept( final T input )
{
return this.getHandler().canAccept( input );
}
@Override
public T extractItems( final T request, final Actionable mode, final BaseActionSource src )
{
if( mode == Actionable.SIMULATE )
{
return this.getHandler().extractItems( request, mode, src );
}
localDepthSemaphore++;
final T leftover = this.getHandler().extractItems( request, mode, src );
localDepthSemaphore--;
if( localDepthSemaphore == 0 )
{
this.monitorDifference( request.copy(), leftover, true, src );
}
return leftover;
}
@Override
public AccessRestriction getAccess()
{
return this.getHandler().getAccess();
}
@Override
public IItemList<T> getAvailableItems( final IItemList out )
{
return this.getHandler().getAvailableItems( out );
}
@Override
public StorageChannel getChannel()
{
return this.getHandler().getChannel();
}
@Override
public int getPriority()
{
return this.getHandler().getPriority();
}
@Override
public int getSlot()
{
return this.getHandler().getSlot();
}
@Nonnull
@Override
public IItemList<T> getStorageList()
{
if( this.hasChanged )
{
this.hasChanged = false;
this.cachedList.resetStatus();
return this.getAvailableItems( this.cachedList );
}
return this.cachedList;
}
@Override
public T injectItems( final T input, final Actionable mode, final BaseActionSource src )
{
if( mode == Actionable.SIMULATE )
{
return this.getHandler().injectItems( input, mode, src );
}
localDepthSemaphore++;
final T leftover = this.getHandler().injectItems( input, mode, src );
localDepthSemaphore--;
if( localDepthSemaphore == 0 )
{
this.monitorDifference( input.copy(), leftover, false, src );
}
return leftover;
}
@Override
public boolean isPrioritized( final T input )
{
return this.getHandler().isPrioritized( input );
}
@Override
public void removeListener( final IMEMonitorHandlerReceiver<T> l )
{
this.listeners.remove( l );
}
@Override
public boolean validForPass( final int i )
{
return this.getHandler().validForPass( i );
}
@Nullable
@SuppressWarnings( "unchecked" )
private IMEInventoryHandler<T> getHandler()
{
switch( this.myChannel )
{
case ITEMS:
return (IMEInventoryHandler<T>) this.myGridCache.getItemInventoryHandler();
case FLUIDS:
return (IMEInventoryHandler<T>) this.myGridCache.getFluidInventoryHandler();
default:
}
return null;
}
private Iterator<Entry<IMEMonitorHandlerReceiver<T>, Object>> getListeners()
{
return this.listeners.entrySet().iterator();
}
private T monitorDifference( final IAEStack original, final T leftOvers, final boolean extraction, final BaseActionSource src )
{
final T diff = (T) original.copy();
if( extraction )
{
diff.setStackSize( leftOvers == null ? 0 : -leftOvers.getStackSize() );
}
else if( leftOvers != null )
{
diff.decStackSize( leftOvers.getStackSize() );
}
if( diff.getStackSize() != 0 )
{
this.postChangesToListeners( ImmutableList.of( diff ), src );
}
return leftOvers;
}
private void notifyListenersOfChange( final Iterable<T> diff, final BaseActionSource src )
{
final Iterator<Entry<IMEMonitorHandlerReceiver<T>, Object>> i = this.getListeners();
while( i.hasNext() )
{
final Entry<IMEMonitorHandlerReceiver<T>, Object> o = i.next();
final IMEMonitorHandlerReceiver<T> receiver = o.getKey();
if( receiver.isValid( o.getValue() ) )
{
receiver.postChange( this, diff, src );
}
else
{
i.remove();
}
}
}
private void postChangesToListeners( final Iterable<T> changes, final BaseActionSource src )
{
this.postChange( true, changes, src );
}
private void updateCache( Iterable<T> changes, boolean add )
{
for( final T changedItem : changes )
{
T difference = changedItem;
if( !add && changedItem != null )
{
difference = changedItem.copy();
difference.setStackSize( -changedItem.getStackSize() );
}
this.cachedList.add( difference );
}
}
protected void postChange( final boolean add, final Iterable<T> changes, final BaseActionSource src )
{
if( localDepthSemaphore > 0 || GLOBAL_DEPTH.contains( this ) )
{
return;
}
GLOBAL_DEPTH.push( this );
localDepthSemaphore++;
this.sendEvent = true;
this.updateCache( changes, add );
this.notifyListenersOfChange( changes, src );
for( final T changedItem : changes )
{
T difference = changedItem;
if( !add && changedItem != null )
{
difference = changedItem.copy();
difference.setStackSize( -changedItem.getStackSize() );
}
if( this.myGridCache.getInterestManager().containsKey( changedItem ) )
{
final Collection<ItemWatcher> list = this.myGridCache.getInterestManager().get( changedItem );
if( !list.isEmpty() )
{
IAEStack fullStack = this.getStorageList().findPrecise( changedItem );
if( fullStack == null )
{
fullStack = changedItem.copy();
fullStack.setStackSize( 0 );
}
this.myGridCache.getInterestManager().enableTransactions();
for( final ItemWatcher iw : list )
{
iw.getHost().onStackChange( this.getStorageList(), fullStack, difference, src, this.getChannel() );
}
this.myGridCache.getInterestManager().disableTransactions();
}
}
}
final NetworkMonitor<?> last = GLOBAL_DEPTH.pop();
localDepthSemaphore--;
if( last != this )
{
throw new IllegalStateException( "Invalid Access to Networked Storage API detected." );
}
}
void forceUpdate( boolean reset )
{
if( reset )
{
this.hasChanged = true;
this.cachedList.resetStatus();
this.getAvailableItems( this.cachedList );
}
final Iterator<Entry<IMEMonitorHandlerReceiver<T>, Object>> i = this.getListeners();
while( i.hasNext() )
{
final Entry<IMEMonitorHandlerReceiver<T>, Object> o = i.next();
@ -81,77 +361,4 @@ public class NetworkMonitor<T extends IAEStack<T>> extends MEMonitorHandler<T>
}
}
@Override
protected IMEInventoryHandler getHandler()
{
switch( this.myChannel )
{
case ITEMS:
return this.myGridCache.getItemInventoryHandler();
case FLUIDS:
return this.myGridCache.getFluidInventoryHandler();
default:
}
return null;
}
@Override
protected void postChangesToListeners( final Iterable<T> changes, final BaseActionSource src )
{
this.postChange( true, changes, src );
}
protected void postChange( final boolean add, final Iterable<T> changes, final BaseActionSource src )
{
if( DEPTH.contains( this ) )
{
return;
}
DEPTH.push( this );
this.sendEvent = true;
this.notifyListenersOfChange( changes, src );
final IItemList<T> myStorageList = this.getStorageList();
for( final T changedItem : changes )
{
T difference = changedItem;
if( !add && changedItem != null )
{
( difference = changedItem.copy() ).setStackSize( -changedItem.getStackSize() );
}
if( this.myGridCache.getInterestManager().containsKey( changedItem ) )
{
final Collection<ItemWatcher> list = this.myGridCache.getInterestManager().get( changedItem );
if( !list.isEmpty() )
{
IAEStack fullStack = myStorageList.findPrecise( changedItem );
if( fullStack == null )
{
fullStack = changedItem.copy();
fullStack.setStackSize( 0 );
}
this.myGridCache.getInterestManager().enableTransactions();
for( final ItemWatcher iw : list )
{
iw.getHost().onStackChange( myStorageList, fullStack, difference, src, this.getChannel() );
}
this.myGridCache.getInterestManager().disableTransactions();
}
}
}
final NetworkMonitor<?> last = DEPTH.pop();
if( last != this )
{
throw new IllegalStateException( "Invalid Access to Networked Storage API detected." );
}
}
}

9
src/main/java/appeng/parts/misc/PartStorageBus.java
View File

@ -378,10 +378,11 @@ public class PartStorageBus extends PartUpgradeable implements IGridTickable, IC
final IMEInventory<IAEItemStack> out = this.getInternalHandler();
if( this.monitor != null )
{
this.monitor.onTick();
}
// TODO: evaluate, if this is really (not) necessary.
// if( this.monitor != null )
// {
// this.monitor.onTick();
// }
IItemList<IAEItemStack> after = AEApi.instance().storage().createItemList();
if( out != null )