NetworkTable.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.networktables;
 
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Consumer;
import org.wpilib.util.protobuf.Protobuf;
import org.wpilib.util.struct.Struct;
import us.hebi.quickbuf.ProtoMessage;

public final class NetworkTable {
  public static final char PATH_SEPARATOR = '/';
 
  private final String m_path;
  private final String m_pathWithSep;
  private final NetworkTableInstance m_inst;

  public static String basenameKey(String key) {
    final int slash = key.lastIndexOf(PATH_SEPARATOR);
    if (slash == -1) {
      return key;
    }
    return key.substring(slash + 1);
  }

  public static String normalizeKey(String key, boolean withLeadingSlash) {
    String normalized;
    if (withLeadingSlash) {
      normalized = PATH_SEPARATOR + key;
    } else {
      normalized = key;
    }
    normalized = normalized.replaceAll(PATH_SEPARATOR + "{2,}", String.valueOf(PATH_SEPARATOR));
 
    if (!withLeadingSlash && normalized.charAt(0) == PATH_SEPARATOR) {
      // remove leading slash, if present
      normalized = normalized.substring(1);
    }
    return normalized;
  }

  public static String normalizeKey(String key) {
    return normalizeKey(key, true);
  }

  public static List<String> getHierarchy(String key) {
    final String normal = normalizeKey(key, true);
    List<String> hierarchy = new ArrayList<>();
    if (normal.length() == 1) {
      hierarchy.add(normal);
      return hierarchy;
    }
    for (int i = 1; ; i = normal.indexOf(PATH_SEPARATOR, i + 1)) {
      if (i == -1) {
        // add the full key
        hierarchy.add(normal);
        break;
      } else {
        hierarchy.add(normal.substring(0, i));
      }
    }
    return hierarchy;
  }

  NetworkTable(NetworkTableInstance inst, String path) {
    m_path = path;
    m_pathWithSep = path + PATH_SEPARATOR;
    m_inst = inst;
  }

  public NetworkTableInstance getInstance() {
    return m_inst;
  }
 
  @Override
  public String toString() {
    return "NetworkTable: " + m_path;
  }

  public Topic getTopic(String name) {
    return m_inst.getTopic(m_pathWithSep + name);
  }

  public BooleanTopic getBooleanTopic(String name) {
    return m_inst.getBooleanTopic(m_pathWithSep + name);
  }

  public IntegerTopic getIntegerTopic(String name) {
    return m_inst.getIntegerTopic(m_pathWithSep + name);
  }

  public FloatTopic getFloatTopic(String name) {
    return m_inst.getFloatTopic(m_pathWithSep + name);
  }

  public DoubleTopic getDoubleTopic(String name) {
    return m_inst.getDoubleTopic(m_pathWithSep + name);
  }

  public StringTopic getStringTopic(String name) {
    return m_inst.getStringTopic(m_pathWithSep + name);
  }

  public RawTopic getRawTopic(String name) {
    return m_inst.getRawTopic(m_pathWithSep + name);
  }

  public BooleanArrayTopic getBooleanArrayTopic(String name) {
    return m_inst.getBooleanArrayTopic(m_pathWithSep + name);
  }

  public IntegerArrayTopic getIntegerArrayTopic(String name) {
    return m_inst.getIntegerArrayTopic(m_pathWithSep + name);
  }

  public FloatArrayTopic getFloatArrayTopic(String name) {
    return m_inst.getFloatArrayTopic(m_pathWithSep + name);
  }

  public DoubleArrayTopic getDoubleArrayTopic(String name) {
    return m_inst.getDoubleArrayTopic(m_pathWithSep + name);
  }

  public StringArrayTopic getStringArrayTopic(String name) {
    return m_inst.getStringArrayTopic(m_pathWithSep + name);
  }

  public <T, MessageType extends ProtoMessage<?>> ProtobufTopic<T> getProtobufTopic(
      String name, Protobuf<T, MessageType> proto) {
    return m_inst.getProtobufTopic(m_pathWithSep + name, proto);
  }

  public <T> StructTopic<T> getStructTopic(String name, Struct<T> struct) {
    return m_inst.getStructTopic(m_pathWithSep + name, struct);
  }

  public <T> StructArrayTopic<T> getStructArrayTopic(String name, Struct<T> struct) {
    return m_inst.getStructArrayTopic(m_pathWithSep + name, struct);
  }
 
  private final ConcurrentMap<String, NetworkTableEntry> m_entries = new ConcurrentHashMap<>();

  public NetworkTableEntry getEntry(String key) {
    NetworkTableEntry entry = m_entries.get(key);
    if (entry == null) {
      entry = m_inst.getEntry(m_pathWithSep + key);
      NetworkTableEntry oldEntry = m_entries.putIfAbsent(key, entry);
      if (oldEntry != null) {
        entry = oldEntry;
      }
    }
    return entry;
  }

  public NetworkTable getSubTable(String key) {
    return new NetworkTable(m_inst, m_pathWithSep + key);
  }

  public boolean containsKey(String key) {
    return !"".equals(key) && getTopic(key).exists();
  }

  public boolean containsSubTable(String key) {
    Topic[] topics = m_inst.getTopics(m_pathWithSep + key + PATH_SEPARATOR, 0);
    return topics.length != 0;
  }

  public List<TopicInfo> getTopicInfo(int types) {
    List<TopicInfo> infos = new ArrayList<>();
    int prefixLen = m_path.length() + 1;
    for (TopicInfo info : m_inst.getTopicInfo(m_pathWithSep, types)) {
      String relativeKey = info.name.substring(prefixLen);
      if (relativeKey.indexOf(PATH_SEPARATOR) != -1) {
        continue;
      }
      infos.add(info);
    }
    return infos;
  }

  public List<TopicInfo> getTopicInfo() {
    return getTopicInfo(0);
  }

  public List<Topic> getTopics(int types) {
    List<Topic> topics = new ArrayList<>();
    int prefixLen = m_path.length() + 1;
    for (TopicInfo info : m_inst.getTopicInfo(m_pathWithSep, types)) {
      String relativeKey = info.name.substring(prefixLen);
      if (relativeKey.indexOf(PATH_SEPARATOR) != -1) {
        continue;
      }
      topics.add(info.getTopic());
    }
    return topics;
  }

  public List<Topic> getTopics() {
    return getTopics(0);
  }

  public Set<String> getKeys(int types) {
    Set<String> keys = new HashSet<>();
    int prefixLen = m_path.length() + 1;
    for (TopicInfo info : m_inst.getTopicInfo(m_pathWithSep, types)) {
      String relativeKey = info.name.substring(prefixLen);
      if (relativeKey.indexOf(PATH_SEPARATOR) != -1) {
        continue;
      }
      keys.add(relativeKey);
    }
    return keys;
  }

  public Set<String> getKeys() {
    return getKeys(0);
  }

  public Set<String> getSubTables() {
    Set<String> keys = new HashSet<>();
    int prefixLen = m_path.length() + 1;
    for (TopicInfo info : m_inst.getTopicInfo(m_pathWithSep, 0)) {
      String relativeKey = info.name.substring(prefixLen);
      int endSubTable = relativeKey.indexOf(PATH_SEPARATOR);
      if (endSubTable == -1) {
        continue;
      }
      keys.add(relativeKey.substring(0, endSubTable));
    }
    return keys;
  }

  public boolean putValue(String key, NetworkTableValue value) {
    return getEntry(key).setValue(value);
  }

  public boolean setDefaultValue(String key, NetworkTableValue defaultValue) {
    return getEntry(key).setDefaultValue(defaultValue);
  }

  public NetworkTableValue getValue(String key) {
    return getEntry(key).getValue();
  }

  public String getPath() {
    return m_path;
  }

  @FunctionalInterface
  public interface TableEventListener {
    void accept(NetworkTable table, String key, NetworkTableEvent event);
  }

  public int addListener(EnumSet<NetworkTableEvent.Kind> eventKinds, TableEventListener listener) {
    final int prefixLen = m_path.length() + 1;
    return m_inst.addListener(
        new String[] {m_pathWithSep},
        eventKinds,
        event -> {
          String topicName = null;
          if (event.topicInfo != null) {
            topicName = event.topicInfo.name;
          } else if (event.valueData != null) {
            topicName = event.valueData.getTopic().getName();
          }
          if (topicName == null) {
            return;
          }
          String relativeKey = topicName.substring(prefixLen);
          if (relativeKey.indexOf(PATH_SEPARATOR) != -1) {
            // part of a sub table
            return;
          }
          listener.accept(this, relativeKey, event);
        });
  }

  public int addListener(
      String key, EnumSet<NetworkTableEvent.Kind> eventKinds, TableEventListener listener) {
    NetworkTableEntry entry = getEntry(key);
    return m_inst.addListener(entry, eventKinds, event -> listener.accept(this, key, event));
  }

  @FunctionalInterface
  public interface SubTableListener {
    void tableCreated(NetworkTable parent, String name, NetworkTable table);
  }

  public int addSubTableListener(SubTableListener listener) {
    final int prefixLen = m_path.length() + 1;
    final NetworkTable parent = this;
 
    return m_inst.addListener(
        new String[] {m_pathWithSep},
        EnumSet.of(NetworkTableEvent.Kind.PUBLISH, NetworkTableEvent.Kind.IMMEDIATE),
        new Consumer<>() {
          final Set<String> m_notifiedTables = new HashSet<>();
 
          @Override
          public void accept(NetworkTableEvent event) {
            if (event.topicInfo == null) {
              return; // should not happen
            }
            String relativeKey = event.topicInfo.name.substring(prefixLen);
            int endSubTable = relativeKey.indexOf(PATH_SEPARATOR);
            if (endSubTable == -1) {
              return;
            }
            String subTableKey = relativeKey.substring(0, endSubTable);
            if (m_notifiedTables.contains(subTableKey)) {
              return;
            }
            m_notifiedTables.add(subTableKey);
            listener.tableCreated(parent, subTableKey, parent.getSubTable(subTableKey));
          }
        });
  }

  public void removeListener(int listener) {
    m_inst.removeListener(listener);
  }
 
  @Override
  public boolean equals(Object other) {
    return other instanceof NetworkTable ntOther
        && m_inst.equals(ntOther.m_inst)
        && m_path.equals(ntOther.m_path);
  }
 
  @Override
  public int hashCode() {
    return Objects.hash(m_inst, m_path);
  }
}