Allow generic peripherals to specify a custom source

- Add a new GenericPeripheral interface. We don't strictly speaking
   need this - could put this on GenericSource - but the separation
   seems cleaner.

 - GenericPeripheral.getType() returns a new PeripheralType class, which
   can either be untyped() or specify a type name. This is a little
   over-engineered (could just be a nullable string), but I'm planning
   to allow multiple types in the future, so want some level of
   future-proofing.

 - Thread this PeripheralType through the method gathering code and
   expose it to the GenericPeripheralProvider, which then chooses an
   appropriate name.

   This is a little ugly (we're leaking information about peripherals
   everywhere), but I think is fine for now. It's all private internals
   after all!

Closes #830

src/main/java/dan200/computercraft/api/peripheral/GenericPeripheral.java

@@ -0,0 +1,45 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2021. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.peripheral;
+
+import dan200.computercraft.api.lua.GenericSource;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.items.IItemHandler;
+
+import javax.annotation.Nonnull;
+
+/**
+ * A {@link GenericSource} which provides methods for a peripheral.
+ *
+ * Unlike a {@link GenericSource}, all methods <strong>should</strong> target the same type, for instance a
+ * {@link TileEntity} subclass or a capability interface. This is not currently enforced.
+ */
+public interface GenericPeripheral extends GenericSource
+{
+    /**
+     * Get the type of the exposed peripheral.
+     *
+     * Unlike normal {@link IPeripheral}s, {@link GenericPeripheral} do not have to have a type. By default, the
+     * resulting peripheral uses the resource name of the wrapped {@link TileEntity} (for instance {@literal minecraft:chest}).
+     *
+     * However, in some cases it may be more appropriate to specify a more readable name. Overriding this method allows
+     * you to do so.
+     *
+     * When multiple {@link GenericPeripheral}s return a non-empty peripheral type for a single tile entity, the
+     * lexicographically smallest will be chosen. In order to avoid this conflict, this method should only be
+     * implemented when your peripheral targets a single tile entity <strong>AND</strong> it's likely that you're the
+     * only mod to do so. Similarly this should <strong>NOT</strong> be implemented when your methods target a
+     * capability or other interface (i.e. {@link IItemHandler}).
+     *
+     * @return The type of this peripheral or {@link PeripheralType#untyped()}.
+     * @see IPeripheral#getType()
+     */
+    @Nonnull
+    default PeripheralType getType()
+    {
+        return PeripheralType.untyped();
+    }
+}

src/main/java/dan200/computercraft/api/peripheral/PeripheralType.java

@@ -0,0 +1,62 @@
+/*
+ * This file is part of the public ComputerCraft API - http://www.computercraft.info
+ * Copyright Daniel Ratcliffe, 2011-2021. This API may be redistributed unmodified and in full only.
+ * For help using the API, and posting your mods, visit the forums at computercraft.info.
+ */
+package dan200.computercraft.api.peripheral;
+
+import com.google.common.base.Strings;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+/**
+ * The type of a {@link GenericPeripheral}.
+ *
+ * When determining the final type of the resulting peripheral, the union of all types is taken, with the
+ * lexicographically smallest non-empty name being chosen.
+ */
+public final class PeripheralType
+{
+    private static final PeripheralType UNTYPED = new PeripheralType( null );
+
+    private final String type;
+
+    public PeripheralType( String type )
+    {
+        this.type = type;
+    }
+
+    /**
+     * An empty peripheral type, used when a {@link GenericPeripheral} does not have an explicit type.
+     *
+     * @return The empty peripheral type.
+     */
+    public static PeripheralType untyped()
+    {
+        return UNTYPED;
+    }
+
+    /**
+     * Create a new non-empty peripheral type.
+     *
+     * @param type The name of the type.
+     * @return The constructed peripheral type.
+     */
+    public static PeripheralType ofType( @Nonnull String type )
+    {
+        if( Strings.isNullOrEmpty( type ) ) throw new IllegalArgumentException( "type cannot be null or empty" );
+        return new PeripheralType( type );
+    }
+
+    /**
+     * Get the name of this peripheral type. This may be {@literal null}.
+     *
+     * @return The type of this peripheral.
+     */
+    @Nullable
+    public String getPrimaryType()
+    {
+        return type;
+    }
+}