Example #1
1
  /**
   * reads all methods by the action-annotations for building agent-actions
   *
   * @param p_class class
   * @param p_root root class
   * @return stream of all methods with inheritance
   */
  private static Stream<Method> methods(final Class<?> p_class, final Class<?> p_root) {
    final Pair<Boolean, IAgentAction.EAccess> l_classannotation = CCommon.isActionClass(p_class);
    if (!l_classannotation.getLeft())
      return p_class.getSuperclass() == null
          ? Stream.of()
          : methods(p_class.getSuperclass(), p_root);

    final Predicate<Method> l_filter =
        IAgentAction.EAccess.WHITELIST.equals(l_classannotation.getRight())
            ? i -> !CCommon.isActionFiltered(i, p_root)
            : i -> CCommon.isActionFiltered(i, p_root);

    return Stream.concat(
        Arrays.stream(p_class.getDeclaredMethods())
            .parallel()
            .map(
                i -> {
                  i.setAccessible(true);
                  return i;
                })
            .filter(i -> !Modifier.isAbstract(i.getModifiers()))
            .filter(i -> !Modifier.isInterface(i.getModifiers()))
            .filter(i -> !Modifier.isNative(i.getModifiers()))
            .filter(i -> !Modifier.isStatic(i.getModifiers()))
            .filter(l_filter),
        methods(p_class.getSuperclass(), p_root));
  }
  public static Assignment addHint(Assignment assignment, Hint hint) {

    assignment.setHints(
        Stream.concat(assignment.getHints().stream(), Stream.of(hint)).collect(toList()));

    return assignment;
  }
 private static Map<String, Method> addMethods(
     Map<String, Method> methods, Class<?> clazz, Predicate<Method> filter) {
   requireNonNull(methods);
   requireNonNull(filter);
   // clazz nullable (why?)
   if (clazz == Object.class) {
     return methods;
   }
   if (clazz == null) {
     return methods;
   }
   Stream.of(clazz.getDeclaredMethods())
       .filter(filter)
       .forEach(
           m -> {
             methods.putIfAbsent(m.getName(), m); // Put only the most recent
             // concrete version of the
             // method
           });
   addMethods(methods, clazz.getSuperclass(), filter); // Recursively add
   // the superclass
   // methods
   Stream.of(clazz.getInterfaces())
       .forEach(
           i -> {
             addMethods(methods, i, filter); // Recursively add the extended
             // interfaces (because they can
             // contain default methods)
           });
   return methods;
 }
 @Override
 protected BackEndDataProvider<StrBean, SerializablePredicate<StrBean>> createDataProvider() {
   return dataProvider =
       new BackEndDataProvider<>(
           query -> {
             Stream<StrBean> stream =
                 data.stream().filter(t -> query.getFilter().orElse(s -> true).test(t));
             if (!query.getSortOrders().isEmpty()) {
               Comparator<StrBean> sorting =
                   query
                       .getSortOrders()
                       .stream()
                       .map(this::getComparator)
                       .reduce((c1, c2) -> c1.thenComparing(c2))
                       .get();
               stream = stream.sorted(sorting);
             }
             List<StrBean> list =
                 stream
                     .skip(query.getOffset())
                     .limit(query.getLimit())
                     .collect(Collectors.toList());
             list.forEach(s -> System.err.println(s.toString()));
             return list.stream();
           },
           query ->
               (int)
                   data.stream().filter(t -> query.getFilter().orElse(s -> true).test(t)).count());
 }
Example #5
0
  public void mainCollectorExample() {
    Stream songsStream = getSongStream().map(s -> s.toUpperCase());
    System.out.println(songsStream.count());

    Set<String> setSongs = getSongStream().filter(s -> s.startsWith("it")).collect(toSet());
    System.out.println("Set count:" + setSongs.size());
    songsStream.close();

    int sum = getSongStream().mapToInt(song -> song.toString().length()).sum();
    System.out.println("sum is :" + sum);

    // lets understand the difference between lazy and eager evaluation
    getSongStream()
        .filter(
            song -> {
              System.out.println("coming song in lazy:" + song);
              return song.startsWith("al");
            });

    getSongStream()
        .filter(
            song -> {
              System.out.println("coming song in eager:" + song);
              return song.startsWith("al");
            })
        .count();

    Stream<String> letters = Stream.of("b", "c", "d", null).filter(letter -> letter.isEmpty());

    // Optional<String> firstLetter = Optional.of(letters.findFirst());

  }
Example #6
0
  @Test
  public void testFunctions() {
    final AtomicLong lf = new AtomicLong(10L);
    Assert.assertEquals(Anoa.of(10L), handler.function(lf::getAndAdd).apply(handler.of(1L)));
    Assert.assertEquals(11L, lf.get());
    Assert.assertEquals(
        Anoa.empty(Stream.of(Meta.OTHER)),
        handler
            .functionChecked(
                __ -> {
                  throw new IOException();
                })
            .apply(handler.of(1L)));

    final AtomicLong lf2 = new AtomicLong(10L);
    Assert.assertEquals(
        Anoa.of(10L),
        handler.biFunction((Long x, Long y) -> lf2.getAndAdd(x + y)).apply(Anoa.of(1L), 1L));
    Assert.assertEquals(12L, lf2.get());

    Assert.assertEquals(
        Anoa.empty(Stream.of(Meta.OTHER)),
        handler
            .biFunctionChecked(
                (_1, _2) -> {
                  throw new IOException();
                })
            .apply(Anoa.of(1L), 1L));
  }
Example #7
0
 public void testConstructException() {
   try (Stream<String> s = Files.lines(testFolder.resolve("notExist"), Charset.forName("UTF-8"))) {
     s.forEach(l -> fail("File is not even exist!"));
   } catch (IOException ioe) {
     assertTrue(ioe instanceof NoSuchFileException);
   }
 }
Example #8
0
 /**
  * Returns whether the given {@link IntArrayND} equals the given object
  *
  * @param array The array
  * @param object The object
  * @return Whether the array equals the object
  */
 static boolean equals(IntArrayND array, Object object) {
   if (array == object) {
     return true;
   }
   if (object == null) {
     return false;
   }
   if (!(object instanceof IntArrayND)) {
     return false;
   }
   IntArrayND other = (IntArrayND) object;
   if (!array.getSize().equals(other.getSize())) {
     return false;
   }
   Stream<MutableIntTuple> coordinates =
       Coordinates.coordinates(array.getPreferredIterationOrder(), array.getSize());
   Iterable<MutableIntTuple> iterable = () -> coordinates.iterator();
   for (IntTuple coordinate : iterable) {
     int arrayValue = array.get(coordinate);
     int otherValue = other.get(coordinate);
     if (arrayValue != otherValue) {
       return false;
     }
   }
   return true;
 }
Example #9
0
 public static void main(String[] args) {
   Personne[] tab = {
     new Personne("thibault", "Rougier", 2001),
     new Personne("thomas", "Niesseron", 1987),
     new Personne("thifaine", "Mitenne", 1959),
     new Personne("maxime", "Forest", 1995),
     new Personne("jules", "Forest", 1995)
   };
   System.out.println("--- Nes apres 1985 : ");
   Stream.of(tab)
       .filter(pp -> pp.getAnnee() > 1985)
       .forEach(pp -> System.out.print(pp.getPrenom() + ", "));
   System.out.println("\n--- Nes avant 2000 :");
   long nombre =
       Stream.of(tab)
           .filter(pp -> pp.getAnnee() < 2000)
           .sorted(Comparator.comparing(Personne::getNom))
           .peek(pp -> System.out.print(pp.getNom() + " "))
           .count();
   System.out.println("\n       Ils sont " + nombre);
   System.out.println("--- Tous tries sur nom + prenom : ");
   Stream.of(tab)
       .sorted(Comparator.comparing(pp -> pp.getNom() + pp.getPrenom()))
       .forEach(pp -> System.out.print("(" + pp.getNom() + ", " + pp.getPrenom() + ") "));
 }
Example #10
0
 public void filterFile() {
   try (Stream<String> lines =
       Files.lines(Paths.get(INPUT_FILE_NAME), Charset.forName("ISO-8859-1"))) {
     lines
         .skip(startLine)
         .filter(
             line -> {
               Matcher m = PATTERN.matcher(line);
               return m.matches();
             })
         .map(
             line -> {
               Matcher m = PATTERN.matcher(line);
               m.matches();
               return m.group(1);
             })
         .filter(
             system -> {
               if (system.equals(currentSystem)) {
                 return false;
               } else {
                 currentSystem = system;
                 return true;
               }
             })
         .map(system -> "jumped to " + system)
         .forEach(System.out::println);
   } catch (IOException ioe) {
     System.out.println(ioe.toString());
   }
 }
 private static Stream<ElmReference> getReferencesFromSingleId(ElmUpperCaseId element) {
   if (ElmCoreLibrary.isBuiltIn(element.getText())) {
     return Stream.empty();
   } else {
     return Stream.of(new ElmTypeReference(element));
   }
 }
Example #12
0
 @SuppressWarnings("unchecked")
 private static <T> T instantiate(
     Class<T> clazz, List<Class<?>> matchingClasses, Object... preInstancedDependencies) {
   try {
     logger.info("Creating instance of: " + clazz);
     Constructor<?> clazzConstructor = Stream.of(clazz.getConstructors()).findFirst().get();
     Class<?>[] parameterTypes = clazzConstructor.getParameterTypes();
     if (parameterTypes.length > 0) {
       Object[] paramInstances =
           Stream.of(parameterTypes)
               .map(
                   paramType ->
                       Stream.of(preInstancedDependencies)
                           .filter(obj -> paramType.isInstance(obj))
                           .findFirst()
                           .orElseGet(
                               () ->
                                   instantiate(
                                       paramType, matchingClasses, preInstancedDependencies)))
               .toArray();
       return (T) clazzConstructor.newInstance(paramInstances);
     } else {
       return clazz.newInstance();
     }
   } catch (Exception e) {
     throw new RuntimeException(e);
   }
 }
 /**
  * @param collector to perform aggregation / reduction operation on the results from active stage
  *     (e.g. to Collect into a List or String)
  * @param fn Function that receives the results of all currently active tasks as input
  * @return A new builder object that can be used to define the next stage in the dataflow
  */
 @SuppressWarnings({"unchecked", "rawtypes"})
 default <T, R> SimpleReactStream<R> allOf(final Collector collector, final Function<T, R> fn) {
   CompletableFuture[] array = lastActiveArray(getLastActive());
   CompletableFuture cf = CompletableFuture.allOf(array);
   Function<Exception, T> f =
       (Exception e) -> {
         BlockingStreamHelper.capture(e, getErrorHandler());
         return BlockingStreamHelper.block(
             this, Collectors.toList(), new StreamWrapper(Stream.of(array), true));
       };
   CompletableFuture onFail = cf.exceptionally(f);
   CompletableFuture onSuccess =
       onFail.thenApplyAsync(
           (result) -> {
             return new StageWithResults(this.getTaskExecutor(), null, result)
                 .submit(
                     () ->
                         (R)
                             fn.apply(
                                 BlockingStreamHelper.aggregateResults(
                                     collector,
                                     Stream.of(array).collect(Collectors.toList()),
                                     getErrorHandler())));
           },
           getTaskExecutor());
   return (SimpleReactStream<R>) withLastActive(new StreamWrapper(onSuccess, isEager()));
 }
Example #14
0
  @Test
  public void reduce() {
    IntStream stream = IntStream.of(1, 2, 3, 4);

    assertEquals(10, stream.reduce(0, (a, b) -> a + b));

    Stream<Integer> stream2 = Arrays.asList(1, 2, 3, 4).stream();

    stream2.reduce(0, (a, b) -> a + b);

    // obviously the operations can be more complex :)

    Stream<Integer> stream3 = Arrays.asList(1, 2, 3, 4).stream();

    // reduce is a superset of map :D
    System.err.println(
        stream3.reduce(
            new ArrayList<Integer>(),
            (List<Integer> a, Integer b) -> {
              a.add(b);
              return a;
            },
            (a, b) -> {
              List<Integer> c = new ArrayList<>(a);
              c.addAll(b);
              return c;
            }));
  }
Example #15
0
 /**
  * Given a list, this method will generate all combinations of multiset of this list. Example :
  *
  * <pre>combinationsMultiset(Arrays.asList("a", "c", "q"))</pre>
  *
  * <pre>
  * [a, c, q]
  * [c, q]
  * [a, q]
  * [a, c]
  * [q]
  * [c]
  * [a]
  * []
  * </pre>
  *
  * @param l The list.
  * @return All combination of multiset of the given list.
  */
 private static <E> Stream<List<E>> combinationsMultiset(List<E> l) {
   if (l.isEmpty()) {
     return Stream.of(Collections.emptyList());
   }
   return combinationsMultiset(l.subList(1, l.size()))
       .flatMap(t -> Stream.of(t, pipe(l.get(0), t)));
 }
  public void example() {
    System.out.println(
        Stream.of(IntStream.of(1), IntStream.of(2)).flatMapToInt((IntStream s) -> s).sum());

    // unchanged, it's not using the varargs overload
    System.out.println(Stream.of(IntStream.of(1)).flatMap(s -> s.boxed()).mapToInt(i -> i).sum());
  }
Example #17
0
  /**
   * Lit le fichier d'une grille de jeu, et en renvoie la matrix des éléments, composée de :
   *
   * <ul>
   *   <li><code>NotEmptyElement</code> si le nombre est compris entre [1, 9]
   *   <li><code>EmptyElement</code> sinon
   * </ul>
   *
   * . <br>
   * <i>Attention : cette méthode est redéfinie dans GridParsed, pour son cas d'utilisation
   * particulier de gestion des éléments plaçables</i>.
   *
   * @param path le chemin vers la grille de jeu
   * @return la matrix d'éléments correspondante
   * @see guillaume.sudotris.metier.grid.GridParsed#initFromFile(Path)
   */
  public static Element[][] parseFileToMatrix(Path path) {
    final Element[][] matrix = new Element[Sudotris.LINES][Sudotris.COLUMNS];

    try (Stream<String> lines = Files.lines(path)) {
      final byte[] lineIndex = {0};
      final byte[] columnIndex = {0};

      lines.forEach(
          line -> {
            line.replaceAll("\\s+", "")
                .chars()
                .forEach(
                    letter -> {
                      final Integer value = Character.getNumericValue(letter);
                      if (value >= 1 && value <= 9) {
                        matrix[lineIndex[0]][columnIndex[0]] =
                            new NotEmptyElement(lineIndex[0], columnIndex[0], value);
                      } else {
                        matrix[lineIndex[0]][columnIndex[0]] =
                            new EmptyElement(lineIndex[0], columnIndex[0]);
                      }

                      columnIndex[0]++;
                    });

            columnIndex[0] = 0;
            lineIndex[0]++;
          });
      lines.close();
    } catch (IOException e) {
      e.printStackTrace();
    }

    return matrix;
  }
  @Override
  public Iterator<Edge> edges(final Object... edgeIds) {
    try {
      if (0 == edgeIds.length) {
        return new HadoopEdgeIterator(this);
      } else {
        // base the conversion function on the first item in the id list as the expectation is that
        // these
        // id values will be a uniform list
        if (edgeIds[0] instanceof Edge) {
          // based on the first item assume all Edges in the argument list
          if (!Stream.of(edgeIds).allMatch(id -> id instanceof Edge))
            throw Graph.Exceptions.idArgsMustBeEitherIdOrElement();

          // no need to get the vertices again, so just flip it back - some implementation may want
          // to treat this
          // as a refresh operation. that's not necessary for hadoopgraph.
          return Stream.of(edgeIds).map(id -> (Edge) id).iterator();
        } else {
          final Class<?> firstClass = edgeIds[0].getClass();
          if (!Stream.of(edgeIds).map(Object::getClass).allMatch(firstClass::equals))
            throw Graph.Exceptions
                .idArgsMustBeEitherIdOrElement(); // todo: change exception to be ids of the same
                                                  // type
          return IteratorUtils.filter(
              new HadoopEdgeIterator(this), vertex -> ElementHelper.idExists(vertex.id(), edgeIds));
        }
      }
    } catch (final IOException e) {
      throw new IllegalStateException(e.getMessage(), e);
    }
  }
Example #19
0
 private void validateFileSystemLoopException(Path start, Path... causes) {
   try (Stream<Path> s = Files.walk(start, FileVisitOption.FOLLOW_LINKS)) {
     try {
       int count = s.mapToInt(p -> 1).reduce(0, Integer::sum);
       fail("Should got FileSystemLoopException, but got " + count + "elements.");
     } catch (UncheckedIOException uioe) {
       IOException ioe = uioe.getCause();
       if (ioe instanceof FileSystemLoopException) {
         FileSystemLoopException fsle = (FileSystemLoopException) ioe;
         boolean match = false;
         for (Path cause : causes) {
           if (fsle.getFile().equals(cause.toString())) {
             match = true;
             break;
           }
         }
         assertTrue(match);
       } else {
         fail("Unexpected UncheckedIOException cause " + ioe.toString());
       }
     }
   } catch (IOException ex) {
     fail("Unexpected IOException " + ex);
   }
 }
Example #20
0
  // stream has already been operated upon or closed
  @Test(expected = IllegalStateException.class)
  public void test7() {
    Stream<String> stream = stringCollection.stream().filter(s -> s.startsWith("a"));

    stream.anyMatch(s -> true);
    stream.noneMatch(s -> true);
  }
Example #21
0
  @Test
  public void testConsumers() {
    final AtomicLong lc = new AtomicLong(0L);
    Assert.assertEquals(Anoa.of(1L), handler.consumer(lc::addAndGet).apply(handler.of(1L)));
    Assert.assertEquals(1L, lc.get());
    Assert.assertEquals(
        Anoa.empty(Stream.of(Meta.OTHER)),
        handler
            .consumerChecked(
                __ -> {
                  throw new IOException();
                })
            .apply(handler.of(1L)));

    final AtomicLong lc2 = new AtomicLong(0L);
    Assert.assertEquals(
        Anoa.of(1L),
        handler.biConsumer((Long x, Long y) -> lc2.addAndGet(x + y)).apply(Anoa.of(1L), 1L));
    Assert.assertEquals(2L, lc2.get());

    Assert.assertEquals(
        Anoa.empty(Stream.of(Meta.OTHER)),
        handler
            .biConsumerChecked(
                (_1, _2) -> {
                  throw new IOException();
                })
            .apply(Anoa.of(1L), 1L));
  }
Example #22
0
 protected OptionalEntity<FileConfig> getFileConfig(final CreateForm form) {
   final String username = systemHelper.getUsername();
   final long currentTime = systemHelper.getCurrentTimeAsLong();
   return getEntity(form, username, currentTime)
       .map(
           entity -> {
             entity.setUpdatedBy(username);
             entity.setUpdatedTime(currentTime);
             copyBeanToBean(
                 form,
                 entity,
                 op ->
                     op.exclude(
                         Stream.concat(
                                 Stream.of(Constants.COMMON_CONVERSION_RULE),
                                 Stream.of(Constants.PERMISSIONS))
                             .toArray(n -> new String[n])));
             final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
             entity.setPermissions(
                 split(form.permissions, "\n")
                     .get(
                         stream ->
                             stream
                                 .map(s -> permissionHelper.encode(s))
                                 .filter(StringUtil::isNotBlank)
                                 .distinct()
                                 .toArray(n -> new String[n])));
             return entity;
           });
 }
Example #23
0
 public List<GameObject> getGameObjectsInRange(
     Vector2f pos, int width, int height, Collection<GameObject> list) {
   Rectangle range = new Rectangle(pos.x, pos.y, width, height);
   Stream<GameObject> filter =
       list.stream().filter(e -> range.contains(e.getPos().x, e.getPos().y));
   return filter.collect(Collectors.toList());
 }
Example #24
0
 public static List<Path> listDir(Path dir) throws IOException {
   List<Path> contents = new LinkedList<>();
   try (Stream<Path> list = Files.list(dir)) {
     list.forEach(contents::add);
   }
   return contents;
 }
Example #25
0
  private void afterDeploymentValidation(
      @Observes AfterDeploymentValidation adv, BeanManager manager) {
    Collection<CamelContext> contexts = new ArrayList<>();
    for (Bean<?> context : manager.getBeans(CamelContext.class, ANY)) {
      contexts.add(getReference(manager, CamelContext.class, context));
    }

    // Add type converters to Camel contexts
    CdiTypeConverterLoader loader = new CdiTypeConverterLoader();
    for (Class<?> converter : converters) {
      for (CamelContext context : contexts) {
        loader.loadConverterMethods(context.getTypeConverterRegistry(), converter);
      }
    }

    // Add routes to Camel contexts
    boolean deploymentException = false;
    Set<Bean<?>> routes = new HashSet<>(manager.getBeans(RoutesBuilder.class, ANY));
    routes.addAll(manager.getBeans(RouteContainer.class, ANY));
    for (Bean<?> context : manager.getBeans(CamelContext.class, ANY)) {
      for (Bean<?> route : routes) {
        Set<Annotation> qualifiers = new HashSet<>(context.getQualifiers());
        qualifiers.retainAll(route.getQualifiers());
        if (qualifiers.size() > 1) {
          deploymentException |= !addRouteToContext(route, context, manager, adv);
        }
      }
    }
    // Let's return to avoid starting misconfigured contexts
    if (deploymentException) {
      return;
    }

    // Trigger eager beans instantiation (calling toString is necessary to force
    // the initialization of normal-scoped beans).
    // FIXME: This does not work with OpenWebBeans for bean whose bean type is an
    // interface as the Object methods does not get forwarded to the bean instances!
    eagerBeans.forEach(type -> getReferencesByType(manager, type.getJavaClass(), ANY).toString());
    manager
        .getBeans(Object.class, ANY, STARTUP)
        .stream()
        .forEach(bean -> getReference(manager, bean.getBeanClass(), bean).toString());

    // Start Camel contexts
    for (CamelContext context : contexts) {
      if (ServiceStatus.Started.equals(context.getStatus())) {
        continue;
      }
      logger.info("Camel CDI is starting Camel context [{}]", context.getName());
      try {
        context.start();
      } catch (Exception exception) {
        adv.addDeploymentProblem(exception);
      }
    }

    // Clean-up
    Stream.of(converters, camelBeans, eagerBeans, cdiBeans).forEach(Set::clear);
    Stream.of(producerBeans, producerQualifiers).forEach(Map::clear);
  }
Example #26
0
  private static Stream<String> apps() {
    if (cl instanceof URLClassLoader) {
      URLClassLoader ucl = (URLClassLoader) cl;

      return Stream.of(ucl.getURLs())
          .map(propagating(url -> Paths.get(url.toURI())))
          .flatMap(
              propagating(
                  path -> {
                    if (Files.isRegularFile(path)) {
                      return zipContents(path);
                    } else if (Files.isDirectory(path)) {
                      return Files.walk(path)
                          .map(subpath -> path.relativize(subpath))
                          .map(subpath -> subpath.toString())
                          .filter(subpath -> subpath.endsWith(".class"))
                          .map(Scanner::toClassName);
                    } else {
                      return Stream.empty();
                    }
                  }))
          .filter(x -> !x.startsWith("com.cakemanny.app."))
          .filter(implementsInterface(App.class));
    } else {
      return Stream.empty();
    }
  }
  @Test
  public void testFirstLast() {
    Supplier<Stream<Integer>> s = () -> IntStreamEx.range(1000).boxed();
    checkShortCircuitCollector("first", Optional.of(0), 1, s, MoreCollectors.first());
    checkShortCircuitCollector(
        "firstLong",
        Optional.of(0),
        1,
        () -> Stream.of(1).flatMap(x -> IntStream.range(0, 1000000000).boxed()),
        MoreCollectors.first(),
        true);
    checkShortCircuitCollector(
        "first",
        Optional.of(1),
        1,
        () -> Stream.iterate(1, x -> x + 1),
        MoreCollectors.first(),
        true);
    assertEquals(
        1, (int) StreamEx.iterate(1, x -> x + 1).parallel().collect(MoreCollectors.first()).get());

    checkCollector("last", Optional.of(999), s, MoreCollectors.last());
    checkCollectorEmpty("first", Optional.empty(), MoreCollectors.first());
    checkCollectorEmpty("last", Optional.empty(), MoreCollectors.last());
  }
  /** {@inheritDoc} */
  @Override
  public void runLearning() {

    this.initLearning();

    efBayesianNetwork = new EF_BayesianNetwork(dag);

    Stream<DataInstance> stream = null;
    if (parallelMode) {
      stream = dataStream.parallelStream(batchSize);
    } else {
      stream = dataStream.stream();
    }

    dataInstanceCount = new AtomicDouble(0);

    sumSS =
        stream
            .peek(
                w -> {
                  dataInstanceCount.getAndAdd(1.0);
                })
            .map(efBayesianNetwork::getSufficientStatistics)
            .reduce(
                efBayesianNetwork.createZeroSufficientStatistics(),
                SufficientStatistics::sumVector);
  }
Example #29
0
 public Boolean isCollectorFullBase() throws BotException {
   final int[] attackableElixirs = {0};
   final BufferedImage image = platform.screenshot(ENEMY_BASE);
   try {
     final URI uri = getClass().getResource("elixirs").toURI();
     Utils.withClasspathFolder(
         uri,
         (path) -> {
           final List<Rectangle> matchedElixirs = new ArrayList<>();
           try (Stream<Path> walk = Files.walk(path, 1)) {
             for (final Iterator<Path> it = walk.iterator(); it.hasNext(); ) {
               final Path next = it.next();
               if (Files.isDirectory(next)) {
                 continue;
               }
               final BufferedImage tar =
                   ImageIO.read(Files.newInputStream(next, StandardOpenOption.READ));
               final List<RegionMatch> doFindAll =
                   TemplateMatcher.findMatchesByGrayscaleAtOriginalResolution(image, tar, 7, 0.8);
               attackableElixirs[0] += countAttackableElixirs(doFindAll, matchedElixirs, next);
             }
           } catch (final IOException e) {
             logger.log(Level.SEVERE, e.getMessage(), e);
           }
         });
   } catch (final URISyntaxException e) {
     logger.log(Level.SEVERE, e.getMessage(), e);
   }
   return attackableElixirs[0] >= 0;
 }
  @SuppressWarnings({"unchecked", "rawtypes"})
  @Override
  public Stream<?> doApply(List<Stream<?>> streamsList) {

    AtomicInteger ctr = new AtomicInteger(2);

    Stream<?> unionizedStream =
        streamsList
            .stream()
            .reduce(
                (lStream, rStream) -> {
                  Stream<?> newStream = Stream.concat(lStream, rStream);
                  int currentStreamIdx = ctr.getAndIncrement();
                  for (int j = 0; j < checkPointProcedures.size(); j++) {
                    Tuple2<Integer, Object> postProc = checkPointProcedures.get(j);
                    if ((Integer) postProc._1() == currentStreamIdx) {
                      SerFunction f = (SerFunction) postProc._2();
                      if (f != null) {
                        newStream = (Stream) f.apply(newStream);
                      }
                    }
                  }
                  return newStream;
                })
            .get();

    if (this.distinct) {
      unionizedStream = unionizedStream.distinct();
    }

    return unionizedStream;
  }