fallbackToTcp(connection);
        }
    }
    
    private boolean isRecoverableError(Exception error) {
        // Check if error is recoverable (temporary network issue, etc.)
        return error instanceof SocketTimeoutException
            || error.getMessage().contains("retry");
    }
    
    private void fallbackToTcp(RdmaConnection connection) {

     * [EventListener] instance will be used during the lifecycle of [call].
     *
     * This method is invoked after [call] is created. See [OkHttpClient.newCall].
     *
     * **It is an error for implementations to issue any mutating operations on the [call] instance
     * from this method.**
     */
    fun create(call: Call): EventListener
  }

  companion object {
    @JvmField
    val NONE: EventListener =

            // - version should NOT be removed (external parents need version to be located)
            // This prevents the "parent.groupId is missing" error reported in issue #7934
            assertNotNull(parentElement.child("groupId").orElse(null));
            assertNotNull(parentElement.child("artifactId").orElse(null));
            assertNotNull(parentElement.child("version").orElse(null));

      return (comparator2 == null)
          ? comparator == Ordering.natural()
          : comparator.equals(comparator2);
    }
    return false;
  }

  // Assumes that delegate doesn't have null elements and comparator.
  static <E> ImmutableSortedSet<E> unsafeDelegateSortedSet(
      SortedSet<E> delegate, boolean isSubset) {
    return delegate.isEmpty()

A duplicação de código aumenta as chances de bugs, problemas de segurança, problemas de desincronização de código (quando você atualiza em um lugar, mas não em outros), etc.

E esses modelos estão compartilhando muitos dos dados e duplicando nomes e tipos de atributos.

Nós poderíamos fazer melhor.

   *
   * 1. Both superclass toArray methods assume that size() gives a correct answer, while our size()
   * might not (and the answer might change while we're building the array).
   *
   * TODO: cpovirk - Is this an issue anywhere anymore? It looks to have been fixed for Java 8
   * (https://bugs.openjdk.org/browse/JDK-7121314) and before Lollipop
   * (https://r.android.com/47508). We *would* need to worry for J2KT, whose own concurrency support

### Multi destination replication

* el decodificador
* codificar
* decodificar

* la excepción
* lanzar

* la expresión
* el statement

* el frontend
* el backend

* la discusión de GitHub
* el issue de GitHub

* el rendimiento
* la optimización de rendimiento

* el tipo de retorno
* el valor de retorno

* la seguridad
* el esquema de seguridad

* la tarea
* la tarea en segundo plano

    defaultDelay: Int,
  ): Int {
    val header = userResponse.header("Retry-After") ?: return defaultDelay

    // https://tools.ietf.org/html/rfc7231#section-7.1.3
    // currently ignores a HTTP-date, and assumes any non int 0 is a delay
    if (header.matches("\\d+".toRegex())) {
      return Integer.valueOf(header)
    }
    return Integer.MAX_VALUE
  }

  companion object {
    /**

    }

    // CHECKSTYLE_OFF: LineLength

    /**
     * Main to test version parsing and comparison.
     * <p>
     * To check how "1.2.7" compares to "1.2-SNAPSHOT", for example, you can issue
     * <pre>java -jar ${maven.repo.local}/org/apache/maven/maven-artifact/${maven.version}/maven-artifact-${maven.version}.jar "1.2.7" "1.2-SNAPSHOT"</pre>