raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 11

19441: Use Optional instead of Option in http core javadsl

Browse source
This commit is contained in:
Endre Sándor Varga 2016-01-15 13:03:27 +01:00
parent 7a39063f2e
commit 57c1dfde8a
54 changed files with 302 additions and 248 deletions
Download patch file Download diff file Expand all files Collapse all files

13
akka-docs/rst/java/code/docs/http/javadsl/ModelDocTest.java
View file

@ -4,13 +4,14 @@
package docs.http.javadsl;
import akka.japi.Option;
import akka.util.ByteString;
import org.junit.Test;
//#import-model
import akka.http.javadsl.model.*;
import akka.http.javadsl.model.headers.*;
import java.util.Optional;
//#import-model
@SuppressWarnings("unused")
@ -79,12 +80,12 @@ public class ModelDocTest {
//#headers
// a method that extracts basic HTTP credentials from a request
private Option<BasicHttpCredentials> getCredentialsOfRequest(HttpRequest request) {
Option<Authorization> auth = request.getHeader(Authorization.class);
if (auth.isDefined() && auth.get().credentials() instanceof BasicHttpCredentials)
return Option.some((BasicHttpCredentials) auth.get().credentials());
private Optional<BasicHttpCredentials> getCredentialsOfRequest(HttpRequest request) {
Optional<Authorization> auth = request.getHeader(Authorization.class);
if (auth.isPresent() && auth.get().credentials() instanceof BasicHttpCredentials)
return Optional.of((BasicHttpCredentials) auth.get().credentials());
else
return Option.none();
return Optional.empty();
}
//#headers
}

2
akka-docs/rst/java/code/docs/http/javadsl/server/HttpServerExampleDocTest.java
View file

@ -202,7 +202,7 @@ public class HttpServerExampleDocTest {
.withEntity(ContentTypes.TEXT_HTML_UTF8,
"<html><body>Hello world!</body></html>");
else if (uri.path().equals("/hello")) {
String name = Util.getOrElse(uri.query().get("name"), "Mister X");
String name = uri.query().get("name").orElse("Mister X");
return
HttpResponse.create()

4
akka-docs/rst/java/code/docs/stream/MigrationsJava.java
View file

@ -209,11 +209,11 @@ public class MigrationsJava {
Uri uri = null;
//#raw-query
final akka.japi.Option<String> theRawQueryString = uri.rawQueryString();
final Optional<String> theRawQueryString = uri.rawQueryString();
//#raw-query
//#query-param
final akka.japi.Option<String> aQueryParam = uri.query().get("a");
final Optional<String> aQueryParam = uri.query().get("a");
//#query-param
//#file-source-sink

4
akka-docs/rst/java/http/routing-dsl/request-vals/header-request-vals.rst
View file

@ -14,10 +14,10 @@ The ``RequestVal`` builder is made up of 2 steps, initially you need to pick whi
match if the header is not present in the request). This is done using one of the below depicted methods::
RequestVal<T> instance()
RequestVal<<Option<T>> optionalInstance()
RequestVal<<Optional<T>> optionalInstance()
RequestVal<String> value()
RequestVal<Option<String>> optionalValue()
RequestVal<Optional<String>> optionalValue()
Examples
--------

2
akka-docs/rst/java/stream/stream-flows-and-basics.rst
View file

@ -127,7 +127,7 @@ Illegal stream elements
In accordance to the Reactive Streams specification (`Rule 2.13 <https://github.com/reactive-streams/reactive-streams-jvm#2.13>`_)
Akka Streams do not allow ``null`` to be passed through the stream as an element. In case you want to model the concept
of absence of a value we recommend using ``akka.japi.Option`` (for Java 6 and 7) or ``java.util.Optional`` which is available since Java 8.
of absence of a value we recommend using ``java.util.Optional`` which is available since Java 8.
.. _back-pressure-explained-java:

26
akka-http-core/src/main/java/akka/http/impl/util/Util.java
View file

@ -6,7 +6,7 @@ package akka.http.impl.util;
import akka.http.impl.model.JavaUri;
import akka.http.javadsl.model.Uri;
import akka.japi.Option;
import scala.compat.java8.OptionConverters;
import scala.None$;
import scala.collection.immutable.Map$;
import scala.collection.immutable.Seq;
@ -14,6 +14,7 @@ import akka.stream.scaladsl.Source;
import java.util.Arrays;
import java.util.Map;
import java.util.Optional;
/**
* Contains internal helper methods.
@ -22,8 +23,8 @@ public abstract class Util {
@SuppressWarnings("unchecked") // no support for covariance of option in Java
// needed to provide covariant conversions that the Java interfaces don't provide automatically.
// The alternative would be having to cast around everywhere instead of doing it here in a central place.
public static <U, T extends U> Option<U> convertOption(scala.Option<T> o) {
return (Option<U>)(Object) akka.japi.Option.fromScalaOption(o);
public static <U, T extends U> Optional<U> convertOption(scala.Option<T> o) {
return (Optional<U>)(Object) OptionConverters.toJava(o);
}
@SuppressWarnings("unchecked") // no support for covariance of Publisher in Java
// needed to provide covariant conversions that the Java interfaces don't provide automatically.
@ -40,8 +41,8 @@ public abstract class Util {
return emptyMap.$plus$plus(scala.collection.JavaConverters.mapAsScalaMapConverter(map).asScala());
}
@SuppressWarnings("unchecked") // contains an upcast
public static <T, U extends T> scala.Option<U> convertOptionToScala(Option<T> o) {
return ((Option<U>) o).asScala();
public static <T, U extends T> scala.Option<U> convertOptionalToScala(Optional<T> o) {
return OptionConverters.toScala((Optional<U>) o);
}
public static final scala.collection.immutable.Map<String, String> emptyMap =
@ -66,23 +67,14 @@ public abstract class Util {
return ((JavaUri) uri).uri();
}
public static <J, V extends J> akka.japi.Option<J> lookupInRegistry(ObjectRegistry<Object, V> registry, int key) {
public static <J, V extends J> Optional<J> lookupInRegistry(ObjectRegistry<Object, V> registry, int key) {
return Util.<J, V>convertOption(registry.getForKey(key));
}
public static <J, V extends J> akka.japi.Option<J> lookupInRegistry(ObjectRegistry<String, V> registry, String key) {
public static <J, V extends J> Optional<J> lookupInRegistry(ObjectRegistry<String, V> registry, String key) {
return Util.<String, J, V>lookupInRegistry(registry, key);
}
public static <K, J, V extends J> akka.japi.Option<J> lookupInRegistry(ObjectRegistry<K, V> registry, K key) {
public static <K, J, V extends J> Optional<J> lookupInRegistry(ObjectRegistry<K, V> registry, K key) {
return Util.<J, V>convertOption(registry.getForKey(key));
}
/**
* Temporary replacement for akka.japi.Option.getOrElse until it gets released there.
*
* FIXME: remove in favor of a proper japi.Option.getOrElse
*/
public static <B, A extends B> B getOrElse(Option<A> option, B defaultValue) {
if (option.isDefined()) return option.get();
else return defaultValue;
}
}

28
akka-http-core/src/main/java/akka/http/javadsl/HttpsContext.java
View file

@ -7,42 +7,44 @@ package akka.http.javadsl;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLParameters;
import akka.japi.Option;
import akka.japi.Util;
import akka.stream.io.ClientAuth;
import java.util.Collection;
import java.util.Optional;
import scala.compat.java8.OptionConverters;
public abstract class HttpsContext {
public abstract SSLContext getSslContext();
public abstract Option<Collection<String>> getEnabledCipherSuites();
public abstract Optional<Collection<String>> getEnabledCipherSuites();
public abstract Option<Collection<String>> getEnabledProtocols();
public abstract Optional<Collection<String>> getEnabledProtocols();
public abstract Option<ClientAuth> getClientAuth();
public abstract Optional<ClientAuth> getClientAuth();
public abstract Option<SSLParameters> getSslParameters();
public abstract Optional<SSLParameters> getSslParameters();
//#http-context-creation
public static HttpsContext create(SSLContext sslContext,
Option<Collection<String>> enabledCipherSuites,
Option<Collection<String>> enabledProtocols,
Option<ClientAuth> clientAuth,
Option<SSLParameters> sslParameters)
Optional<Collection<String>> enabledCipherSuites,
Optional<Collection<String>> enabledProtocols,
Optional<ClientAuth> clientAuth,
Optional<SSLParameters> sslParameters)
//#http-context-creation
{
final scala.Option<scala.collection.immutable.Seq<String>> ecs;
if (enabledCipherSuites.isDefined()) ecs = scala.Option.apply(Util.immutableSeq(enabledCipherSuites.get()));
if (enabledCipherSuites.isPresent()) ecs = scala.Option.apply(Util.immutableSeq(enabledCipherSuites.get()));
else ecs = scala.Option.empty();
final scala.Option<scala.collection.immutable.Seq<String>> ep;
if(enabledProtocols.isDefined()) ep = scala.Option.apply(Util.immutableSeq(enabledProtocols.get()));
if(enabledProtocols.isPresent()) ep = scala.Option.apply(Util.immutableSeq(enabledProtocols.get()));
else ep = scala.Option.empty();
return new akka.http.scaladsl.HttpsContext(sslContext,
ecs,
ep,
clientAuth.asScala(),
sslParameters.asScala());
OptionConverters.toScala(clientAuth),
OptionConverters.toScala(sslParameters));
}
}

17
akka-http-core/src/main/java/akka/http/javadsl/model/ContentRange.java
View file

@ -5,19 +5,22 @@
package akka.http.javadsl.model;
import akka.http.scaladsl.model.ContentRange$;
import akka.japi.Option;
import java.util.Optional;
import java.util.OptionalLong;
import scala.compat.java8.OptionConverters;
public abstract class ContentRange {
public abstract boolean isByteContentRange();
public abstract boolean isSatisfiable();
public abstract boolean isOther();
public abstract Option<Long> getSatisfiableFirst();
public abstract Option<Long> getSatisfiableLast();
public abstract OptionalLong getSatisfiableFirst();
public abstract OptionalLong getSatisfiableLast();
public abstract Option<String> getOtherValue();
public abstract Optional<String> getOtherValue();
public abstract Option<Long> getInstanceLength();
public abstract OptionalLong getInstanceLength();
public static ContentRange create(long first, long last) {
return ContentRange$.MODULE$.apply(first, last);
@ -26,8 +29,8 @@ public abstract class ContentRange {
return ContentRange$.MODULE$.apply(first, last, instanceLength);
}
@SuppressWarnings("unchecked")
public static ContentRange create(long first, long last, Option<Long> instanceLength) {
return ContentRange$.MODULE$.apply(first, last, ((Option<Object>) (Object) instanceLength).asScala());
public static ContentRange create(long first, long last, OptionalLong instanceLength) {
return ContentRange$.MODULE$.apply(first, last, OptionConverters.toScala(instanceLength));
}
public static ContentRange createUnsatisfiable(long length) {
return new akka.http.scaladsl.model.ContentRange.Unsatisfiable(length);

5
akka-http-core/src/main/java/akka/http/javadsl/model/DateTime.java
View file

@ -4,9 +4,10 @@
package akka.http.javadsl.model;
import akka.japi.Option;
import akka.http.impl.util.Util;
import java.util.Optional;
/**
* Immutable, fast and efficient Date + Time implementation without any dependencies.
* Does not support TimeZones, all DateTime values are always GMT based.
@ -101,7 +102,7 @@ public abstract class DateTime {
* Returns a new DateTime instance parsed from IsoDateTimeString as Some(dateTime). Returns None if
* parsing has failed.
*/
public static Option<DateTime> fromIsoDateTimeString(String isoDateTimeString) {
public static Optional<DateTime> fromIsoDateTimeString(String isoDateTimeString) {
return Util.<DateTime, akka.http.scaladsl.model.DateTime>convertOption(akka.http.scaladsl.model.DateTime.fromIsoDateTimeString(isoDateTimeString));
}

5
akka-http-core/src/main/java/akka/http/javadsl/model/HttpCharsets.java
View file

@ -6,7 +6,8 @@ package akka.http.javadsl.model;
import akka.http.impl.util.Util;
import akka.http.scaladsl.model.HttpCharsets$;
import akka.japi.Option;
import java.util.Optional;
/**
* Contains a set of predefined charsets.
@ -31,7 +32,7 @@ public final class HttpCharsets {
/**
* Returns Some(charset) if the charset with the given name was found and None otherwise.
*/
public static Option<HttpCharset> lookup(String name) {
public static Optional<HttpCharset> lookup(String name) {
return Util.<HttpCharset, akka.http.scaladsl.model.HttpCharset>lookupInRegistry(HttpCharsets$.MODULE$, name);
}
}

5
akka-http-core/src/main/java/akka/http/javadsl/model/HttpEntity.java
View file

@ -6,12 +6,13 @@ package akka.http.javadsl.model;
import akka.http.impl.util.Util;
import akka.http.scaladsl.model.HttpEntity$;
import akka.japi.Option;
import akka.stream.Materializer;
import akka.stream.javadsl.Source;
import akka.util.ByteString;
import scala.concurrent.Future;
import java.util.OptionalLong;
/**
* Represents the entity of an Http message. An entity consists of the content-type of the data
* and the actual data itself. Some subtypes of HttpEntity also define the content-length of the
@ -77,7 +78,7 @@ public interface HttpEntity {
/**
* Returns Some(contentLength) if the length is defined and none otherwise.
*/
Option<Long> getContentLengthOption();
OptionalLong getContentLengthOption();
/**
* Returns a stream of data bytes this entity consists of.

6
akka-http-core/src/main/java/akka/http/javadsl/model/HttpMessage.java
View file

@ -4,10 +4,10 @@
package akka.http.javadsl.model;
import akka.japi.Option;
import akka.util.ByteString;
import java.io.File;
import java.util.Optional;
/**
* The base type for an Http message (request or response).
@ -37,13 +37,13 @@ public interface HttpMessage {
* Try to find the first header with the given name (case-insensitive) and return
* Some(header), otherwise this method returns None.
*/
Option<HttpHeader> getHeader(String headerName);
Optional<HttpHeader> getHeader(String headerName);
/**
* Try to find the first header of the given class and return
* Some(header), otherwise this method returns None.
*/
<T extends HttpHeader> Option<T> getHeader(Class<T> headerClass);
<T extends HttpHeader> Optional<T> getHeader(Class<T> headerClass);
/**
* The entity of this message.

5
akka-http-core/src/main/java/akka/http/javadsl/model/HttpMethods.java
View file

@ -5,9 +5,10 @@
package akka.http.javadsl.model;
import akka.http.impl.util.Util;
import akka.japi.Option;
import akka.http.scaladsl.model.HttpMethods$;
import java.util.Optional;
/**
* Contains static constants for predefined method types.
*/
@ -34,7 +35,7 @@ public final class HttpMethods {
/**
* Looks up a predefined HTTP method with the given name.
*/
public static Option<HttpMethod> lookup(String name) {
public static Optional<HttpMethod> lookup(String name) {
return Util.<HttpMethod, akka.http.scaladsl.model.HttpMethod>lookupInRegistry(HttpMethods$.MODULE$, name);
}
}

6
akka-http-core/src/main/java/akka/http/javadsl/model/MediaTypes.java
View file

@ -6,8 +6,8 @@ package akka.http.javadsl.model;
import akka.http.impl.util.Util;
import akka.http.scaladsl.model.MediaTypes$;
import akka.japi.Option;
import scala.collection.immutable.List;
import java.util.Optional;
/**
* Contains the set of predefined media-types.
@ -197,7 +197,7 @@ public abstract class MediaTypes {
/**
* Looks up a media-type with the given main-type and sub-type.
*/
public static Option<MediaType> lookup(String mainType, String subType) {
public static Optional<MediaType> lookup(String mainType, String subType) {
return Util.<scala.Tuple2<String, String>, MediaType, akka.http.scaladsl.model.MediaType>lookupInRegistry(MediaTypes$.MODULE$, new scala.Tuple2<String, String>(mainType, subType));
}
}

9
akka-http-core/src/main/java/akka/http/javadsl/model/Multipart.java
View file

@ -5,11 +5,12 @@
package akka.http.javadsl.model;
import java.util.Map;
import java.util.Optional;
import scala.concurrent.Future;
import akka.http.javadsl.model.headers.ContentDisposition;
import akka.http.javadsl.model.headers.ContentDispositionType;
import akka.http.javadsl.model.headers.RangeUnit;
import akka.japi.Option;
import akka.stream.Materializer;
import akka.stream.javadsl.Source;
@ -52,11 +53,11 @@ public interface Multipart {
Iterable<HttpHeader> getHeaders();
Option<ContentDisposition> getContentDispositionHeader();
Optional<ContentDisposition> getContentDispositionHeader();
Map<String, String> getDispositionParams();
Option<ContentDispositionType> getDispositionType();
Optional<ContentDispositionType> getDispositionType();
Future<? extends Multipart.BodyPart.Strict> toStrict(long timeoutMillis, Materializer materializer);
@ -106,7 +107,7 @@ public interface Multipart {
String getName();
Map<String, String> getAdditionalDispositionParams();
Iterable<HttpHeader> getAdditionalHeaders();
Option<String> getFilename();
Optional<String> getFilename();
Future<Multipart.FormData.BodyPart.Strict> toStrict(long timeoutMillis, Materializer materializer);

4
akka-http-core/src/main/java/akka/http/javadsl/model/Query.java
View file

@ -6,7 +6,6 @@ package akka.http.javadsl.model;
import akka.http.impl.model.JavaQuery;
import akka.http.scaladsl.model.*;
import akka.japi.Option;
import akka.japi.Pair;
import akka.parboiled2.CharPredicate;
import akka.parboiled2.ParserInput$;
@ -14,12 +13,13 @@ import akka.parboiled2.ParserInput$;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;
import java.util.Optional;
public abstract class Query {
/**
* Returns the value of the first parameter with the given key if it exists.
*/
public abstract Option<String> get(String key);
public abstract Optional<String> get(String key);
/**
* Returns the value of the first parameter with the given key or the provided default value.

8
akka-http-core/src/main/java/akka/http/javadsl/model/RemoteAddress.java
View file

@ -4,15 +4,15 @@
package akka.http.javadsl.model;
import akka.japi.Option;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.Optional;
import scala.compat.java8.OptionConverters;
public abstract class RemoteAddress {
public abstract boolean isUnknown();
public abstract Option<InetAddress> getAddress();
public abstract Optional<InetAddress> getAddress();
/**
* Returns a port if defined or 0 otherwise.
@ -21,7 +21,7 @@ public abstract class RemoteAddress {
public static final RemoteAddress UNKNOWN = akka.http.scaladsl.model.RemoteAddress.Unknown$.MODULE$;
public static RemoteAddress create(InetAddress address) {
return akka.http.scaladsl.model.RemoteAddress.apply(address, Option.none().asScala());
return akka.http.scaladsl.model.RemoteAddress.apply(address, OptionConverters.toScala(Optional.empty()));
}
public static RemoteAddress create(InetSocketAddress address) {
return akka.http.scaladsl.model.RemoteAddress.apply(address);

5
akka-http-core/src/main/java/akka/http/javadsl/model/StatusCodes.java
View file

@ -6,7 +6,8 @@ package akka.http.javadsl.model;
import akka.http.impl.util.Util;
import akka.http.scaladsl.model.StatusCodes$;
import akka.japi.Option;
import java.util.Optional;
/**
* Contains the set of predefined status-codes along with static methods to access and create custom
@ -109,7 +110,7 @@ public final class StatusCodes {
/**
* Looks up a status-code by numeric code and returns Some(code). Returns None otherwise.
*/
public static Option<StatusCode> lookup(int intValue) {
public static Optional<StatusCode> lookup(int intValue) {
return Util.<StatusCode, akka.http.scaladsl.model.StatusCode>lookupInRegistry(StatusCodes$.MODULE$, intValue);
}
}

10
akka-http-core/src/main/java/akka/http/javadsl/model/Uri.java
View file

@ -6,13 +6,13 @@ package akka.http.javadsl.model;
import akka.http.impl.model.JavaUri;
import akka.http.scaladsl.model.UriJavaAccessor;
import akka.japi.Option;
import akka.japi.Pair;
import akka.parboiled2.ParserInput$;
import java.nio.charset.Charset;
import java.util.List;
import java.util.Map;
import java.util.Optional;
/**
* Represents an Uri. Use the `withX` methods to create modified copies of a given instance.
@ -66,12 +66,12 @@ public abstract class Uri {
/**
* Returns a decoded String representation of the query of this Uri.
*/
public abstract Option<String> queryString(Charset charset);
public abstract Optional<String> queryString(Charset charset);
/**
* Returns an undecoded String representation of the query of this Uri.
*/
public abstract Option<String> rawQueryString();
public abstract Optional<String> rawQueryString();
/**
* Returns the parsed Query instance of this Uri.
@ -86,7 +86,7 @@ public abstract class Uri {
/**
* Returns the fragment part of this Uri.
*/
public abstract Option<String> fragment();
public abstract Optional<String> fragment();
/**
* Returns a copy of this instance with a new scheme.
@ -146,7 +146,7 @@ public abstract class Uri {
/**
* Returns a copy of this instance with a new optional fragment.
*/
public abstract Uri fragment(Option<String> fragment);
public abstract Uri fragment(Optional<String> fragment);
public static final akka.http.scaladsl.model.Uri.ParsingMode STRICT = UriJavaAccessor.pmStrict();
public static final akka.http.scaladsl.model.Uri.ParsingMode RELAXED = UriJavaAccessor.pmRelaxed();

11
akka-http-core/src/main/java/akka/http/javadsl/model/headers/ByteRange.java
View file

@ -5,17 +5,18 @@
package akka.http.javadsl.model.headers;
import akka.http.scaladsl.model.headers.ByteRange$;
import akka.japi.Option;
import java.util.OptionalLong;
public abstract class ByteRange {
public abstract boolean isSlice();
public abstract boolean isFromOffset();
public abstract boolean isSuffix();
public abstract Option<Long> getSliceFirst();
public abstract Option<Long> getSliceLast();
public abstract Option<Long> getOffset();
public abstract Option<Long> getSuffixLength();
public abstract OptionalLong getSliceFirst();
public abstract OptionalLong getSliceLast();
public abstract OptionalLong getOffset();
public abstract OptionalLong getSuffixLength();
public static ByteRange createSlice(long first, long last) {
return ByteRange$.MODULE$.apply(first, last);

9
akka-http-core/src/main/java/akka/http/javadsl/model/headers/CacheDirectives.java
View file

@ -4,6 +4,11 @@
package akka.http.javadsl.model.headers;
import scala.compat.java8.OptionConverters;
import java.util.Optional;
import java.util.OptionalLong;
public final class CacheDirectives {
private CacheDirectives() {}
@ -11,10 +16,10 @@ public final class CacheDirectives {
return new akka.http.scaladsl.model.headers.CacheDirectives.max$minusage(deltaSeconds);
}
public static CacheDirective MAX_STALE() {
return new akka.http.scaladsl.model.headers.CacheDirectives.max$minusstale(akka.japi.Option.none().asScala());
return new akka.http.scaladsl.model.headers.CacheDirectives.max$minusstale(OptionConverters.toScala(Optional.empty()));
}
public static CacheDirective MAX_STALE(long deltaSeconds) {
return new akka.http.scaladsl.model.headers.CacheDirectives.max$minusstale(akka.japi.Option.some((Object) deltaSeconds).asScala());
return new akka.http.scaladsl.model.headers.CacheDirectives.max$minusstale(OptionConverters.toScala(OptionalLong.of(deltaSeconds)));
}
public static CacheDirective MIN_FRESH(long deltaSeconds) {
return new akka.http.scaladsl.model.headers.CacheDirectives.min$minusfresh(deltaSeconds);

39
akka-http-core/src/main/java/akka/http/javadsl/model/headers/HttpCookie.java
View file

@ -6,20 +6,23 @@ package akka.http.javadsl.model.headers;
import akka.http.javadsl.model.DateTime;
import akka.http.impl.util.Util;
import akka.japi.Option;
import scala.compat.java8.OptionConverters;
import java.util.Optional;
import java.util.OptionalLong;
public abstract class HttpCookie {
public abstract String name();
public abstract String value();
public abstract HttpCookiePair pair();
public abstract Option<DateTime> getExpires();
public abstract Option<Long> getMaxAge();
public abstract Option<String> getDomain();
public abstract Option<String> getPath();
public abstract Optional<DateTime> getExpires();
public abstract OptionalLong getMaxAge();
public abstract Optional<String> getDomain();
public abstract Optional<String> getPath();
public abstract boolean secure();
public abstract boolean httpOnly();
public abstract Option<String> getExtension();
public abstract Optional<String> getExtension();
public static HttpCookie create(String name, String value) {
return new akka.http.scaladsl.model.headers.HttpCookie(
@ -28,11 +31,11 @@ public abstract class HttpCookie {
false, false,
Util.<String>scalaNone());
}
public static HttpCookie create(String name, String value, Option<String> domain, Option<String> path) {
public static HttpCookie create(String name, String value, Optional<String> domain, Optional<String> path) {
return new akka.http.scaladsl.model.headers.HttpCookie(
name, value,
Util.<akka.http.scaladsl.model.DateTime>scalaNone(), Util.scalaNone(),
domain.asScala(), path.asScala(),
OptionConverters.toScala(domain), OptionConverters.toScala(path),
false, false,
Util.<String>scalaNone());
}
@ -40,22 +43,22 @@ public abstract class HttpCookie {
public static HttpCookie create(
String name,
String value,
Option<DateTime> expires,
Option<Long> maxAge,
Option<String> domain,
Option<String> path,
Optional<DateTime> expires,
OptionalLong maxAge,
Optional<String> domain,
Optional<String> path,
boolean secure,
boolean httpOnly,
Option<String> extension) {
Optional<String> extension) {
return new akka.http.scaladsl.model.headers.HttpCookie(
name, value,
Util.<DateTime, akka.http.scaladsl.model.DateTime>convertOptionToScala(expires),
((Option<Object>) (Object) maxAge).asScala(),
domain.asScala(),
path.asScala(),
Util.<DateTime, akka.http.scaladsl.model.DateTime>convertOptionalToScala(expires),
OptionConverters.toScala(maxAge),
OptionConverters.toScala(domain),
OptionConverters.toScala(path),
secure,
httpOnly,
extension.asScala());
OptionConverters.toScala(extension));
}
/**

6
akka-http-core/src/main/scala/akka/http/ConnectionPoolSettings.scala
View file

@ -5,6 +5,7 @@
package akka.http
import java.lang.{ Iterable ⇒ JIterable }
import java.util.Optional
import akka.actor.ActorSystem
import akka.event.LoggingAdapter
@ -13,6 +14,7 @@ import akka.http.scaladsl.HttpsContext
import com.typesafe.config.Config
import scala.concurrent.duration.Duration
import scala.compat.java8.OptionConverters._
final case class HostConnectionPoolSetup(host: String, port: Int, setup: ConnectionPoolSetup)
@ -24,9 +26,9 @@ final case class ConnectionPoolSetup(
object ConnectionPoolSetup {
/** Java API */
def create(settings: ConnectionPoolSettings,
httpsContext: akka.japi.Option[akka.http.javadsl.HttpsContext],
httpsContext: Optional[akka.http.javadsl.HttpsContext],
log: LoggingAdapter): ConnectionPoolSetup =
ConnectionPoolSetup(settings, httpsContext.map(_.asInstanceOf[HttpsContext]), log)
ConnectionPoolSetup(settings, httpsContext.asScala.map(_.asInstanceOf[HttpsContext]), log)
}
final case class ConnectionPoolSettings(

6
akka-http-core/src/main/scala/akka/http/impl/model/JavaQuery.scala
View file

@ -4,6 +4,7 @@
package akka.http.impl.model
import java.util.Optional
import java.{ util ⇒ ju }
import akka.http.impl.model.parser.CharacterClasses
import akka.http.impl.util.StringRendering
@ -11,15 +12,16 @@ import akka.http.javadsl.model.HttpCharset
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.scaladsl.model.UriRendering
import akka.http.scaladsl.{ model ⇒ sm }
import akka.japi.{ Pair, Option }
import akka.japi.Pair
import akka.parboiled2.CharPredicate
import scala.collection.JavaConverters._
import akka.http.impl.util.JavaMapping.Implicits._
import scala.compat.java8.OptionConverters._
/** INTERNAL API */
case class JavaQuery(query: sm.Uri.Query) extends jm.Query {
override def get(key: String): Option[String] = query.get(key)
override def get(key: String): Optional[String] = query.get(key).asJava
override def toMap: ju.Map[String, String] = query.toMap.asJava
override def toList: ju.List[Pair[String, String]] = query.map(_.asJava).asJava
override def getOrElse(key: String, _default: String): String = query.getOrElse(key, _default)

11
akka-http-core/src/main/scala/akka/http/impl/model/JavaUri.scala
View file

@ -5,12 +5,13 @@
package akka.http.impl.model
import java.nio.charset.Charset
import java.util.Optional
import java.{ lang ⇒ jl }
import akka.http.scaladsl.model.Uri.ParsingMode
import akka.japi.Option
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.scaladsl.{ model ⇒ sm }
import akka.http.impl.util.JavaMapping.Implicits._
import scala.compat.java8.OptionConverters._
/** INTERNAL API */
case class JavaUri(uri: sm.Uri) extends jm.Uri {
@ -36,12 +37,12 @@ case class JavaUri(uri: sm.Uri) extends jm.Uri {
gatherSegments(uri.path).asJava
}
def rawQueryString: Option[String] = uri.rawQueryString
def queryString(charset: Charset): Option[String] = uri.queryString(charset)
def rawQueryString: Optional[String] = uri.rawQueryString.asJava
def queryString(charset: Charset): Optional[String] = uri.queryString(charset).asJava
def query: jm.Query = uri.query().asJava
def query(charset: Charset, mode: ParsingMode): jm.Query = uri.query(charset, mode).asJava
def fragment: Option[String] = uri.fragment
def fragment: Optional[String] = uri.fragment.asJava
// Modification methods
@ -69,7 +70,7 @@ case class JavaUri(uri: sm.Uri) extends jm.Uri {
u.withPath(newPath)
}
def fragment(fragment: Option[String]): jm.Uri = t(_.copy(fragment = fragment))
def fragment(fragment: Optional[String]): jm.Uri = t(_.copy(fragment = fragment.asScala))
def fragment(fragment: String): jm.Uri = t(_.withFragment(fragment))
override def toString: String = uri.toString

11
akka-http-core/src/main/scala/akka/http/impl/util/JavaMapping.scala
View file

@ -5,6 +5,7 @@
package akka.http.impl.util
import java.net.InetAddress
import java.util.Optional
import java.{ util ⇒ ju, lang ⇒ jl }
import akka.japi.Pair
import akka.stream.javadsl
@ -17,6 +18,8 @@ import akka.http.impl.model.{ JavaQuery, JavaUri }
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.scaladsl.{ model ⇒ sm }
import scala.compat.java8.OptionConverters._
import scala.util.Try
/** INTERNAL API */
@ -101,10 +104,10 @@ private[http] object JavaMapping {
def toScala(javaObject: ju.Map[K, V]): immutable.Map[K, V] = javaObject.asScala.toMap
def toJava(scalaObject: immutable.Map[K, V]): ju.Map[K, V] = scalaObject.asJava
}
implicit def option[_J, _S](implicit mapping: JavaMapping[_J, _S]): JavaMapping[akka.japi.Option[_J], Option[_S]] =
new JavaMapping[akka.japi.Option[_J], Option[_S]] {
def toScala(javaObject: japi.Option[_J]): Option[_S] = javaObject.asScala.map(mapping.toScala)
def toJava(scalaObject: Option[_S]): japi.Option[_J] = japi.Option.fromScalaOption(scalaObject.map(mapping.toJava))
implicit def option[_J, _S](implicit mapping: JavaMapping[_J, _S]): JavaMapping[Optional[_J], Option[_S]] =
new JavaMapping[Optional[_J], Option[_S]] {
def toScala(javaObject: Optional[_J]): Option[_S] = javaObject.asScala.map(mapping.toScala)
def toJava(scalaObject: Option[_S]): Optional[_J] = scalaObject.map(mapping.toJava).asJava
}
implicit def flowMapping[JIn, SIn, JOut, SOut, M](implicit inMapping: JavaMapping[JIn, SIn], outMapping: JavaMapping[JOut, SOut]): JavaMapping[javadsl.Flow[JIn, JOut, M], scaladsl.Flow[SIn, SOut, M]] =

53
akka-http-core/src/main/scala/akka/http/javadsl/Http.scala
View file

@ -5,6 +5,7 @@
package akka.http.javadsl
import java.net.InetSocketAddress
import java.util.Optional
import akka.http.impl.util.JavaMapping
import akka.http.javadsl.model.ws._
import akka.stream
@ -14,7 +15,7 @@ import scala.language.implicitConversions
import scala.concurrent.Future
import scala.util.Try
import akka.stream.scaladsl.Keep
import akka.japi.{ Pair, Option, Function }
import akka.japi.{ Pair, Function }
import akka.actor.{ ExtendedActorSystem, ActorSystem, ExtensionIdProvider, ExtensionId }
import akka.event.LoggingAdapter
import akka.stream.Materializer
@ -25,6 +26,8 @@ import akka.http.scaladsl.{ model ⇒ sm }
import akka.http.javadsl.model._
import akka.http._
import scala.compat.java8.OptionConverters._
object Http extends ExtensionId[Http] with ExtensionIdProvider {
override def get(system: ActorSystem): Http = super.get(system)
def lookup() = Http
@ -36,8 +39,8 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
private lazy val delegate = akka.http.scaladsl.Http(system)
private implicit def convertHttpsContext(hctx: Option[HttpsContext]) =
hctx.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext])
private implicit def convertHttpsContext(hctx: Optional[HttpsContext]): Option[akka.http.scaladsl.HttpsContext] =
hctx.asScala.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext])
/**
* Constructs a server layer stage using the configured default [[ServerSettings]]. The returned [[BidiFlow]] isn't
@ -60,7 +63,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* this layer produces if the `akka.http.server.remote-address-header` configuration option is enabled.
*/
def serverLayer(settings: ServerSettings,
remoteAddress: Option[InetSocketAddress],
remoteAddress: Optional[InetSocketAddress],
materializer: Materializer): BidiFlow[HttpResponse, SslTlsOutbound, SslTlsInbound, HttpRequest, Unit] =
adaptServerLayer(delegate.serverLayer(settings, remoteAddress.asScala)(materializer))
@ -70,7 +73,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* this layer produces if the `akka.http.server.remote-address-header` configuration option is enabled.
*/
def serverLayer(settings: ServerSettings,
remoteAddress: Option[InetSocketAddress],
remoteAddress: Optional[InetSocketAddress],
log: LoggingAdapter,
materializer: Materializer): BidiFlow[HttpResponse, SslTlsOutbound, SslTlsInbound, HttpRequest, Unit] =
adaptServerLayer(delegate.serverLayer(settings, remoteAddress.asScala, log)(materializer))
@ -102,7 +105,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def bind(interface: String, port: Int,
settings: ServerSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter,
materializer: Materializer): Source[IncomingConnection, Future[ServerBinding]] =
new Source(delegate.bind(interface, port, settings, httpsContext, log)(materializer)
@ -133,7 +136,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
def bindAndHandle(handler: Flow[HttpRequest, HttpResponse, _],
interface: String, port: Int,
settings: ServerSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter,
materializer: Materializer): Future[ServerBinding] =
delegate.bindAndHandle(handler.asInstanceOf[Flow[sm.HttpRequest, sm.HttpResponse, _]].asScala,
@ -163,7 +166,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
def bindAndHandleSync(handler: Function[HttpRequest, HttpResponse],
interface: String, port: Int,
settings: ServerSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter,
materializer: Materializer): Future[ServerBinding] =
delegate.bindAndHandleSync(handler.apply(_).asScala,
@ -192,7 +195,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def bindAndHandleAsync(handler: Function[HttpRequest, Future[HttpResponse]],
interface: String, port: Int,
settings: ServerSettings, httpsContext: Option[HttpsContext],
settings: ServerSettings, httpsContext: Optional[HttpsContext],
parallelism: Int, log: LoggingAdapter,
materializer: Materializer): Future[ServerBinding] =
delegate.bindAndHandleAsync(handler.apply(_).asInstanceOf[Future[sm.HttpResponse]],
@ -259,7 +262,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* Every materialization of the produced flow will attempt to establish a new outgoing connection.
*/
def outgoingConnection(host: String, port: Int,
localAddress: Option[InetSocketAddress],
localAddress: Optional[InetSocketAddress],
settings: ClientConnectionSettings,
log: LoggingAdapter): Flow[HttpRequest, HttpResponse, Future[OutgoingConnection]] =
Flow.fromGraph {
@ -275,14 +278,14 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* for encryption on the connection.
*/
def outgoingConnectionTls(host: String, port: Int,
localAddress: Option[InetSocketAddress],
localAddress: Optional[InetSocketAddress],
settings: ClientConnectionSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter): Flow[HttpRequest, HttpResponse, Future[OutgoingConnection]] =
Flow.fromGraph {
akka.stream.scaladsl.Flow[HttpRequest].map(_.asScala)
.viaMat(delegate.outgoingConnectionTls(host, port, localAddress.asScala, settings,
httpsContext.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log))(Keep.right)
httpsContext.asScala.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log))(Keep.right)
.mapMaterializedValue(_.map(new OutgoingConnection(_))(ec))
}
@ -336,10 +339,10 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def newHostConnectionPoolTls[T](host: String, port: Int,
settings: ConnectionPoolSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter, materializer: Materializer): Flow[Pair[HttpRequest, T], Pair[Try[HttpResponse], T], HostConnectionPool] =
adaptTupleFlow(delegate.newHostConnectionPoolTls[T](host, port, settings,
httpsContext.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log)(materializer))
httpsContext.asScala.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log)(materializer))
/**
* Starts a new connection pool to the given host and configuration and returns a [[Flow]] which dispatches
@ -414,10 +417,10 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def cachedHostConnectionPoolTls[T](host: String, port: Int,
settings: ConnectionPoolSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter, materializer: Materializer): Flow[Pair[HttpRequest, T], Pair[Try[HttpResponse], T], HostConnectionPool] =
adaptTupleFlow(delegate.cachedHostConnectionPoolTls[T](host, port, settings,
httpsContext.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log)(materializer))
httpsContext.asScala.map(_.asInstanceOf[akka.http.scaladsl.HttpsContext]), log)(materializer))
/**
* Returns a [[Flow]] which dispatches incoming HTTP requests to the per-ActorSystem pool of outgoing
@ -470,7 +473,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* object of type `T` from the application which is emitted together with the corresponding response.
*/
def superPool[T](settings: ConnectionPoolSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter, materializer: Materializer): Flow[Pair[HttpRequest, T], Pair[Try[HttpResponse], T], Unit] =
adaptTupleFlow(delegate.superPool[T](settings, httpsContext, log)(materializer))
@ -496,7 +499,7 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def singleRequest(request: HttpRequest,
settings: ConnectionPoolSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter, materializer: Materializer): Future[HttpResponse] =
delegate.singleRequest(request.asScala, settings, httpsContext, log)(materializer)
@ -545,12 +548,12 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
* The layer is not reusable and must only be materialized once.
*/
def websocketClientFlow(request: WebsocketRequest,
localAddress: Option[InetSocketAddress],
localAddress: Optional[InetSocketAddress],
settings: ClientConnectionSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter): Flow[Message, Message, Future[WebsocketUpgradeResponse]] =
adaptWsFlow {
delegate.websocketClientFlow(request.asScala, localAddress, settings, httpsContext, log)
delegate.websocketClientFlow(request.asScala, localAddress.asScala, settings, httpsContext, log)
}
/**
@ -572,16 +575,16 @@ class Http(system: ExtendedActorSystem) extends akka.actor.Extension {
*/
def singleWebsocketRequest[T](request: WebsocketRequest,
clientFlow: Flow[Message, Message, T],
localAddress: Option[InetSocketAddress],
localAddress: Optional[InetSocketAddress],
settings: ClientConnectionSettings,
httpsContext: Option[HttpsContext],
httpsContext: Optional[HttpsContext],
log: LoggingAdapter,
materializer: Materializer): Pair[Future[WebsocketUpgradeResponse], T] =
adaptWsResultTuple {
delegate.singleWebsocketRequest(
request.asScala,
adaptWsFlow[T](clientFlow),
localAddress,
localAddress.asScala,
settings,
httpsContext,
log)(materializer)

4
akka-http-core/src/main/scala/akka/http/javadsl/model/ContentType.scala
View file

@ -3,7 +3,7 @@
*/
package akka.http.javadsl.model
import akka.japi.Option
import java.util.Optional
/**
* Represents an Http content-type. A content-type consists of a media-type and an optional charset.
@ -41,5 +41,5 @@ trait ContentType {
/**
* Returns the charset if this ContentType is non-binary.
*/
def getCharsetOption: Option[HttpCharset]
def getCharsetOption: Optional[HttpCharset]
}

9
akka-http-core/src/main/scala/akka/http/javadsl/model/ws/WebsocketUpgradeResponse.scala
View file

@ -4,10 +4,11 @@
package akka.http.javadsl.model.ws
import java.util.Optional
import akka.http.javadsl.model.HttpResponse
import akka.http.scaladsl
import akka.http.scaladsl.model.ws.{ InvalidUpgradeResponse, ValidUpgrade }
import akka.japi.Option
/**
* Represents an upgrade response for a Websocket upgrade request. Can either be valid, in which
@ -26,7 +27,7 @@ trait WebsocketUpgradeResponse {
* If valid, returns `Some(subprotocol)` (if any was requested), or `None` if none was
* chosen or offered.
*/
def chosenSubprotocol: Option[String]
def chosenSubprotocol: Optional[String]
/**
* If invalid, the reason why the server's upgrade response could not be accepted.
@ -42,7 +43,7 @@ object WebsocketUpgradeResponse {
new WebsocketUpgradeResponse {
def isValid: Boolean = true
def response: HttpResponse = resp
def chosenSubprotocol: Option[String] = chosen.asJava
def chosenSubprotocol: Optional[String] = chosen.asJava
def invalidationReason: String =
throw new UnsupportedOperationException("invalidationReason must not be called for valid response")
}
@ -50,7 +51,7 @@ object WebsocketUpgradeResponse {
new WebsocketUpgradeResponse {
def isValid: Boolean = false
def response: HttpResponse = resp
def chosenSubprotocol: Option[String] = throw new UnsupportedOperationException("chosenSubprotocol must not be called for valid response")
def chosenSubprotocol: Optional[String] = throw new UnsupportedOperationException("chosenSubprotocol must not be called for valid response")
def invalidationReason: String = cause
}
}

13
akka-http-core/src/main/scala/akka/http/scaladsl/Http.scala
View file

@ -6,7 +6,7 @@ package akka.http.scaladsl
import java.net.InetSocketAddress
import java.util.concurrent.ConcurrentHashMap
import java.util.{ Collection ⇒ JCollection }
import java.util.{ Collection ⇒ JCollection, Optional }
import javax.net.ssl._
import akka.actor._
@ -21,7 +21,6 @@ import akka.http.scaladsl.model._
import akka.http.scaladsl.model.headers.Host
import akka.http.scaladsl.model.ws.{ WebsocketUpgradeResponse, WebsocketRequest, Message }
import akka.http.scaladsl.util.FastFuture
import akka.japi
import akka.stream.Materializer
import akka.stream.io._
import akka.stream.scaladsl._
@ -35,6 +34,8 @@ import scala.concurrent.{ ExecutionContext, Future, Promise, TimeoutException }
import scala.util.Try
import scala.util.control.NonFatal
import scala.compat.java8.OptionConverters._
class HttpExt(private val config: Config)(implicit val system: ActorSystem) extends akka.actor.Extension
with DefaultSSLContextCreation {
@ -723,16 +724,16 @@ final case class HttpsContext(sslContext: SSLContext,
override def getSslContext: SSLContext = sslContext
/** Java API */
override def getEnabledCipherSuites: japi.Option[JCollection[String]] = enabledCipherSuites.map(_.asJavaCollection)
override def getEnabledCipherSuites: Optional[JCollection[String]] = enabledCipherSuites.map(_.asJavaCollection).asJava
/** Java API */
override def getEnabledProtocols: japi.Option[JCollection[String]] = enabledProtocols.map(_.asJavaCollection)
override def getEnabledProtocols: Optional[JCollection[String]] = enabledProtocols.map(_.asJavaCollection).asJava
/** Java API */
override def getClientAuth: japi.Option[ClientAuth] = clientAuth
override def getClientAuth: Optional[ClientAuth] = clientAuth.asJava
/** Java API */
override def getSslParameters: japi.Option[SSLParameters] = sslParameters
override def getSslParameters: Optional[SSLParameters] = sslParameters.asJava
}
trait DefaultSSLContextCreation {

18
akka-http-core/src/main/scala/akka/http/scaladsl/model/ContentRange.scala
View file

@ -4,18 +4,20 @@
package akka.http.scaladsl.model
import java.util.{ OptionalLong, Optional }
import java.{ lang ⇒ jl }
import akka.http.impl.util.{ Rendering, ValueRenderable }
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.impl.util.JavaMapping.Implicits._
import scala.compat.java8.OptionConverters._
sealed trait ContentRange extends jm.ContentRange with ValueRenderable {
// default implementations to override
def isSatisfiable: Boolean = false
def isOther: Boolean = false
def getSatisfiableFirst: akka.japi.Option[jl.Long] = akka.japi.Option.none
def getSatisfiableLast: akka.japi.Option[jl.Long] = akka.japi.Option.none
def getOtherValue: akka.japi.Option[String] = akka.japi.Option.none
def getSatisfiableFirst: OptionalLong = OptionalLong.empty()
def getSatisfiableLast: OptionalLong = OptionalLong.empty()
def getOtherValue: Optional[String] = Optional.empty()
}
sealed trait ByteContentRange extends ContentRange {
@ -24,7 +26,7 @@ sealed trait ByteContentRange extends ContentRange {
/** Java API */
def isByteContentRange: Boolean = true
/** Java API */
def getInstanceLength: akka.japi.Option[jl.Long] = instanceLength.asJava
def getInstanceLength: OptionalLong = instanceLength.asPrimitive
}
// http://tools.ietf.org/html/rfc7233#section-4.2
@ -48,9 +50,9 @@ object ContentRange {
/** Java API */
override def isSatisfiable: Boolean = true
/** Java API */
override def getSatisfiableFirst: akka.japi.Option[jl.Long] = akka.japi.Option.some(first)
override def getSatisfiableFirst: OptionalLong = OptionalLong.of(first)
/** Java API */
override def getSatisfiableLast: akka.japi.Option[jl.Long] = akka.japi.Option.some(last)
override def getSatisfiableLast: OptionalLong = OptionalLong.of(last)
}
/**
@ -70,8 +72,8 @@ object ContentRange {
/** Java API */
def isByteContentRange = false
/** Java API */
def getInstanceLength: akka.japi.Option[jl.Long] = akka.japi.Option.none
def getInstanceLength: OptionalLong = OptionalLong.empty()
/** Java API */
override def getOtherValue: akka.japi.Option[String] = akka.japi.Option.some(value)
override def getOtherValue: Optional[String] = Optional.of(value)
}
}

4
akka-http-core/src/main/scala/akka/http/scaladsl/model/ContentType.scala
View file

@ -6,7 +6,7 @@ package akka.http.scaladsl.model
import language.implicitConversions
import akka.http.impl.util._
import akka.japi.{ Option ⇒ JOption }
import java.util.Optional
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.impl.util.JavaMapping.Implicits._
@ -49,7 +49,7 @@ sealed trait ContentType extends jm.ContentType with ValueRenderable {
private[http] def render[R <: Rendering](r: R): r.type = r ~~ mediaType
/** Java API */
def getCharsetOption: JOption[jm.HttpCharset] = charsetOption.asJava
def getCharsetOption: Optional[jm.HttpCharset] = charsetOption.asJava
}
object ContentType {

7
akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpEntity.scala
View file

@ -4,6 +4,8 @@
package akka.http.scaladsl.model
import java.util.OptionalLong
import language.implicitConversions
import java.io.File
import java.lang.{ Iterable ⇒ JIterable, Long ⇒ JLong }
@ -21,6 +23,8 @@ import akka.http.scaladsl.util.FastFuture
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.impl.util.JavaMapping.Implicits._
import scala.compat.java8.OptionConverters._
/**
* Models the entity (aka "body" or "content) of an HTTP message.
*/
@ -82,8 +86,7 @@ sealed trait HttpEntity extends jm.HttpEntity {
stream.javadsl.Source.fromGraph(dataBytes.asInstanceOf[Source[ByteString, AnyRef]])
/** Java API */
override def getContentLengthOption: japi.Option[JLong] =
japi.Option.fromScalaOption(contentLengthOption.asInstanceOf[Option[JLong]]) // Scala autoboxing
override def getContentLengthOption: OptionalLong = contentLengthOption.asPrimitive
// default implementations, should be overridden
override def isCloseDelimited: Boolean = false

9
akka-http-core/src/main/scala/akka/http/scaladsl/model/HttpMessage.scala
View file

@ -5,6 +5,7 @@
package akka.http.scaladsl.model
import java.lang.{ Iterable ⇒ JIterable }
import java.util.Optional
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{ Future, ExecutionContext }
@ -18,6 +19,8 @@ import akka.http.javadsl.{ model ⇒ jm }
import akka.http.scaladsl.util.FastFuture._
import headers._
import scala.compat.java8.OptionConverters._
/**
* Common base class of HttpRequest and HttpResponse.
*/
@ -110,11 +113,11 @@ sealed trait HttpMessage extends jm.HttpMessage {
/** Java API */
def getHeaders: JIterable[jm.HttpHeader] = (headers: immutable.Seq[jm.HttpHeader]).asJava
/** Java API */
def getHeader[T <: jm.HttpHeader](headerClass: Class[T]): akka.japi.Option[T] = header(ClassTag(headerClass))
def getHeader[T <: jm.HttpHeader](headerClass: Class[T]): Optional[T] = header(ClassTag(headerClass)).asJava
/** Java API */
def getHeader(headerName: String): akka.japi.Option[jm.HttpHeader] = {
def getHeader(headerName: String): Optional[jm.HttpHeader] = {
val lowerCased = headerName.toRootLowerCase
headers.find(_.is(lowerCased))
Util.convertOption(headers.find(_.is(lowerCased))) // Upcast because of invariance
}
/** Java API */
def addHeaders(headers: JIterable[jm.HttpHeader]): Self = mapHeaders(_ ++ headers.asScala.asInstanceOf[Iterable[HttpHeader]])

13
akka-http-core/src/main/scala/akka/http/scaladsl/model/Multipart.scala
View file

@ -5,13 +5,15 @@
package akka.http.scaladsl.model
import java.io.File
import java.util.Optional
import akka.http.impl.util.Util
import scala.collection.immutable.VectorBuilder
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.Future
import scala.collection.immutable
import scala.collection.JavaConverters._
import scala.util.{ Failure, Success, Try }
import akka.japi.{ Option ⇒ JOption }
import akka.event.{ NoLogging, LoggingAdapter }
import akka.stream.impl.ConstantFun
import akka.stream.Materializer
@ -23,6 +25,8 @@ import akka.http.impl.engine.rendering.BodyPartRenderer
import akka.http.javadsl.{ model ⇒ jm }
import FastFuture._
import scala.compat.java8.OptionConverters._
/**
* The model of multipart content for media-types `multipart/\*` (general multipart content),
* `multipart/form-data` and `multipart/byteranges`.
@ -157,14 +161,13 @@ object Multipart {
def getHeaders: java.lang.Iterable[jm.HttpHeader] = (headers: immutable.Seq[jm.HttpHeader]).asJava
/** Java API */
def getContentDispositionHeader: JOption[jm.headers.ContentDisposition] =
JOption.fromScalaOption(contentDispositionHeader)
def getContentDispositionHeader: Optional[jm.headers.ContentDisposition] = Util.convertOption(contentDispositionHeader)
/** Java API */
def getDispositionParams: java.util.Map[String, String] = dispositionParams.asJava
/** Java API */
def getDispositionType: JOption[jm.headers.ContentDispositionType] = JOption.fromScalaOption(dispositionType)
def getDispositionType: Optional[jm.headers.ContentDispositionType] = Util.convertOption(dispositionType)
/** Java API */
def toStrict(timeoutMillis: Long, materializer: Materializer): Future[_ <: jm.Multipart.BodyPart.Strict] =
@ -409,7 +412,7 @@ object Multipart {
(additionalHeaders: immutable.Seq[jm.HttpHeader]).asJava
/** Java API */
def getFilename: JOption[String] = JOption.fromScalaOption(filename)
def getFilename: Optional[String] = filename.asJava
/** Java API */
override def toStrict(timeoutMillis: Long, materializer: Materializer): Future[jm.Multipart.FormData.BodyPart.Strict] =

3
akka-http-core/src/main/scala/akka/http/scaladsl/model/RemoteAddress.scala
View file

@ -5,6 +5,7 @@
package akka.http.scaladsl.model
import java.net.{ InetSocketAddress, UnknownHostException, InetAddress }
import java.util.Optional
import akka.http.impl.util._
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.impl.util.JavaMapping.Implicits._
@ -15,7 +16,7 @@ sealed abstract class RemoteAddress extends jm.RemoteAddress with ValueRenderabl
def isUnknown: Boolean
/** Java API */
def getAddress: akka.japi.Option[InetAddress] = toOption.asJava
def getAddress: Optional[InetAddress] = toOption.asJava
/** Java API */
def getPort: Int = toIP.flatMap(_.port).getOrElse(0)

20
akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/ByteRange.scala
View file

@ -4,20 +4,20 @@
package akka.http.scaladsl.model.headers
import java.{ lang ⇒ jl }
import akka.japi.{ Option ⇒ JOption }
import java.util.OptionalLong
import akka.http.impl.util.{ Rendering, ValueRenderable }
import akka.http.javadsl.{ model ⇒ jm }
sealed abstract class ByteRange extends jm.headers.ByteRange with ValueRenderable {
/** Java API */
def getSliceFirst: JOption[jl.Long] = JOption.none
def getSliceFirst: OptionalLong = OptionalLong.empty
/** Java API */
def getSliceLast: JOption[jl.Long] = JOption.none
def getSliceLast: OptionalLong = OptionalLong.empty
/** Java API */
def getOffset: JOption[jl.Long] = JOption.none
def getOffset: OptionalLong = OptionalLong.empty
/** Java API */
def getSuffixLength: JOption[jl.Long] = JOption.none
def getSuffixLength: OptionalLong = OptionalLong.empty
/** Java API */
def isSlice: Boolean = false
@ -41,9 +41,9 @@ object ByteRange {
/** Java API */
override def isSlice: Boolean = true
/** Java API */
override def getSliceFirst: JOption[jl.Long] = JOption.some(first)
override def getSliceFirst: OptionalLong = OptionalLong.of(first)
/** Java API */
override def getSliceLast: JOption[jl.Long] = JOption.some(last)
override def getSliceLast: OptionalLong = OptionalLong.of(last)
}
final case class FromOffset(offset: Long) extends ByteRange {
@ -53,7 +53,7 @@ object ByteRange {
/** Java API */
override def isFromOffset: Boolean = true
/** Java API */
override def getOffset: JOption[jl.Long] = JOption.some(offset)
override def getOffset: OptionalLong = OptionalLong.of(offset)
}
final case class Suffix(length: Long) extends ByteRange {
@ -63,6 +63,6 @@ object ByteRange {
/** Java API */
override def isSuffix: Boolean = true
/** Java API */
override def getSuffixLength: JOption[jl.Long] = JOption.some(length)
override def getSuffixLength: OptionalLong = OptionalLong.of(length)
}
}

15
akka-http-core/src/main/scala/akka/http/scaladsl/model/headers/HttpCookie.scala
View file

@ -7,11 +7,12 @@ package akka.http.scaladsl.model.headers
import akka.http.impl.model.parser.CharacterClasses
import akka.http.javadsl.model.headers
import akka.parboiled2.CharPredicate
import akka.japi.{ Option ⇒ JOption }
import java.util.{ Optional, OptionalLong }
import akka.http.scaladsl.model.DateTime
import akka.http.impl.util._
import akka.http.javadsl.{ model ⇒ jm }
import akka.http.impl.util.JavaMapping.Implicits._
import scala.compat.java8.OptionConverters._
// see http://tools.ietf.org/html/rfc6265
// sealed abstract to prevent generation of default apply method in companion
@ -59,7 +60,7 @@ final case class HttpCookie(
httpOnly: Boolean = false,
extension: Option[String] = None) extends jm.headers.HttpCookie with ToStringRenderable {
/** Returns the name/value pair for this cookie, to be used in [[Cookiie]] headers. */
/** Returns the name/value pair for this cookie, to be used in [[Cookie]] headers. */
def pair: HttpCookiePair = HttpCookiePair(name, value)
// TODO: suppress running these requires for cookies created from our header parser
@ -84,15 +85,15 @@ final case class HttpCookie(
}
/** Java API */
def getExtension: JOption[String] = extension.asJava
def getExtension: Optional[String] = extension.asJava
/** Java API */
def getPath: JOption[String] = path.asJava
def getPath: Optional[String] = path.asJava
/** Java API */
def getDomain: JOption[String] = domain.asJava
def getDomain: Optional[String] = domain.asJava
/** Java API */
def getMaxAge: JOption[java.lang.Long] = maxAge.asJava
def getMaxAge: OptionalLong = maxAge.asPrimitive
/** Java API */
def getExpires: JOption[jm.DateTime] = expires.asJava
def getExpires: Optional[jm.DateTime] = expires.map(_.asJava).asJava
/** Java API */
def withExpires(dateTime: jm.DateTime): headers.HttpCookie = copy(expires = Some(dateTime.asScala))
/** Java API */

2
akka-http-core/src/test/java/akka/http/javadsl/model/JavaApiTestCases.java
View file

@ -26,7 +26,7 @@ public class JavaApiTestCases {
if (request.method() == HttpMethods.GET) {
Uri uri = request.getUri();
if (uri.path().equals("/hello")) {
String name = Util.getOrElse(uri.query().get("name"), "Mister X");
String name = uri.query().get("name").orElse("Mister X");
return
HttpResponse.create()

8
akka-http-core/src/test/scala/akka/http/javadsl/model/JavaApiSpec.scala
View file

@ -4,6 +4,8 @@
package akka.http.javadsl.model
import java.util.Optional
import akka.japi.Pair
import org.scalatest.{ FreeSpec, MustMatchers }
@ -53,10 +55,10 @@ class JavaApiSpec extends FreeSpec with MustMatchers {
}
"access single parameter" in {
val query = Uri.create("/abc?name=blub").query()
query.get("name") must be(akka.japi.Option.some("blub"))
query.get("age") must be(akka.japi.Option.none)
query.get("name") must be(Optional.of("blub"))
query.get("age") must be(Optional.empty())
Uri.create("/abc?name=blub&name=blib").query.get("name") must be(akka.japi.Option.some("blub"))
Uri.create("/abc?name=blub&name=blib").query.get("name") must be(Optional.of("blub"))
}
}
}

13
akka-http-core/src/test/scala/akka/http/javadsl/model/JavaApiTestCaseSpecs.scala
View file

@ -4,11 +4,13 @@
package akka.http.javadsl.model
import javax.net.ssl.SSLContext
import java.util.Optional
import javax.net.ssl.{ SSLParameters, SSLContext }
import akka.http.javadsl.model.headers.Cookie
import akka.http.scaladsl.model
import akka.http.scaladsl.model.headers.BasicHttpCredentials
import akka.stream.io.ClientAuth
import org.scalatest.{ FreeSpec, MustMatchers }
import scala.collection.immutable
@ -59,12 +61,11 @@ class JavaApiTestCaseSpecs extends FreeSpec with MustMatchers {
Uri.create("/order").query(JavaApiTestCases.addSessionId(orderId)) must be(Uri.create("/order?orderId=123&session=abcdefghijkl"))
}
"create HttpsContext" in {
import akka.japi.{ Option ⇒ JOption }
akka.http.javadsl.HttpsContext.create(SSLContext.getDefault,
JOption.none,
JOption.none,
JOption.none,
JOption.none) mustNot be(null)
Optional.empty[java.util.Collection[String]],
Optional.empty[java.util.Collection[String]],
Optional.empty[ClientAuth],
Optional.empty[SSLParameters]) mustNot be(null)
}
}
}

5
akka-http-tests/src/test/java/akka/http/javadsl/server/values/FormFieldsTest.java
View file

@ -10,10 +10,11 @@ import akka.http.javadsl.model.MediaTypes;
import akka.http.javadsl.server.RequestVal;
import akka.http.javadsl.testkit.JUnitRouteTest;
import akka.http.javadsl.testkit.TestRoute;
import akka.japi.Option;
import akka.japi.Pair;
import org.junit.Test;
import java.util.Optional;
public class FormFieldsTest extends JUnitRouteTest {
static FormField<String> stringParam = FormFields.stringValue("stringParam");
static FormField<Byte> byteParam = FormFields.byteValue("byteParam");
@ -29,7 +30,7 @@ public class FormFieldsTest extends JUnitRouteTest {
static FormField<Long> hexLongParam = FormFields.hexLongValue("hexLongParam");
static RequestVal<String> nameWithDefault = FormFields.stringValue("nameWithDefault").withDefault("John Doe");
static RequestVal<Option<Integer>> optionalIntParam = FormFields.intValue("optionalIntParam").optional();
static RequestVal<Optional<Integer>> optionalIntParam = FormFields.intValue("optionalIntParam").optional();
private Pair<String, String> param(String name, String value) {
return Pair.create(name, value);

3
akka-http-tests/src/test/java/akka/http/javadsl/server/values/ParametersTest.java
View file

@ -11,7 +11,6 @@ import akka.http.javadsl.server.RequestVal;
import akka.http.javadsl.server.RouteResult;
import akka.http.javadsl.testkit.JUnitRouteTest;
import akka.http.javadsl.testkit.TestRoute;
import akka.japi.Option;
import org.junit.Test;
import java.util.*;
@ -31,7 +30,7 @@ public class ParametersTest extends JUnitRouteTest {
static Parameter<Long> hexLongParam = Parameters.hexLongValue("hexLongParam");
static RequestVal<String> nameWithDefault = Parameters.stringValue("nameWithDefault").withDefault("John Doe");
static RequestVal<Option<Integer>> optionalIntParam = Parameters.intValue("optionalIntParam").optional();
static RequestVal<Optional<Integer>> optionalIntParam = Parameters.intValue("optionalIntParam").optional();
static RequestVal<Map<String, String>> paramMap = Parameters.asMap();
static RequestVal<Map<String, Collection<String>>> paramMultiMap = Parameters.asMultiMap();

15
akka-http/src/main/scala/akka/http/impl/server/CookieImpl.scala
View file

@ -4,26 +4,27 @@
package akka.http.impl.server
import java.util.Optional
import akka.http.javadsl.model.headers.HttpCookie
import akka.http.javadsl.server.values.Cookie
import akka.http.javadsl.server.{ Directive, Directives, RequestVal }
import akka.http.scaladsl.server.Directive1
import akka.http.scaladsl.server.directives.CookieDirectives._
import akka.japi.Option
import akka.http.impl.util.JavaMapping.Implicits._
case class CookieImpl(name: String, domain: Option[String] = None, path: Option[String] = None) extends Cookie {
def withDomain(domain: String): Cookie = copy(domain = Option.some(domain))
def withPath(path: String): Cookie = copy(path = Option.some(path))
case class CookieImpl(name: String, domain: Optional[String] = Optional.empty[String], path: Optional[String] = Optional.empty[String]) extends Cookie {
def withDomain(domain: String): Cookie = copy(domain = Optional.of(domain))
def withPath(path: String): Cookie = copy(path = Optional.of(path))
val value: RequestVal[String] =
new StandaloneExtractionImpl[String] {
def directive: Directive1[String] = cookie(name).map(_.value)
}
def optionalValue(): RequestVal[Option[String]] =
new StandaloneExtractionImpl[Option[String]] {
def directive: Directive1[Option[String]] = optionalCookie(name).map(_.map(_.value).asJava)
def optionalValue(): RequestVal[Optional[String]] =
new StandaloneExtractionImpl[Optional[String]] {
def directive: Directive1[Optional[String]] = optionalCookie(name).map(_.map(_.value).asJava)
}
def set(value: String): Directive =

17
akka-http/src/main/scala/akka/http/impl/server/FormFieldImpl.scala
View file

@ -4,16 +4,19 @@
package akka.http.impl.server
import java.util.Optional
import akka.http.javadsl.server.RequestVal
import akka.http.javadsl.server.values.FormField
import akka.http.scaladsl.common.{ StrictForm, NameUnmarshallerReceptacle, NameReceptacle }
import akka.http.scaladsl.unmarshalling._
import akka.japi.{ Option ⇒ JOption }
import scala.reflect.ClassTag
import akka.http.scaladsl.server.directives.FormFieldDirectives._
import akka.http.scaladsl.server.{ Directives, Directive1 }
import scala.compat.java8.OptionConverters._
/**
* INTERNAL API
*/
@ -27,19 +30,19 @@ private[http] class FormFieldImpl[T, U](receptacle: NameReceptacle[T])(
formField(receptacle).map(conv)
}
def optional: RequestVal[JOption[U]] =
new StandaloneExtractionImpl[JOption[U]] {
def directive: Directive1[JOption[U]] = optionalDirective
def optional: RequestVal[Optional[U]] =
new StandaloneExtractionImpl[Optional[U]] {
def directive: Directive1[Optional[U]] = optionalDirective
}
private def optionalDirective: Directive1[JOption[U]] =
private def optionalDirective: Directive1[Optional[U]] =
extractMaterializer.flatMap { implicit fm ⇒
formField(receptacle.?).map(v ⇒ JOption.fromScalaOption(v.map(conv)))
formField(receptacle.?).map(v ⇒ v.map(conv).asJava)
}
def withDefault(defaultValue: U): RequestVal[U] =
new StandaloneExtractionImpl[U] {
def directive: Directive1[U] = optionalDirective.map(_.getOrElse(defaultValue))
def directive: Directive1[U] = optionalDirective.map(_.orElse(defaultValue))
}
}
object FormFieldImpl {

17
akka-http/src/main/scala/akka/http/impl/server/ParameterImpl.scala
View file

@ -4,17 +4,20 @@
package akka.http.impl.server
import java.util.Optional
import akka.http.javadsl.server.RequestVal
import akka.http.javadsl.server.values.Parameter
import akka.http.scaladsl.common.{ NameUnmarshallerReceptacle, NameReceptacle }
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.unmarshalling._
import akka.japi.{ Option ⇒ JOption }
import scala.reflect.ClassTag
import akka.http.scaladsl.server.directives.ParameterDirectives
import akka.http.scaladsl.server.Directive1
import scala.compat.java8.OptionConverters._
/**
* INTERNAL API
*/
@ -25,19 +28,19 @@ private[http] class ParameterImpl[T, U](receptacle: NameReceptacle[T])(
import ParameterDirectives._
def directive: Directive1[U] = parameter(receptacle).map(conv)
def optional: RequestVal[JOption[U]] =
new StandaloneExtractionImpl[JOption[U]] {
def directive: Directive1[JOption[U]] = optionalDirective
def optional: RequestVal[Optional[U]] =
new StandaloneExtractionImpl[Optional[U]] {
def directive: Directive1[Optional[U]] = optionalDirective
}
private def optionalDirective: Directive1[JOption[U]] =
private def optionalDirective: Directive1[Optional[U]] =
extractMaterializer.flatMap { implicit fm ⇒
parameter(receptacle.?).map(v ⇒ JOption.fromScalaOption(v.map(conv)))
parameter(receptacle.?).map(v ⇒ v.map(conv).asJava)
}
def withDefault(defaultValue: U): RequestVal[U] =
new StandaloneExtractionImpl[U] {
def directive: Directive1[U] = optionalDirective.map(_.getOrElse(defaultValue))
def directive: Directive1[U] = optionalDirective.map(_.orElse(defaultValue))
}
}
private[http] object ParameterImpl {

7
akka-http/src/main/scala/akka/http/impl/server/PathMatcherImpl.scala
View file

@ -4,16 +4,19 @@
package akka.http.impl.server
import java.util.Optional
import akka.http.javadsl.server.values.PathMatcher
import akka.japi.Option
import scala.reflect.ClassTag
import akka.http.scaladsl.server.{ PathMatcher ⇒ ScalaPathMatcher }
import scala.compat.java8.OptionConverters
/**
* INTERNAL API
*/
private[http] class PathMatcherImpl[T: ClassTag](val matcher: ScalaPathMatcher[Tuple1[T]])
extends ExtractionImpl[T] with PathMatcher[T] {
def optional: PathMatcher[Option[T]] = new PathMatcherImpl[Option[T]](matcher.?.map(Option.fromScalaOption))
def optional: PathMatcher[Optional[T]] = new PathMatcherImpl[Optional[T]](matcher.?.map(OptionConverters.toJava))
}

12
akka-http/src/main/scala/akka/http/javadsl/server/values/Cookie.scala
View file

@ -6,27 +6,27 @@ package akka.http.javadsl.server.values
import akka.http.impl.server.{ RouteStructure, CookieImpl }
import akka.http.javadsl.server.{ Directive, RequestVal, Route }
import akka.japi.Option
import java.util.Optional
import scala.annotation.varargs
import scala.collection.immutable
import scala.compat.java8.OptionConverters._
abstract class Cookie {
def name(): String
def domain(): Option[String]
def path(): Option[String]
def domain(): Optional[String]
def path(): Optional[String]
def withDomain(domain: String): Cookie
def withPath(path: String): Cookie
def value(): RequestVal[String]
def optionalValue(): RequestVal[Option[String]]
def optionalValue(): RequestVal[Optional[String]]
def set(value: String): Directive
@varargs
def delete(innerRoute: Route, moreInnerRoutes: Route*): Route =
RouteStructure.DeleteCookie(name(), domain(), path())(innerRoute, moreInnerRoutes.toList)
RouteStructure.DeleteCookie(name(), domain().asScala, path().asScala)(innerRoute, moreInnerRoutes.toList)
}
object Cookies {
def create(name: String): Cookie = new CookieImpl(name)

4
akka-http/src/main/scala/akka/http/javadsl/server/values/FormField.scala
View file

@ -5,17 +5,17 @@
package akka.http.javadsl.server
package values
import java.util.Optional
import java.{ lang ⇒ jl }
import akka.http.impl.server.{ FormFieldImpl, Util }
import akka.http.scaladsl.unmarshalling._
import akka.japi.function.Function
import akka.japi.{ Option ⇒ JOption }
import scala.reflect.ClassTag
trait FormField[T] extends RequestVal[T] {
def optional: RequestVal[JOption[T]]
def optional: RequestVal[Optional[T]]
def withDefault(defaultValue: T): RequestVal[T]
}

5
akka-http/src/main/scala/akka/http/javadsl/server/values/Parameter.scala
View file

@ -5,7 +5,7 @@
package akka.http.javadsl.server.values
import java.util.AbstractMap.SimpleEntry
import java.util.{ Collection ⇒ JCollection, Map ⇒ JMap }
import java.util.{ Collection ⇒ JCollection, Map ⇒ JMap, Optional }
import java.{ lang ⇒ jl }
import akka.http.impl.server.{ ParameterImpl, StandaloneExtractionImpl, Util }
@ -13,7 +13,6 @@ import akka.http.javadsl.server.RequestVal
import akka.http.scaladsl.server.directives.ParameterDirectives
import akka.http.scaladsl.unmarshalling.Unmarshaller
import akka.japi.function.Function
import akka.japi.{ Option ⇒ JOption }
import scala.reflect.ClassTag
@ -21,7 +20,7 @@ import scala.reflect.ClassTag
* A RequestVal representing a query parameter of type T.
*/
trait Parameter[T] extends RequestVal[T] {
def optional: RequestVal[JOption[T]]
def optional: RequestVal[Optional[T]]
def withDefault(defaultValue: T): RequestVal[T]
}

4
akka-http/src/main/scala/akka/http/javadsl/server/values/PathMatchers.scala
View file

@ -4,13 +4,13 @@
package akka.http.javadsl.server.values
import java.util.Optional
import java.util.regex.Pattern
import java.{ lang ⇒ jl, util ⇒ ju }
import akka.http.impl.server.PathMatcherImpl
import akka.http.javadsl.server.RequestVal
import akka.http.scaladsl.server.{ PathMatcher0, PathMatcher1, PathMatchers ⇒ ScalaPathMatchers, PathMatcher ⇒ ScalaPathMatcher }
import akka.japi.Option
import akka.japi.function.Function
import scala.collection.JavaConverters._
@ -26,7 +26,7 @@ import scala.util.matching.Regex
* "consumes" a part of the path which is recorded in [[RequestContext.unmatchedPath]].
*/
trait PathMatcher[T] extends RequestVal[T] {
def optional: PathMatcher[Option[T]]
def optional: PathMatcher[Optional[T]]
}
/**

6
akka-stream/src/main/scala/akka/stream/io/SslTls.scala
View file

@ -5,6 +5,7 @@ package akka.stream.io
import java.lang.{ Integer ⇒ jInteger }
import java.security.Principal
import java.util.Optional
import akka.japi
import akka.stream._
@ -14,6 +15,7 @@ import javax.net.ssl._
import scala.annotation.varargs
import scala.collection.immutable
import java.security.cert.Certificate
import scala.compat.java8.OptionConverters
/**
* Stream cipher support based upon JSSE.
@ -106,8 +108,8 @@ object SslTls {
* The SSLEngine may use this information e.g. when an endpoint identification algorithm was
* configured using [[SSLParameters.setEndpointIdentificationAlgorithm]].
*/
def create(sslContext: SSLContext, firstSession: NegotiateNewSession, role: Role, hostInfo: japi.Option[japi.Pair[String, jInteger]], closing: Closing): JavaFlow =
new javadsl.BidiFlow(apply(sslContext, firstSession, role, closing, hostInfo.asScala.map(e ⇒ (e.first, e.second))))
def create(sslContext: SSLContext, firstSession: NegotiateNewSession, role: Role, hostInfo: Optional[japi.Pair[String, jInteger]], closing: Closing): JavaFlow =
new javadsl.BidiFlow(apply(sslContext, firstSession, role, closing, OptionConverters.toScala(hostInfo).map(e ⇒ (e.first, e.second))))
/**
* INTERNAL API.

4
akka-stream/src/main/scala/akka/stream/javadsl/Sink.scala
View file

@ -103,7 +103,7 @@ object Sink {
/**
* A `Sink` that materializes into a `Future` of the optional first value received.
* If the stream completes before signaling at least a single element, the value of the Future will be an empty [[akka.japi.Option]].
* If the stream completes before signaling at least a single element, the value of the Future will be an empty [[java.util.Optional]].
* If the stream signals an error errors before signaling at least a single element, the Future will be failed with the streams exception.
*
* See also [[head]].
@ -124,7 +124,7 @@ object Sink {
/**
* A `Sink` that materializes into a `Future` of the optional last value received.
* If the stream completes before signaling at least a single element, the value of the Future will be an empty [[akka.japi.Option]].
* If the stream completes before signaling at least a single element, the value of the Future will be an empty [[java.util.Optional]].
* If the stream signals an error errors before signaling at least a single element, the Future will be failed with the streams exception.
*
* See also [[head]].

3
project/Dependencies.scala
View file

@ -156,10 +156,11 @@ object Dependencies {
// akka stream & http
lazy val httpCore = l ++= Seq(
java8Compat,
Test.sprayJson, // for WS Autobahn test metadata
Test.junitIntf, Test.junit, Test.scalatest.value)
lazy val http = l ++= Seq()
lazy val http = l ++= Seq(java8Compat)
// special, since it also includes a compiler plugin
lazy val parsing = Seq(