* @param acceptedRoles array of role names that can access the API
     */
    public void setAcceptedRoles(final String[] acceptedRoles) {
        this.acceptedRoles = acceptedRoles;
    }

    /**
     * Gets the server path with access token for API requests.
     *
     * @return the complete server path including the access token
     * @throws FessSystemException if no access token is available
     */

                }
                start = (pageNumber - 1) * form.getPageSize();
            }
        }
        form.start = start;

        return doSearch(form);
    }

    /**
     * Gets the display query.
     * @param form The search form.
     * @param labelTypeItems The list of label type items.
     * @return The display query.
     */

 * Given a request and cached response, this figures out whether to use the network, the cache, or
 * both.
 *
 * Selecting a cache strategy may add conditions to the request (like the "If-Modified-Since" header
 * for conditional GETs) or warnings to the cached response (if the cached data is potentially
 * stale).
 */
class CacheStrategy internal constructor(
  /** The request to send on the network, or null if this call doesn't use the network. */

       * Returns an input stream containing one or more certificate PEM files. This implementation just
       * embeds the PEM files in Java strings; most applications will instead read this from a resource
       * file that gets bundled with the application.
       */
      private fun trustedCertificatesInputStream(): InputStream {
        ... // Full source omitted. See sample.
      }

                }
                scrollId = response.getScrollId();
            }
        } finally {
            SuggestUtil.deleteScrollContext(client, scrollId);
        }
    }

    /**
     * Gets the total hit count from a scroll search.
     *
     * @param client The OpenSearch client
     * @param settings The suggest settings containing timeout configurations
     * @param index The index name to search

        // no-op
    }

    @Override
    public String getName() {
        return "form";
    }

    /**
     * Gets the parameter value for the specified name.
     * @param name The parameter name.
     * @return The parameter value, or null if not found.
     */
    public String getParameter(final String name) {

                } else {
                    sb.append(ch);
                }
            }
            return sb.toString();
        }
        return s;
    }

    /**
     * Gets the simple name of this dictionary file.
     * @return the simple name of the file
     */
    public String getSimpleName() {
        return new File(path).getName();
    }

    /**

Sometimes there's an action required like calling the application layer or responding to a ping, and the thread discovering the action is not the thread that should do the work. We enqueue a runnable on this executor and it gets handled by one of the executor's threads.

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

   */
  @AndroidIncompatible
  public void testTaskThrowsError() throws Exception {
    class MyError extends Error {}
    CyclicBarrier barrier = new CyclicBarrier(2);
    // we need to make sure the error gets thrown on a different thread.
    ExecutorService service = newSingleThreadExecutor();
    try {
      SequentialExecutor executor = new SequentialExecutor(service);
      Runnable errorTask =
          () -> {

        try {
            init(f);
        } catch (final Exception e) {
            logger.error("Error setting filter config", e);
        }
    }

    /**
     * Gets the filter configuration.
     * @return the filter configuration or null
     */
    public FilterConfig getFilterConfig() {
        return null;
    }