/**
   * this method will call initialize for each message, since we are caching the entity indexes, we
   * don't worry about aggregating by app id
   *
   * @param indexOperationMessage
   */
  private void initializeEntityIndexes(final IndexOperationMessage indexOperationMessage) {

    // create a set so we can have a unique list of appIds for which we call createEntityIndex
    Set<UUID> appIds = new HashSet<>();

    // loop through all indexRequests and add the appIds to the set
    indexOperationMessage
        .getIndexRequests()
        .forEach(
            req -> {
              UUID appId = IndexingUtils.getApplicationIdFromIndexDocId(req.documentId);
              appIds.add(appId);
            });

    // loop through all deindexRequests and add the appIds to the set
    indexOperationMessage
        .getDeIndexRequests()
        .forEach(
            req -> {
              UUID appId = IndexingUtils.getApplicationIdFromIndexDocId(req.documentId);
              appIds.add(appId);
            });

    // for each of the appIds in the unique set, call create entity index to ensure the aliases are
    // created
    appIds.forEach(
        appId -> {
          ApplicationScope appScope = CpNamingUtils.getApplicationScope(appId);
          entityIndexFactory.createEntityIndex(
              indexLocationStrategyFactory.getIndexLocationStrategy(appScope));
        });
  }
 @OnMessage
 public void handleMessage(String message, Session session) {
   logger.info("Received message " + message);
   peers.forEach(
       peer -> {
         if (session != peer) {
           peer.getAsyncRemote().sendObject(message);
         }
       });
 }
Example #3
0
  @Test
  public void testInference() {
    QueryTree queryTree = new QueryTree();

    JoinCondition jc1 =
        new JoinCondition(
            SAMPLED_TABLE_NAME, FOREIGN_KEY_COLUMN, FOREIGN_TABLE_NAME, FOREIGN_TABLE_KEY_COLUMN);
    queryTree.getJoinConditions().add(jc1);

    TableInfo sampledTableInfo = new TableInfo();

    sampledTableInfo.setName(SAMPLED_TABLE_NAME);
    sampledTableInfo.setColumns(columnSet);

    TableInfo foreignTableInfo = new TableInfo();
    foreignTableInfo.setName(FOREIGN_TABLE_NAME);
    foreignTableInfo.setColumns(foreignColumnSet);
    foreignTableInfo.setPrimaryKeys(new HashSet<>(Arrays.asList(FOREIGN_TABLE_KEY_COLUMN)));

    Set<TableInfo> tableInfoSet = new HashSet<TableInfo>();
    tableInfoSet.add(sampledTableInfo);
    tableInfoSet.add(foreignTableInfo);

    FuncDependencies funcDep = new FuncDependencies(queryTree, tableInfoSet);

    Set<String> det =
        new HashSet<String>(
            Arrays.asList(
                Utility.formatColumnName(SAMPLED_TABLE_NAME, KEY1),
                Utility.formatColumnName(
                    SAMPLED_TABLE_NAME, FuncDependencies.ANNOTATION_COLUMN_NAME)));
    Set<String> dep = new HashSet<>();

    columnSet.forEach(
        (columnName) -> dep.add(Utility.formatColumnName(SAMPLED_TABLE_NAME, columnName)));
    foreignColumnSet.forEach(
        (columnName) -> dep.add(Utility.formatColumnName(FOREIGN_TABLE_NAME, columnName)));

    /*Infer that P.KEY1, P.pi ----> HEAD(P) and HEAD(Q)*/
    Assert.assertTrue("Inferrence failed", funcDep.infer(det, dep));
  }
  public static String fromJExpr2KExprString(Expression jexpr, Set<SimpleName> names) {
    HashMap<String, String> typeEnv = new HashMap<>();
    HashMap<String, String> fromJVarName2KVarName = extractJVar2KVarMapping(names.stream());

    names.forEach(
        name -> {
          typeEnv.put(
              fromJVarName2KVarName.get(name.getIdentifier()), name.resolveTypeBinding().getName());
        });

    return fromJExpr2KExprString(jexpr, fromJVarName2KVarName, typeEnv);
  }
Example #5
0
  @Override
  public List<String> runTests() {
    final List<String> errors = new ArrayList<>();
    try {
      final T instance = (T) clazz.newInstance();
      methodsUnderTest.forEach(
          field -> testSetter(instance, field).ifPresent(value -> errors.add(value)));
    } catch (IllegalAccessException | InstantiationException e) {
      throw new TestAidException("Setter test failed to run", e);
    }

    return errors;
  }
  // batch job (possibly real-time using streaming APIs)
  public static void createProductAssociativityGraphPerCategory() {
    Set<String> customers = purchasesCache.keySet();
    customers.forEach(
        customer -> {
          List<String> customerPurchases = Lists.newArrayList(purchasesCache.get(customer));
          for (int i = 0; i < customerPurchases.size(); i++) {
            for (int j = i + 1; j < customerPurchases.size(); j++) {
              Product product1 = productCache.get(customerPurchases.get(i));
              Product product2 = productCache.get(customerPurchases.get(j));

              if (product1.category.equals(product2.category)) {
                ProductAssociativityGraph graph =
                    productAssociativityGraphMap.getOrDefault(
                        product1.category, ProductAssociativityGraph.create());

                graph.addAssociation(Vertex.create(product1.id), Vertex.create(product2.id), 1);
                productAssociativityGraphMap.putIfAbsent(product1.category, graph);
              }
            }
          }
        });
  }
  /**
   * Puts all the given staff into the given lessonPlans, avoiding all given lessonPlans. Returns
   * true if it successfully put the staff into the lessonPlans.
   *
   * @param lessonPlans The lessonPlans to have staff put in.
   * @param staffList The staff to put into the lessonPlans.
   * @param overloadedPeriods The lessonPlans which overlap.
   * @return True if successfully put the staff into the lessonPlans.
   */
  private boolean putStaffIntoLessonPlan(
      List<LessonPlan> lessonPlans,
      List<Staff> staffList,
      List<Set<LessonPlan>> overloadedPeriods) {
    boolean done = false;

    while (!done) {
      Set<SubjectSet> subjectSets = new HashSet<>();
      lessonPlans.forEach(lessonPlan -> subjectSets.add(lessonPlan.subjectSet));

      for (SubjectSet subjectSet : subjectSets) {
        List<LessonPlan> lessonsForSubjectSet =
            lessonPlans
                .stream() // Turn list into an iterating stream
                .filter(
                    lessonPlan ->
                        lessonPlan.subjectSet.id
                            == subjectSet
                                .id) // Only add lessonsPlans who's subjectSet is the subjectSet
                // currently being processed.
                .collect(
                    Collectors.toCollection(
                        ArrayList::new)); // Collect all which meet the filter into an ArrayList and
        // return it

        /*List<LessonPlan> lessonsForSubjectSet = new ArrayList<>();                //This is the equivalent of the above
        for (LessonPlan lessonPlan : lessonPlans) {
            if (lessonPlan.subjectSet.id == subjectSet.id) {
                lessonsForSubjectSet.add(lessonPlan);
            }
        }*/

        if (lessonsForSubjectSet.get(0).staff.id
            == -1) { // Only check first as all will be set if the first is set
          Set<SubjectSet> possibleConflicts =
              new HashSet<>(); // A set containing every subjectSet which happens at the same time
          // as the current subjectSet
          for (Set<LessonPlan> overloadedPeriod : overloadedPeriods) {
            if (overloadedPeriod
                .stream()
                .anyMatch(lessonPlan -> lessonPlan.subjectSet.id == subjectSet.id)) {
              // Only a set rather than List(Set) as do not need to know when the conflict is,
              overloadedPeriod.forEach(
                  lessonPlan ->
                      possibleConflicts.add(
                          lessonPlan.subjectSet)); // only there is a conflict between the current
              // subjectSet and the subjectSets
              // in the set
            }
          }

          for (Staff staff : staffList) {
            if (staff.currentHoursPerWeek >= staff.hoursPerWeek) {
              break;
            }

            Set<SubjectSet> subjectSetsForStaff =
                new HashSet<>(); // A set containing the subjectSets taught by the current staff
            lessonsForSubjectSet.forEach(
                lessonPlan -> {
                  if (lessonPlan.staff.id != -1 && lessonPlan.id != staff.id) {
                    subjectSetsForStaff.add(lessonPlan.subjectSet);
                  }
                });

            if (Collections.disjoint(
                possibleConflicts,
                subjectSetsForStaff)) { // disjoint returns true if the collections has no elements
              // in common
              staff.currentHoursPerWeek += lessonsForSubjectSet.size();
              for (LessonPlan lessonPlan : lessonPlans) {
                if (lessonPlan.subjectSet.id == subjectSet.id) {
                  LessonPlan lesson =
                      new LessonPlan(
                          lessonPlan.id,
                          staff,
                          lessonPlan.classroom,
                          lessonPlan.period,
                          lessonPlan.subjectSet);
                  lessonPlans.set(lessonPlans.indexOf(lessonPlan), lesson);
                }
              }
            }
          }
        }
      }

      done =
          lessonPlans
              .stream()
              .allMatch(
                  lessonPlan ->
                      lessonPlan.staff
                          != null); // Checks if every lessonPlan has a member of staff teaching it
    }

    return true;
  }
Example #8
0
 private void updateConfig() {
   JSONArray chats = new JSONArray();
   availableChats.forEach(chats::put);
   config.put("chats", chats);
 }
Example #9
0
  /**
   * Provides the Observer with a new item to observe.
   *
   * <p>The {@link com.caricah.iotracah.core.modules.Server} may call this method 0 or more times.
   *
   * <p>The {@code Observable} will not call this method again after it calls either {@link
   * #onCompleted} or {@link #onError}.
   *
   * @param iotMessage the item emitted by the Observable
   */
  @Override
  public void onNext(IOTMessage iotMessage) {

    getExecutorService()
        .submit(
            () -> {
              log.info(" onNext : received {}", iotMessage);
              try {

                IOTMessage response = null;

                switch (iotMessage.getMessageType()) {
                  case ConnectMessage.MESSAGE_TYPE:
                    ConnectMessage connectMessage = (ConnectMessage) iotMessage;
                    response =
                        ConnectAcknowledgeMessage.from(
                            connectMessage.isDup(),
                            connectMessage.getQos(),
                            connectMessage.isRetain(),
                            connectMessage.getKeepAliveTime(),
                            MqttConnectReturnCode.CONNECTION_ACCEPTED);

                    break;
                  case SubscribeMessage.MESSAGE_TYPE:
                    SubscribeMessage subscribeMessage = (SubscribeMessage) iotMessage;

                    List<Integer> grantedQos = new ArrayList<>();
                    subscribeMessage
                        .getTopicFilterList()
                        .forEach(
                            topic -> {
                              String topicKey =
                                  quickCheckIdKey(
                                      "",
                                      Arrays.asList(topic.getKey().split(Constant.PATH_SEPARATOR)));

                              Set<String> channelIds = subscriptions.get(topicKey);

                              if (Objects.isNull(channelIds)) {
                                channelIds = new HashSet<>();
                              }

                              channelIds.add(subscribeMessage.getConnectionId());
                              subscriptions.put(topicKey, channelIds);

                              grantedQos.add(topic.getValue());
                            });

                    response =
                        SubscribeAcknowledgeMessage.from(
                            subscribeMessage.getMessageId(), grantedQos);

                    break;
                  case UnSubscribeMessage.MESSAGE_TYPE:
                    UnSubscribeMessage unSubscribeMessage = (UnSubscribeMessage) iotMessage;
                    response =
                        UnSubscribeAcknowledgeMessage.from(unSubscribeMessage.getMessageId());

                    break;
                  case Ping.MESSAGE_TYPE:
                    response = iotMessage;
                    break;
                  case PublishMessage.MESSAGE_TYPE:
                    PublishMessage publishMessage = (PublishMessage) iotMessage;

                    Set<String> matchingTopics =
                        getMatchingSubscriptions("", publishMessage.getTopic());

                    for (String match : matchingTopics) {
                      Set<String> channelIds = subscriptions.get(match);

                      if (Objects.nonNull(channelIds)) {

                        channelIds.forEach(
                            id -> {
                              PublishMessage clonePublishMessage = publishMessage.cloneMessage();
                              clonePublishMessage.copyTransmissionData(iotMessage);
                              clonePublishMessage.setConnectionId(id);
                              pushToServer(clonePublishMessage);
                            });
                      }
                    }

                    if (MqttQoS.AT_MOST_ONCE.value() == publishMessage.getQos()) {

                      break;

                    } else if (MqttQoS.AT_LEAST_ONCE.value() == publishMessage.getQos()) {

                      response = AcknowledgeMessage.from(publishMessage.getMessageId());
                      break;
                    }

                  case PublishReceivedMessage.MESSAGE_TYPE:
                  case ReleaseMessage.MESSAGE_TYPE:
                  case CompleteMessage.MESSAGE_TYPE:
                  case DisconnectMessage.MESSAGE_TYPE:
                  case AcknowledgeMessage.MESSAGE_TYPE:
                  default:
                    DisconnectMessage disconnectMessage = DisconnectMessage.from(true);
                    disconnectMessage.copyTransmissionData(iotMessage);

                    throw new ShutdownException(disconnectMessage);
                }

                if (Objects.nonNull(response)) {

                  response.copyTransmissionData(iotMessage);
                  pushToServer(response);
                }

              } catch (ShutdownException e) {

                IOTMessage response = e.getResponse();
                if (Objects.nonNull(response)) {
                  pushToServer(response);
                }

              } catch (Exception e) {
                log.error(" onNext : Serious error that requires attention ", e);
              }
            });
  }
 protected final void fireChangeEvent() {
   listeners.forEach(MarkerModelListener::markerChanged);
 }
 @Override
 public void metadataUpdated() {
   listeners.forEach(MetadataListener::metadataUpdated);
 }
 @Override
 public void gameOver(Set<String> usernames) {
   usernames.forEach(roomContainer::remove);
 }