Protobuf.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.util.protobuf;
 
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Predicate;
import us.hebi.quickbuf.Descriptors.Descriptor;
import us.hebi.quickbuf.Descriptors.FileDescriptor;
import us.hebi.quickbuf.ProtoMessage;
import us.hebi.quickbuf.RepeatedDouble;
import us.hebi.quickbuf.RepeatedMessage;

public interface Protobuf<T, MessageType extends ProtoMessage<?>> {
  Class<T> getTypeClass();

  default String getTypeString() {
    return "proto:" + getDescriptor().getFullName();
  }

  Descriptor getDescriptor();

  MessageType createMessage();

  T unpack(MessageType msg);

  void pack(MessageType msg, T value);

  default void unpackInto(T out, MessageType msg) {
    throw new UnsupportedOperationException("object does not support unpackInto");
  }

  default boolean isImmutable() {
    return false;
  }

  default boolean isCloneable() {
    return false;
  }

  default T clone(T obj) throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
  }

  default void forEachDescriptor(Predicate<String> exists, BiConsumer<String, byte[]> fn) {
    forEachDescriptorImpl(getDescriptor().getFile(), exists, fn);
  }
 
  private static void forEachDescriptorImpl(
      FileDescriptor desc, Predicate<String> exists, BiConsumer<String, byte[]> fn) {
    String name = "proto:" + desc.getFullName();
    if (exists.test(name)) {
      return;
    }
    for (FileDescriptor dep : desc.getDependencies()) {
      forEachDescriptorImpl(dep, exists, fn);
    }
    fn.accept(name, desc.toProtoBytes());
  }

  static <T, MessageType extends ProtoMessage<MessageType>> T[] unpackArray(
      RepeatedMessage<MessageType> msg, Protobuf<T, MessageType> proto) {
    @SuppressWarnings("unchecked")
    T[] result = (T[]) Array.newInstance(proto.getTypeClass(), msg.length());
    for (int i = 0; i < result.length; i++) {
      result[i] = proto.unpack(msg.get(i));
    }
    return result;
  }

  static double[] unpackArray(RepeatedDouble msg) {
    double[] result = new double[msg.length()];
    for (int i = 0; i < result.length; i++) {
      result[i] = msg.get(i);
    }
    return result;
  }

  static <T, MessageType extends ProtoMessage<MessageType>> List<T> unpackList(
      RepeatedMessage<MessageType> msg, Protobuf<T, MessageType> proto) {
    ArrayList<T> result = new ArrayList<>(msg.length());
    for (var item : msg) {
      result.add(proto.unpack(item));
    }
    return result;
  }

  static <T, MessageType extends ProtoMessage<MessageType>> void packArray(
      RepeatedMessage<MessageType> msg, T[] arr, Protobuf<T, MessageType> proto) {
    msg.clear();
    msg.reserve(arr.length);
    for (var obj : arr) {
      proto.pack(msg.next(), obj);
    }
  }

  static void packArray(RepeatedDouble msg, double[] arr) {
    msg.clear();
    msg.reserve(arr.length);
    msg.addAll(arr);
  }

  static <T, MessageType extends ProtoMessage<MessageType>> void packList(
      RepeatedMessage<MessageType> msg, List<T> list, Protobuf<T, MessageType> proto) {
    msg.clear();
    msg.reserve(list.size());
    for (var obj : list) {
      proto.pack(msg.next(), obj);
    }
  }
}