DataLogJNI.java

// TODO - RobotCore - modified
 
// 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.io.IOException;
// import java.nio.ByteBuffer;
// import java.util.concurrent.atomic.AtomicBoolean;
// import org.wpilib.util.runtime.RuntimeLoader;

public class DataLogJNI {
  static void bgSetDir(long impl, String dir, long maxSize) {
    throw new UnsupportedOperationException("Unimplemented method 'flush'");
    // TODO - Must fix    
   }
 
  static String bgGetDir(long impl) {
    throw new UnsupportedOperationException("Unimplemented method 'flush'");
    // TODO - Must fix    
  }
  static void flush(long impl) {
    throw new UnsupportedOperationException("Unimplemented method 'flush'");
    // TODO - Must fix
  }
 
  static void pause(long impl)
  {
    throw new UnsupportedOperationException("Unimplemented method 'pause'");
    // TODO - Must fix
  } 
  
  static void resume(long impl) {
    throw new UnsupportedOperationException("Unimplemented method 'resume'");
    // TODO - Must fix
  }  
 
  static void stop(long impl)
  {
    throw new UnsupportedOperationException("Unimplemented method 'stop'");
    // TODO - Must fix
  }  
 
  static void addSchema(long impl, String name, String type, byte[] schema, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'addSchema'");
    // TODO - Must fix
  }
 
  static void addSchemaString(long impl, String name, String type, String schema, long timestamp)
  {
    throw new UnsupportedOperationException("Unimplemented method 'addShemaString'");
    // TODO - Must fix
  } 
 
  static int start(long impl, String name, String type, String metadata, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'start'");
    // return 0; // TODO - Must fix
  } 
 
  static void finish(long impl, int entry, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'finish'");
    // TODO - Must fix
  }  
 
  static void setMetadata(long impl, int entry, String metadata, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'setMetadata'");
    // TODO - Must fix
  }
 
  static void close(long impl) {
    throw new UnsupportedOperationException("Unimplemented method 'DataLogJNI.close'");
    // TODO - Must fix
  }  
 
  static void appendRaw(long impl, int entry, byte[] data, int start, int len, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendRaw'");
    // TODO - Must fix
  }
 
  static void appendRaw(long impl, int entry, ByteBuffer data, int start, int len, long timestamp) { 
    throw new UnsupportedOperationException("Unimplemented method 'appendRaw'");
    // TODO - Must fix
  }
  
  static void appendBoolean(long impl, int entry, boolean value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendBoolean'");
    // TODO - Must fix
  }  
 
  static void appendInteger(long impl, int entry, long value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendInteger'");
    // TODO - Must fix
  } 
 
  static void appendFloat(long impl, int entry, float value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendFloat'");
    // TODO - Must fix
  }  
 
  static void appendDouble(long impl, int entry, double value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendDouble'");
    // TODO - Must fix
  }
 
  static void appendString(long impl, int entry, String value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendString'");
    // TODO - Must fix
  } 
 
  static void appendBooleanArray(long impl, int entry, boolean[] value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendBooleanArray'");
    // TODO - Must fix
  }  
 
  static void appendIntegerArray(long impl, int entry, long[] value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendIntegerArray'");
    // TODO - Must fix
  }
 
  static void appendFloatArray(long impl, int entry, float[] value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendFloatArray'");
    // TODO - Must fix
  }
 
  static void appendDoubleArray(long impl, int entry, double[] value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendDoubleArray'");
    // TODO - Must fix
  }
  
  static void appendStringArray(long impl, int entry, String[] value, long timestamp) {
    throw new UnsupportedOperationException("Unimplemented method 'appendStringArray'");
    // TODO - Must fix
  }
 
  static long bgCreate(String dir, String filename, double period, String extraHeader) {
    throw new UnsupportedOperationException("Unimplemented method 'bgCreate'");
    // return 0; // TODO - Must fix
  }  
 
  static void bgSetFilename(long impl, String filename) {
    throw new UnsupportedOperationException("Unimplemented method 'bgSetFilename'");
    // TODO - Must fix
  } 
 
  public static long createFileLogger(String file, long log, String key) {
    throw new UnsupportedOperationException("Unimplemented method 'createFileLogger'");
    // return 0; // TODO - Must fix
  }  
 
  public static void freeFileLogger(long fileTail) {
    throw new UnsupportedOperationException("Unimplemented method 'freeFileLogger'");
    // TODO - Must fix
  }  
 
  
 
  // static boolean libraryLoaded = false;
 
  // /** Sets whether JNI should be loaded in the static block. */
  // public static class Helper {
  //   private static AtomicBoolean extractOnStaticLoad = new AtomicBoolean(true);
 
  //   /**
  //    * Returns true if the JNI should be loaded in the static block.
  //    *
  //    * @return True if the JNI should be loaded in the static block.
  //    */
  //   public static boolean getExtractOnStaticLoad() {
  //     return extractOnStaticLoad.get();
  //   }
 
  //   /**
  //    * Sets whether the JNI should be loaded in the static block.
  //    *
  //    * @param load Whether the JNI should be loaded in the static block.
  //    */
  //   public static void setExtractOnStaticLoad(boolean load) {
  //     extractOnStaticLoad.set(load);
  //   }
 
  //   /** Utility class. */
  //   private Helper() {}
  // }
 
  // static {
  //   if (Helper.getExtractOnStaticLoad()) {
  //     try {
  //       RuntimeLoader.loadLibrary("datalogjni");
  //     } catch (Exception ex) {
  //       ex.printStackTrace();
  //       System.exit(1);
  //     }
  //     libraryLoaded = true;
  //   }
  // }
 
  // /**
  //  * Force load the library.
  //  *
  //  * @throws IOException if the library failed to load
  //  */
  // public static synchronized void forceLoad() throws IOException {
  //   if (libraryLoaded) {
  //     return;
  //   }
  //   RuntimeLoader.loadLibrary("datalogjni");
  //   libraryLoaded = true;
  // }
 
  // /**
  //  * Create a new Data Log background writer. The log will be initially created with a temporary
  //  * filename.
  //  *
  //  * @param dir directory to store the log
  //  * @param filename filename to use; if none provided, a random filename is generated of the form
  //  *     "wpilog_{}.wpilog"
  //  * @param period time between automatic flushes to disk, in seconds; this is a time/storage
  //  *     tradeoff
  //  * @param extraHeader extra header data
  //  * @return data log background writer implementation handle
  //  */
  // static native long bgCreate(String dir, String filename, double period, String extraHeader);
 
  // /**
  //  * Change log filename.
  //  *
  //  * @param impl data log background writer implementation handle
  //  * @param filename filename
  //  */
  // static native void bgSetFilename(long impl, String filename);
 
  // /**
  //  * Create a new Data Log foreground writer.
  //  *
  //  * @param filename filename to use
  //  * @param extraHeader extra header data
  //  * @return data log writer implementation handle
  //  * @throws IOException if file cannot be opened
  //  */
  // static native long fgCreate(String filename, String extraHeader) throws IOException;
 
  // /**
  //  * Create a new Data Log foreground writer to a memory buffer.
  //  *
  //  * @param extraHeader extra header data
  //  * @return data log writer implementation handle
  //  */
  // static native long fgCreateMemory(String extraHeader);
 
  // /**
  //  * Explicitly flushes the log data to disk.
  //  *
  //  * @param impl data log background writer implementation handle
  //  */
  // static native void flush(long impl);
 
  // /**
  //  * Flushes the log data to a memory buffer (only valid with fgCreateMemory data logs).
  //  *
  //  * @param impl data log background writer implementation handle
  //  * @param buf output data buffer
  //  * @param pos position in write buffer to start copying from
  //  * @return Number of bytes written to buffer; 0 if no more to copy
  //  */
  // static native int copyWriteBuffer(long impl, byte[] buf, int pos);
 
  // /**
  //  * Pauses appending of data records to the log. While paused, no data records are saved (e.g.
  //  * AppendX is a no-op). Has no effect on entry starts / finishes / metadata changes.
  //  *
  //  * @param impl data log background writer implementation handle
  //  */
  // static native void pause(long impl);
 
  // /**
  //  * Resumes appending of data records to the log. If called after Stop(), opens a new file (with
  //  * random name if SetFilename was not called after Stop()) and appends Start records and schema
  //  * data values for all previously started entries and schemas.
  //  *
  //  * @param impl data log background writer implementation handle
  //  */
  // static native void resume(long impl);
 
  // /**
  //  * Stops appending all records to the log, and closes the log file.
  //  *
  //  * @param impl data log background writer implementation handle
  //  */
  // static native void stop(long impl);
 
  // /**
  //  * Registers a data schema. Data schemas provide information for how a certain data type string
  //  * can be decoded. The type string of a data schema indicates the type of the schema itself (e.g.
  //  * "protobuf" for protobuf schemas, "struct" for struct schemas, etc). In the data log, schemas
  //  * are saved just like normal records, with the name being generated from the provided name:
  //  * "/.schema/<name>". Duplicate calls to this function with the same name are silently
  //  * ignored.
  //  *
  //  * @param impl data log implementation handle
  //  * @param name Name (the string passed as the data type for records using this schema)
  //  * @param type Type of schema (e.g. "protobuf", "struct", etc)
  //  * @param schema Schema data
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void addSchema(long impl, String name, String type, byte[] schema, long timestamp);
 
  // static native void addSchemaString(
  //     long impl, String name, String type, String schema, long timestamp);
 
  // /**
  //  * Start an entry. Duplicate names are allowed (with the same type), and result in the same index
  //  * being returned (Start/Finish are reference counted). A duplicate name with a different type
  //  * will result in an error message being printed to the console and 0 being returned (which will
  //  * be ignored by the Append functions).
  //  *
  //  * @param impl data log implementation handle
  //  * @param name Name
  //  * @param type Data type
  //  * @param metadata Initial metadata (e.g. data properties)
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  * @return Entry index
  //  */
  // static native int start(long impl, String name, String type, String metadata, long timestamp);
 
  // /**
  //  * Finish an entry.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void finish(long impl, int entry, long timestamp);
 
  // /**
  //  * Updates the metadata for an entry.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index
  //  * @param metadata New metadata for the entry
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void setMetadata(long impl, int entry, String metadata, long timestamp);
 
  // /**
  //  * Closes the data log implementation handle.
  //  *
  //  * @param impl data log implementation handle
  //  */
  // static native void close(long impl);
 
  // /**
  //  * Appends a raw record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by WPI_DataLog_Start()
  //  * @param data Byte array to record
  //  * @param len Length of byte array
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendRaw(
  //     long impl, int entry, byte[] data, int start, int len, long timestamp);
 
  // /**
  //  * Appends a raw record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by WPI_DataLog_Start()
  //  * @param data ByteBuffer to record
  //  * @param len Length of byte array
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static void appendRaw(long impl, int entry, ByteBuffer data, int start, int len, long timestamp) {
  //   if (start < 0) {
  //     throw new IndexOutOfBoundsException("start must be >= 0");
  //   }
  //   if (len < 0) {
  //     throw new IndexOutOfBoundsException("len must be >= 0");
  //   }
  //   int capacity = data.capacity();
  //   if (start > capacity || len > capacity - start) {
  //     throw new IndexOutOfBoundsException("start + len must be within buffer capacity");
  //   }
  //   if (data.isDirect()) {
  //     appendRawBuffer(impl, entry, data, start, len, timestamp);
  //   } else if (data.hasArray()) {
  //     appendRaw(impl, entry, data.array(), data.arrayOffset() + start, len, timestamp);
  //   } else {
  //     throw new UnsupportedOperationException("ByteBuffer must be direct or have a backing array");
  //   }
  // }
 
  // static native void appendRawBuffer(
  //     long impl, int entry, ByteBuffer data, int start, int len, long timestamp);
 
  // /**
  //  * Appends a boolean record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Boolean value to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendBoolean(long impl, int entry, boolean value, long timestamp);
 
  // /**
  //  * Appends an integer record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Integer value to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendInteger(long impl, int entry, long value, long timestamp);
 
  // /**
  //  * Appends a float record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Float value to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendFloat(long impl, int entry, float value, long timestamp);
 
  // /**
  //  * Appends a double record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Double value to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendDouble(long impl, int entry, double value, long timestamp);
 
  // /**
  //  * Appends a string record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value String value to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendString(long impl, int entry, String value, long timestamp);
 
  // /**
  //  * Appends a boolean array record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Boolean array to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendBooleanArray(long impl, int entry, boolean[] value, long timestamp);
 
  // /**
  //  * Appends an integer array record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Integer array to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendIntegerArray(long impl, int entry, long[] value, long timestamp);
 
  // /**
  //  * Appends a float array record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Float array to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendFloatArray(long impl, int entry, float[] value, long timestamp);
 
  // /**
  //  * Appends a double array record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value Double array to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendDoubleArray(long impl, int entry, double[] value, long timestamp);
 
  // /**
  //  * Appends a string array record to the log.
  //  *
  //  * @param impl data log implementation handle
  //  * @param entry Entry index, as returned by Start()
  //  * @param value String array to record
  //  * @param timestamp Time stamp in nanoseconds (may be 0 to indicate now)
  //  */
  // static native void appendStringArray(long impl, int entry, String[] value, long timestamp);
 
  // /**
  //  * Create a native FileLogger. When the specified file is modified, appended data will be appended
  //  * to the specified data log.
  //  *
  //  * @param file path to the file
  //  * @param log data log implementation handle
  //  * @param key log key to append data to
  //  * @return The FileLogger handle.
  //  */
  // public static native long createFileLogger(String file, long log, String key);
 
  // /**
  //  * Free a native FileLogger. This causes the FileLogger to stop appending data to the log.
  //  *
  //  * @param fileTail The FileLogger handle.
  //  */
  // public static native void freeFileLogger(long fileTail);
 
  // /** Utility class. */
  // private DataLogJNI() {}
}