* Identical to {@link #appendTo(Appendable, Object, Object, Object...)}, except that it does not
   * throw {@link IOException}.
   */
  @CanIgnoreReturnValue
  public final StringBuilder appendTo(
      StringBuilder builder,
      @Nullable Object first,
      @Nullable Object second,
      @Nullable Object... rest) {
    return appendTo(builder, iterable(first, second, rest));
  }

  /**

 * @since 10.0
 */
public class DeadEvent {

  private final Object source;
  private final Object event;

  /**
   * Creates a new DeadEvent.
   *
   * @param source object broadcasting the DeadEvent (generally the {@link EventBus}).
   * @param event the event that could not be delivered.
   */
  public DeadEvent(Object source, Object event) {
    this.source = checkNotNull(source);

#### Secret Keys

The MinIO server uses a unique, randomly generated secret key per object also known as, Object Encryption Key ([OEK](#oek)). Neither the client-provided SSE-C key nor the KMS-managed key is directly used to en/decrypt an object. Instead, the OEK is stored as part of the object metadata next to the object in an encrypted form. To en/decrypt the OEK another secret key is needed also known as, Key Encryption Key ([KEK](#kek)).

        Supplier<Object> supplier = () -> Boolean.TRUE;

        monitorTarget.append(buf, "boolKey", supplier);
        assertEquals("\"boolKey\":\"true\"", buf.toString());
    }

    // Test append method with Date value (other object type)
    public void test_append_dateValue() {
        StringBuilder buf = new StringBuilder();
        Date date = new Date(1609459200000L);
        Supplier<Object> supplier = () -> date;

@GwtIncompatible
public final class SafeTreeSet<E> implements Serializable, NavigableSet<E> {
  @SuppressWarnings("unchecked")
  private static final Comparator<Object> NATURAL_ORDER =
      new Comparator<Object>() {
        @Override
        public int compare(Object o1, Object o2) {
          return ((Comparable<Object>) o1).compareTo(o2);
        }
      };

  private final NavigableSet<E> delegate;

  public SafeTreeSet() {

        }

        /**
         * The configuration setting object.
         */
        protected Object setting;

        /**
         * Sets the configuration setting object.
         * @param setting The configuration setting object.
         * @return The ApiConfigResponse instance.
         */
        public ApiConfigResponse setting(final Object setting) {
            this.setting = setting;

            return checkedEntry(from);
          }
        };
      }

      @Override
      public Object[] toArray() {
        /*
         * standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
         * can be used with collections that may contain null. This collection is a collection of

    List<@Nullable Object> args = Lists.newArrayListWithCapacity(params.size());
    for (Parameter param : params) {
      FreshValueGenerator generator = newFreshValueGenerator();
      argGenerators.add(generator);
      args.add(generateDummyArg(param, generator));
    }
    Object instance = createInstance(factory, args);
    List<Object> equalArgs = generateEqualFactoryArguments(factory, params, args);

  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenAndAnnotatedInSubclassEvents = new ArrayList<>();

    public void neitherOverriddenNorAnnotated(Object o) {
      neitherOverriddenNorAnnotatedEvents.add(o);
    }

When object locking is used in conjunction with replication, both source and destination buckets needs to have [object locking](https://docs.min.io/community/minio-object-store/administration/object-management/object-retention.html) enabled. Similarly objects encrypted on the server side, will be replicated if destination also supports encryption.