mirror of
https://github.com/SquidDev-CC/CC-Tweaked
synced 2024-06-24 22:23:21 +00:00
![SquidDev](/assets/img/avatar_default.png)
illuaminate does not handle Java files, for obvious reasons. In order to get around that, we have a series of stub files within /doc/stub which mirrored the Java ones. While this works, it has a few problems: - The link to source code does not work - it just links to the stub file. - There's no guarantee that documentation remains consistent with the Java code. This change found several methods which were incorrectly documented beforehand. We now replace this with a custom Java doclet[1], which extracts doc comments from @LuaFunction annotated methods and generates stub-files from them. These also contain a @source annotation, which allows us to correctly link them back to the original Java code. There's some issues with this which have yet to be fixed. However, I don't think any of them are major blockers right now: - The custom doclet relies on Java 9 - I think it's /technically/ possible to do this on Java 8, but the API is significantly uglier. This means that we need to run javadoc on a separate JVM. This is possible, and it works locally and on CI, but is definitely not a nice approach. - illuaminate now requires the doc stubs to be generated in order for the linter to pass, which does make running the linter locally much harder (especially given the above bullet point). We could notionally include the generated stubs (or at least a cut down version of them) in the repo, but I'm not 100% sure about that. [1]: https://docs.oracle.com/javase/9/docs/api/jdk/javadoc/doclet/package-summary.html
369 lines
11 KiB
Java
369 lines
11 KiB
Java
/*
|
|
* This file is part of ComputerCraft - http://www.computercraft.info
|
|
* Copyright Daniel Ratcliffe, 2011-2020. Do not distribute without permission.
|
|
* Send enquiries to dratcliffe@gmail.com
|
|
*/
|
|
package dan200.computercraft.core.apis;
|
|
|
|
import dan200.computercraft.api.filesystem.IMount;
|
|
import dan200.computercraft.api.filesystem.IWritableMount;
|
|
import dan200.computercraft.api.lua.*;
|
|
import dan200.computercraft.api.peripheral.IDynamicPeripheral;
|
|
import dan200.computercraft.api.peripheral.IPeripheral;
|
|
import dan200.computercraft.api.peripheral.IWorkMonitor;
|
|
import dan200.computercraft.api.peripheral.NotAttachedException;
|
|
import dan200.computercraft.core.asm.LuaMethod;
|
|
import dan200.computercraft.core.asm.NamedMethod;
|
|
import dan200.computercraft.core.asm.PeripheralMethod;
|
|
import dan200.computercraft.core.computer.ComputerSide;
|
|
import dan200.computercraft.core.tracking.TrackingField;
|
|
|
|
import javax.annotation.Nonnull;
|
|
import javax.annotation.Nullable;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* CC's "native" peripheral API. This is wrapped within CraftOS to provide a version which works with modems.
|
|
*
|
|
* @cc.module peripheral
|
|
* @hidden
|
|
*/
|
|
public class PeripheralAPI implements ILuaAPI, IAPIEnvironment.IPeripheralChangeListener
|
|
{
|
|
private class PeripheralWrapper extends ComputerAccess
|
|
{
|
|
private final String side;
|
|
private final IPeripheral peripheral;
|
|
|
|
private final String type;
|
|
private final Map<String, PeripheralMethod> methodMap;
|
|
private boolean attached;
|
|
|
|
PeripheralWrapper( IPeripheral peripheral, String side )
|
|
{
|
|
super( environment );
|
|
this.side = side;
|
|
this.peripheral = peripheral;
|
|
attached = false;
|
|
|
|
type = Objects.requireNonNull( peripheral.getType(), "Peripheral type cannot be null" );
|
|
|
|
methodMap = PeripheralAPI.getMethods( peripheral );
|
|
}
|
|
|
|
public IPeripheral getPeripheral()
|
|
{
|
|
return peripheral;
|
|
}
|
|
|
|
public String getType()
|
|
{
|
|
return type;
|
|
}
|
|
|
|
public Collection<String> getMethods()
|
|
{
|
|
return methodMap.keySet();
|
|
}
|
|
|
|
public synchronized boolean isAttached()
|
|
{
|
|
return attached;
|
|
}
|
|
|
|
public synchronized void attach()
|
|
{
|
|
attached = true;
|
|
peripheral.attach( this );
|
|
}
|
|
|
|
public void detach()
|
|
{
|
|
// Call detach
|
|
peripheral.detach( this );
|
|
|
|
synchronized( this )
|
|
{
|
|
// Unmount everything the detach function forgot to do
|
|
unmountAll();
|
|
}
|
|
|
|
attached = false;
|
|
}
|
|
|
|
public MethodResult call( ILuaContext context, String methodName, IArguments arguments ) throws LuaException
|
|
{
|
|
PeripheralMethod method;
|
|
synchronized( this )
|
|
{
|
|
method = methodMap.get( methodName );
|
|
}
|
|
|
|
if( method == null ) throw new LuaException( "No such method " + methodName );
|
|
|
|
environment.addTrackingChange( TrackingField.PERIPHERAL_OPS );
|
|
return method.apply( peripheral, context, this, arguments );
|
|
}
|
|
|
|
// IComputerAccess implementation
|
|
@Override
|
|
public synchronized String mount( @Nonnull String desiredLoc, @Nonnull IMount mount, @Nonnull String driveName )
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
return super.mount( desiredLoc, mount, driveName );
|
|
}
|
|
|
|
@Override
|
|
public synchronized String mountWritable( @Nonnull String desiredLoc, @Nonnull IWritableMount mount, @Nonnull String driveName )
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
return super.mountWritable( desiredLoc, mount, driveName );
|
|
}
|
|
|
|
@Override
|
|
public synchronized void unmount( String location )
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
super.unmount( location );
|
|
}
|
|
|
|
@Override
|
|
public int getID()
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
return super.getID();
|
|
}
|
|
|
|
@Override
|
|
public void queueEvent( @Nonnull String event, Object... arguments )
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
super.queueEvent( event, arguments );
|
|
}
|
|
|
|
@Nonnull
|
|
@Override
|
|
public String getAttachmentName()
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
return side;
|
|
}
|
|
|
|
@Nonnull
|
|
@Override
|
|
public Map<String, IPeripheral> getAvailablePeripherals()
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
|
|
Map<String, IPeripheral> peripherals = new HashMap<>();
|
|
for( PeripheralWrapper wrapper : PeripheralAPI.this.peripherals )
|
|
{
|
|
if( wrapper != null && wrapper.isAttached() )
|
|
{
|
|
peripherals.put( wrapper.getAttachmentName(), wrapper.getPeripheral() );
|
|
}
|
|
}
|
|
|
|
return Collections.unmodifiableMap( peripherals );
|
|
}
|
|
|
|
@Nullable
|
|
@Override
|
|
public IPeripheral getAvailablePeripheral( @Nonnull String name )
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
|
|
for( PeripheralWrapper wrapper : peripherals )
|
|
{
|
|
if( wrapper != null && wrapper.isAttached() && wrapper.getAttachmentName().equals( name ) )
|
|
{
|
|
return wrapper.getPeripheral();
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Nonnull
|
|
@Override
|
|
public IWorkMonitor getMainThreadMonitor()
|
|
{
|
|
if( !attached ) throw new NotAttachedException();
|
|
return super.getMainThreadMonitor();
|
|
}
|
|
}
|
|
|
|
private final IAPIEnvironment environment;
|
|
private final PeripheralWrapper[] peripherals = new PeripheralWrapper[6];
|
|
private boolean running;
|
|
|
|
public PeripheralAPI( IAPIEnvironment environment )
|
|
{
|
|
this.environment = environment;
|
|
this.environment.setPeripheralChangeListener( this );
|
|
running = false;
|
|
}
|
|
|
|
// IPeripheralChangeListener
|
|
|
|
@Override
|
|
public void onPeripheralChanged( ComputerSide side, IPeripheral newPeripheral )
|
|
{
|
|
synchronized( peripherals )
|
|
{
|
|
int index = side.ordinal();
|
|
if( peripherals[index] != null )
|
|
{
|
|
// Queue a detachment
|
|
final PeripheralWrapper wrapper = peripherals[index];
|
|
if( wrapper.isAttached() ) wrapper.detach();
|
|
|
|
// Queue a detachment event
|
|
environment.queueEvent( "peripheral_detach", side.getName() );
|
|
}
|
|
|
|
// Assign the new peripheral
|
|
peripherals[index] = newPeripheral == null ? null
|
|
: new PeripheralWrapper( newPeripheral, side.getName() );
|
|
|
|
if( peripherals[index] != null )
|
|
{
|
|
// Queue an attachment
|
|
final PeripheralWrapper wrapper = peripherals[index];
|
|
if( running && !wrapper.isAttached() ) wrapper.attach();
|
|
|
|
// Queue an attachment event
|
|
environment.queueEvent( "peripheral", side.getName() );
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String[] getNames()
|
|
{
|
|
return new String[] { "peripheral" };
|
|
}
|
|
|
|
@Override
|
|
public void startup()
|
|
{
|
|
synchronized( peripherals )
|
|
{
|
|
running = true;
|
|
for( int i = 0; i < 6; i++ )
|
|
{
|
|
PeripheralWrapper wrapper = peripherals[i];
|
|
if( wrapper != null && !wrapper.isAttached() ) wrapper.attach();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void shutdown()
|
|
{
|
|
synchronized( peripherals )
|
|
{
|
|
running = false;
|
|
for( int i = 0; i < 6; i++ )
|
|
{
|
|
PeripheralWrapper wrapper = peripherals[i];
|
|
if( wrapper != null && wrapper.isAttached() )
|
|
{
|
|
wrapper.detach();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@LuaFunction
|
|
public final boolean isPresent( String sideName )
|
|
{
|
|
ComputerSide side = ComputerSide.valueOfInsensitive( sideName );
|
|
if( side != null )
|
|
{
|
|
synchronized( peripherals )
|
|
{
|
|
PeripheralWrapper p = peripherals[side.ordinal()];
|
|
if( p != null ) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@LuaFunction
|
|
public final Object[] getType( String sideName )
|
|
{
|
|
ComputerSide side = ComputerSide.valueOfInsensitive( sideName );
|
|
if( side == null ) return null;
|
|
|
|
synchronized( peripherals )
|
|
{
|
|
PeripheralWrapper p = peripherals[side.ordinal()];
|
|
if( p != null ) return new Object[] { p.getType() };
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@LuaFunction
|
|
public final Object[] getMethods( String sideName )
|
|
{
|
|
ComputerSide side = ComputerSide.valueOfInsensitive( sideName );
|
|
if( side == null ) return null;
|
|
|
|
synchronized( peripherals )
|
|
{
|
|
PeripheralWrapper p = peripherals[side.ordinal()];
|
|
if( p != null ) return new Object[] { p.getMethods() };
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@LuaFunction
|
|
public final MethodResult call( ILuaContext context, IArguments args ) throws LuaException
|
|
{
|
|
ComputerSide side = ComputerSide.valueOfInsensitive( args.getString( 0 ) );
|
|
String methodName = args.getString( 1 );
|
|
IArguments methodArgs = args.drop( 2 );
|
|
|
|
if( side == null ) throw new LuaException( "No peripheral attached" );
|
|
|
|
PeripheralWrapper p;
|
|
synchronized( peripherals )
|
|
{
|
|
p = peripherals[side.ordinal()];
|
|
}
|
|
if( p == null ) throw new LuaException( "No peripheral attached" );
|
|
|
|
try
|
|
{
|
|
return p.call( context, methodName, methodArgs ).adjustError( 1 );
|
|
}
|
|
catch( LuaException e )
|
|
{
|
|
// We increase the error level by one in order to shift the error level to where peripheral.call was
|
|
// invoked. It would be possible to do it in Lua code, but would add significantly more overhead.
|
|
if( e.getLevel() > 0 ) throw new FastLuaException( e.getMessage(), e.getLevel() + 1 );
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public static Map<String, PeripheralMethod> getMethods( IPeripheral peripheral )
|
|
{
|
|
String[] dynamicMethods = peripheral instanceof IDynamicPeripheral
|
|
? Objects.requireNonNull( ((IDynamicPeripheral) peripheral).getMethodNames(), "Peripheral methods cannot be null" )
|
|
: LuaMethod.EMPTY_METHODS;
|
|
|
|
List<NamedMethod<PeripheralMethod>> methods = PeripheralMethod.GENERATOR.getMethods( peripheral.getClass() );
|
|
|
|
Map<String, PeripheralMethod> methodMap = new HashMap<>( methods.size() + dynamicMethods.length );
|
|
for( int i = 0; i < dynamicMethods.length; i++ )
|
|
{
|
|
methodMap.put( dynamicMethods[i], PeripheralMethod.DYNAMIC.get( i ) );
|
|
}
|
|
for( NamedMethod<PeripheralMethod> method : methods )
|
|
{
|
|
methodMap.put( method.getName(), method.getMethod() );
|
|
}
|
|
return methodMap;
|
|
}
|
|
}
|