Writing + Using Features

public class FeatureOverview implements Feature {
	{
		// returns true if this is currently active
		// true means it will receive updates for the current OpMode
		boolean isActive = isActive();
	}

	// we won't look at the dependency system closely here
	private Dependency<?> dependency = (VoidDependency) (Wrapper opMode, List<? extends Feature> resolvedFeatures, boolean yielding) -> {};

	@NonNull
	@Override
	public Dependency<?> getDependency() {
		return dependency;
	}

	@Override
	public void setDependency(@NonNull Dependency<?> dependency) {
		this.dependency = dependency;
	}

	//
	// Hooks
	//

	// By default, all the hooks are empty, so you only need to override the ones you want to use

	@Override
	public void preUserInitHook(Wrapper opMode) {}

	@Override
	public void postUserInitHook(Wrapper opMode) {}

	@Override
	public void preUserInitLoopHook(Wrapper opMode) {}

	@Override
	public void postUserInitLoopHook(Wrapper opMode) {}

	@Override
	public void preUserStartHook(Wrapper opMode) {}

	@Override
	public void postUserStartHook(Wrapper opMode) {}

	@Override
	public void preUserLoopHook(Wrapper opMode) {}

	@Override
	public void postUserLoopHook(Wrapper opMode) {}

	@Override
	public void preUserStopHook(Wrapper opMode) {}

	@Override
	public void postUserStopHook(Wrapper opMode) {}

	// cleanup differs from postUserStopHook, it runs after the OpMode has completely stopped,
	// and is guaranteed to run, even if the OpMode stopped from a crash.
	@Override
	public void cleanup(Wrapper opMode) {}

	{
		// finally, lets look at some Feature related FeatureRegistrar methods

		FeatureRegistrar.getActiveFeatures(); // list of currently active features
		FeatureRegistrar.getRegisteredFeatures(); // list of registered features

		FeatureRegistrar.isFeatureActive(this); // boolean, same as Feature.isActive()

		// don't register and deregister Features a lot, its expensive
		// try to keep this to only during construction / init, or only one or two at runtime
		// the more you do, the more expensive it is
		FeatureRegistrar.registerFeature(this); // same as Feature.register()
		FeatureRegistrar.deregisterFeature(this); // same as Feature.deregister()
	}
}

public final class BulkReads implements Feature {
	// first, we need to set up the dependency
	// this makes a rule that says:
	// "for this feature to receive updates about an OpMode, it must have @BulkReads.Attach"
	private Dependency<?> dependency = new SingleAnnotation<>(Attach.class);
	// getters and setters for dependency
	@NonNull
	@Override
	public Dependency<?> getDependency() {
		return dependency;
	}

	@Override
	public void setDependency(@NonNull Dependency<?> dependency) {
		this.dependency = dependency;
	}

	// we'll make the constructor private
	private JavaBulkReads() {}
	// our singleton instance
	public static final JavaBulkReads INSTANCE = new JavaBulkReads();

	private List<LynxModule> modules;

	@Override
	public void preUserInitHook(@NonNull Wrapper opMode) {
		// collect and store the modules
		modules = opMode.getOpMode().hardwareMap.getAll(LynxModule.class);
		// set them to manual
		modules.forEach(lynxModule -> lynxModule.setBulkCachingMode(LynxModule.BulkCachingMode.MANUAL));
	}

	// now, in each pre phase, we'll clear the bulk cache
	// we do this in pre, as most calculations and updates happen during
	// post,
	@Override
	public void preUserInitLoopHook(@NonNull Wrapper opMode) {
		modules.forEach(LynxModule::clearBulkCache);
	}

	@Override
	public void preUserStartHook(@NonNull Wrapper opMode) {
		modules.forEach(LynxModule::clearBulkCache);
	}

	@Override
	public void preUserLoopHook(@NonNull Wrapper opMode) {
		modules.forEach(LynxModule::clearBulkCache);
	}

	// cleanup is a guaranteed run post stop
	// here, we'll drop our references to the modules
	@Override
	public void cleanup(@NonNull Wrapper opMode) {
		modules = null;
	}

	// the @BulkReads.Attach annotation
	@Target(ElementType.TYPE)
	@Retention(RetentionPolicy.RUNTIME)
	public @interface Attach {}
}

public class PID implements Feature {
	// first, we need to set up the dependency
	// Yielding just says "this isn't too important, always attach me, but run me after more important things"
	// Yielding is reusable!
	private Dependency<?> dependency = Yielding.INSTANCE;
	@NonNull
	@Override
	public Dependency<?> getDependency() {
		return dependency;
	}

	@Override
	public void setDependency(@NonNull Dependency<?> dependency) {
		this.dependency = dependency;
	}

	public PID(/* encoder, motor, coefficients... */) {
		// store them...
	}

	{
		// regardless of constructor used, call register when the class is instantiated
		register();
	}

	private void update() {
		// calculate next output using encoder, target and coefficients

		// don't update motor power if the controller isn't enabled
		if (!enabled) return;

		// set motor power to calculated output
	}

	// users should be able to change the target
	private int target = 0;

	public int getTarget() {
		return target;
	}

	public void setTarget(int target) {
		this.target = target;
	}

	// users should be able to enable / disable the controller
	private boolean enabled = true;

	public boolean isEnabled() {
		return enabled;
	}

	public void setEnabled(boolean enabled) {
		this.enabled = enabled;
	}

	// after init loop and loop we will update the controller
	@Override
	public void postUserInitLoopHook(@NonNull Wrapper opMode) {
		update();
	}

	@Override
	public void postUserLoopHook(@NonNull Wrapper opMode) {
		update();
	}

	// in cleanup we deregister, which prevents this from sticking around for another OpMode,
	// unless the user calls register again
	@Override
	public void cleanup(@NonNull Wrapper opMode) {
		deregister();
	}
}

// we add this, and BulkReads will receive updates for this OpMode
// which means it will handle bulk reads for us!
@BulkReads.Attach
// this annotation makes it so that the FeatureRegistrar will log all the reasons
// for any registered Features that weren't activated
@FeatureRegistrar.LogDependencyResolutionExceptions
public class Usage extends OpMode {
	public Usage() {
		// instead of `@FeatureRegistrar.LogDependencyResolutionExceptions`
		// checkFeatures can be used to ensure that all features
		// passed to the function will be activated,
		// or will throw an error for them specifically
		// both are good debugging tools!
		FeatureRegistrar.checkFeatures(BulkReads.INSTANCE/*, varargs Features*/);
	}

	// we'll look at OpModeLazyCell later, but this means that this PID will be instantiated in init for us
	// for this example it doesn't really matter, but if we actually implemented it, then we would need to use this
	// to ensure that we don't access the hardware map until init
	private final OpModeLazyCell<PID> pidCell = new OpModeLazyCell<>(PID::new);
	private PID getPID() { return pidCell.get(); }
	@Override
	public void init() {
	}

	// we can set the target in loop if we want
	// and we don't need to worry about anything else!
	@Override
	public void loop() {
		if (gamepad1.a) {
			getPID().setTarget(100);
		}
		else if (gamepad1.b) {
			getPID().setTarget(0);
		}
	}
}