play.libs.typedmap.TypedKey java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Tabnine
}

/**
 * Creates a TypedKey without a name.
 *
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create() {
  return new TypedKey<>(TypedKey$.MODULE$.apply());
}

/**
 * Add an attribute to the request.
 *
 * @param key The key of the attribute to add.
 * @param value The value of the attribute to add.
 * @param <T> The type of the attribute to add.
 * @return the request builder with extra attribute
 */
public <T> RequestBuilder attr(TypedKey<T> key, T value) {
  req = req.addAttr(key.asScala(), value);
  return this;
}

@Override
public Object getAttribute(final String name) {
  return ofNullable(attributes.get(name))
      .orElseGet(() -> playDelegate.attrs().getOptional(TypedKey.create(name)).orElse(null));
}

  @Override
  public CompletionStage<F.Tuple<Optional<? extends Subject>, Http.RequestHeader>> apply(final DeadboltHandler deadboltHandler,
                                    final Http.RequestHeader requestHeader)
  {
    if (cacheUserPerRequestEnabled)
    {
      final TypedKey<Subject> deadboltHandlerCacheId = this.typedKeyCache.computeIfAbsent(deadboltHandler.getId(), k -> TypedKey.create("deadbolt.java.cache-user." + k));
      final Optional<? extends Subject> cachedUser = requestHeader.attrs().getOptional(deadboltHandlerCacheId);
      if (cachedUser.isPresent())
      {
        return CompletableFuture.completedFuture(F.Tuple(cachedUser, requestHeader));
      }
      else
      {
        return deadboltHandler.getSubject(requestHeader).thenApply(subjectOption -> subjectOption.map(s -> F.<Optional<? extends Subject>, Http.RequestHeader>Tuple(Optional.of(s), requestHeader.addAttr(deadboltHandlerCacheId, s))).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
      }
    }
    return deadboltHandler.getSubject(requestHeader).thenApply(subjectOption -> subjectOption.map(s -> F.<Optional<? extends Subject>, Http.RequestHeader>Tuple(Optional.of(s), requestHeader)).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
  }
}

/**
 * Creates a TypedKey with the given name.
 *
 * @param displayName The name to display when printing this key.
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create(String displayName) {
  return new TypedKey<>(TypedKey$.MODULE$.apply(displayName));
}

/**
 * Get a value from the map, throwing an exception if it is not present.
 *
 * @param key The key for the value to retrieve.
 * @param <A> The type of value to retrieve.
 * @return The value, if it is present in the map.
 * @throws java.util.NoSuchElementException If the value isn't present in the map.
 */
public <A> A get(TypedKey<A> key) {
  return underlying.apply(key.asScala());
}

  @Override
  public CompletionStage<F.Tuple<Optional<? extends Subject>, Http.RequestHeader>> apply(final DeadboltHandler deadboltHandler,
                                    final Http.RequestHeader requestHeader)
  {
    if (cacheUserPerRequestEnabled)
    {
      final TypedKey<Subject> deadboltHandlerCacheId = this.typedKeyCache.computeIfAbsent(deadboltHandler.getId(), k -> TypedKey.create("deadbolt.java.cache-user." + k));
      final Optional<? extends Subject> cachedUser = requestHeader.attrs().getOptional(deadboltHandlerCacheId);
      if (cachedUser.isPresent())
      {
        return CompletableFuture.completedFuture(F.Tuple(cachedUser, requestHeader));
      }
      else
      {
        return deadboltHandler.getSubject(requestHeader).thenApply(subjectOption -> subjectOption.map(s -> F.<Optional<? extends Subject>, Http.RequestHeader>Tuple(Optional.of(s), requestHeader.addAttr(deadboltHandlerCacheId, s))).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
      }
    }
    return deadboltHandler.getSubject(requestHeader).thenApply(subjectOption -> subjectOption.map(s -> F.<Optional<? extends Subject>, Http.RequestHeader>Tuple(Optional.of(s), requestHeader)).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
  }
}

/**
 * Creates a TypedKey with the given name.
 *
 * @param displayName The name to display when printing this key.
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create(String displayName) {
  return new TypedKey<>(TypedKey$.MODULE$.apply(displayName));
}

/**
 * Add an attribute to the request.
 *
 * @param key The key of the attribute to add.
 * @param value The value of the attribute to add.
 * @param <T> The type of the attribute to add.
 * @return the request builder with extra attribute
 */
public <T> RequestBuilder attr(TypedKey<T> key, T value) {
  req = req.addAttr(key.asScala(), value);
  return this;
}

  @Override
  public CompletionStage<F.Tuple<Optional<Result>, Http.RequestHeader>> apply(final DeadboltHandler deadboltHandler,
                                     final Http.RequestHeader requestHeader,
                                     final Optional<String> content)
  {
    final CompletionStage<Optional<Result>> promise;
    if (cacheBeforeAuthCheckPerRequestEnabled)
    {
      final TypedKey<Boolean> deadboltHandlerCacheId = this.typedKeyCache.computeIfAbsent(deadboltHandler.getId(), k -> TypedKey.create("deadbolt.java.cache-before-auth-check." + k));
      if (requestHeader.attrs().containsKey(deadboltHandlerCacheId))
      {
        return CompletableFuture.completedFuture(F.Tuple(Optional.empty(), requestHeader));
      }
      else
      {
        return deadboltHandler.beforeAuthCheck(requestHeader, content)
                     .thenApply(beforeAuthCheckOption -> beforeAuthCheckOption.map(r -> F.Tuple(Optional.of(r), requestHeader)).orElse(F.Tuple(Optional.empty(), requestHeader.addAttr(deadboltHandlerCacheId, true))));
      }
    }
    return deadboltHandler.beforeAuthCheck(requestHeader, content).thenApply(beforeAuthCheckOption -> beforeAuthCheckOption.map(r -> F.Tuple(Optional.of(r), requestHeader)).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
  }
}

/**
 * Creates a TypedKey with the given name.
 *
 * @param displayName The name to display when printing this key.
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create(String displayName) {
  return new TypedKey<>(TypedKey$.MODULE$.apply(displayName));
}

/**
 * Add an attribute to the request.
 *
 * @param key The key of the attribute to add.
 * @param value The value of the attribute to add.
 * @param <T> The type of the attribute to add.
 * @return the request builder with extra attribute
 */
public <T> RequestBuilder attr(TypedKey<T> key, T value) {
  req = req.addAttr(key.asScala(), value);
  return this;
}

  @Override
  public CompletionStage<F.Tuple<Optional<Result>, Http.RequestHeader>> apply(final DeadboltHandler deadboltHandler,
                                     final Http.RequestHeader requestHeader,
                                     final Optional<String> content)
  {
    final CompletionStage<Optional<Result>> promise;
    if (cacheBeforeAuthCheckPerRequestEnabled)
    {
      final TypedKey<Boolean> deadboltHandlerCacheId = this.typedKeyCache.computeIfAbsent(deadboltHandler.getId(), k -> TypedKey.create("deadbolt.java.cache-before-auth-check." + k));
      if (requestHeader.attrs().containsKey(deadboltHandlerCacheId))
      {
        return CompletableFuture.completedFuture(F.Tuple(Optional.empty(), requestHeader));
      }
      else
      {
        return deadboltHandler.beforeAuthCheck(requestHeader, content)
                     .thenApply(beforeAuthCheckOption -> beforeAuthCheckOption.map(r -> F.Tuple(Optional.of(r), requestHeader)).orElse(F.Tuple(Optional.empty(), requestHeader.addAttr(deadboltHandlerCacheId, true))));
      }
    }
    return deadboltHandler.beforeAuthCheck(requestHeader, content).thenApply(beforeAuthCheckOption -> beforeAuthCheckOption.map(r -> F.Tuple(Optional.of(r), requestHeader)).orElseGet(() -> F.Tuple(Optional.empty(), requestHeader)));
  }
}

/**
 * Creates a TypedKey without a name.
 *
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create() {
  return new TypedKey<>(TypedKey$.MODULE$.apply());
}

/**
 * Check if the map contains a value with the given key.
 *
 * @param key The key to check for.
 * @return True if the value is present, false otherwise.
 */
public boolean containsKey(TypedKey<?> key) {
  return underlying.contains(key.asScala());
}

/**
 * Creates a TypedKey without a name.
 *
 * @param <A> The type of value this key is associated with.
 * @return A fresh key.
 */
public static <A> TypedKey<A> create() {
  return new TypedKey<>(TypedKey$.MODULE$.apply());
}

/**
 * Check if the map contains a value with the given key.
 *
 * @param key The key to check for.
 * @return True if the value is present, false otherwise.
 */
public boolean containsKey(TypedKey<?> key) {
  return underlying.contains(key.asScala());
}

/**
 * @param id the id to be used
 * @return the builder instance
 */
public RequestBuilder id(Long id) {
  attr(new TypedKey<>(RequestAttrKey.Id()), id);
  return this;
}

/**
 * Get a value from the map, throwing an exception if it is not present.
 *
 * @param key The key for the value to retrieve.
 * @param <A> The type of value to retrieve.
 * @return The value, if it is present in the map.
 * @throws java.util.NoSuchElementException If the value isn't present in the map.
 */
public <A> A get(TypedKey<A> key) {
  return underlying.apply(key.asScala());
}

/**
 * @param id the id to be used
 * @return the builder instance
 */
public RequestBuilder id(Long id) {
  attr(new TypedKey<>(RequestAttrKey.Id()), id);
  return this;
}

Javadoc

A TypedKey is a key that can be used to get and set values in a TypedMap or any object with typed keys. This class uses reference equality for comparisons, so each new instance is different key.

Most used methods

<init>
asScala
create
Creates a TypedKey with the given name.

Popular in Java

Making http post requests using okhttp
onCreateOptionsMenu (Activity)
requestLocationUpdates (LocationManager)
scheduleAtFixedRate (Timer)
FlowLayout (java.awt)
A flow layout arranges components in a left-to-right flow, much like lines of text in a paragraph. F
ConnectException (java.net)
A ConnectException is thrown if a connection cannot be established to a remote host on a specific po
URLEncoder (java.net)
This class is used to encode a string using the format required by application/x-www-form-urlencoded
Executors (java.util.concurrent)
Factory and utility methods for Executor, ExecutorService, ScheduledExecutorService, ThreadFactory,
JarFile (java.util.jar)
JarFile is used to read jar entries and their associated data from jar files.
XPath (javax.xml.xpath)
XPath provides access to the XPath evaluation environment and expressions. Evaluation of XPath Expr

How to useTypedKey in play.libs.typedmap

Best Java code snippets using play.libs.typedmap.TypedKey (Showing top 20 results out of 315)

How to use
TypedKey
in
play.libs.typedmap