Cfrtjryk

I'm trying to see if someone can come up with a better solution for this algorithm.

I have an input of three lists/queues and I have to group/sort the elements of xpn, tu, and efx — depending on the presence (or not) of UniqueKey. For instance, if UniqueKey exists, I have to try to form a list/tuple of xpn, tu, and efx (if they exists for that UniqueKey)...and so on.

This is the "main" class:

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)

public final class Request {

  private Map<String, List<Tuple3<Node, Node, Node>>> result;



  private Queue<Node> xpn;



  private Queue<Node> tu;



  private Queue<Node> efx;



  public Map<String, List<Tuple3<Node, Node, Node>>> transform() {

    final int max = estimateSize();

    result = new LinkedHashMap<>(max / 3);

    for (int i = 0; i < max; i++) {

      pollFrom(xpn).ifPresent(it -> process(it, Category.XPN));

      pollFrom(tu).ifPresent(it -> process(it, Category.TU));

      pollFrom(efx).ifPresent(it -> process(it, Category.EFX));

    }

    return Collections.unmodifiableMap(result);

  }



  private int estimateSize() {

    final int sizes = { sizeOf(xpn), sizeOf(tu), sizeOf(efx) };

    int max = sizes[0];

    for (int i = 1; i < sizes.length; i++) {

      if (sizes[i] > max) { max = sizes[i]; }

    }

    return max;

  }



  private Optional<Node> pollFrom(final Queue<Node> collection) {

    return (null != collection) ? Optional.ofNullable(collection.poll()) : Optional.empty();

  }



  private void process(final Node thiz, final Category category) {

    if (result.containsKey(thiz.getUniqueKey())) {

      final List<Tuple3<Node, Node, Node>> values = result.get(thiz.getUniqueKey());

      final Optional<Tuple3<Node, Node, Node>> optional = values.stream()

        .filter(tuple3 -> emptyBucket.apply(tuple3, category))

        .findFirst();

      if (optional.isPresent()) {

        final Tuple3<Node, Node, Node> tuple3 = optional.get();

        if (Category.XPN == category) {

          tuple3.update1(thiz);

        } else if (Category.TU == category) {

          tuple3.update2(thiz);

        } else {

          tuple3.update3(thiz);

        }

      } else {

        result.get(thiz.getUniqueKey()).add(tupleFrom(thiz, category));

      }

    } else {

      final List<Tuple3<Node, Node, Node>> list = new LinkedList<>();

      list.add(tupleFrom(thiz, category));

      result.put((null != thiz.getUniqueKey()) ? thiz.getUniqueKey() : IdGen.uuid(), list);

    }

  }



  private BiFunction<Tuple3<Node, Node, Node>, Category, Boolean> emptyBucket = (tuple, category) -> {

    if (Category.XPN == category) {

      return null == tuple._1();

    } else if (Category.TU == category) {

      return null == tuple._2();

    } else { // EFX

      return null == tuple._3();

    }

  };



  private Tuple3<Node, Node, Node> tupleFrom(final Node thiz, final Category category) {

    final Tuple3<Node, Node, Node> empty = new Tuple3<>(null, null, null);

    switch (category) {

      case XPN:

        return empty.update1(thiz);

      case TU:

        return empty.update2(thiz);

      case EFX:

        return empty.update3(thiz);

    }

    return empty;

  }



  private int sizeOf(final Collection<Node> collection) {

    return (null != collection) ? collection.size() : 0;

  }



  private enum Category {

    XPN, // 1st element in tuple

    TU,  // 2nd element in tuple

    EFX  // 3rd element in tuple

  }

}

The content of Node and Tuple3 are irrelevant, but I can post it if that may help. I'm just trying to see if there is a better way of doing this. The reason you don't see a constructor is because that class is being constructed/deserialized via Jackson. I would really like to avoid having result at class level.

PS: Don't mind about the method/variable names.

Not sure why you're making it so hard on yourself. Why not just go through each of the 3 queues individually?

For the first queue, just go through it and make a new Node for each element. Add it to your result list.

For the other 2 queues, check if the index is already in the result list. If it is, add it to that node, otherwise create a new node.