interface Parameters : ValueSourceParameters {

        val ignoreIncomingBuildReceipt: Property<Boolean>

        @get:Optional
        val buildReceiptFileContents: Property<String>
    }

    override fun obtain(): String? = parameters.run {
        buildReceiptString()

 * A value whose type is not specified statically. Use this with [Adapters.any] which will attempt
 * to resolve a concrete type.
 */
internal data class AnyValue(
  var tagClass: Int,
  var tag: Long,
  var constructed: Boolean = false,
  var length: Long = -1L,
  val bytes: ByteString,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0

      // The cast is safe because of the `run` and `error` checks.
      afterRanInterruptiblySuccess(uncheckedCastNullableTToT(result));
    } else {
      afterRanInterruptiblyFailure(error);
    }
  }

  abstract boolean isDone();

  abstract T runInterruptibly() throws Exception;

  abstract void afterRanInterruptiblySuccess(T result);

  abstract void afterRanInterruptiblyFailure(Throwable error);

            "1180::3dd0:7f8e:57b7:34d5",
            "1180::71a3:2b00:ddd3:753f",
            "1180::8b2:d61e:e5c:b333",
            "1180::b059:65f4:e877:c40",
            "fe80::34",
            "fec0::34");
    boolean processedNamedInterface = false;
    for (String ipString : ipStrings) {
      for (String scopeId : getMachineScopesAndInterfaces()) {
        String withScopeId = ipString + "%" + scopeId;
        assertTrue(

                        {
                            "required": False,
                            "schema": {
                                "title": "Teleport",
                                "type": "boolean",
                                "default": False,
                            },
                            "name": "teleport",
                            "in": "query",
                        }

package org.codelibs.fess.crawler.container;

import org.codelibs.core.lang.StringUtil;

/**
 * @author shinsuke
 *
 */
public interface CrawlerContainer {

    <T> T getComponent(String name);

    boolean available();

    void destroy();

    default void initialize() {
        final StringBuilder buf = new StringBuilder(100);
        final String value = System.getProperty("java.protocol.handler.pkgs");

        : Iterators.singletonIterator(connectingEdge);
  }

  @Override
  public int size() {
    return getConnectingEdge() == null ? 0 : 1;
  }

  @Override
  public boolean contains(@CheckForNull Object edge) {
    E connectingEdge = getConnectingEdge();
    return (connectingEdge != null && connectingEdge.equals(edge));
  }

  @CheckForNull
  private E getConnectingEdge() {

  @Override
  void write(int b);

  @Override
  void write(byte b[]);

  @Override
  void write(byte b[], int off, int len);

  @Override
  void writeBoolean(boolean v);

  @Override
  void writeByte(int v);

  @Override
  void writeShort(int v);

  @Override
  void writeChar(int v);

  @Override
  void writeInt(int v);

  @Override

     */
    public static DocumentBuilderFactory newInstance() {
        return newInstance(false);
    }

    public static DocumentBuilderFactory newInstance(final boolean external) {
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        if (!external) {
            try {
                factory.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");

  private val retryOnConnectionFailure: Boolean,
  private val user: ConnectionUser,
  private val routePlanner: RealRoutePlanner,
  // Specifics to this plan.
  override val route: Route,
  internal val routes: List<Route>?,
  private val attempt: Int,
  private val tunnelRequest: Request?,
  internal val connectionSpecIndex: Int,
  internal val isTlsFallback: Boolean,
) : RoutePlanner.Plan, ExchangeCodec.Carrier {