return user;
    }

    protected boolean isTargetUser(final String username) {
        if (targetUsers == null) {
            return true;
        }
        return stream(targetUsers).get(stream -> stream.anyMatch(s -> s.equals(username)));
    }

    protected int executeCommand(final String[] commands, final String username, final String password) {
        if (commands == null || commands.length == 0) {

	if want != got {
		return fmt.Errorf("Invalid key checksum, want %x, got %x", want, got)
	}

	stream, err := sio.AES_256_GCM.Stream(key)
	if err != nil {
		return err
	}
	// Zero nonce, we only use each key once, and 32 bytes is plenty.
	nonce := make([]byte, stream.NonceSize())
	encr := stream.DecryptReader(r, nonce, nil)
	_, err = io.Copy(w, encr)
	if err == nil {
		fmt.Println(okMsg)
	}
	return err

     */
    void write(Writer output, Map<String, Object> options, Model model) throws IOException;

    /**
     * Writes the supplied model to the specified byte stream. The stream will be automatically closed before the method
     * returns.
     *
     * @param output The stream to serialize the model to, must not be {@code null}.
     * @param options The options to use for serialization, may be {@code null} to use the default values.

            }
        }

        final Stream<String> projectProfiles = projectsIncludingParents.stream()
                .flatMap(p -> p.getModel().getDelegate().getProfiles().stream())
                .map(Profile::getId);
        final Stream<String> settingsProfiles =
                session.getSettings().getProfiles().stream().map(org.apache.maven.settings.Profile::getId);

    }

    public void addDefaultSort(final String fieldName, final String order) {
        final List<SortBuilder<?>> list = new ArrayList<>();
        if (defaultSortBuilders != null) {
            stream(defaultSortBuilders).of(stream -> stream.forEach(builder -> list.add(builder)));
        }
        list.add(createFieldSortBuilder(fieldName, SortOrder.DESC.toString().equalsIgnoreCase(order) ? SortOrder.DESC : SortOrder.ASC));

    } // -- void write( Writer, Model )

    /**
     * Method write.
     *
     * @param stream a stream object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(OutputStream stream, Model model) throws IOException {
        super.write(stream, model);
    } // -- void write( OutputStream, Model )

 * limitations under the License.
 */
package okhttp3.internal.http2

import java.io.IOException

/** Thrown when an HTTP/2 stream is canceled without damage to the socket that carries it. */
class StreamResetException(
  @JvmField val errorCode: ErrorCode,

package mockwebserver3

import okhttp3.ExperimentalOkHttpApi

/**
 * Handles a call's stream directly. Use this instead of [MockResponseBody] to begin sending
 * response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
@ExperimentalOkHttpApi
interface StreamHandler {
  fun handle(stream: Stream)

        if (StringUtil.isNotBlank(fessConfig.getQueryFacetFields())) {
            field = StreamUtil.split(fessConfig.getQueryFacetFields(), ",")
                    .get(stream -> stream.map(String::trim).filter(StringUtil::isNotEmpty).distinct().toArray(n -> new String[n]));
        }
        if (StringUtil.isNotBlank(fessConfig.getQueryFacetFieldsSize())) {

        this.exclusions = exclusions;
        this.predicates =
                exclusions.stream().map(ExclusionArtifactFilter::toPredicate).collect(Collectors.toList());
    }

    @Override
    public boolean include(Artifact artifact) {
        return predicates.stream().noneMatch(p -> p.test(artifact));
    }

    private static Predicate<Artifact> toPredicate(Exclusion exclusion) {