if rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); db.AddError(err) == nil {
					dest := db.Statement.Dest
					db.Statement.Dest = db.Statement.ReflectValue.Addr().Interface()
					gorm.Scan(rows, db, mode)
					db.Statement.Dest = dest
					db.AddError(rows.Close())

					if db.Statement.Result != nil {
						db.Statement.Result.RowsAffected = db.RowsAffected
					}
				}

	for idx, field := range fields {
		if field != nil {
			values[idx] = field.NewValuePool.Get()
		} else if len(fields) == 1 {
			if reflectValue.CanAddr() {
				values[idx] = reflectValue.Addr().Interface()
			} else {
				values[idx] = reflectValue.Interface()
			}
		}
	}

	db.RowsAffected++
	db.AddError(rows.Scan(values...))
	joinedNestedSchemaMap := make(map[string]interface{})

          @Subscribe
          public void eat(Object food) {
            objectEvents.add(food);
          }
        };

    List<Comparable<?>> compEvents = new ArrayList<>();
    Object compCatcher =
        new Object() {
          @Subscribe
          public void eat(Comparable<?> food) {
            compEvents.add(food);
          }
        };
    bus.register(stringCatcher);
    bus.register(objCatcher);

            defaultMap.put(Constants.ITEM_VALUE, "all");
            langItems.add(defaultMap);
            return langItems;
        }
    }

    /**
     * Adds a shutdown hook.
     *
     * @param hook The shutdown hook to add.
     */
    public void addShutdownHook(final Runnable hook) {
        shutdownHookList.add(hook);
    }

    /**
     * Gets the hostname of the local machine.

            this.dependencies = (dependencies != null) ? dependencies : Collections.emptyList();
            return this;
        }

        /**
         * Adds the specified direct dependency.
         *
         * @param dependency the dependency to add, may be {@code null}
         * @return this request for chaining, never {@code null}
         */
        @Nonnull

     */
    @CanIgnoreReturnValue
    @Override
    public Builder<K, V> put(K key, V value) {
      super.put(key, value);
      return this;
    }

    /**
     * Adds the given {@code entry} to the bimap. Duplicate keys or values are not allowed, and will
     * cause {@link #build} to fail.
     *
     * @since 19.0
     */
    @CanIgnoreReturnValue
    @Override

public static class RdmaChannelInfo {
    private final int remoteKey;
    private final long address;
    private final int length;
    
    public RdmaChannelInfo(int key, long addr, int len) {
        this.remoteKey = key;
        this.address = addr;
        this.length = len;
    }
    
    // Getters...
}
```

## 6. Configuration

### 6.1 Configuration Properties
```java

        User u = user;
        for (final AuthenticationChain chain : chains) {
            u = chain.load(u);
        }
        return u;
    }

    /**
     * Adds an authentication chain to the manager.
     * @param chain The authentication chain to add.
     */
    public void addChain(final AuthenticationChain chain) {
        chains = ArrayUtils.addAll(chains, chain);
    }

    /**

      name: String,
      value: String,
    ) = apply {
      headers.add(name, value)
    }

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) =
      apply {
        headers.removeAll(name)
      }

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) =
      apply {

*   Math and Linear Algebra:
    *   Add `tf.linalg.LinearOperatorTridiag`.
    *   Add `LinearOperatorBlockLowerTriangular`
    *   Add broadcasting support to
        tf.linalg.triangular_solve[#26204](https://github.com/tensorflow/tensorflow/issues/26204),
        tf.math.invert_permutation.
    *   Add `tf.math.sobol_sample` op.
    *   Add `tf.math.xlog1py`.