Ejemplo n.º 1
0
 /**
  * Construct an enumerator. The <code>plus</code> function is derived from the <code>successor
  * </code> and <code>predecessor</code>.
  *
  * @param successor The successor function.
  * @param predecessor The predecessor function.
  * @param max The potential maximum value.
  * @param min The potential minimum value.
  * @param order The ordering for the type.
  * @return An enumerator with the given values.
  */
 public static <A> Enumerator<A> enumerator(
     final F<A, Option<A>> successor,
     final F<A, Option<A>> predecessor,
     final Option<A> max,
     final Option<A> min,
     final Ord<A> order) {
   return new Enumerator<A>(
       successor,
       predecessor,
       max,
       min,
       order,
       curry(
           (a, l) -> {
             if (l == 0L) return some(a);
             else if (l < 0L) {
               A aa = a;
               for (long x = l; x < 0; x++) {
                 final Option<A> s = predecessor.f(aa);
                 if (s.isNone()) return none();
                 else aa = s.some();
               }
               return some(aa);
             } else {
               A aa = a;
               for (long x = l; x > 0; x--) {
                 final Option<A> s = successor.f(aa);
                 if (s.isNone()) return none();
                 else aa = s.some();
               }
               return some(aa);
             }
           }));
 }
  private int sub() throws Exception {
    Array<P2<String, Option<UUID>>> parse = outvoicePaidClient.parse(outvoicePaidClient.get());

    int i = 0;
    for (P2<String, Option<UUID>> p : parse) {
      RegistrationsSqlMapper.Registration registration;
      try (Connection c = dataSource.getConnection()) {
        c.setAutoCommit(false);

        Option<UUID> apiClientRef = p._2();
        if (apiClientRef.isNone()) continue;

        Option<UUID> registrationId =
            registrationsSqlMapper.invoiceReferenceToRegistrationId(c, apiClientRef.some());
        if (registrationId.isNone()) continue;

        registration = registrationsSqlMapper.one(c, registrationId.some()).some();
      }

      if (registration.tuple.state != RegistrationState.INVOICING) continue;

      markAsPaidService.markAsPaid(registration.id);
      i++;
    }
    return i;
  }
Ejemplo n.º 3
0
  private void onEvent(NexusDao dao, HasNexusEvent e) throws SQLException {

    NexusEvent event = e.event;

    String repositoryId =
        event.guid.replaceAll(
            "^" + quote(server.url.toASCIIString()) + "/content/repositories/([-a-zA-Z0-9]*)/.*",
            "$1");

    if (repositoryId.length() == 0) {
      return;
    }

    Option<NexusRepositoryDto> r = dao.findRepository(server.uuid, repositoryId);

    if (r.isNone()) {
      return;
    }

    NexusRepositoryDto repository = r.some();

    Option<ArtifactDto> a = dao.findArtifact(repository.uuid, event.artifactId);

    UUID uuid;

    if (a.isNone()) {
      System.out.println("New artifact: " + event.artifactId);
      uuid = dao.insertArtifact(repository.uuid, event.artifactId);
    } else {
      ArtifactDto artifact = a.some();

      //            System.out.println("Updated artifact: " + event.artifactId);

      uuid = artifact.uuid;
    }

    if (e instanceof NewSnapshotEvent) {
      NewSnapshotEvent newSnapshotEvent = (NewSnapshotEvent) e;

      dao.insertNewSnapshotEvent(
          uuid,
          event.guid,
          event.creator,
          event.date,
          newSnapshotEvent.snapshotTimestamp,
          newSnapshotEvent.buildNumber,
          newSnapshotEvent.url.toASCIIString());
    } else if (e instanceof NewReleaseEvent) {
      NewReleaseEvent nre = (NewReleaseEvent) e;

      dao.insertNewReleaseEvent(
          uuid, event.guid, event.creator, event.date, nre.url.toASCIIString());
    } else {
      System.out.println("Unknown event type: " + event.getClass().getName());
    }
  }
Ejemplo n.º 4
0
  @Path("/events/{eventName}/icons/levels/{level}.png")
  @GET
  @Produces("image/png")
  public Response getLevelIcon(
      @PathParam("eventName") final String eventName, @PathParam("level") final String level) {
    OperationResult<Event> eventResult = incogito.getEventByName(eventName);

    if (!eventResult.isOk()) {
      return toJsr311(eventResult);
    }

    Option<LevelId> levelOption = some(level).bind(Level.LevelId.valueOf);

    if (!levelOption.isSome()) {
      return toJsr311(OperationResult.<Object>notFound("Level '" + level + "' not known."));
    }

    Option<File> fileOption =
        eventResult.value().levels.get(levelOption.some()).map(Level.iconFile_);

    if (!fileOption.isSome()) {
      return toJsr311(OperationResult.<Object>notFound("No icon for level '" + level + "'."));
    }

    // TODO: How about some caching here?

    Option<byte[]> bytes =
        join(
            fileOption
                .map(IO.<byte[]>runFileInputStream_().f(IO.ByteArrays.streamToByteArray))
                .map(compose(P1.<Option<byte[]>>__1(), Callables.<byte[]>option())));

    return toJsr311(fromOption(bytes, "Unable to read level file."), cacheForOneHourCacheControl);
  }
Ejemplo n.º 5
0
 /**
  * Returns <code>None</code> if this projection has no value or if the given predicate <code>p
  * </code> does not hold for the value, otherwise, returns a left in <code>Some</code>.
  *
  * @param f The predicate function to test on this projection's value.
  * @return <code>None</code> if this projection has no value or if the given predicate <code>p
  *     </code> does not hold for the value, otherwise, returns a left in <code>Some</code>.
  */
 public <X> Option<Either<X, B>> filter(final Func<B, Boolean> f) {
   return isRight()
       ? f.f(value())
           ? Option.<Either<X, B>>some(new Right<X, B>(value()))
           : Option.<Either<X, B>>none()
       : Option.<Either<X, B>>none();
 }
Ejemplo n.º 6
0
 /**
  * Returns <code>None</code> if this projection has no value or if the given predicate <code>p
  * </code> does not hold for the value, otherwise, returns a right in <code>Some</code>.
  *
  * @param f The predicate function to test on this projection's value.
  * @return <code>None</code> if this projection has no value or if the given predicate <code>p
  *     </code> does not hold for the value, otherwise, returns a right in <code>Some</code>.
  */
 public <X> Option<Either<A, X>> filter(final Func<A, Boolean> f) {
   return isLeft()
       ? f.f(value())
           ? Option.<Either<A, X>>some(new Left<A, X>(value()))
           : Option.<Either<A, X>>none()
       : Option.<Either<A, X>>none();
 }
  @POST
  @Path("/mark-as-printed")
  @Consumes(MediaType.APPLICATION_JSON)
  @Produces(MediaType.APPLICATION_JSON)
  public Response markAsPrinted(@Context HttpServletRequest request, String body) throws Exception {
    authService.guardAuthenticatedUser(request);

    int i = 0;
    for (UUID uuid : registrationListRequest(body)) {
      try (Connection c = dataSource.getConnection()) {
        registrationsSqlMapper.replacePrintedNametag(c, uuid, Option.some(new PrintedNametag()));
      }
      i++;
    }

    return Response.ok(
            ArgoUtils.format(
                Result.success(String.format("Markerade %s namnbrickor som utskrivna.", i))))
        .build();
  }
Ejemplo n.º 8
0
  @Path("/events/{eventName}/sessions/{sessionId}/session-interest")
  @POST
  public Response setSessionInterest(
      @Context final SecurityContext securityContext,
      @PathParam("eventName") final String eventName,
      @PathParam("sessionId") final String sessionId,
      String payload) {

    Option<String> userName = getUserName.f(securityContext);

    if (userName.isNone()) {
      return Response.status(Status.UNAUTHORIZED).build();
    }

    OperationResult<User> result =
        incogito.setInterestLevel(
            userName.some(), eventName, new SessionId(sessionId), InterestLevel.valueOf(payload));

    return this.<User>defaultResponsePatternMatcher()
        .add(OkOperationResult.class, this.<OperationResult<User>>created())
        .match(result);
  }
Ejemplo n.º 9
0
/**
 * Abstracts over a type that may have a successor and/or predecessor value. This implies ordering
 * for that type. A user may construct an enumerator with an optimised version for <code>plus</code>
 * , otherwise a default is implemented using the given successor/predecessor implementations.
 *
 * <p>For any enumerator e, the following laws must satisfy:
 *
 * <ul>
 *   <li>forall a. e.successor(a).forall(\t -> e.predecessor(t).forall(\z -> z == a))
 *   <li>forall a. e.predecessor(a).forall(\t -> e.successor(t).forall(\z -> z == a))
 *   <li>e.max().forall(\t -> e.successor(t).isNone)
 *   <li>e.min().forall(\t -> e.predecessor(t).isNone)
 *   <li>forall a n. e.plus(a, 0) == Some(a)
 *   <li>forall a n | n > 0. e.plus(a, n) == e.plus(a, n - 1)
 *   <li>forall a n | n < 0. e.plus(a, n) == e.plus(a, n + 1)
 * </ul>
 *
 * @version %build.number%
 */
public final class Enumerator<A> {
  private final F<A, Option<A>> successor;
  private final F<A, Option<A>> predecessor;
  private final Option<A> max;
  private final Option<A> min;
  private final Ord<A> order;
  private final F<A, F<Long, Option<A>>> plus;

  private Enumerator(
      final F<A, Option<A>> successor,
      final F<A, Option<A>> predecessor,
      final Option<A> max,
      final Option<A> min,
      final Ord<A> order,
      final F<A, F<Long, Option<A>>> plus) {
    this.successor = successor;
    this.predecessor = predecessor;
    this.max = max;
    this.min = min;
    this.order = order;
    this.plus = plus;
  }

  /**
   * Returns the potential successor of a value for this enumerator in curried form.
   *
   * @return The potential successor of a value for this enumerator in curried form.
   */
  public F<A, Option<A>> successor() {
    return successor;
  }

  /**
   * Returns the potential successor of a value for this enumerator.
   *
   * @param a The value to return the successor of.
   * @return The potential successor of a value for this enumerator.
   */
  public Option<A> successor(final A a) {
    return successor.f(a);
  }

  /**
   * Returns the potential predecessor of a value for this enumerator in curried form.
   *
   * @return The potential predecessor of a value for this enumerator in curried form.
   */
  public F<A, Option<A>> predecessor() {
    return predecessor;
  }

  /**
   * Returns the potential predecessor of a value for this enumerator.
   *
   * @param a The value to return the predecessor of.
   * @return The potential predecessor of a value for this enumerator.
   */
  public Option<A> predecessor(final A a) {
    return predecessor.f(a);
  }

  /**
   * Returns the maximum value for this enumerator if there is one.
   *
   * @return The maximum value for this enumerator if there is one.
   */
  public Option<A> max() {
    return max;
  }

  /**
   * Returns the minimum value for this enumerator if there is one.
   *
   * @return The minimum value for this enumerator if there is one.
   */
  public Option<A> min() {
    return min;
  }

  /**
   * Returns a function that moves a value along the enumerator a given number of times.
   *
   * @return A function that moves a value along the enumerator a given number of times.
   */
  public F<A, F<Long, Option<A>>> plus() {
    return plus;
  }

  /**
   * Returns a function that moves a value along the enumerator a given number of times.
   *
   * @param a The value to begin moving along from.
   * @return A function that moves a value along the enumerator a given number of times.
   */
  public F<Long, Option<A>> plus(final A a) {
    return plus.f(a);
  }

  /**
   * Returns a function that moves a value along the enumerator a given number of times.
   *
   * @param l The number of times to move along the enumerator.
   * @return A function that moves a value along the enumerator a given number of times.
   */
  public F<A, Option<A>> plus(final long l) {
    return flip(plus).f(l);
  }

  /**
   * Moves a value along the enumerator a given number of times.
   *
   * @param a The value to begin moving along from.
   * @param l The number of times to move along the enumerator.
   * @return A potential value after having moved the given number of times.
   */
  public Option<A> plus(final A a, final long l) {
    return plus.f(a).f(l);
  }

  /**
   * Returns the ordering for the enumerator.
   *
   * @return The ordering for the enumerator.
   */
  public Ord<A> order() {
    return order;
  }

  /**
   * Invariant functor map over this enumerator.
   *
   * @param f The covariant map.
   * @param g The contra-variant map.
   * @return An enumerator after the given functions are applied.
   */
  public <B> Enumerator<B> xmap(final F<A, B> f, final F<B, A> g) {
    final F<Option<A>, Option<B>> of = o -> o.map(f);
    return enumerator(
        compose(compose(of, successor), g),
        compose(compose(of, predecessor), g),
        max.map(f),
        min.map(f),
        order.contramap(g),
        compose(compose(Function.<Long, Option<A>, Option<B>>compose().f(of), plus), g));
  }

  /**
   * Returns a stream of the values from this enumerator, starting at the given value, counting up.
   *
   * @param a A value at which to begin the stream.
   * @return a stream of the values from this enumerator, starting at the given value, counting up.
   */
  public Stream<A> toStream(final A a) {
    final F<A, A> id = identity();
    return Stream.fromFunction(this, id, a);
  }

  /**
   * Create a new enumerator with the given minimum value.
   *
   * @param min A minimum value.
   * @return A new enumerator identical to this one, but with the given minimum value.
   */
  public Enumerator<A> setMin(final Option<A> min) {
    return enumerator(successor, predecessor, max, min, order, plus);
  }

  /**
   * Create a new enumerator with the given maximum value.
   *
   * @param max A maximum value.
   * @return A new enumerator identical to this one, but with the given maximum value.
   */
  public Enumerator<A> setMax(final Option<A> max) {
    return enumerator(successor, predecessor, max, min, order, plus);
  }

  /**
   * Construct an enumerator. `
   *
   * @param successor The successor function.
   * @param predecessor The predecessor function.
   * @param max The potential maximum value.
   * @param min The potential minimum value.
   * @param order The ordering for the type.
   * @param plus The function to move the enumeration a given number of times. This may be supplied
   *     for a performance enhancement for certain types.
   * @return An enumerator with the given values.
   */
  public static <A> Enumerator<A> enumerator(
      final F<A, Option<A>> successor,
      final F<A, Option<A>> predecessor,
      final Option<A> max,
      final Option<A> min,
      final Ord<A> order,
      final F<A, F<Long, Option<A>>> plus) {
    return new Enumerator<A>(successor, predecessor, max, min, order, plus);
  }

  /**
   * Construct an enumerator. The <code>plus</code> function is derived from the <code>successor
   * </code> and <code>predecessor</code>.
   *
   * @param successor The successor function.
   * @param predecessor The predecessor function.
   * @param max The potential maximum value.
   * @param min The potential minimum value.
   * @param order The ordering for the type.
   * @return An enumerator with the given values.
   */
  public static <A> Enumerator<A> enumerator(
      final F<A, Option<A>> successor,
      final F<A, Option<A>> predecessor,
      final Option<A> max,
      final Option<A> min,
      final Ord<A> order) {
    return new Enumerator<A>(
        successor,
        predecessor,
        max,
        min,
        order,
        curry(
            (a, l) -> {
              if (l == 0L) return some(a);
              else if (l < 0L) {
                A aa = a;
                for (long x = l; x < 0; x++) {
                  final Option<A> s = predecessor.f(aa);
                  if (s.isNone()) return none();
                  else aa = s.some();
                }
                return some(aa);
              } else {
                A aa = a;
                for (long x = l; x > 0; x--) {
                  final Option<A> s = successor.f(aa);
                  if (s.isNone()) return none();
                  else aa = s.some();
                }
                return some(aa);
              }
            }));
  }

  /** An enumerator for <code>boolean</code>. */
  public static final Enumerator<Boolean> booleanEnumerator =
      enumerator(
          b -> b ? Option.<Boolean>none() : some(true),
          b -> b ? some(false) : Option.<Boolean>none(),
          some(true),
          some(false),
          booleanOrd);

  /** An enumerator for <code>byte</code>. */
  public static final Enumerator<Byte> byteEnumerator =
      enumerator(
          b -> b == Byte.MAX_VALUE ? Option.<Byte>none() : some((byte) (b + 1)),
          b -> b == Byte.MIN_VALUE ? Option.<Byte>none() : some((byte) (b - 1)),
          some(Byte.MAX_VALUE),
          some(Byte.MIN_VALUE),
          byteOrd);

  /** An enumerator for <code>char</code>. */
  public static final Enumerator<Character> charEnumerator =
      enumerator(
          c -> c == Character.MAX_VALUE ? Option.<Character>none() : some((char) (c + 1)),
          c -> c == Character.MIN_VALUE ? Option.<Character>none() : some((char) (c - 1)),
          some(Character.MAX_VALUE),
          some(Character.MIN_VALUE),
          charOrd);

  /** An enumerator for <code>double</code>. */
  public static final Enumerator<Double> doubleEnumerator =
      enumerator(
          d -> d == Double.MAX_VALUE ? Option.<Double>none() : some(d + 1D),
          d -> d == Double.MIN_VALUE ? Option.<Double>none() : some(d - 1D),
          some(Double.MAX_VALUE),
          some(Double.MIN_VALUE),
          doubleOrd);

  /** An enumerator for <code>float</code>. */
  public static final Enumerator<Float> floatEnumerator =
      enumerator(
          f -> f == Float.MAX_VALUE ? Option.<Float>none() : some(f + 1F),
          f -> f == Float.MIN_VALUE ? Option.<Float>none() : some(f - 1F),
          some(Float.MAX_VALUE),
          some(Float.MIN_VALUE),
          floatOrd);

  /** An enumerator for <code>int</code>. */
  public static final Enumerator<Integer> intEnumerator =
      enumerator(
          i -> i == Integer.MAX_VALUE ? Option.<Integer>none() : some(i + 1),
          i -> i == Integer.MIN_VALUE ? Option.<Integer>none() : some(i - 1),
          some(Integer.MAX_VALUE),
          some(Integer.MIN_VALUE),
          intOrd);

  /** An enumerator for <code>BigInteger</code>. */
  public static final Enumerator<BigInteger> bigintEnumerator =
      enumerator(
          i -> some(i.add(BigInteger.ONE)),
          i -> some(i.subtract(BigInteger.ONE)),
          Option.<BigInteger>none(),
          Option.<BigInteger>none(),
          bigintOrd,
          curry((i, l) -> some(i.add(BigInteger.valueOf(l)))));

  /** An enumerator for <code>BigDecimal</code>. */
  public static final Enumerator<BigDecimal> bigdecimalEnumerator =
      enumerator(
          i -> some(i.add(BigDecimal.ONE)),
          i -> some(i.subtract(BigDecimal.ONE)),
          Option.<BigDecimal>none(),
          Option.<BigDecimal>none(),
          bigdecimalOrd,
          curry((d, l) -> some(d.add(BigDecimal.valueOf(l)))));

  /** An enumerator for <code>long</code>. */
  public static final Enumerator<Long> longEnumerator =
      enumerator(
          i -> i == Long.MAX_VALUE ? Option.<Long>none() : some(i + 1L),
          i -> i == Long.MIN_VALUE ? Option.<Long>none() : some(i - 1L),
          some(Long.MAX_VALUE),
          some(Long.MIN_VALUE),
          longOrd);

  /** An enumerator for <code>short</code>. */
  public static final Enumerator<Short> shortEnumerator =
      enumerator(
          i -> i == Short.MAX_VALUE ? Option.<Short>none() : some((short) (i + 1)),
          i -> i == Short.MIN_VALUE ? Option.<Short>none() : some((short) (i - 1)),
          some(Short.MAX_VALUE),
          some(Short.MIN_VALUE),
          shortOrd);

  /** An enumerator for <code>Ordering</code>. */
  public static final Enumerator<Ordering> orderingEnumerator =
      enumerator(
          o -> o == LT ? some(EQ) : o == EQ ? some(GT) : Option.<Ordering>none(),
          o -> o == GT ? some(EQ) : o == EQ ? some(LT) : Option.<Ordering>none(),
          some(GT),
          some(LT),
          orderingOrd);

  /** An enumerator for <code>Natural</code> */
  public static final Enumerator<Natural> naturalEnumerator =
      enumerator(
          n -> Option.some(n.succ()),
          n -> n.pred(),
          Option.<Natural>none(),
          some(Natural.ZERO),
          naturalOrd,
          curry(
              (n, l) ->
                  some(n).apply(Natural.natural(l).map(Function.curry((n1, n2) -> n1.add(n2))))));
}