DataLog.java

// 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 org.wpilib.datalog;
 
import java.nio.ByteBuffer;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.wpilib.util.WPIUtilJNI;
import org.wpilib.util.protobuf.Protobuf;
import org.wpilib.util.struct.Struct;

public class DataLog implements AutoCloseable {
  protected DataLog(long impl) {
    m_impl = impl;
  }

  public void flush() {
    DataLogJNI.flush(m_impl);
  }

  public void pause() {
    DataLogJNI.pause(m_impl);
  }

  public void resume() {
    DataLogJNI.resume(m_impl);
  }

  public void stop() {
    DataLogJNI.stop(m_impl);
  }

  public boolean hasSchema(String name) {
    return m_schemaMap.containsKey(name);
  }

  public void addSchema(String name, String type, byte[] schema, long timestamp) {
    if (m_schemaMap.putIfAbsent(name, 1) != null) {
      return;
    }
    DataLogJNI.addSchema(m_impl, name, type, schema, timestamp);
  }

  public void addSchema(String name, String type, byte[] schema) {
    addSchema(name, type, schema, 0);
  }

  public void addSchema(String name, String type, String schema, long timestamp) {
    if (m_schemaMap.putIfAbsent(name, 1) != null) {
      return;
    }
    DataLogJNI.addSchemaString(m_impl, name, type, schema, timestamp);
  }

  public void addSchema(String name, String type, String schema) {
    addSchema(name, type, schema, 0);
  }

  public void addSchema(Protobuf<?, ?> proto, long timestamp) {
    final long actualTimestamp = timestamp == 0 ? WPIUtilJNI.now() : timestamp;
    proto.forEachDescriptor(
        this::hasSchema,
        (typeString, schema) ->
            addSchema(typeString, "proto:FileDescriptorProto", schema, actualTimestamp));
  }

  public void addSchema(Protobuf<?, ?> proto) {
    addSchema(proto, 0);
  }

  public void addSchema(Struct<?> struct, long timestamp) {
    addSchemaImpl(struct, timestamp == 0 ? WPIUtilJNI.now() : timestamp, new HashSet<>());
  }

  public void addSchema(Struct<?> struct) {
    addSchema(struct, 0);
  }

  public int start(String name, String type, String metadata, long timestamp) {
    return DataLogJNI.start(m_impl, name, type, metadata, timestamp);
  }

  public int start(String name, String type, String metadata) {
    return start(name, type, metadata, 0);
  }

  public int start(String name, String type) {
    return start(name, type, "");
  }

  public void finish(int entry, long timestamp) {
    DataLogJNI.finish(m_impl, entry, timestamp);
  }

  public void finish(int entry) {
    finish(entry, 0);
  }

  public void setMetadata(int entry, String metadata, long timestamp) {
    DataLogJNI.setMetadata(m_impl, entry, metadata, timestamp);
  }

  public void setMetadata(int entry, String metadata) {
    setMetadata(entry, metadata, 0);
  }
 
  @Override
  public void close() {
    DataLogJNI.close(m_impl);
    m_impl = 0;
  }

  public void appendRaw(int entry, byte[] data, long timestamp) {
    appendRaw(entry, data, 0, data.length, timestamp);
  }

  public void appendRaw(int entry, byte[] data, int start, int len, long timestamp) {
    DataLogJNI.appendRaw(m_impl, entry, data, start, len, timestamp);
  }

  public void appendRaw(int entry, ByteBuffer data, long timestamp) {
    int pos = data.position();
    appendRaw(entry, data, pos, data.limit() - pos, timestamp);
  }

  public void appendRaw(int entry, ByteBuffer data, int start, int len, long timestamp) {
    DataLogJNI.appendRaw(m_impl, entry, data, start, len, timestamp);
  }

  public void appendBoolean(int entry, boolean value, long timestamp) {
    DataLogJNI.appendBoolean(m_impl, entry, value, timestamp);
  }

  public void appendInteger(int entry, long value, long timestamp) {
    DataLogJNI.appendInteger(m_impl, entry, value, timestamp);
  }

  public void appendFloat(int entry, float value, long timestamp) {
    DataLogJNI.appendFloat(m_impl, entry, value, timestamp);
  }

  public void appendDouble(int entry, double value, long timestamp) {
    DataLogJNI.appendDouble(m_impl, entry, value, timestamp);
  }

  public void appendString(int entry, String value, long timestamp) {
    DataLogJNI.appendString(m_impl, entry, value, timestamp);
  }

  public void appendBooleanArray(int entry, boolean[] arr, long timestamp) {
    DataLogJNI.appendBooleanArray(m_impl, entry, arr, timestamp);
  }

  public void appendIntegerArray(int entry, long[] arr, long timestamp) {
    DataLogJNI.appendIntegerArray(m_impl, entry, arr, timestamp);
  }

  public void appendFloatArray(int entry, float[] arr, long timestamp) {
    DataLogJNI.appendFloatArray(m_impl, entry, arr, timestamp);
  }

  public void appendDoubleArray(int entry, double[] arr, long timestamp) {
    DataLogJNI.appendDoubleArray(m_impl, entry, arr, timestamp);
  }

  public void appendStringArray(int entry, String[] arr, long timestamp) {
    DataLogJNI.appendStringArray(m_impl, entry, arr, timestamp);
  }

  public long getImpl() {
    return m_impl;
  }
 
  private void addSchemaImpl(Struct<?> struct, long timestamp, Set<String> seen) {
    String typeString = struct.getTypeString();
    if (hasSchema(typeString)) {
      return;
    }
    if (!seen.add(typeString)) {
      throw new UnsupportedOperationException(typeString + ": circular reference with " + seen);
    }
    for (Struct<?> inner : struct.getNested()) {
      addSchemaImpl(inner, timestamp, seen);
    }
    addSchema(typeString, "structschema", struct.getSchema(), timestamp);
    seen.remove(typeString);
  }

  protected long m_impl;
 
  private final ConcurrentMap<String, Integer> m_schemaMap = new ConcurrentHashMap<>();
}