@Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse list(final OptionalThing<Integer> pageNumber, final SearchForm form) {
        pageNumber.ifPresent(num -> {
            boostDocPager.setCurrentPageNumber(pageNumber.get());
        }).orElse(() -> {
            boostDocPager.setCurrentPageNumber(0);
        });
        return asHtml(path_AdminBoostdoc_AdminBoostdocJsp).renderWith(data -> {
            searchPaging(data, form);

     * condition is for http on the http port.
     */
    @Internal
    Closure waitCondition = { AntFixture fixture, AntBuilder ant ->
        File tmpFile = new File(fixture.cwd, 'wait.success')
        ant.get(src: "http://${fixture.addressAndPort}",
                dest: tmpFile.toString(),
                ignoreerrors: true, // do not fail on error, so logging information can be flushed
                retries: 10)

network, you should also make sure that it provides a way for users to
get its source.  For example, if your program is a web application, its
interface could display a "Source" link that leads users to an archive
of the code.  There are many ways you could offer source, and different
solutions will be better for different programs; see section 13 for the
specific requirements.

  You should also get your employer (if you work as a programmer) or school,

        if (this.transportContext.getConfig().getNetbiosCachePolicy() == 0) {
            return;
        }
        synchronized (this.addressCache) {
            CacheEntry entry = this.addressCache.get(hostName);
            if (entry == null) {
                entry = new CacheEntry(hostName, addr, expiration);
                this.addressCache.put(hostName, entry);
            } else {

        }
    }

    /**
     * Get validation statistics
     */
    public ValidationStats getStats() {
        return new ValidationStats(totalValidations.get(), failedValidations.get(), bufferOverflowsPrevented.get(),
                integerOverflowsPrevented.get());
    }

    /**
     * Reset statistics
     */
    public void resetStats() {

                    final List<String> inputStrings = split(sides.get(0), ",");
                    inputs = new String[inputStrings.size()];
                    for (int i = 0; i < inputs.length; i++) {
                        inputs[i] = unescape(inputStrings.get(i)).trim();
                    }

                    final List<String> outputStrings = split(sides.get(1), ",");
                    outputs = new String[outputStrings.size()];

    /**
     * Reflectively get the chained next request from a SMB2 request.
     */
    private static Object getNextOf(Object req) throws Exception {
        Class<?> cls = req.getClass().getSuperclass(); // ServerMessageBlock2Request
        Field f = cls.getSuperclass().getDeclaredField("next"); // ServerMessageBlock2.next
        f.setAccessible(true);
        return f.get(req);
    }

    /**

                return queryType;
            }

            // Delegate all other methods to base config
            @Override
            public String get(String key) {
                return baseConfig.get(key);
            }

            @Override
            public String getIndexFieldTitle() {
                return baseConfig.getIndexFieldTitle();
            }

            @Override

        // request header
        for (final Header header : requestHeaderList) {
            httpGet.addHeader(header);
        }

        HttpEntity httpEntity = null;
        try {
            // get a content
            final HttpResponse response = executeHttpClient(httpGet);
            httpEntity = response.getEntity();

            final int httpStatusCode = response.getStatusLine().getStatusCode();

	resp, err := getBackgroundHealStatusRPC.Call(ctx, client.gridConn(), grid.NewMSS())
	return resp.ValueOrZero(), err
}

// GetMetacacheListing - get a new or existing metacache.
func (client *peerRESTClient) GetMetacacheListing(ctx context.Context, o listPathOptions) (*metacache, error) {
	if client == nil {
		resp := localMetacacheMgr.getBucket(ctx, o.Bucket).findCache(o)