@Override
  @SuppressWarnings("ConstantConditions")
  protected void doVisitField(
      @Nullable VariableElement oldField, @Nullable VariableElement newField) {
    if (!shouldCheck(oldField, newField)) {
      return;
    }

    Predicate<VariableElement> isNotEnumConstant = v -> v.getKind() != ElementKind.ENUM_CONSTANT;

    List<? extends VariableElement> fields =
        ElementFilter.fieldsIn(oldField.getEnclosingElement().getEnclosedElements());
    fields.removeIf(isNotEnumConstant);

    int oldIdx = fields.indexOf(oldField);

    fields = ElementFilter.fieldsIn(newField.getEnclosingElement().getEnclosedElements());
    fields.removeIf(isNotEnumConstant);

    int newIdx = fields.indexOf(newField);

    if (newIdx != oldIdx) {
      pushActive(oldField, newField, oldIdx, newIdx);
    }
  }
示例#2
1
 /* (non-Javadoc)
  * @see de.codesourcery.javr.assembler.parser.LexerIf#setIgnoreWhitespace(boolean)
  */
 public void setIgnoreWhitespace(boolean ignoreWhitespace) {
   if (DEBUG) {
     System.out.println(
         "setIgnoreWhitespace(): ignore="
             + this.ignoreWhitespace
             + " => ignore="
             + ignoreWhitespace);
   }
   if (this.ignoreWhitespace == ignoreWhitespace) {
     return;
   }
   if (this.ignoreWhitespace && !ignoreWhitespace) {
     // change: ignore whitespace -> do not ignore
     if (!tokens.isEmpty()) {
       int offset = tokens.get(0).offset;
       if (DEBUG) {
         System.out.println("current token: " + tokens.get(0));
       }
       tokens.clear();
       scanner.setOffset(offset);
       parseTokens();
     }
   } else {
     // change: do not ignore whitespace -> ignore whitespace
     tokens.removeIf(tok -> tok.is(TokenType.WHITESPACE));
   }
   this.ignoreWhitespace = ignoreWhitespace;
 }
示例#3
1
  /**
   * Exercise 2
   *
   * <p>Remove the words that have odd lengths from the list.
   */
  private void exercise2() {
    List<String> list =
        new ArrayList<>(Arrays.asList("alpha", "bravo", "charlie", "delta", "echo", "foxtrot"));

    /* YOUR CODE HERE */
    list.removeIf(w -> w.length() % 2 != 0);
    list.forEach(System.out::println);
  }
示例#4
1
  static void collectionTest() {
    // removeIf
    Collection<String> c = new HashSet<>();
    c.add("Content 1");
    c.add("Content 2");
    c.add("Content 3");
    c.add("Content 4");
    c.removeIf(s -> s.contains("2"));
    System.out.println("removeIf : " + c);

    /// 基本操作
    List<Integer> list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(a -> a % 3 == 0);
    System.out.println("a % 3 == 0 " + list);

    // OR 操作
    Predicate<Integer> predicate2 = a -> a % 3 == 0;
    Predicate<Integer> predicate3 = a -> a % 5 == 0;
    list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(predicate2.or(predicate3));
    System.out.println("a % 3 == 0 or a % 5 == 0 " + list);

    // AND 操作
    predicate2 = a -> a % 3 == 0;
    predicate3 = a -> a % 5 == 0;
    list = new ArrayList(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11));
    list.removeIf(predicate2.and(predicate3));
    System.out.println("a % 3 == 0 and a % 5 == 0 " + list);

    List<String> stringList = Arrays.asList("a", "b");
    stringList.forEach(System.out::println);

    stringList = Arrays.asList("a", "b", "c");
    stringList.replaceAll(String::toUpperCase);
    System.out.println(stringList); // [A, B, C]

    stringList = Arrays.asList("a", "b", "c");
    stringList.sort(String::compareTo);

    Map<String, Integer> map = new HashMap<>();
    map.put("A", 10);
    map.put("B", 20);
    map.put("C", 30);
    map.forEach((k, v) -> System.out.println("Item : " + k + " Count : " + v));
    System.out.println(map.getOrDefault("D", 40)); // => 40
  }
 /**
  * Add the given history to the entry (uses AutocompleteMenuUpdater if non-null).
  *
  * @param entry
  */
 public void updateHistory(final String entry) {
   if (updater != null) updater.updateHistory(entry);
   else { // add entry to top of menu items (for the particular autocomplete menu instance)
     // (Currently, there are two instances of this class in the editor: one for the inline editor,
     // one for the palette)
     final List<MenuItem> items = menu.getItems();
     // remove entry if present, to avoid duplication
     items.removeIf((item) -> item.getText().equals(entry));
     items.add(0, createMenuItem(entry));
   }
 }
示例#6
1
  public void removeIf(Predicate<Entity> pred) {
    entityList.removeIf(
        e -> {
          if (pred.test(e)) {
            e.destroy();
            return true;
          }

          return false;
        });
  }
  public static void main(String[] args) {
    List<String> strings = new ArrayList<>();
    Collections.addAll(strings, "Java", "7", "FTW");

    strings.forEach(x -> System.out.print(x + " ")); // Will output: Java 8 FTW

    System.out.println("\nLets update to Java 8 :) ...");
    strings.replaceAll(x -> x == "7" ? "8" : x); // similar to something we'll see later...
    strings.forEach(x -> System.out.print(x + " ")); // Will output: Java 8 WAT

    System.out.println("\nNow lets remove the version...");
    strings.removeIf(x -> x == "8");
    strings.forEach(x -> System.out.print(x + " ")); // Will output: Java 8 WAT
  }
示例#8
0
  public void modtagContainer(Container container) {

    int i = 0;

    if (lister.isEmpty()) {

      lister.add(new ArrayList<Container>());

    } else if (!receiveBeforePickup) {

      for (List<Container> l : lister) {

        l.removeIf(e -> e.getPickupDate().isEqual(container.getDateOfArrival()));
      }

      removeEmptyListe();
    }

    while (!checkList(container, lister.get(i))) {

      lister.add(new ArrayList<Container>());
      placed = checkList(container, lister.get(i++));
    }

    removeEmptyListe();

    if (receiveBeforePickup) {
      for (List<Container> l : lister) {

        l.removeIf(e -> e.getPickupDate().isEqual(container.getDateOfArrival()));
      }

      removeEmptyListe();
    }
    getMaxAntalContainer();
    getMaxAntalPlace();
  }
	public static void testPredicate(){
		List<Integer> strList=new ArrayList<Integer>();
		strList.add(5);
		strList.add(1001);
		strList.add(1002);
		final Predicate< Integer> filter=new Predicate<Integer>() {
			@Override
			public boolean test(Integer t) {
				if(t>4){
				    return true;
				}else{
					return false;
				}
			}				
		};		
		strList.removeIf(filter);
		System.out.println(strList.size()+strList.toString());
		
	}
示例#10
0
  @SubscribeEvent
  public void checkingameGUI(TickEvent.RenderTickEvent e) {
    boolean b = mc.ingameGUI instanceof SAOIngameGUI;
    if (mc.ingameGUI != null && SAOOption.DEFAULT_UI.getValue() == b)
      mc.ingameGUI = b ? new GuiIngameForge(mc) : new SAOIngameGUI(mc);

    deadHandlers.forEach(
        ent -> {
          final boolean deadStart = (ent.deathTime == 1);
          final boolean deadExactly = (ent.deathTime >= 18);
          if (deadStart) {
            ent.deathTime++;
            SAOSound.playAtEntity(ent, SAOSound.PARTICLES_DEATH);
          }

          if (deadExactly) {
            StaticRenderer.doSpawnDeathParticles(mc, ent);
            ent.setDead();
          }
        });
    deadHandlers.removeIf(ent -> ent.isDead);
  }
示例#11
0
  public static void runGame(String filename, int port, int rounds, int time)
      throws IOException, InterruptedException, ExecutionException {
    final World world;
    int users = 0;
    try {
      WorldParser wp = new WorldParser();
      world = wp.parse(filename);
      users = world.getNumberOfSpawnpoints();
    } catch (FileNotFoundException e) {
      logger.error("Map file not found: '" + filename + "'.");
      return;
    }

    Message info = new InfoMessage(time, rounds, filename, users);

    logger.info("Starting graphics server.");
    GraphicsServer graphics = new GraphicsServer(info, port + 10);
    graphics.start();

    logger.info("Waiting for clients to connect.");
    ServerSocket socket = new ServerSocket(port);
    List<Player> players = new ArrayList<>();
    for (int i = 0; i < users; i++) {
      Socket client = socket.accept();
      Connection conn = new Connection(client);
      new Thread(conn).start();
      conn.sendMessage(info);
      players.add(new Player(conn));
    }
    logger.info("All clients connected.");

    logger.info("Setting spawnpoints.");
    Collections.shuffle(players);
    Queue<Vector2d> spawnpoints = world.getSpawnpoints();
    for (Player player : players) {
      player.setSpawn(spawnpoints.poll());
    }

    logger.info("Sending initial game state.");
    Message state0 = new GameStateMessage(0, world, players);
    players.stream().peek(p -> p.send(state0));
    graphics.sendToAll(state0);
    logger.info("Recieved loadout from all.");

    logger.info("Starting game.");
    for (int round = 1; round <= rounds; round++) {
      for (Player player : players) {
        logger.info("Starting player '" + player.getName() + "' turn.");
        logger.info("Clearing all messages from player queue.");
        player.clear();
        logger.info("Sending first round to all.");
        Message state = new GameStateMessage(round, world, players);
        players.stream().forEach(p -> p.send(state));
        graphics.sendToAll(state);

        if (player.isDead()) {
          logger.info(player.getName() + " is dead. Respawning...");
          player.respawn();
        } else {
          List<ActionMessage> actions = new ArrayList<>();
          Instant stop = Instant.now().plus(time, MILLIS);
          for (int a = 0; a < 3; a++) {
            logger.info("Waiting for action " + a + ".");
            long timeout = Math.max(0, MILLIS.between(Instant.now(), stop));
            ActionMessage action = player.next(timeout, MILLISECONDS);
            if (action == null) {
              logger.debug(
                  "==> Player '" + player.getName() + "' timed out in round " + round + ".");
              break;
            }

            try {
              logger.info("Performing action.");
              action.performAction(player, world);
              actions.add(action);
              logger.info("Successful message: " + action.toString());
              players.stream().forEach(p -> p.send(action));
            } catch (ProtocolException e) {
              logger.debug(e.getMessage());
              player.send(new ErrorMessage(e));
            }
          }
          logger.info("Waiting to complete round.");
          Thread.sleep(Math.max(0, MILLIS.between(Instant.now(), stop)));
          player.send(new EndTurnMessage());

          logger.info("Sending actions to graphics.");
          for (Message m : actions) {
            graphics.sendToAll(m);
          }
        }
      }

      Collections.rotate(players, 1);
    }

    players.sort(comparing(Player::score));
    Collections.reverse(players);
    players.removeIf(p -> p.score() < players.get(0).score());
    String winner;
    if (players.size() > 1) {
      winner =
          String.format(
              "A %d-way tie between: %s",
              players.size(), String.join(", ", players.toArray(new String[players.size()])));
    } else {
      winner = String.format("The winner is ", players.get(0));
    }

    logger.info("Winner: " + winner);
    Message message = new GameFinishedMessage(winner);
    players.stream().forEach(p -> p.send(message));
    graphics.sendToAll(message);
    socket.close();
  }
示例#12
0
 @Test
 public void removeIfTest() {
   list.removeIf(x -> x.startsWith("A"));
   assertEquals(list, Collections.singletonList("YNDX"));
 }
  @Override
  public CorfuDBView getNewView(CorfuDBView oldView, NetworkException e) {
    /* it's null, don't change anything */
    if (e == null) {
      return oldView;
    }
    /* Is the exception for a Logging Unit? */
    if (e.protocol instanceof IWriteOnceLogUnit) {
      /* Okay, so was it a read or a write? */
      if (e.write) {
        /* in the case of a write, find the segment belonging to the protocol,
          and remove that protocol from the segment.
        */
        CorfuDBView newView = (CorfuDBView) Serializer.copyShallow(oldView);

        for (CorfuDBViewSegment segment : newView.getSegments()) {
          for (List<IServerProtocol> nodeList : segment.getGroups()) {
            if (nodeList.size() > 1) {
              nodeList.removeIf(n -> n.getFullString().equals(e.protocol.getFullString()));
            }
          }
        }

        log.info("Reconfiguring all nodes in view to new epoch " + oldView.getEpoch() + 1);
        newView.moveAllToNewEpoch(oldView.getEpoch() + 1);
        return newView;
      }
      /* for reads, we don't do anything, for now...
       */
      log.warn("Reconfigure due to read, ignoring");
      return oldView;
    } else if (e.protocol instanceof ISimpleSequencer) {
      if (oldView.getSequencers().size() <= 1) {
        log.warn(
            "Request reconfiguration of sequencers but there is no fail-over available! [available sequencers="
                + oldView.getSequencers().size()
                + "]");
        return oldView;
      } else {
        CorfuDBView newView = (CorfuDBView) Serializer.copyShallow(oldView);
        newView.moveAllToNewEpoch(oldView.getEpoch() + 1);

        /* Interrogate each log unit to figure out last issued token */
        long last = -1;
        for (CorfuDBViewSegment segment : newView.getSegments()) {
          int groupNum = 1;
          for (List<IServerProtocol> nodeList : segment.getGroups()) {
            for (IServerProtocol n : nodeList) {
              try {
                last =
                    Long.max(
                        last,
                        ((IWriteOnceLogUnit) n).highestAddress() * segment.getGroups().size()
                            + groupNum);
              } catch (NetworkException ne) {

              }
            }
            groupNum++;
          }
        }

        log.warn(
            "Removing sequencer "
                + e.protocol.getFullString()
                + " from configuration, discover last sequence was "
                + last);
        newView.getSequencers().removeIf(n -> n.getFullString().equals(e.protocol.getFullString()));
        try {
          ((ISimpleSequencer) newView.getSequencers().get(0)).recover(last);
        } catch (Exception ex) {
          log.warn("Tried to install recovered sequence from sequencer, but failed", e);
        }
        return newView;
      }
    } else {
      log.warn("Request reconfiguration for protocol we don't know how to reconfigure", e.protocol);
      return (CorfuDBView) Serializer.copyShallow(oldView);
    }
  }
  /**
   * Puts the given lesson plans into classrooms based on the distance the member fo staff will have
   * to travel between each lesson.
   *
   * @param lessonPlans The lessonPlans to be put into classrooms.
   * @param classrooms The classrooms to put lessons plans into.
   * @param distances The distances between the classrooms.
   * @return The list of lessonPlans after they have been put into classrooms.
   */
  private boolean putLessonPlansIntoClassrooms(
      List<LessonPlan> lessonPlans, List<Classroom> classrooms, List<Distance> distances) {

    // Create a week of periods for this subject
    List<List<LessonPlan>> week = new ArrayList<>();
    for (int i = 0; i < 5; i++) {
      week.add(new ArrayList<>());
    }
    lessonPlans
        .stream()
        .forEach(lessonPlan -> week.get(lessonPlan.period.day.id - 1).add(lessonPlan));

    List<Period> periods;
    // Iterate through each day
    for (int dayNo = 0; dayNo < week.size(); dayNo++) {
      // Get the periods of this day
      try {
        periods =
            daoManager
                .getPeriodDao()
                .getAllByDay(
                    daoManager
                        .getDayDao()
                        .getById(dayNo + 1)
                        .orElseThrow(
                            () -> new IllegalStateException("Failed to find periods in a day")));
        // The above exception should never be thrown
        periods.sort((o1, o2) -> o1.startTime.getHour() - o2.startTime.getHour());
      } catch (DataAccessException e) {
        DataExceptionHandler.handleJavaFx(e, "period", false);
        return false;
      } catch (DataConnectionException e) {
        DataExceptionHandler.handleJavaFx(e, null, true);
        return false;
      }

      // Get this days lessons and randomly allocate the first period
      List<LessonPlan> day = week.get(dayNo);
      List<LessonPlan> firstPeriod = new ArrayList<>();
      day.forEach(
          lessonPlan -> {
            if (lessonPlan.period.startTime.equals(LocalTime.of(9, 10))) {
              firstPeriod.add(lessonPlan);
            }
          });
      classrooms
          .stream()
          .forEach(
              classroom -> {
                for (LessonPlan lessonPlan : firstPeriod) {
                  if (lessonPlan.classroom.id == -1) {
                    lessonPlan.classroom = classroom;
                    break;
                  }
                }
              });
      // Store the first period in the timetabled list
      firstPeriod.forEach(
          lessonPlan -> {
            int index = lessonPlans.indexOf(lessonPlan);
            lessonPlans.set(index, lessonPlan);
          });

      List<LessonPlan> previousPeriod = new ArrayList<>(firstPeriod);
      // Iterate through the other periods
      for (int periodNo = 1; periodNo < 5; periodNo++) {
        List<LessonPlan> period = new ArrayList<>();
        for (LessonPlan lessonPlan : day) {
          if (lessonPlan.period.equals(periods.get(periodNo - 1))) {
            period.add(lessonPlan);
          }
        }

        // Timetable lessons where the staff member had a lesson previously
        for (LessonPlan lessonPlan : period) {
          Staff staff = lessonPlan.staff;
          Optional<LessonPlan> previousLesson =
              previousPeriod.stream().filter(lesson -> lesson.staff.equals(staff)).findFirst();

          if (previousLesson.isPresent()) {
            Optional<LessonPlan> planOptional =
                period
                    .stream()
                    .filter(plan -> plan.classroom.equals(previousLesson.get().classroom))
                    .findFirst();

            if (planOptional.isPresent()) {
              List<Distance> availableRooms =
                  distances
                      .stream()
                      .filter(
                          distance ->
                              distance.startRoom.equals(planOptional.get().classroom)
                                  || distance.endRoom.equals(planOptional.get().classroom))
                      .collect(Collectors.toList());
              availableRooms.removeIf(
                  distance -> {
                    boolean remove = false;
                    for (LessonPlan plan : period) {
                      if (plan.classroom.equals(distance.startRoom)
                          || plan.classroom.equals(distance.endRoom)) {
                        remove = true;
                      }
                    }

                    return remove;
                  });

              availableRooms.sort((o1, o2) -> o1.distance - o2.distance);
              Distance nextTrip = availableRooms.get(0);

              if (nextTrip.startRoom.equals(planOptional.get().classroom)) {
                lessonPlan.classroom = nextTrip.endRoom;
              } else if (nextTrip.endRoom.equals(planOptional.get().classroom)) {
                lessonPlan.classroom = nextTrip.startRoom;
              } else {
                assert false : "The new classroom should be one from the shortest distance!";
              }
            } else {
              lessonPlan.classroom = previousLesson.get().classroom;
            }
          }
        }

        // Timetable the remaining lessons randomly
        for (LessonPlan lessonPlan : period) {
          if (lessonPlan.classroom != null) {
            List<Classroom> availableRooms = new ArrayList<>();
            availableRooms.addAll(classrooms);

            availableRooms.removeIf(
                classroom -> {
                  boolean remove = false;
                  for (LessonPlan plan : period) {
                    if (classroom.equals(plan.classroom)) {
                      remove = true;
                    }
                  }
                  return remove;
                });
            lessonPlan.classroom = availableRooms.get(0);
          }
        }

        previousPeriod = period;
      }
    }
    return true;
  }
  @Override
  public void onEnable() {
    MineCloud.environmentSetup();

    mongo = MineCloud.instance().mongo();
    redis = MineCloud.instance().redis();

    redis.addChannel(
        SimpleRedisChannel.create("server-start-notif", redis)
            .addCallback(
                (message) ->
                    getProxy()
                        .getScheduler()
                        .schedule(
                            this,
                            () -> {
                              if (message.type() != MessageType.BINARY) {
                                return;
                              }

                              try {
                                MessageInputStream stream = message.contents();

                                Server server =
                                    mongo.repositoryBy(Server.class).findFirst(stream.readString());

                                addServer(server);
                              } catch (IOException ignored) {
                              }
                            },
                            1,
                            TimeUnit.SECONDS)));

    redis.addChannel(
        SimpleRedisChannel.create("server-shutdown-notif", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();

                  removeServer(stream.readString());
                }));

    redis.addChannel(
        SimpleRedisChannel.create("teleport", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();
                  ProxiedPlayer player = getProxy().getPlayer(stream.readString());

                  if (player == null) {
                    return;
                  }

                  String name = stream.readString();
                  ServerInfo info = getProxy().getServerInfo(name);

                  if (info == null) {
                    ServerRepository repository = mongo.repositoryBy(Server.class);
                    Server server = repository.findOne("_id", name);

                    if (server != null) {
                      addServer(server);
                      info = getProxy().getServerInfo(name);
                    }
                  }

                  player.connect(info);
                }));

    redis.addChannel(
        SimpleRedisChannel.create("teleport-type", redis)
            .addCallback(
                (message) -> {
                  if (message.type() != MessageType.BINARY) {
                    return;
                  }

                  MessageInputStream stream = message.contents();
                  ProxiedPlayer player = getProxy().getPlayer(stream.readString());

                  if (player == null) {
                    return;
                  }

                  ServerType type =
                      mongo.repositoryBy(ServerType.class).findFirst(stream.readString());

                  if (type == null) {
                    getLogger()
                        .log(Level.SEVERE, "Received teleport message with invalid server type");
                    return;
                  }

                  ServerRepository repository = mongo.repositoryBy(Server.class);
                  List<Server> servers =
                      repository
                          .find(
                              repository
                                  .createQuery()
                                  .field("network")
                                  .equal(bungee().network())
                                  .field("type")
                                  .equal(type)
                                  .field("port")
                                  .notEqual(-1)
                                  .field("ramUsage")
                                  .notEqual(-1))
                          .asList();

                  Collections.sort(
                      servers, (a, b) -> a.onlinePlayers().size() - b.onlinePlayers().size());

                  Server server = servers.get(0);
                  ServerInfo info = getProxy().getServerInfo(server.name());

                  if (info == null) {
                    getLogger()
                        .warning("Cannot find " + server.name() + " in ServerInfo store, adding.");
                    addServer(server);
                    info = getProxy().getServerInfo(server.name());
                  }

                  player.connect(info);
                }));

    getProxy()
        .getScheduler()
        .schedule(
            this,
            () ->
                getProxy()
                    .getScheduler()
                    .runAsync(
                        this,
                        () -> {
                          Bungee bungee = bungee();

                          if (bungee != null) {
                            return;
                          }

                          getLogger().info("Bungee removed from database, going down...");
                          getProxy().stop(); // bye bye
                        }),
            2,
            2,
            TimeUnit.SECONDS);

    BungeeType type = bungee().type();

    File nContainer = new File("nplugins/");
    nContainer.mkdirs();

    type.plugins()
        .forEach(
            (plugin) -> {
              String version = plugin.version();
              PluginType pluginType = plugin.type();
              File pluginsContainer =
                  new File("/mnt/minecloud/plugins/", pluginType.name() + "/" + version);
              List<File> plugins = new ArrayList<>();

              getLogger().info("Loading " + pluginType.name() + "...");

              if (validateFolder(pluginsContainer, pluginType, version)) return;

              for (File f : pluginsContainer.listFiles()) {
                if (f.isDirectory()) continue; // ignore directories
                File pl = new File(nContainer, f.getName());

                try {
                  Files.copy(f, pl);
                } catch (IOException ex) {
                  getLogger()
                      .log(
                          Level.SEVERE,
                          "Could not load " + pluginType.name() + ", printing stacktrace...");
                  ex.printStackTrace();
                  return;
                }

                plugins.add(pl);
              }

              File configs =
                  new File(
                      "/mnt/minecloud/configs/",
                      pluginType.name()
                          + "/"
                          + (plugin.config() == null ? version : plugin.config()));
              File configContainer = new File(nContainer, pluginType.name());

              if (!validateFolder(configs, pluginType, version))
                copyFolder(configs, configContainer);
            });

    getProxy()
        .getScheduler()
        .schedule(
            this,
            () -> {
              ServerRepository repository = mongo.repositoryBy(Server.class);
              List<Server> servers =
                  repository
                      .find(repository.createQuery().field("network").equal(bungee().network()))
                      .asList();

              servers.removeIf((s) -> s.port() == -1);
              servers.forEach(this::addServer);

              getProxy().setReconnectHandler(new ReconnectHandler(this));
              getProxy().getPluginManager().registerListener(this, new MineCloudListener(this));

              // release plugin manager lock
              try {
                Field f = PluginManager.class.getDeclaredField("toLoad");

                f.setAccessible(true);
                f.set(getProxy().getPluginManager(), new HashMap<>());
              } catch (NoSuchFieldException | IllegalAccessException ignored) {
              }

              getProxy().getPluginManager().detectPlugins(nContainer);
              getProxy().getPluginManager().loadPlugins();
              getProxy()
                  .getPluginManager()
                  .getPlugins()
                  .stream()
                  .filter((p) -> !p.getDescription().getName().equals("MineCloud-Bungee"))
                  .forEach(Plugin::onEnable);
            },
            0,
            TimeUnit.SECONDS);
  }
示例#16
0
 private void verificarCondiciones() {
   inscripciones.removeIf(inscripcion -> inscripcion.noVerificaLaCondicion(this));
 }