import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Creates an AE fluid stack from the specified essentia gas with the amount
 * specified.
 *
 * @param essentiaGas
 * @param fluidAmount
 * @return
 */
public IAEFluidStack createAEFluidStackInFluidUnits( final GaseousEssentia essentiaGas, final long fluidAmount )
{
	IAEFluidStack ret = null;
	try
	{
		ret = AEApi.instance().storage().createFluidStack( new FluidStack( essentiaGas, 1 ) );

		ret.setStackSize( fluidAmount );
	}
	catch( Exception e )
	{
	}

	return ret;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
@Override
public IMEMonitor<IAEFluidStack> getFluidInventory()
{
	// Check connectivity
	if( ( this.accessPoint == null ) || !this.isConnected() )
	{
		return null;
	}

	try
	{
		// Get the storage grid
		IStorageGrid storageGrid = this.accessPoint.getActionableNode().getGrid().getCache( IStorageGrid.class );

		// Return the monitor
		return storageGrid.getFluidInventory();
	}
	catch( Exception e )
	{
		// Ignored
	}

	return null;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Checks if the sub-grid can accept this gas.
 */
@Override
public boolean canAccept( final IAEFluidStack fluidStack )
{
	// Is the fluid an essentia gas?
	if( this.isFluidEssentiaGas( fluidStack ) )
	{
		// Pass to handler
		if( this.handler != null )
		{
			return this.handler.canAccept( fluidStack );
		}
	}

	return false;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Attempts to extract the gas from the sub-grid.
 */
@Override
public IAEFluidStack extractItems( final IAEFluidStack request, final Actionable mode, final BaseActionSource source )
{
	// Is the fluid an essentia gas?
	if( this.isFluidEssentiaGas( request ) )
	{
		if( this.handler != null )
		{
			// Extract the gas
			IAEFluidStack extractedGas = this.handler.extractItems( request, mode, source );

			return extractedGas;
		}
	}

	return null;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Gets the gases from the sub-grid.
 */
@Override
public IItemList<IAEFluidStack> getAvailableItems( final IItemList<IAEFluidStack> out )
{
	if( this.handler != null )
	{
		// Get the subgrids fluids
		IItemList<IAEFluidStack> subGridFluids = this.handler.getAvailableItems( AEApi.instance().storage().createFluidList() );

		for( IAEFluidStack fluid : subGridFluids )
		{
			// Is the fluid as essentia gas?
			if( this.isFluidEssentiaGas( fluid ) )
			{
				// Add to the output list
				out.add( fluid );
			}
		}

	}

	return out;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Attempts to inject the gas into the sub-network.
 */
@Override
public IAEFluidStack injectItems( final IAEFluidStack input, final Actionable mode, final BaseActionSource source )
{
	// Is the fluid an essentia gas?
	if( this.isFluidEssentiaGas( input ) )
	{
		if( this.handler != null )
		{
			// Inject the gas
			IAEFluidStack remainingGas = this.handler.injectItems( input, mode, source );

			return remainingGas;
		}
	}
	return input;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Checks if the specified is prioritized.
 */
@Override
public final boolean isPrioritized( final IAEFluidStack fluidStack )
{
	// Ensure the fluid stack is an essentia gas
	if( !this.isFluidEssentiaGas( fluidStack ) )
	{
		// Not an essentia gas.
		return false;
	}

	// Is the aspect prioritized?
	try
	{
		return this.filteredAspects.contains( ( (GaseousEssentia)fluidStack.getFluidStack().getFluid() ).getAspect() );
	}
	catch( Exception e )
	{
		return false;
	}
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Gets the list of essentia gasses stored on the cell.
 */
@Override
public IItemList<IAEFluidStack> getAvailableItems( final IItemList<IAEFluidStack> availableList )
{
	for( IAspectStack essentiaStack : this.storedEssentia )
	{
		// Skip if null
		if( essentiaStack == null )
		{
			continue;
		}

		// Get the gas
		GaseousEssentia essentiaGas = GaseousEssentia.getGasFromAspect( essentiaStack.getAspect() );

		// Create the AE fluid stack
		availableList.add( EssentiaConversionHelper.INSTANCE.createAEFluidStackInEssentiaUnits( essentiaGas, essentiaStack.getStackSize() ) );

	}

	return availableList;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * The creative cell can only provide essentia based on its parition table.
 */
@Override
public IAEFluidStack extractItems( final IAEFluidStack request, final Actionable mode, final BaseActionSource src )
{
	// Ensure there is a request, and that it is an essentia gas
	if( ( request != null ) && ( request.getFluid() != null ) && ( request.getFluid() instanceof GaseousEssentia ) )
	{
		// Get the aspect of the essentia
		Aspect requestAspect = ( (GaseousEssentia)request.getFluid() ).getAspect();

		// Is the cell partitioned for this aspect?
		if( ( requestAspect != null ) && ( this.partitionAspects.contains( requestAspect ) ) )
		{
			return request.copy();
		}
	}

	return null;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Available items based on partition table.
 */
@Override
public IItemList<IAEFluidStack> getAvailableItems( final IItemList<IAEFluidStack> availableList )
{
	for( Aspect aspect : this.partitionAspects )
	{
		// Get the gas
		GaseousEssentia essentiaGas = GaseousEssentia.getGasFromAspect( aspect );

		// Create the AE fluid stack
		availableList.add( EssentiaConversionHelper.INSTANCE.createAEFluidStackInEssentiaUnits( essentiaGas, 2000000000 ) );

	}

	return availableList;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Attempts to inject the fluid into the container.
 * Returns the amount that was injected in milibuckets.
 *
 * @param container
 * @param fluidStack
 * @param mode
 * @return
 */
public long injectFluidIntoContainer( final IAspectContainer container, final IAEFluidStack fluidStack, final Actionable mode )
{
	// Do we have an input?
	if( fluidStack == null )
	{
		// No input
		return 0;
	}

	// Is the container whitelisted?
	if( !this.perms.canInjectToAspectContainerTile( container ) )
	{
		// Not whitelisted
		return 0;
	}

	// Get the fluid.
	Fluid fluid = fluidStack.getFluid();

	// Ensure it is a gas
	if( !( fluid instanceof GaseousEssentia ) )
	{
		// Not essentia gas
		return 0;
	}

	// Get the aspect of the gas
	Aspect gasAspect = ( (GaseousEssentia)fluid ).getAspect();

	// Get the amount to fill
	long amountToFill = EssentiaConversionHelper.INSTANCE.convertFluidAmountToEssentiaAmount( fluidStack.getStackSize() );

	// Inject
	long injectedAmount_EU = this.injectEssentiaIntoContainer( container, (int)amountToFill, gasAspect, mode );

	return EssentiaConversionHelper.INSTANCE.convertEssentiaAmountToFluidAmount( injectedAmount_EU );
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Converts an AE fluid stack into an AspectStack.
 *
 * @param fluidStack
 * @return Aspect stack if converted, null otherwise.
 */
public AspectStack convertAEFluidStackToAspectStack( final IAEFluidStack fluidStack )
{
	// Is the fluid an essentia gas?
	if( fluidStack.getFluid() instanceof GaseousEssentia )
	{
		// Create an aspect stack to match the fluid
		return new AspectStack( ( (GaseousEssentia)fluidStack.getFluid() ).getAspect(), this.convertFluidAmountToEssentiaAmount( fluidStack
						.getStackSize() ) );
	}

	return null;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Creates an AE fluid stack from the specified essentia gas. This will
 * convert the specified amount from essentia units to fluid units(mb).
 *
 * @param Aspect
 * @param essentiaAmount
 * @return
 */
public IAEFluidStack createAEFluidStackInEssentiaUnits( final Aspect aspect, final long essentiaAmount )
{
	GaseousEssentia essentiaGas = GaseousEssentia.getGasFromAspect( aspect );

	if( essentiaGas == null )
	{
		return null;
	}

	return this.createAEFluidStackInFluidUnits( essentiaGas, this.convertEssentiaAmountToFluidAmount( essentiaAmount ) );
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Mirror method of the injectEssentia. Used to defer power calculations, because the simulation is not always accurate, and Essentia gas should
 * not be stored in partial amounts.
 *
 * @param aspect
 * @param amount
 * @param mode
 * @param source
 * @return Amount that was <strong>not</strong> injected
 */
private long injectEssentiaSafely(	final Aspect aspect, final long amount, final Actionable mode, final BaseActionSource source,
									final GaseousEssentia essentiaGas )
{
	// Create the fluid request
	IAEFluidStack fluidRequest = EssentiaConversionHelper.INSTANCE.createAEFluidStackInEssentiaUnits( essentiaGas, amount );

	// Inject fluid
	IAEFluidStack fluidRejected = this.fluidMonitor.injectItems( fluidRequest, mode, source );

	// Was any rejected?
	if( ( fluidRejected != null ) && ( fluidRejected.getStackSize() > 0 ) )
	{
		if( fluidRejected.getStackSize() == fluidRequest.getStackSize() )
		{
			// All essentia was rejected
			return amount;
		}

		// Calculate the adjusted amount, essentia gas can not be stored in partial units
		long rejectedAdjustedAmount = EssentiaConversionHelper.INSTANCE.convertFluidAmountToEssentiaAmount( fluidRejected.getStackSize() );
		return rejectedAdjustedAmount;
	}

	// All essentia was accepted.
	return 0;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * Wraps the specified fluid monitor and energy grid.
 *
 * @param fluidMonitor
 * Fluid monitor to listen to
 * @param energyGrid
 * Energy grid to extract power from
 * @param validationToken
 * Used to validate the state of the fluid listener, can not be null
 */
public void wrap( final IMEMonitor<IAEFluidStack> fluidMonitor, final IEnergyGrid energyGrid, final Object validationToken )
{
	// Ensure the token is not null
	if( validationToken != null )
	{
		// Set the token
		this.token = new WeakReference<Object>( validationToken );
	}
	else
	{
		// Throw exception
		throw new NullPointerException( "Validation Token Can Not Be Null" );
	}

	// Set the fluid monitor
	this.fluidMonitor = fluidMonitor;

	// Set the energy grid
	this.energyGrid = energyGrid;

	// Add listener
	this.fluidMonitor.addListener( this, this.token );

	// Mark that the cache needs to be updated
	this.cacheNeedsUpdate = true;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
@Override
public boolean canAccept( final IAEFluidStack fluidStack )
{
	// Ensure we have an internal handler
	if( this.internalHandler != null )
	{
		// Pass to handler
		return this.internalHandler.canAccept( fluidStack );
	}

	// No handler
	return false;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
@Override
public IAEFluidStack extractItems( final IAEFluidStack request, final Actionable mode, final BaseActionSource source )
{
	// Ensure we have an internal handler
	if( this.internalHandler != null )
	{
		// Pass to handler
		return this.internalHandler.extractItems( request, mode, source );
	}

	// No handler
	return null;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
@Override
public IItemList<IAEFluidStack> getAvailableItems( final IItemList<IAEFluidStack> out )
{
	// Ensure we have an internal handler
	if( this.internalHandler != null )
	{
		// Pass to handler
		return this.internalHandler.getAvailableItems( out );
	}

	// No handler
	return out;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
@Override
public IAEFluidStack injectItems( final IAEFluidStack input, final Actionable mode, final BaseActionSource source )
{
	// Ensure we have an internal handler
	if( this.internalHandler != null )
	{
		// Pass to handler
		return this.internalHandler.injectItems( input, mode, source );
	}

	// No handler
	return input;
}
 

import appeng.api.storage.data.IAEFluidStack; //导入依赖的package包/类
/**
 * A change occurred in the sub-grid, inform the host grid.
 */
@Override
public void postChange( final IBaseMonitor<IAEFluidStack> monitor, final Iterable<IAEFluidStack> change, final BaseActionSource actionSource )
{
	try
	{
		IActionHost actionHost = null;

		// Get the action source
		if( actionSource instanceof PlayerSource )
		{
			// From the player source
			actionHost = ( (PlayerSource)actionSource ).via;
		}
		else if( actionSource instanceof MachineSource )
		{
			// From the machine source
			actionHost = ( (MachineSource)actionSource ).via;
		}

		// Ensure there is an action host
		if( actionHost != null )
		{
			// Post update if change did not come from host grid, prevents double posting.
			if( actionHost.getActionableNode().getGrid() != this.partStorageBus.getActionableNode().getGrid() )
			{
				// Update the host grid
				this.postAlterationToHostGrid( change );
			}
		}
	}
	catch( Exception e )
	{

	}
}