NetworkTableInstance.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.
 
// THIS FILE WAS AUTO-GENERATED BY ./ntcore/generate_topics.py. DO NOT MODIFY
 
package org.wpilib.networktables;
 
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.OptionalLong;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Consumer;
import org.wpilib.datalog.DataLog;
import org.wpilib.util.WPIUtilJNI;
import org.wpilib.util.concurrent.Event;
import org.wpilib.util.protobuf.Protobuf;
import org.wpilib.util.struct.Struct;
import us.hebi.quickbuf.ProtoMessage;

public final class NetworkTableInstance implements AutoCloseable {
  public enum NetworkMode {
    SERVER(0x01),

    CLIENT(0x04),

    STARTING(0x08),

    LOCAL(0x10);
 
    private final int value;
 
    NetworkMode(int value) {
      this.value = value;
    }

    public int getValue() {
      return value;
    }
  }

  public static final int DEFAULT_PORT = 5810;

  private NetworkTableInstance(int handle) {
    m_owned = false;
    m_handle = handle;
  }

  @Override
  public synchronized void close() {
    if (m_owned && m_handle != 0) {
      m_listeners.close();
      m_schemas.forEach((k, v) -> v.close());
      NetworkTablesJNI.destroyInstance(m_handle);
      m_handle = 0;
    }
  }

  public boolean isValid() {
    return m_handle != 0;
  }
 
  /* The default instance. */
  private static NetworkTableInstance s_defaultInstance;

  public static synchronized NetworkTableInstance getDefault() {
    if (s_defaultInstance == null) {
      s_defaultInstance = new NetworkTableInstance(NetworkTablesJNI.getDefaultInstance());
    }
    return s_defaultInstance;
  }

  public static NetworkTableInstance create() {
    NetworkTableInstance inst = new NetworkTableInstance(NetworkTablesJNI.createInstance());
    inst.m_owned = true;
    return inst;
  }

  public static NetworkTableInstance fromNativeHandle(int handle) {
    return new NetworkTableInstance(handle);
  }

  public int getHandle() {
    return m_handle;
  }

  public Topic getTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic == null) {
      int handle = NetworkTablesJNI.getTopic(m_handle, name);
      topic = new Topic(this, handle);
      Topic oldTopic = m_topics.putIfAbsent(name, topic);
      if (oldTopic != null) {
        topic = oldTopic;
      }
      // also cache by handle
      m_topicsByHandle.putIfAbsent(handle, topic);
    }
    return topic;
  }

  public BooleanTopic getBooleanTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof BooleanTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    BooleanTopic wrapTopic = new BooleanTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public IntegerTopic getIntegerTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof IntegerTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    IntegerTopic wrapTopic = new IntegerTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public FloatTopic getFloatTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof FloatTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    FloatTopic wrapTopic = new FloatTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public DoubleTopic getDoubleTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof DoubleTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    DoubleTopic wrapTopic = new DoubleTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public StringTopic getStringTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof StringTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    StringTopic wrapTopic = new StringTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public RawTopic getRawTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof RawTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    RawTopic wrapTopic = new RawTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public BooleanArrayTopic getBooleanArrayTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof BooleanArrayTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    BooleanArrayTopic wrapTopic = new BooleanArrayTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public IntegerArrayTopic getIntegerArrayTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof IntegerArrayTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    IntegerArrayTopic wrapTopic = new IntegerArrayTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public FloatArrayTopic getFloatArrayTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof FloatArrayTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    FloatArrayTopic wrapTopic = new FloatArrayTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public DoubleArrayTopic getDoubleArrayTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof DoubleArrayTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    DoubleArrayTopic wrapTopic = new DoubleArrayTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public StringArrayTopic getStringArrayTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic instanceof StringArrayTopic t) {
      return t;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    StringArrayTopic wrapTopic = new StringArrayTopic(this, handle);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }
 

  public <T, MessageType extends ProtoMessage<?>>
      ProtobufTopic<T> getProtobufTopic(String name, Protobuf<T, MessageType> proto) {
    Topic topic = m_topics.get(name);
    if (topic instanceof ProtobufTopic<?> t && t.getProto().equals(proto)) {
      @SuppressWarnings("unchecked")
      ProtobufTopic<T> wrapTopic = (ProtobufTopic<T>) topic;
      return wrapTopic;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    ProtobufTopic<T> wrapTopic = ProtobufTopic.wrap(this, handle, proto);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public <T>
      StructTopic<T> getStructTopic(String name, Struct<T> struct) {
    Topic topic = m_topics.get(name);
    if (topic instanceof StructTopic<?> t && t.getStruct().equals(struct)) {
      @SuppressWarnings("unchecked")
      StructTopic<T> wrapTopic = (StructTopic<T>) topic;
      return wrapTopic;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    StructTopic<T> wrapTopic = StructTopic.wrap(this, handle, struct);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }

  public <T>
      StructArrayTopic<T> getStructArrayTopic(String name, Struct<T> struct) {
    Topic topic = m_topics.get(name);
    if (topic instanceof StructArrayTopic<?> t && t.getStruct().equals(struct)) {
      @SuppressWarnings("unchecked")
      StructArrayTopic<T> wrapTopic = (StructArrayTopic<T>) topic;
      return wrapTopic;
    }
 
    int handle;
    if (topic == null) {
      handle = NetworkTablesJNI.getTopic(m_handle, name);
    } else {
      handle = topic.getHandle();
    }
 
    StructArrayTopic<T> wrapTopic = StructArrayTopic.wrap(this, handle, struct);
    m_topics.put(name, wrapTopic);
 
    // also cache by handle
    m_topicsByHandle.put(handle, wrapTopic);
 
    return wrapTopic;
  }
 
  private Topic[] topicHandlesToTopics(int[] handles) {
    Topic[] topics = new Topic[handles.length];
    for (int i = 0; i < handles.length; i++) {
      topics[i] = getCachedTopic(handles[i]);
    }
    return topics;
  }

  public Topic[] getTopics() {
    return topicHandlesToTopics(NetworkTablesJNI.getTopics(m_handle, "", 0));
  }

  public Topic[] getTopics(String prefix) {
    return topicHandlesToTopics(NetworkTablesJNI.getTopics(m_handle, prefix, 0));
  }

  public Topic[] getTopics(String prefix, int types) {
    return topicHandlesToTopics(NetworkTablesJNI.getTopics(m_handle, prefix, types));
  }

  public Topic[] getTopics(String prefix, String[] types) {
    return topicHandlesToTopics(NetworkTablesJNI.getTopicsStr(m_handle, prefix, types));
  }

  public TopicInfo[] getTopicInfo() {
    return NetworkTablesJNI.getTopicInfos(this, m_handle, "", 0);
  }

  public TopicInfo[] getTopicInfo(String prefix) {
    return NetworkTablesJNI.getTopicInfos(this, m_handle, prefix, 0);
  }

  public TopicInfo[] getTopicInfo(String prefix, int types) {
    return NetworkTablesJNI.getTopicInfos(this, m_handle, prefix, types);
  }

  public TopicInfo[] getTopicInfo(String prefix, String[] types) {
    return NetworkTablesJNI.getTopicInfosStr(this, m_handle, prefix, types);
  }
 
  /* Cache of created entries. */
  private final ConcurrentMap<String, NetworkTableEntry> m_entries = new ConcurrentHashMap<>();

  public NetworkTableEntry getEntry(String name) {
    NetworkTableEntry entry = m_entries.get(name);
    if (entry == null) {
      entry = new NetworkTableEntry(this, NetworkTablesJNI.getEntry(m_handle, name));
      NetworkTableEntry oldEntry = m_entries.putIfAbsent(name, entry);
      if (oldEntry != null) {
        entry = oldEntry;
      }
    }
    return entry;
  }
 
  /* Cache of created topics. */
  private final ConcurrentMap<String, Topic> m_topics = new ConcurrentHashMap<>();
  private final ConcurrentMap<Integer, Topic> m_topicsByHandle = new ConcurrentHashMap<>();
 
  Topic getCachedTopic(String name) {
    Topic topic = m_topics.get(name);
    if (topic == null) {
      int handle = NetworkTablesJNI.getTopic(m_handle, name);
      topic = new Topic(this, handle);
      Topic oldTopic = m_topics.putIfAbsent(name, topic);
      if (oldTopic != null) {
        topic = oldTopic;
      }
      // also cache by handle
      m_topicsByHandle.putIfAbsent(handle, topic);
    }
    return topic;
  }
 
  Topic getCachedTopic(int handle) {
    Topic topic = m_topicsByHandle.get(handle);
    if (topic == null) {
      topic = new Topic(this, handle);
      Topic oldTopic = m_topicsByHandle.putIfAbsent(handle, topic);
      if (oldTopic != null) {
        topic = oldTopic;
      }
    }
    return topic;
  }
 
  /* Cache of created tables. */
  private final ConcurrentMap<String, NetworkTable> m_tables = new ConcurrentHashMap<>();

  public NetworkTable getTable(String key) {
    // prepend leading / if not present
    String theKey;
    if (key.isEmpty() || "/".equals(key)) {
      theKey = "";
    } else if (key.charAt(0) == NetworkTable.PATH_SEPARATOR) {
      theKey = key;
    } else {
      theKey = NetworkTable.PATH_SEPARATOR + key;
    }
 
    // cache created tables
    NetworkTable table = m_tables.get(theKey);
    if (table == null) {
      table = new NetworkTable(this, theKey);
      NetworkTable oldTable = m_tables.putIfAbsent(theKey, table);
      if (oldTable != null) {
        table = oldTable;
      }
    }
    return table;
  }
 
  /*
   * Callback Creation Functions
   */
 
  private static class ListenerStorage implements AutoCloseable {
    private final ReentrantLock m_lock = new ReentrantLock();
    private final Map<Integer, Consumer<NetworkTableEvent>> m_listeners = new HashMap<>();
 
    @SuppressWarnings("PMD.SingularField")
    private Thread m_thread;
 
    private int m_poller;
    private boolean m_waitQueue;
    private final Event m_waitQueueEvent = new Event();
    private final Condition m_waitQueueCond = m_lock.newCondition();
    private final NetworkTableInstance m_inst;
 
    ListenerStorage(NetworkTableInstance inst) {
      m_inst = inst;
    }
 
    int add(
        String[] prefixes,
        EnumSet<NetworkTableEvent.Kind> eventKinds,
        Consumer<NetworkTableEvent> listener) {
      m_lock.lock();
      try {
        if (m_poller == 0) {
          m_poller = NetworkTablesJNI.createListenerPoller(m_inst.getHandle());
          startThread();
        }
        int h = NetworkTablesJNI.addListener(m_poller, prefixes, eventKinds);
        m_listeners.put(h, listener);
        return h;
      } finally {
        m_lock.unlock();
      }
    }
 
    int add(
        int handle,
        EnumSet<NetworkTableEvent.Kind> eventKinds,
        Consumer<NetworkTableEvent> listener) {
      m_lock.lock();
      try {
        if (m_poller == 0) {
          m_poller = NetworkTablesJNI.createListenerPoller(m_inst.getHandle());
          startThread();
        }
        int h = NetworkTablesJNI.addListener(m_poller, handle, eventKinds);
        m_listeners.put(h, listener);
        return h;
      } finally {
        m_lock.unlock();
      }
    }
 
    int addLogger(int minLevel, int maxLevel, Consumer<NetworkTableEvent> listener) {
      m_lock.lock();
      try {
        if (m_poller == 0) {
          m_poller = NetworkTablesJNI.createListenerPoller(m_inst.getHandle());
          startThread();
        }
        int h = NetworkTablesJNI.addLogger(m_poller, minLevel, maxLevel);
        m_listeners.put(h, listener);
        return h;
      } finally {
        m_lock.unlock();
      }
    }
 
    void remove(int listener) {
      m_lock.lock();
      try {
        m_listeners.remove(listener);
      } finally {
        m_lock.unlock();
      }
      NetworkTablesJNI.removeListener(listener);
    }
 
    @Override
    public void close() {
      if (m_poller != 0) {
        NetworkTablesJNI.destroyListenerPoller(m_poller);
      }
      m_poller = 0;
    }
 
    @SuppressWarnings("PMD.AvoidCatchingGenericException")
    private void startThread() {
      m_thread =
          new Thread(
              () -> {
                boolean wasInterrupted = false;
                int[] handles = new int[] { m_poller, m_waitQueueEvent.getHandle() };
                while (!Thread.interrupted()) {
                  try {
                    WPIUtilJNI.waitForObjects(handles);
                  } catch (InterruptedException ex) {
                    m_lock.lock();
                    try {
                      if (m_waitQueue) {
                        m_waitQueue = false;
                        m_waitQueueCond.signalAll();
                      }
                    } finally {
                      m_lock.unlock();
                    }
                    Thread.currentThread().interrupt();
                    // don't try to destroy poller, as its handle is likely no longer valid
                    wasInterrupted = true;
                    break;
                  }
                  for (NetworkTableEvent event :
                      NetworkTablesJNI.readListenerQueue(m_inst, m_poller)) {
                    Consumer<NetworkTableEvent> listener;
                    m_lock.lock();
                    try {
                      listener = m_listeners.get(event.listener);
                    } finally {
                      m_lock.unlock();
                    }
                    if (listener != null) {
                      try {
                        listener.accept(event);
                      } catch (Throwable throwable) {
                        System.err.println(
                            "Unhandled exception during listener callback: "
                            + throwable.toString());
                        throwable.printStackTrace();
                      }
                    }
                  }
                  m_lock.lock();
                  try {
                    if (m_waitQueue) {
                      m_waitQueue = false;
                      m_waitQueueCond.signalAll();
                    }
                  } finally {
                    m_lock.unlock();
                  }
                }
                m_lock.lock();
                try {
                  if (!wasInterrupted) {
                    NetworkTablesJNI.destroyListenerPoller(m_poller);
                  }
                  m_poller = 0;
                } finally {
                  m_lock.unlock();
                }
              },
              "NTListener");
      m_thread.setDaemon(true);
      m_thread.start();
    }
 
    boolean waitForQueue(double timeout) {
      m_lock.lock();
      try {
        if (m_poller != 0) {
          m_waitQueue = true;
          m_waitQueueEvent.set();
          while (m_waitQueue) {
            try {
              if (timeout < 0) {
                m_waitQueueCond.await();
              } else {
                return m_waitQueueCond.await((long) (timeout * 1e9), TimeUnit.NANOSECONDS);
              }
            } catch (InterruptedException ex) {
              Thread.currentThread().interrupt();
              return true;
            }
          }
        }
      } finally {
        m_lock.unlock();
      }
      return true;
    }
  }
 
  private final ListenerStorage m_listeners = new ListenerStorage(this);

  public void removeListener(int listener) {
    m_listeners.remove(listener);
  }

  public boolean waitForListenerQueue(double timeout) {
    return m_listeners.waitForQueue(timeout);
  }

  public int addConnectionListener(
      boolean immediateNotify, Consumer<NetworkTableEvent> listener) {
    EnumSet<NetworkTableEvent.Kind> eventKinds = EnumSet.of(NetworkTableEvent.Kind.CONNECTION);
    if (immediateNotify) {
      eventKinds.add(NetworkTableEvent.Kind.IMMEDIATE);
    }
    return m_listeners.add(m_handle, eventKinds, listener);
  }

  public int addTimeSyncListener(
      boolean immediateNotify, Consumer<NetworkTableEvent> listener) {
    EnumSet<NetworkTableEvent.Kind> eventKinds = EnumSet.of(NetworkTableEvent.Kind.TIME_SYNC);
    if (immediateNotify) {
      eventKinds.add(NetworkTableEvent.Kind.IMMEDIATE);
    }
    return m_listeners.add(m_handle, eventKinds, listener);
  }

  public int addListener(
      Topic topic,
      EnumSet<NetworkTableEvent.Kind> eventKinds,
      Consumer<NetworkTableEvent> listener) {
    if (topic.getInstance().getHandle() != m_handle) {
      throw new IllegalArgumentException("topic is not from this instance");
    }
    return m_listeners.add(topic.getHandle(), eventKinds, listener);
  }

  public int addListener(
      Subscriber subscriber,
      EnumSet<NetworkTableEvent.Kind> eventKinds,
      Consumer<NetworkTableEvent> listener) {
    if (subscriber.getTopic().getInstance().getHandle() != m_handle) {
      throw new IllegalArgumentException("subscriber is not from this instance");
    }
    return m_listeners.add(subscriber.getHandle(), eventKinds, listener);
  }

  public int addListener(
      MultiSubscriber subscriber,
      EnumSet<NetworkTableEvent.Kind> eventKinds,
      Consumer<NetworkTableEvent> listener) {
    if (subscriber.getInstance().getHandle() != m_handle) {
      throw new IllegalArgumentException("subscriber is not from this instance");
    }
    return m_listeners.add(subscriber.getHandle(), eventKinds, listener);
  }

  public int addListener(
      NetworkTableEntry entry,
      EnumSet<NetworkTableEvent.Kind> eventKinds,
      Consumer<NetworkTableEvent> listener) {
    if (entry.getTopic().getInstance().getHandle() != m_handle) {
      throw new IllegalArgumentException("entry is not from this instance");
    }
    return m_listeners.add(entry.getHandle(), eventKinds, listener);
  }

  public int addListener(
      String[] prefixes,
      EnumSet<NetworkTableEvent.Kind> eventKinds,
      Consumer<NetworkTableEvent> listener) {
    return m_listeners.add(prefixes, eventKinds, listener);
  }
 
  /*
   * Client/Server Functions
   */

  public EnumSet<NetworkMode> getNetworkMode() {
    int flags = NetworkTablesJNI.getNetworkMode(m_handle);
    EnumSet<NetworkMode> rv = EnumSet.noneOf(NetworkMode.class);
    for (NetworkMode mode : NetworkMode.values()) {
      if ((flags & mode.getValue()) != 0) {
        rv.add(mode);
      }
    }
    return rv;
  }

  public void startLocal() {
    NetworkTablesJNI.startLocal(m_handle);
  }

  public void stopLocal() {
    NetworkTablesJNI.stopLocal(m_handle);
  }

  public void startServer() {
    startServer("networktables.json");
  }

  public void startServer(String persistFilename) {
    startServer(persistFilename, "", "");
  }

  public void startServer(String persistFilename, String listenAddress) {
    startServer(persistFilename, listenAddress, "");
  }

  public void startServer(String persistFilename, String listenAddress, String mdnsService) {
    startServer(persistFilename, listenAddress, mdnsService, DEFAULT_PORT);
  }

  public void startServer(String persistFilename, String listenAddress, String mdnsService,
      int port) {
    NetworkTablesJNI.startServer(m_handle, persistFilename, listenAddress, mdnsService, port);
  }

  public void stopServer() {
    NetworkTablesJNI.stopServer(m_handle);
  }

  public void startClient(String identity) {
    NetworkTablesJNI.startClient(m_handle, identity);
  }

  public void stopClient() {
    NetworkTablesJNI.stopClient(m_handle);
  }

  public void setServer(String serverName) {
    setServer(serverName, 0);
  }

  public void setServer(String serverName, int port) {
    NetworkTablesJNI.setServer(m_handle, serverName, port);
  }

  public void setServer(String[] serverNames) {
    setServer(serverNames, 0);
  }

  public void setServer(String[] serverNames, int port) {
    int[] ports = new int[serverNames.length];
    Arrays.fill(ports, port);
    setServer(serverNames, ports);
  }

  public void setServer(String[] serverNames, int[] ports) {
    NetworkTablesJNI.setServer(m_handle, serverNames, ports);
  }

  public void setServerMdns(String serviceName) {
    NetworkTablesJNI.setServerMdns(m_handle, serviceName);
  }

  public void setServerMdns(String serviceName, String serverName) {
    setServerMdns(serviceName, serverName, 0);
  }

  public void setServerMdns(String serviceName, String serverName, int port) {
    NetworkTablesJNI.setServerMdns(m_handle, serviceName, serverName, port);
  }

  public void setServerMdns(String serviceName, String[] serverNames) {
    setServerMdns(serviceName, serverNames, 0);
  }

  public void setServerMdns(String serviceName, String[] serverNames, int port) {
    int[] ports = new int[serverNames.length];
    Arrays.fill(ports, port);
    setServerMdns(serviceName, port, serverNames, ports);
  }

  public void setServerMdns(String serviceName, String[] serverNames, int[] ports) {
    setServerMdns(serviceName, 0, serverNames, ports);
  }

  public void setServerMdns(
      String serviceName, int mdnsPort, String[] serverNames, int[] ports) {
    NetworkTablesJNI.setServerMdns(
        m_handle, serviceName, mdnsPort, serverNames, ports);
  }

  public void setServerTeam(String team) {
    setServerTeam(team, 0);
  }

  public void setServerTeam(String team, int port) {
    NetworkTablesJNI.setServerTeam(m_handle, team, port);
  }

  public void setServerFixed(String team) {
    setServerFixed(team, 0);
  }

  public void setServerFixed(String team, int port) {
    NetworkTablesJNI.setServerFixed(m_handle, team, port);
  }

  public void disconnect() {
    NetworkTablesJNI.disconnect(m_handle);
  }

  public void startDSClient() {
    startDSClient(0);
  }

  public void startDSClient(int port) {
    NetworkTablesJNI.startDSClient(m_handle, port);
  }

  public void stopDSClient() {
    NetworkTablesJNI.stopDSClient(m_handle);
  }

  public void flushLocal() {
    NetworkTablesJNI.flushLocal(m_handle);
  }

  public void flush() {
    NetworkTablesJNI.flush(m_handle);
  }

  public ConnectionInfo[] getConnections() {
    return NetworkTablesJNI.getConnections(m_handle);
  }

  public boolean isConnected() {
    return NetworkTablesJNI.isConnected(m_handle);
  }

  public OptionalLong getServerTimeOffset() {
    return NetworkTablesJNI.getServerTimeOffset(m_handle);
  }

  public int startEntryDataLog(DataLog log, String prefix, String logPrefix) {
    return NetworkTablesJNI.startEntryDataLog(m_handle, log, prefix, logPrefix);
  }

  public static void stopEntryDataLog(int logger) {
    NetworkTablesJNI.stopEntryDataLog(logger);
  }

  public int startConnectionDataLog(DataLog log, String name) {
    return NetworkTablesJNI.startConnectionDataLog(m_handle, log, name);
  }

  public static void stopConnectionDataLog(int logger) {
    NetworkTablesJNI.stopConnectionDataLog(logger);
  }

  public int addLogger(int minLevel, int maxLevel, Consumer<NetworkTableEvent> func) {
    return m_listeners.addLogger(minLevel, maxLevel, func);
  }

  public boolean hasSchema(String name) {
    return m_schemas.containsKey("/.schema/" + name);
  }

  public void addSchema(String name, String type, byte[] schema) {
    m_schemas.computeIfAbsent("/.schema/" + name, k -> {
      RawPublisher pub = getRawTopic(k).publishEx(type, "{\"retained\":true}");
      pub.setDefault(schema);
      return pub;
    });
  }

  public void addSchema(String name, String type, String schema) {
    m_schemas.computeIfAbsent("/.schema/" + name, k -> {
      RawPublisher pub = getRawTopic(k).publishEx(type, "{\"retained\":true}");
      pub.setDefault(StandardCharsets.UTF_8.encode(schema));
      return pub;
    });
  }

  public void addSchema(Protobuf<?, ?> proto) {
    proto.forEachDescriptor(
        this::hasSchema,
        (typeString, schema) -> addSchema(typeString, "proto:FileDescriptorProto", schema));
  }

  public void addSchema(Struct<?> struct) {
    addSchemaImpl(struct, new HashSet<>());
  }
 
  @Override
  public boolean equals(Object other) {
    return other == this || other instanceof NetworkTableInstance inst && m_handle == inst.m_handle;
  }
 
  @Override
  public int hashCode() {
    return m_handle;
  }
 
  private void addSchemaImpl(Struct<?> struct, Set<String> seen) {
    String typeString = struct.getTypeString();
    if (hasSchema(typeString)) {
      return;
    }
    if (!seen.add(typeString)) {
      throw new UnsupportedOperationException(typeString + ": circular reference with " + seen);
    }
    addSchema(typeString, "structschema", struct.getSchema());
    for (Struct<?> inner : struct.getNested()) {
      addSchemaImpl(inner, seen);
    }
    seen.remove(typeString);
  }
 
  private boolean m_owned;
  private int m_handle;
  private final ConcurrentMap<String, RawPublisher> m_schemas = new ConcurrentHashMap<>();
}