if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
        return set.headSet(lastInclusive, true);
      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
        return set.tailSet(firstExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return set.subSet(firstExclusive, false, lastExclusive, false);

     * Gets the interim result of the model building up to the point where it failed.
     *
     * @return The interim model building result or {@code null} if not available.
     */
    public ModelBuildingResult getResult() {
        return result;
    }

    /**
     * Gets the model that could not be built properly.
     *
     * @return The erroneous model or {@code null} if not available.
     */
    public Model getModel() {

    }

    int writeSetupWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeParametersWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readSetupWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }

	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc == nil {
		return 0, io.EOF
	}
	return pr.rc.Read(p)
}

func (pr *syncReadCloser) Close() error {
	pr.mu.Lock()
	defer pr.mu.Unlock()
	if pr.rc != nil {
		err := pr.rc.Close()
		pr.rc = nil
		return err
	}
	return nil

        }
        latch.countDown();
    }

    public Promise then(final Consumer<RESPONSE> consumer) {
        return promise.then(consumer);
    }

    public Promise error(final Consumer<Throwable> consumer) {
        return promise.error(consumer);
    }

    public Promise promise() {
        return promise;
    }

    public class Promise {
        public Promise then(final Consumer<RESPONSE> consumer) {

    protected String prepareWebappPath() {
        final String value = System.getProperty(FESS_WEBAPP_PATH);
        if (value != null) {
            return value;
        }
        return super.prepareWebappPath();
    }

    @Override
    protected String getMarkDir() {
        return new File(System.getProperty(JAVA_IO_TMPDIR), "fessboot").getAbsolutePath();
    }

      result.add(value(i))
    }
  }
  return result?.toList().orEmpty()
}

internal fun Headers.commonIterator(): Iterator<Pair<String, String>> {
  return Array(size) { name(it) to value(it) }.iterator()
}

internal fun Headers.commonNewBuilder(): Headers.Builder {
  val result = Headers.Builder()
  result.namesAndValues += namesAndValues
  return result
}

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(webConfig.getId()).created(true).status(Status.OK).result());
    }

            policy.merge(repository.getSnapshots());
            return policy;
        } else if ((nature & RepositoryMetadata.SNAPSHOT) != 0) {
            return repository.getSnapshots();
        } else {
            return repository.getReleases();
        }
    }

		IdleMode:       0, // Default is on
	}

	if err = config.CheckValidKeys(config.ScannerSubSys, kvs, DefaultKVS); err != nil {
		return cfg, err
	}

	excessVersions, err := strconv.ParseInt(env.Get(EnvExcessVersions, kvs.GetWithDefault(ExcessVersions, DefaultKVS)), 10, 64)
	if err != nil {
		return cfg, err
	}
	cfg.ExcessVersions = excessVersions