// to the zero value of the respective element type. If the argument
// type is a type parameter, the type parameter's type set must
// contain only map or slice types, and clear performs the operation
// implied by the type argument. If t is nil, clear is a no-op.
func clear[T ~[]Type | ~map[Type]Type1](t T)

// The close built-in function closes a channel, which must be either

	if pools, ok := objAPI.(*erasureServerPools); ok {
		pools.StopRebalance()
	}
}

// LoadRebalanceMeta notifies all peers to load rebalance.bin from object layer.
// Note: Only peers participating in rebalance operation, namely the first node
// in each pool will load rebalance.bin.
func (sys *NotificationSys) LoadRebalanceMeta(ctx context.Context, startRebalance bool) {
	ng := WithNPeers(len(sys.peerClients))

	info := madmin.GetPartitions(context.Background(), globalLocalNodeName)
	return madminPartitions.NewJSONWith(&info), nil
}

// GetOSInfoHandler - returns operating system's information.
func (s *peerRESTServer) GetOSInfoHandler(_ *grid.MSS) (*grid.JSON[madmin.OSInfo], *grid.RemoteErr) {
	info := madmin.GetOSInfo(context.Background(), globalLocalNodeName)

     * URL tracking when certain HTTP status codes are encountered.
     *
     * @param urlQueue the URL queue item that was processed
     * @param responseData the response data from the crawl operation
     */
    @Override
    protected void processResponse(final UrlQueue<?> urlQueue, final ResponseData responseData) {
        super.processResponse(urlQueue, responseData);

        // When
        request.setSessionBinding(false);

        // Then
        assertFalse((boolean) sessionBindingField.get(request));
    }

    @Test
    @DisplayName("Should handle chain operation correctly")
    void testChain() {
        // Given
        ServerMessageBlock2 nextMessage = mock(ServerMessageBlock2.class);

        // When
        boolean result = request.chain(nextMessage);

 * inserted by producers and extracted by consumers. Once created, the capacity cannot be increased.
 * Attempts to {@code put} an element into a full queue will result in the operation blocking;
 * attempts to {@code take} an element from an empty queue will similarly block.
 *
 * <p>This class supports an optional fairness policy for ordering waiting producer and consumer

            if (existing != null) {
                return existing;
            }
        }

        // Check pool size limits using atomic operation
        if (!nonPooled) {
            int currentSize = this.connections.size();
            if (currentSize >= maxPoolSize) {
                // Try to remove idle connections
                removeIdleConnections();

    // being selected in phase 1
    checkState(boxedBoolean, "", (Object) boxedLong);

    // ternaries introduce their own problems. because of the ternary (which requires a boxing
    // operation) no overload can be selected in phase 1.  and in phase 2 it is ambiguous since it
    // matches with the second parameter being boxed and without it being boxed.  The cast to Object
    // avoids this.

    // being selected in phase 1
    checkState(boxedBoolean, "", (Object) boxedLong);

    // ternaries introduce their own problems. because of the ternary (which requires a boxing
    // operation) no overload can be selected in phase 1.  and in phase 2 it is ambiguous since it
    // matches with the second parameter being boxed and without it being boxed.  The cast to Object
    // avoids this.

                }
                _src = _src.deferred;
                e.decode(_src);

            }
        }
    }

    /**
     * DCE/RPC message for NetrDfsEnumEx operation to enumerate DFS entries
     */
    public static class NetrDfsEnumEx extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x15;
        }

        /**