Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

[epilogue] Rename DataLogger to EpilogueBackend for clarity (#7453)

Browse Source 
Update documentation and internal names correspondingly
This commit is contained in:
Sam Carlberg
2024-11-30 01:10:51 -05:00
committed by GitHub
parent 65f3345407
commit 806d56e564
29 changed files with 448 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ArrayHandler.java
View File

@@ -60,7 +60,7 @@ public class ArrayHandler extends ElementHandler {
if (m_structHandler.isLoggableType(componentType)) {
// Struct arrays need to pass in the struct serializer
return "dataLogger.log(\""
return "backend.log(\""
+ loggedName(element)
+ "\", "
+ elementAccess(element)
@@ -69,7 +69,7 @@ public class ArrayHandler extends ElementHandler {
+ ")";
} else {
// Primitive or string array
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
}
}

4
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/CollectionHandler.java
View File

@@ -43,7 +43,7 @@ public class CollectionHandler extends ElementHandler {
var componentType = ((DeclaredType) dataType).getTypeArguments().get(0);
if (m_structHandler.isLoggableType(componentType)) {
return "dataLogger.log(\""
return "backend.log(\""
+ loggedName(element)
+ "\", "
+ elementAccess(element)
@@ -51,7 +51,7 @@ public class CollectionHandler extends ElementHandler {
+ m_structHandler.structAccess(componentType)
+ ")";
} else {
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
}
}

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ConfiguredLoggerHandler.java
View File

@@ -32,7 +32,7 @@ public class ConfiguredLoggerHandler extends ElementHandler {
return "Epilogue."
+ StringUtils.lowerCamelCase(loggerType.asElement().getSimpleName())
+ ".tryUpdate(dataLogger.getSubLogger(\""
+ ".tryUpdate(backend.getNested(\""
+ loggedName(element)
+ "\"), "
+ elementAccess(element)

4
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/ElementHandler.java
View File

@@ -6,7 +6,7 @@ package edu.wpi.first.epilogue.processor;
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
import javax.annotation.processing.ProcessingEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
@@ -157,7 +157,7 @@ public abstract class ElementHandler {
/**
* Generates a code snippet to place in a generated logger file to log the value of a field or
* method. Log invocations are placed in a generated implementation of {@link
* ClassSpecificLogger#update(DataLogger, Object)}, with access to the data logger and logged
* ClassSpecificLogger#update(EpilogueBackend, Object)}, with access to the backend and logged
* object passed to the method call.
*
* @param element the field or method element to generate the logger call for

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EnumHandler.java
View File

@@ -28,6 +28,6 @@ public class EnumHandler extends ElementHandler {
@Override
public String logInvocation(Element element) {
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
}

4
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/EpilogueGenerator.java
View File

@@ -154,9 +154,9 @@ public class EpilogueGenerator {
out.println(
" "
+ StringUtils.loggerFieldName(mainRobotClass)
+ ".tryUpdate(config.dataLogger.getSubLogger(config.root), robot, config.errorHandler);");
+ ".tryUpdate(config.backend.getNested(config.root), robot, config.errorHandler);");
out.println(
" config.dataLogger.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);");
" config.backend.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);");
out.println(" }");
out.println();

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggableHandler.java
View File

@@ -161,7 +161,7 @@ public class LoggableHandler extends ElementHandler {
}
private String generateLoggerCall(Element element, TypeElement type, String elementReference) {
return ("Epilogue.%s.tryUpdate(dataLogger.getSubLogger(\"%s\"), %s, "
return ("Epilogue.%s.tryUpdate(backend.getNested(\"%s\"), %s, "
+ "Epilogue.getConfig().errorHandler)")
.formatted(StringUtils.loggerFieldName(type), loggedName(element), elementReference);
}

5
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/LoggerGenerator.java
View File

@@ -192,7 +192,7 @@ public class LoggerGenerator {
out.println("import edu.wpi.first.epilogue.Logged;");
out.println("import edu.wpi.first.epilogue.Epilogue;");
out.println("import edu.wpi.first.epilogue.logging.ClassSpecificLogger;");
out.println("import edu.wpi.first.epilogue.logging.DataLogger;");
out.println("import edu.wpi.first.epilogue.logging.EpilogueBackend;");
if (requiresVarHandles) {
out.println("import java.lang.invoke.MethodHandles;");
out.println("import java.lang.invoke.VarHandle;");
@@ -255,7 +255,8 @@ public class LoggerGenerator {
// @Override
// public void update(DataLogger dataLogger, Foo object) {
out.println(" @Override");
out.println(" public void update(DataLogger dataLogger, " + simpleClassName + " object) {");
out.println(
" public void update(EpilogueBackend backend, " + simpleClassName + " object) {");
// Build a map of importance levels to the fields logged at those levels
// e.g. { DEBUG: [fieldA, fieldB], INFO: [fieldC], CRITICAL: [fieldD, fieldE, fieldF] }

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/MeasureHandler.java
View File

@@ -32,6 +32,6 @@ public class MeasureHandler extends ElementHandler {
@Override
public String logInvocation(Element element) {
// DataLogger has builtin support for logging measures
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
}

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/PrimitiveHandler.java
View File

@@ -36,6 +36,6 @@ public class PrimitiveHandler extends ElementHandler {
@Override
public String logInvocation(Element element) {
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
}

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SendableHandler.java
View File

@@ -47,7 +47,7 @@ public class SendableHandler extends ElementHandler {
return null;
}
return "logSendable(dataLogger.getSubLogger(\""
return "logSendable(backend.getNested(\""
+ loggedName(element)
+ "\"), "
+ elementAccess(element)

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/StructHandler.java
View File

@@ -39,7 +39,7 @@ public class StructHandler extends ElementHandler {
@Override
public String logInvocation(Element element) {
return "dataLogger.log(\""
return "backend.log(\""
+ loggedName(element)
+ "\", "
+ elementAccess(element)

2
epilogue-processor/src/main/java/edu/wpi/first/epilogue/processor/SupplierHandler.java
View File

@@ -43,7 +43,7 @@ public class SupplierHandler extends ElementHandler {
@Override
public String logInvocation(Element element) {
return "dataLogger.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
return "backend.log(\"" + loggedName(element) + "\", " + elementAccess(element) + ")";
}
@Override

292
epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/AnnotationProcessorTest.java
View File

@@ -40,7 +40,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -48,9 +48,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
backend.log("x", object.x);
}
}
}
@@ -79,7 +79,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -87,10 +87,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("y", object.y);
backend.log("x", object.x);
backend.log("y", object.y);
}
}
}
@@ -118,7 +118,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
@@ -139,9 +139,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", (double) $x.get(object));
backend.log("x", (double) $x.get(object));
}
}
}
@@ -169,7 +169,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
@@ -190,9 +190,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
logSendable(dataLogger.getSubLogger("chooser"), (edu.wpi.first.wpilibj.smartdashboard.SendableChooser<java.lang.String>) $chooser.get(object));
logSendable(backend.getNested("chooser"), (edu.wpi.first.wpilibj.smartdashboard.SendableChooser<java.lang.String>) $chooser.get(object));
}
}
}
@@ -222,7 +222,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -230,15 +230,15 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("low", object.low);
backend.log("low", object.low);
}
if (Epilogue.shouldLog(Logged.Importance.INFO)) {
dataLogger.log("medium", object.medium);
backend.log("medium", object.medium);
}
if (Epilogue.shouldLog(Logged.Importance.CRITICAL)) {
dataLogger.log("high", object.high);
backend.log("high", object.high);
}
}
}
@@ -270,7 +270,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -278,9 +278,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("enumValue", object.enumValue);
backend.log("enumValue", object.enumValue);
}
}
}
@@ -314,7 +314,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -322,12 +322,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -361,7 +361,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -369,10 +369,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("getX", object.getX());
backend.log("x", object.x);
backend.log("getX", object.getX());
}
}
}
@@ -406,7 +406,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -414,10 +414,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("getX", object.getX());
backend.log("x", object.x);
backend.log("getX", object.getX());
}
}
}
@@ -451,7 +451,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -459,12 +459,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -498,7 +498,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -506,12 +506,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -545,7 +545,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -553,12 +553,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -595,7 +595,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -603,12 +603,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -644,7 +644,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -652,12 +652,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -694,7 +694,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -702,13 +702,13 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("arr1", object.arr1);
dataLogger.log("list", object.list);
dataLogger.log("getX", object.getX());
dataLogger.log("getArr1", object.getArr1());
backend.log("x", object.x);
backend.log("arr1", object.arr1);
backend.log("list", object.list);
backend.log("getX", object.getX());
backend.log("getArr1", object.getArr1());
}
}
}
@@ -753,7 +753,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -761,13 +761,13 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x, edu.wpi.first.epilogue.Example.Structable.struct);
dataLogger.log("arr1", object.arr1, edu.wpi.first.epilogue.Example.Structable.struct);
dataLogger.log("list", object.list, edu.wpi.first.epilogue.Example.Structable.struct);
dataLogger.log("getX", object.getX(), edu.wpi.first.epilogue.Example.Structable.struct);
dataLogger.log("getArr1", object.getArr1(), edu.wpi.first.epilogue.Example.Structable.struct);
backend.log("x", object.x, edu.wpi.first.epilogue.Example.Structable.struct);
backend.log("arr1", object.arr1, edu.wpi.first.epilogue.Example.Structable.struct);
backend.log("list", object.list, edu.wpi.first.epilogue.Example.Structable.struct);
backend.log("getX", object.getX(), edu.wpi.first.epilogue.Example.Structable.struct);
backend.log("getArr1", object.getArr1(), edu.wpi.first.epilogue.Example.Structable.struct);
}
}
}
@@ -804,7 +804,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -812,12 +812,12 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("list", object.list);
dataLogger.log("set", object.set);
dataLogger.log("queue", object.queue);
dataLogger.log("stack", object.stack);
backend.log("list", object.list);
backend.log("set", object.set);
backend.log("queue", object.queue);
backend.log("stack", object.stack);
}
}
}
@@ -854,7 +854,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -862,7 +862,7 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
}
}
""";
@@ -985,7 +985,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -993,10 +993,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("value", object.value);
dataLogger.log("upcast", object.upcast());
backend.log("value", object.value);
backend.log("upcast", object.upcast());
}
}
}
@@ -1037,7 +1037,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1045,10 +1045,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
Epilogue.childLogger.tryUpdate(dataLogger.getSubLogger("child"), object.child, Epilogue.getConfig().errorHandler);
Epilogue.ioLogger.tryUpdate(dataLogger.getSubLogger("io"), object.io, Epilogue.getConfig().errorHandler);
Epilogue.childLogger.tryUpdate(backend.getNested("child"), object.child, Epilogue.getConfig().errorHandler);
Epilogue.ioLogger.tryUpdate(backend.getNested("io"), object.io, Epilogue.getConfig().errorHandler);
}
}
}
@@ -1124,7 +1124,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1132,31 +1132,31 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
var $$asInterface = object.asInterface;
if ($$asInterface instanceof edu.wpi.first.epilogue.Impl1 edu_wpi_first_epilogue_Impl1) {
Epilogue.impl1Logger.tryUpdate(dataLogger.getSubLogger("asInterface"), edu_wpi_first_epilogue_Impl1, Epilogue.getConfig().errorHandler);
Epilogue.impl1Logger.tryUpdate(backend.getNested("asInterface"), edu_wpi_first_epilogue_Impl1, Epilogue.getConfig().errorHandler);
} else if ($$asInterface instanceof edu.wpi.first.epilogue.Impl2 edu_wpi_first_epilogue_Impl2) {
Epilogue.impl2Logger.tryUpdate(dataLogger.getSubLogger("asInterface"), edu_wpi_first_epilogue_Impl2, Epilogue.getConfig().errorHandler);
Epilogue.impl2Logger.tryUpdate(backend.getNested("asInterface"), edu_wpi_first_epilogue_Impl2, Epilogue.getConfig().errorHandler);
} else {
// Base type edu.wpi.first.epilogue.IFace
Epilogue.iFaceLogger.tryUpdate(dataLogger.getSubLogger("asInterface"), $$asInterface, Epilogue.getConfig().errorHandler);
Epilogue.iFaceLogger.tryUpdate(backend.getNested("asInterface"), $$asInterface, Epilogue.getConfig().errorHandler);
};
Epilogue.impl1Logger.tryUpdate(dataLogger.getSubLogger("firstImpl"), object.firstImpl, Epilogue.getConfig().errorHandler);
Epilogue.impl2Logger.tryUpdate(dataLogger.getSubLogger("secondImpl"), object.secondImpl, Epilogue.getConfig().errorHandler);
Epilogue.impl1Logger.tryUpdate(backend.getNested("firstImpl"), object.firstImpl, Epilogue.getConfig().errorHandler);
Epilogue.impl2Logger.tryUpdate(backend.getNested("secondImpl"), object.secondImpl, Epilogue.getConfig().errorHandler);
var $$complex = object.complex;
if ($$complex instanceof edu.wpi.first.epilogue.ConcreteLogged edu_wpi_first_epilogue_ConcreteLogged) {
Epilogue.concreteLoggedLogger.tryUpdate(dataLogger.getSubLogger("complex"), edu_wpi_first_epilogue_ConcreteLogged, Epilogue.getConfig().errorHandler);
Epilogue.concreteLoggedLogger.tryUpdate(backend.getNested("complex"), edu_wpi_first_epilogue_ConcreteLogged, Epilogue.getConfig().errorHandler);
} else if ($$complex instanceof edu.wpi.first.epilogue.I4 edu_wpi_first_epilogue_I4) {
Epilogue.i4Logger.tryUpdate(dataLogger.getSubLogger("complex"), edu_wpi_first_epilogue_I4, Epilogue.getConfig().errorHandler);
Epilogue.i4Logger.tryUpdate(backend.getNested("complex"), edu_wpi_first_epilogue_I4, Epilogue.getConfig().errorHandler);
} else if ($$complex instanceof edu.wpi.first.epilogue.I2 edu_wpi_first_epilogue_I2) {
Epilogue.i2Logger.tryUpdate(dataLogger.getSubLogger("complex"), edu_wpi_first_epilogue_I2, Epilogue.getConfig().errorHandler);
Epilogue.i2Logger.tryUpdate(backend.getNested("complex"), edu_wpi_first_epilogue_I2, Epilogue.getConfig().errorHandler);
} else if ($$complex instanceof edu.wpi.first.epilogue.I3 edu_wpi_first_epilogue_I3) {
Epilogue.i3Logger.tryUpdate(dataLogger.getSubLogger("complex"), edu_wpi_first_epilogue_I3, Epilogue.getConfig().errorHandler);
Epilogue.i3Logger.tryUpdate(backend.getNested("complex"), edu_wpi_first_epilogue_I3, Epilogue.getConfig().errorHandler);
} else {
// Base type edu.wpi.first.epilogue.I
Epilogue.iLogger.tryUpdate(dataLogger.getSubLogger("complex"), $$complex, Epilogue.getConfig().errorHandler);
Epilogue.iLogger.tryUpdate(backend.getNested("complex"), $$complex, Epilogue.getConfig().errorHandler);
};
}
}
@@ -1187,7 +1187,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class Outer$ExampleLogger extends ClassSpecificLogger<Outer.Example> {
public Outer$ExampleLogger() {
@@ -1195,9 +1195,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Outer.Example object) {
public void update(EpilogueBackend backend, Outer.Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
backend.log("x", object.x);
}
}
}
@@ -1233,7 +1233,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class A$B$C$D$ExampleLogger extends ClassSpecificLogger<A.B.C.D.Example> {
public A$B$C$D$ExampleLogger() {
@@ -1241,9 +1241,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, A.B.C.D.Example object) {
public void update(EpilogueBackend backend, A.B.C.D.Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
backend.log("x", object.x);
}
}
}
@@ -1273,7 +1273,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class CustomExampleLogger extends ClassSpecificLogger<Outer.Example> {
public CustomExampleLogger() {
@@ -1281,9 +1281,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Outer.Example object) {
public void update(EpilogueBackend backend, Outer.Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
backend.log("x", object.x);
}
}
}
@@ -1326,7 +1326,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1334,16 +1334,16 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
var $$theField = object.theField;
if ($$theField instanceof edu.wpi.first.epilogue.Base edu_wpi_first_epilogue_Base) {
Epilogue.baseLogger.tryUpdate(dataLogger.getSubLogger("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler);
Epilogue.baseLogger.tryUpdate(backend.getNested("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler);
} else if ($$theField instanceof edu.wpi.first.epilogue.ExtendingInterface edu_wpi_first_epilogue_ExtendingInterface) {
Epilogue.extendingInterfaceLogger.tryUpdate(dataLogger.getSubLogger("theField"), edu_wpi_first_epilogue_ExtendingInterface, Epilogue.getConfig().errorHandler);
Epilogue.extendingInterfaceLogger.tryUpdate(backend.getNested("theField"), edu_wpi_first_epilogue_ExtendingInterface, Epilogue.getConfig().errorHandler);
} else {
// Base type edu.wpi.first.epilogue.I
Epilogue.iLogger.tryUpdate(dataLogger.getSubLogger("theField"), $$theField, Epilogue.getConfig().errorHandler);
Epilogue.iLogger.tryUpdate(backend.getNested("theField"), $$theField, Epilogue.getConfig().errorHandler);
};
}
}
@@ -1378,7 +1378,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;
@@ -1399,14 +1399,14 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
var $$theField = (edu.wpi.first.epilogue.I) $theField.get(object);
if ($$theField instanceof edu.wpi.first.epilogue.Base edu_wpi_first_epilogue_Base) {
Epilogue.baseLogger.tryUpdate(dataLogger.getSubLogger("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler);
Epilogue.baseLogger.tryUpdate(backend.getNested("theField"), edu_wpi_first_epilogue_Base, Epilogue.getConfig().errorHandler);
} else {
// Base type edu.wpi.first.epilogue.I
Epilogue.iLogger.tryUpdate(dataLogger.getSubLogger("theField"), $$theField, Epilogue.getConfig().errorHandler);
Epilogue.iLogger.tryUpdate(backend.getNested("theField"), $$theField, Epilogue.getConfig().errorHandler);
};
}
}
@@ -1433,7 +1433,7 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Point point) {
public void update(EpilogueBackend backend, Point point) {
// Implementation is irrelevant
}
}
@@ -1451,7 +1451,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1459,9 +1459,9 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
Epilogue.customPointLogger.tryUpdate(dataLogger.getSubLogger("point"), object.point, Epilogue.getConfig().errorHandler);
Epilogue.customPointLogger.tryUpdate(backend.getNested("point"), object.point, Epilogue.getConfig().errorHandler);
}
}
}
@@ -1514,7 +1514,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1522,10 +1522,10 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x());
dataLogger.log("y", object.y());
backend.log("x", object.x());
backend.log("y", object.y());
}
}
}
@@ -1602,7 +1602,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1610,11 +1610,11 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("x", object.x);
dataLogger.log("withANoOpTransform", object.withANoOpTransform());
dataLogger.log("withTemp", object.withTemp());
backend.log("x", object.x);
backend.log("withANoOpTransform", object.withANoOpTransform());
backend.log("withTemp", object.withTemp());
}
}
}
@@ -1654,7 +1654,7 @@ class AnnotationProcessorTest {
import edu.wpi.first.epilogue.Logged;
import edu.wpi.first.epilogue.Epilogue;
import edu.wpi.first.epilogue.logging.ClassSpecificLogger;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
public class ExampleLogger extends ClassSpecificLogger<Example> {
public ExampleLogger() {
@@ -1662,14 +1662,14 @@ class AnnotationProcessorTest {
}
@Override
public void update(DataLogger dataLogger, Example object) {
public void update(EpilogueBackend backend, Example object) {
if (Epilogue.shouldLog(Logged.Importance.DEBUG)) {
dataLogger.log("Member Prefix", object.m_memberPrefix);
dataLogger.log("Constant Prefix", object.kConstantPrefix);
dataLogger.log("Other Constant Prefix", object.k_otherConstantPrefix);
dataLogger.log("Other Prefix", object.s_otherPrefix);
dataLogger.log("The Getter Method", object.getTheGetterMethod());
dataLogger.log("optedOut", object.optedOut());
backend.log("Member Prefix", object.m_memberPrefix);
backend.log("Constant Prefix", object.kConstantPrefix);
backend.log("Other Constant Prefix", object.k_otherConstantPrefix);
backend.log("Other Prefix", object.s_otherPrefix);
backend.log("The Getter Method", object.getTheGetterMethod());
backend.log("optedOut", object.optedOut());
}
}
}

14
epilogue-processor/src/test/java/edu/wpi/first/epilogue/processor/EpilogueGeneratorTest.java
View File

@@ -155,8 +155,8 @@ class EpilogueGeneratorTest {
*/
public static void update(edu.wpi.first.epilogue.Example robot) {
long start = System.nanoTime();
exampleLogger.tryUpdate(config.dataLogger.getSubLogger(config.root), robot, config.errorHandler);
config.dataLogger.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
exampleLogger.tryUpdate(config.backend.getNested(config.root), robot, config.errorHandler);
config.backend.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
}
/**
@@ -235,8 +235,8 @@ class EpilogueGeneratorTest {
*/
public static void update(edu.wpi.first.epilogue.AlphaBot robot) {
long start = System.nanoTime();
alphaBotLogger.tryUpdate(config.dataLogger.getSubLogger(config.root), robot, config.errorHandler);
config.dataLogger.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
alphaBotLogger.tryUpdate(config.backend.getNested(config.root), robot, config.errorHandler);
config.backend.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
}
/**
@@ -267,8 +267,8 @@ class EpilogueGeneratorTest {
*/
public static void update(edu.wpi.first.epilogue.BetaBot robot) {
long start = System.nanoTime();
betaBotLogger.tryUpdate(config.dataLogger.getSubLogger(config.root), robot, config.errorHandler);
config.dataLogger.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
betaBotLogger.tryUpdate(config.backend.getNested(config.root), robot, config.errorHandler);
config.backend.log(\"Epilogue/Stats/Last Run\", (System.nanoTime() - start) / 1e6);
}
/**
@@ -314,7 +314,7 @@ class EpilogueGeneratorTest {
public CustomLogger() { super(A.class); }
@Override
public void update(DataLogger logger, A object) {} // implementation is irrelevant
public void update(EpilogueBackend backend, A object) {} // implementation is irrelevant
}
@Logged

8
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/EpilogueConfiguration.java
View File

@@ -4,8 +4,8 @@
package edu.wpi.first.epilogue;
import edu.wpi.first.epilogue.logging.DataLogger;
import edu.wpi.first.epilogue.logging.NTDataLogger;
import edu.wpi.first.epilogue.logging.EpilogueBackend;
import edu.wpi.first.epilogue.logging.NTEpilogueBackend;
import edu.wpi.first.epilogue.logging.errors.ErrorHandler;
import edu.wpi.first.epilogue.logging.errors.ErrorPrinter;
import edu.wpi.first.networktables.NetworkTableInstance;
@@ -18,11 +18,11 @@ import edu.wpi.first.units.measure.Time;
@SuppressWarnings("checkstyle:MemberName")
public class EpilogueConfiguration {
/**
* The data logger implementation for Epilogue to use. By default, this will log data directly to
* The backend implementation for Epilogue to use. By default, this will log data directly to
* NetworkTables. NetworkTable data can be mirrored to a log file on disk by calling {@code
* DataLogManager.start()} in your {@code robotInit} method.
*/
public DataLogger dataLogger = new NTDataLogger(NetworkTableInstance.getDefault());
public EpilogueBackend backend = new NTEpilogueBackend(NetworkTableInstance.getDefault());
/**
* The period Epilogue will log at. By default this is the period that the robot runs at. This is

16
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/ClassSpecificLogger.java
View File

@@ -42,26 +42,26 @@ public abstract class ClassSpecificLogger<T> {
/**
* Updates an object's fields in a data log.
*
* @param dataLogger the logger to update
* @param backend the backend to update
* @param object the object to update in the log
*/
protected abstract void update(DataLogger dataLogger, T object);
protected abstract void update(EpilogueBackend backend, T object);
/**
* Attempts to update the data log. Will do nothing if the logger is {@link #disable() disabled}.
*
* @param dataLogger the logger to log data to
* @param backend the backend to log data to
* @param object the data object to log
* @param errorHandler the handler to use if logging raised an exception
*/
@SuppressWarnings("PMD.AvoidCatchingGenericException")
public final void tryUpdate(DataLogger dataLogger, T object, ErrorHandler errorHandler) {
public final void tryUpdate(EpilogueBackend backend, T object, ErrorHandler errorHandler) {
if (m_disabled) {
return;
}
try {
update(dataLogger, object);
update(backend, object);
} catch (Exception e) {
errorHandler.handle(e, this);
}
@@ -98,10 +98,10 @@ public abstract class ClassSpecificLogger<T> {
/**
* Logs a sendable type.
*
* @param dataLogger the logger to log data into
* @param backend the backend to log data into
* @param sendable the sendable object to log
*/
protected void logSendable(DataLogger dataLogger, Sendable sendable) {
protected void logSendable(EpilogueBackend backend, Sendable sendable) {
if (sendable == null) {
return;
}
@@ -110,7 +110,7 @@ public abstract class ClassSpecificLogger<T> {
m_sendables.computeIfAbsent(
sendable,
s -> {
var b = new LogBackedSendableBuilder(dataLogger);
var b = new LogBackedSendableBuilder(backend);
s.initSendable(b);
return b;
});

30
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/DataLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/EpilogueBackend.java
View File

@@ -9,40 +9,40 @@ import edu.wpi.first.units.Unit;
import edu.wpi.first.util.struct.Struct;
import java.util.Collection;
/** A data logger is a generic interface for logging discrete data points. */
public interface DataLogger {
/** A backend is a generic interface for Epilogue to log discrete data points. */
public interface EpilogueBackend {
/**
* Creates a data logger that logs to multiple backends at once. Data reads will still only occur
* once; data is passed to all composed loggers at once.
* Creates a backend that logs to multiple backends at once. Data reads will still only occur
* once; data is passed to all composed backends at once.
*
* @param loggers the loggers to compose together
* @return the multi logger
* @param backends the backends to compose together
* @return the multi backend
*/
static DataLogger multi(DataLogger... loggers) {
return new MultiLogger(loggers);
static EpilogueBackend multi(EpilogueBackend... backends) {
return new MultiBackend(backends);
}
/**
* Creates a lazy version of this logger. A lazy logger will only log data to a field when its
* Creates a lazy version of this backend. A lazy backend will only log data to a field when its
* value changes, which can help keep file size and bandwidth usage in check. However, there is an
* additional CPU and memory overhead associated with tracking the current value of every logged
* entry. The most surefire way to reduce CPU and memory usage associated with logging is to log
* fewer things - which can be done by opting out of logging unnecessary data or increasing the
* minimum logged importance level in the Epilogue configuration.
*
* @return the lazy logger
* @return the lazy backend
*/
default DataLogger lazy() {
return new LazyLogger(this);
default EpilogueBackend lazy() {
return new LazyBackend(this);
}
/**
* Gets a logger that can be used to log nested data underneath a specific path.
* Gets a backend that can be used to log nested data underneath a specific path.
*
* @param path the path to use for logging nested data under
* @return the sub logger
* @return the nested backend
*/
DataLogger getSubLogger(String path);
EpilogueBackend getNested(String path);
/**
* Logs a 32-bit integer data point.

16
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/FileLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/FileBackend.java
View File

@@ -26,24 +26,24 @@ import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
/** A data logger implementation that saves information to a WPILib {@link DataLog} file on disk. */
public class FileLogger implements DataLogger {
/** A backend implementation that saves information to a WPILib {@link DataLog} file on disk. */
public class FileBackend implements EpilogueBackend {
private final DataLog m_dataLog;
private final Map<String, DataLogEntry> m_entries = new HashMap<>();
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
private final Map<String, NestedBackend> m_subLoggers = new HashMap<>();
/**
* Creates a new file logger.
* Creates a new file-based backend.
*
* @param dataLog the data log to save data to
*/
public FileLogger(DataLog dataLog) {
this.m_dataLog = requireNonNullParam(dataLog, "dataLog", "FileLogger");
public FileBackend(DataLog dataLog) {
this.m_dataLog = requireNonNullParam(dataLog, "dataLog", "FileBackend");
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
public EpilogueBackend getNested(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@SuppressWarnings("unchecked")

56
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/LazyLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/LazyBackend.java
View File

@@ -11,36 +11,36 @@ import java.util.Map;
import java.util.Objects;
/**
* A data logger implementation that only logs data when it changes. Useful for keeping bandwidth
* and file sizes down. However, because it still needs to check that data has changed, it cannot
* avoid expensive sensor reads.
* A backend implementation that only logs data when it changes. Useful for keeping bandwidth and
* file sizes down. However, because it still needs to check that data has changed, it cannot avoid
* expensive sensor reads.
*/
public class LazyLogger implements DataLogger {
private final DataLogger m_logger;
public class LazyBackend implements EpilogueBackend {
private final EpilogueBackend m_backend;
// Keep a record of the most recent value written to each entry
// Note that this may duplicate a lot of data, and will box primitives.
private final Map<String, Object> m_previousValues = new HashMap<>();
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
private final Map<String, NestedBackend> m_subLoggers = new HashMap<>();
/**
* Creates a new lazy logger wrapper around another logger.
* Creates a new lazy backend wrapper around another backend.
*
* @param logger the logger to delegate to
* @param backend the backend to delegate to
*/
public LazyLogger(DataLogger logger) {
this.m_logger = logger;
public LazyBackend(EpilogueBackend backend) {
this.m_backend = backend;
}
@Override
public DataLogger lazy() {
public EpilogueBackend lazy() {
// Already lazy, don't need to wrap it again
return this;
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
public EpilogueBackend getNested(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@Override
@@ -53,7 +53,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -66,7 +66,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -79,7 +79,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -92,7 +92,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -105,7 +105,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -118,7 +118,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -131,7 +131,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -144,7 +144,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -157,7 +157,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -170,7 +170,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -183,7 +183,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -196,7 +196,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -209,7 +209,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value);
m_backend.log(identifier, value);
}
@Override
@@ -222,7 +222,7 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value, struct);
m_backend.log(identifier, value, struct);
}
@Override
@@ -235,6 +235,6 @@ public class LazyLogger implements DataLogger {
}
m_previousValues.put(identifier, value);
m_logger.log(identifier, value, struct);
m_backend.log(identifier, value, struct);
}
}

60
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/LogBackedSendableBuilder.java
View File

@@ -18,24 +18,24 @@ import java.util.function.LongConsumer;
import java.util.function.LongSupplier;
import java.util.function.Supplier;
/** A sendable builder implementation that sends data to a {@link DataLogger}. */
@SuppressWarnings("PMD.CouplingBetweenObjects") // most methods simply delegate to the logger
/** A sendable builder implementation that sends data to a {@link EpilogueBackend}. */
@SuppressWarnings("PMD.CouplingBetweenObjects") // most methods simply delegate to the backend
public class LogBackedSendableBuilder implements SendableBuilder {
private final DataLogger m_logger;
private final EpilogueBackend m_backend;
private final Collection<Runnable> m_updates = new ArrayList<>();
/**
* Creates a new sendable builder that delegates writes to an underlying data logger.
* Creates a new sendable builder that delegates writes to an underlying backend.
*
* @param logger the data logger to write the sendable data to
* @param backend the backend to write the sendable data to
*/
public LogBackedSendableBuilder(DataLogger logger) {
this.m_logger = logger;
public LogBackedSendableBuilder(EpilogueBackend backend) {
this.m_backend = backend;
}
@Override
public void setSmartDashboardType(String type) {
m_logger.log(".type", type);
m_backend.log(".type", type);
}
@Override
@@ -50,132 +50,132 @@ public class LogBackedSendableBuilder implements SendableBuilder {
@Override
public void addBooleanProperty(String key, BooleanSupplier getter, BooleanConsumer setter) {
m_updates.add(() -> m_logger.log(key, getter.getAsBoolean()));
m_updates.add(() -> m_backend.log(key, getter.getAsBoolean()));
}
@Override
public void publishConstBoolean(String key, boolean value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addIntegerProperty(String key, LongSupplier getter, LongConsumer setter) {
m_updates.add(() -> m_logger.log(key, getter.getAsLong()));
m_updates.add(() -> m_backend.log(key, getter.getAsLong()));
}
@Override
public void publishConstInteger(String key, long value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addFloatProperty(String key, FloatSupplier getter, FloatConsumer setter) {
m_updates.add(() -> m_logger.log(key, getter.getAsFloat()));
m_updates.add(() -> m_backend.log(key, getter.getAsFloat()));
}
@Override
public void publishConstFloat(String key, float value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addDoubleProperty(String key, DoubleSupplier getter, DoubleConsumer setter) {
m_updates.add(() -> m_logger.log(key, getter.getAsDouble()));
m_updates.add(() -> m_backend.log(key, getter.getAsDouble()));
}
@Override
public void publishConstDouble(String key, double value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addStringProperty(String key, Supplier<String> getter, Consumer<String> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstString(String key, String value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addBooleanArrayProperty(
String key, Supplier<boolean[]> getter, Consumer<boolean[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstBooleanArray(String key, boolean[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addIntegerArrayProperty(
String key, Supplier<long[]> getter, Consumer<long[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstIntegerArray(String key, long[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addFloatArrayProperty(
String key, Supplier<float[]> getter, Consumer<float[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstFloatArray(String key, float[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addDoubleArrayProperty(
String key, Supplier<double[]> getter, Consumer<double[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstDoubleArray(String key, double[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addStringArrayProperty(
String key, Supplier<String[]> getter, Consumer<String[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstStringArray(String key, String[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override
public void addRawProperty(
String key, String typeString, Supplier<byte[]> getter, Consumer<byte[]> setter) {
if (getter != null) {
m_updates.add(() -> m_logger.log(key, getter.get()));
m_updates.add(() -> m_backend.log(key, getter.get()));
}
}
@Override
public void publishConstRaw(String key, String typeString, byte[] value) {
m_logger.log(key, value);
m_backend.log(key, value);
}
@Override

134
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/MultiBackend.java Normal file
View File

@@ -0,0 +1,134 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package edu.wpi.first.epilogue.logging;
import edu.wpi.first.util.struct.Struct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* A backend implementation that delegates to other backends. Helpful for simultaneous logging to
* multiple data stores at once.
*/
public class MultiBackend implements EpilogueBackend {
private final List<EpilogueBackend> m_backends;
private final Map<String, NestedBackend> m_nestedBackends = new HashMap<>();
// Use EpilogueBackend.multi(...) instead of instantiation directly
MultiBackend(EpilogueBackend... backends) {
this.m_backends = List.of(backends);
}
@Override
public EpilogueBackend getNested(String path) {
return m_nestedBackends.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@Override
public void log(String identifier, int value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, long value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, float value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, double value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, boolean value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, byte[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, int[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, long[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, float[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, double[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, boolean[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, String value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public void log(String identifier, String[] value) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value);
}
}
@Override
public <S> void log(String identifier, S value, Struct<S> struct) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value, struct);
}
}
@Override
public <S> void log(String identifier, S[] value, Struct<S> struct) {
for (EpilogueBackend backend : m_backends) {
backend.log(identifier, value, struct);
}
}
}

134
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/MultiLogger.java
View File

@@ -1,134 +0,0 @@
// Copyright (c) FIRST and other WPILib contributors.
// Open Source Software; you can modify and/or share it under the terms of
// the WPILib BSD license file in the root directory of this project.
package edu.wpi.first.epilogue.logging;
import edu.wpi.first.util.struct.Struct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* A data logger implementation that delegates to other loggers. Helpful for simultaneous logging to
* multiple data stores at once.
*/
public class MultiLogger implements DataLogger {
private final List<DataLogger> m_loggers;
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
// Use DataLogger.multi(...) instead of instantiation directly
MultiLogger(DataLogger... loggers) {
this.m_loggers = List.of(loggers);
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
}
@Override
public void log(String identifier, int value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, long value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, float value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, double value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, boolean value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, byte[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, int[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, long[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, float[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, double[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, boolean[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, String value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public void log(String identifier, String[] value) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value);
}
}
@Override
public <S> void log(String identifier, S value, Struct<S> struct) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value, struct);
}
}
@Override
public <S> void log(String identifier, S[] value, Struct<S> struct) {
for (DataLogger logger : m_loggers) {
logger.log(identifier, value, struct);
}
}
}

16
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/NTDataLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/NTEpilogueBackend.java
View File

@@ -24,27 +24,27 @@ import java.util.HashMap;
import java.util.Map;
/**
* A data logger implementation that sends data over network tables. Be careful when using this,
* since sending too much data may cause bandwidth or CPU starvation.
* A backend implementation that sends data over network tables. Be careful when using this, since
* sending too much data may cause bandwidth or CPU starvation.
*/
public class NTDataLogger implements DataLogger {
public class NTEpilogueBackend implements EpilogueBackend {
private final NetworkTableInstance m_nt;
private final Map<String, Publisher> m_publishers = new HashMap<>();
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
private final Map<String, NestedBackend> m_nestedBackends = new HashMap<>();
/**
* Creates a data logger that sends information to NetworkTables.
* Creates a logging backend that sends information to NetworkTables.
*
* @param nt the NetworkTable instance to use to send data to
*/
public NTDataLogger(NetworkTableInstance nt) {
public NTEpilogueBackend(NetworkTableInstance nt) {
this.m_nt = nt;
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
public EpilogueBackend getNested(String path) {
return m_nestedBackends.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@Override

22
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/SubLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/NestedBackend.java
View File

@@ -9,21 +9,21 @@ import java.util.HashMap;
import java.util.Map;
/**
* A data logger that logs to an underlying logger, prepending all logged data with a specific
* prefix. Useful for logging nested data structures.
* A backend that logs to an underlying backend, prepending all logged data with a specific prefix.
* Useful for logging nested data structures.
*/
public class SubLogger implements DataLogger {
public class NestedBackend implements EpilogueBackend {
private final String m_prefix;
private final DataLogger m_impl;
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
private final EpilogueBackend m_impl;
private final Map<String, NestedBackend> m_nestedBackends = new HashMap<>();
/**
* Creates a new sublogger underneath another logger.
* Creates a new nested backed underneath another backend.
*
* @param prefix the prefix to append to all data logged in the sublogger
* @param impl the data logger to log to
* @param prefix the prefix to append to all data logged in the nested backend
* @param impl the backend to log to
*/
public SubLogger(String prefix, DataLogger impl) {
public NestedBackend(String prefix, EpilogueBackend impl) {
// Add a trailing slash if not already present
if (prefix.endsWith("/")) {
this.m_prefix = prefix;
@@ -34,8 +34,8 @@ public class SubLogger implements DataLogger {
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
public EpilogueBackend getNested(String path) {
return m_nestedBackends.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@Override

10
epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/NullLogger.java → epilogue-runtime/src/main/java/edu/wpi/first/epilogue/logging/NullBackend.java
View File

@@ -6,14 +6,14 @@ package edu.wpi.first.epilogue.logging;
import edu.wpi.first.util.struct.Struct;
/** Null data logger implementation that logs nothing. */
public class NullLogger implements DataLogger {
/** Null backend implementation that logs nothing. */
public class NullBackend implements EpilogueBackend {
/** Default constructor. */
public NullLogger() {}
public NullBackend() {}
@Override
public DataLogger getSubLogger(String path) {
// Since a sublogger would still log nothing and has no state, we can just return the same
public EpilogueBackend getNested(String path) {
// Since a nested backend would still log nothing and has no state, we can just return the same
// null-logging implementation
return this;
}

18
epilogue-runtime/src/test/java/edu/wpi/first/epilogue/logging/ClassSpecificLoggerTest.java
View File

@@ -19,10 +19,10 @@ class ClassSpecificLoggerTest {
}
@Override
protected void update(DataLogger dataLogger, Point2d object) {
dataLogger.log("x", object.x);
dataLogger.log("y", object.y);
dataLogger.log("dim", object.dim);
protected void update(EpilogueBackend backend, Point2d object) {
backend.log("x", object.x);
backend.log("y", object.y);
backend.log("dim", object.dim);
}
}
}
@@ -31,14 +31,14 @@ class ClassSpecificLoggerTest {
void testReadPrivate() {
var point = new Point2d(1, 4, 2);
var logger = new Point2d.Logger();
var dataLog = new TestLogger();
logger.update(dataLog.getSubLogger("Point"), point);
var dataLog = new TestBackend();
logger.update(dataLog.getNested("Point"), point);
assertEquals(
List.of(
new TestLogger.LogEntry<>("Point/x", 1.0),
new TestLogger.LogEntry<>("Point/y", 4.0),
new TestLogger.LogEntry<>("Point/dim", 2)),
new TestBackend.LogEntry<>("Point/x", 1.0),
new TestBackend.LogEntry<>("Point/y", 4.0),
new TestBackend.LogEntry<>("Point/dim", 2)),
dataLog.getEntries());
}
}

24
epilogue-runtime/src/test/java/edu/wpi/first/epilogue/logging/LazyLoggerTest.java → epilogue-runtime/src/test/java/edu/wpi/first/epilogue/logging/LazyBackendTest.java
View File

@@ -10,36 +10,36 @@ import static org.junit.jupiter.api.Assertions.assertSame;
import java.util.List;
import org.junit.jupiter.api.Test;
class LazyLoggerTest {
class LazyBackendTest {
@Test
void lazyOfLazyReturnsSelf() {
var lazy = new LazyLogger(new NullLogger());
var lazy = new LazyBackend(new NullBackend());
assertSame(lazy, lazy.lazy());
}
@Test
void lazyInt() {
var logger = new TestLogger();
var lazy = new LazyLogger(logger);
var backend = new TestBackend();
var lazy = new LazyBackend(backend);
{
// First time logging to "int" should go through
lazy.log("int", 0);
assertEquals(List.of(new TestLogger.LogEntry<>("int", 0)), logger.getEntries());
assertEquals(List.of(new TestBackend.LogEntry<>("int", 0)), backend.getEntries());
}
{
// Logging the current value shouldn't go through
lazy.log("int", 0);
assertEquals(List.of(new TestLogger.LogEntry<>("int", 0)), logger.getEntries());
assertEquals(List.of(new TestBackend.LogEntry<>("int", 0)), backend.getEntries());
}
{
// Logging a new value should go through
lazy.log("int", 1);
assertEquals(
List.of(new TestLogger.LogEntry<>("int", 0), new TestLogger.LogEntry<>("int", 1)),
logger.getEntries());
List.of(new TestBackend.LogEntry<>("int", 0), new TestBackend.LogEntry<>("int", 1)),
backend.getEntries());
}
{
@@ -47,10 +47,10 @@ class LazyLoggerTest {
lazy.log("int", 0);
assertEquals(
List.of(
new TestLogger.LogEntry<>("int", 0),
new TestLogger.LogEntry<>("int", 1),
new TestLogger.LogEntry<>("int", 0)),
logger.getEntries());
new TestBackend.LogEntry<>("int", 0),
new TestBackend.LogEntry<>("int", 1),
new TestBackend.LogEntry<>("int", 0)),
backend.getEntries());
}
}
}

8
epilogue-runtime/src/test/java/edu/wpi/first/epilogue/logging/TestLogger.java → epilogue-runtime/src/test/java/edu/wpi/first/epilogue/logging/TestBackend.java
View File

@@ -12,10 +12,10 @@ import java.util.List;
import java.util.Map;
@SuppressWarnings("PMD.TestClassWithoutTestCases") // This is not a test class!
public class TestLogger implements DataLogger {
public class TestBackend implements EpilogueBackend {
public record LogEntry<T>(String identifier, T value) {}
private final Map<String, SubLogger> m_subLoggers = new HashMap<>();
private final Map<String, NestedBackend> m_nestedBackends = new HashMap<>();
private final List<LogEntry<?>> m_entries = new ArrayList<>();
@@ -24,8 +24,8 @@ public class TestLogger implements DataLogger {
}
@Override
public DataLogger getSubLogger(String path) {
return m_subLoggers.computeIfAbsent(path, k -> new SubLogger(k, this));
public EpilogueBackend getNested(String path) {
return m_nestedBackends.computeIfAbsent(path, k -> new NestedBackend(k, this));
}
@Override