* the very old Android Ice Cream Sandwich release), then this stream throws an exception instead of
 * creating a file that would be more accessible. (This behavior is new in Guava 32.0.0. Previous
 * versions would create a file that is more accessible, as discussed in <a
 * href="https://github.com/google/guava/issues/2575">Guava issue 2575</a>. TODO: b/283778848 - Fill
 * in CVE number once it's available.)
 *

  //
  // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the
  // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.
  //
  // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL
  // expressions. This includes:

      /*
       * Coverage mode generates synthetic fields.  If we ever add private
       * fields, they will cause similar problems, and we may want to switch
       * this check to isAccessible().
       */
      if (!field.isSynthetic() && field.getType() == String.class) {
        builder.add(field);
      }
    }
    return builder.build();
  }

type KMSLogger struct{}

// LogOnceIf is the implementation of LogOnceIf, accessible using the Logger interface
func (l KMSLogger) LogOnceIf(ctx context.Context, err error, id string, errKind ...interface{}) {
	logger.LogOnceIf(ctx, "kms", err, id, errKind...)
}

// LogIf is the implementation of LogIf, accessible using the Logger interface
func (l KMSLogger) LogIf(ctx context.Context, err error, errKind ...interface{}) {

  //
  // The `apiVersion`, `kind`, `metadata.name` and `metadata.generateName` are always accessible from the root of the
  // object and from any x-kubernetes-embedded-resource annotated objects. No other metadata properties are accessible.
  //
  // Unknown data preserved in custom resources via x-kubernetes-preserve-unknown-fields is not accessible in CEL
  // expressions. This includes:

object JavaRecordEncoding : Encoding {
    override suspend fun WriteContext.encode(value: Any) {
        val clazz = value::class.java
        writeClass(clazz)
        for (field in clazz.relevantFields) {
            field.isAccessible = true
            val fieldName = field.name
            val fieldValue = field.get(value)
            unsupportedFieldTypeFor(field)?.let {
                reportUnsupportedFieldType(it, "serialize", fieldName, fieldValue)

        exceptionClass);
    checkArgument(
        hasConstructorUsableByGetChecked(exceptionClass),
        "Futures.getChecked exception type (%s) must be an accessible class with an accessible "
            + "constructor whose parameters (if any) must be of type String and/or Throwable",
        exceptionClass);
  }

  private FuturesGetChecked() {}

        int kindCode;
        String kind = accessRule.getKind();
        switch (kind) {
            case "accessible":
            case "0":
                kindCode = 0;
                break;
            case "nonaccessible":
            case "1":
                kindCode = 1;
                break;
            case "discouraged":
            case "2":

# ADR-0001 - Use Architectural Decision Records

## Date

2023-12-01

## Context

In a distributed team with many subteams, the best solution to communicate decisions is to use a format accessible by everyone in charge of development.

We use *Specification* and *Discovery* documents stored in Google Drive, but they present some downsides:

  // nodeTopology defines which nodes have access to the storage
  // for which capacity was reported. If not set, the storage is
  // not accessible from any node in the cluster. If empty, the
  // storage is accessible from all nodes. This field is
  // immutable.
  //
  // +optional
  optional k8s.io.apimachinery.pkg.apis.meta.v1.LabelSelector nodeTopology = 2;