Example #1
7
  public SelectMany05Bean() {

    HobbitBean[] hobbits = {
      new HobbitBean("Bilbo", "Ring Finder"),
      new HobbitBean("Frodo", "Ring Bearer"),
      new HobbitBean("Merry", "Trouble Maker"),
      new HobbitBean("Pippin", "Trouble Maker")
    };

    Set<SelectItem> items = new LinkedHashSet<SelectItem>();
    for (HobbitBean hobbit : hobbits) {
      items.add(new SelectItem(hobbit.getName()));
    }
    hobbitCollection = new TreeSet<HobbitBean>();
    hobbitCollection.addAll(Arrays.asList(hobbits));
    possibleValues = Collections.unmodifiableSet(items);
    initialSortedSetValues = new TreeSet<String>(Collections.reverseOrder());
    initialSortedSetValues.add("Pippin");
    initialSortedSetValues.add("Frodo");
    initialCollectionValues = new LinkedHashSet<String>(2);
    initialCollectionValues.add("Bilbo");
    initialCollectionValues.add("Merry");
    initialSetValues = new CopyOnWriteArraySet<String>(); // not Cloneable
    initialSetValues.add("Frodo");
    initialListValues = new Vector<String>();
    initialListValues.add("Bilbo");
    initialListValues.add("Pippin");
    initialListValues.add("Merry");
    hobbitDataModel =
        new ListDataModel<HobbitBean>(new ArrayList<HobbitBean>(Arrays.asList(hobbits)));
  }
 /**
  * misleading method name, examples are all instances from the a-Part of the atomicRole(a,b) it
  * has nothing to do with the actual Domain class
  *
  * @param atomicRole
  */
 public void makeNegativeExamplesFromDomain(OWLObjectProperty atomicRole) {
   fromDomain.clear();
   logger.debug("making Negative Examples from Domain of : " + atomicRole);
   fromDomain.addAll(reasoningService.getPropertyMembers(atomicRole).keySet());
   fromDomain.removeAll(fullPositiveSet);
   logger.debug("|-neg Example size from Domain: " + this.fromDomain.size());
 }
Example #3
0
  public void executeMojo() throws MojoExecutionException {
    getLog().info("Validating " + getHosts() + " using migrations at " + getMigrationsPath() + "");

    try {
      MigrationManager manager = createMigrationManager();
      SortedSet<Migration> pendingMigrations = manager.pendingMigrations();
      StringBuilder sb = new StringBuilder();
      sb.append("\n            Database: ").append(getHosts());
      sb.append("\n          Up-to-date: ").append(pendingMigrations.isEmpty());
      sb.append("\n  Pending Migrations: ");

      if (!pendingMigrations.isEmpty()) {
        boolean first = true;
        for (Migration migration : pendingMigrations) {
          if (!first) {
            sb.append("\n                      ");
          }
          first = false;
          sb.append(migration.getFilename());
        }
      }

      getLog().info(sb.toString());
    } catch (Exception e) {
      throw new MojoExecutionException("Failed to validate " + getHosts(), e);
    }
  }
 /** {@inheritDoc} */
 @Override
 public void onMatching(
     String docUri, Type type, SortedSet<Annotation> goldAnnos, SortedSet<Annotation> sysAnnos) {
   if (goldAnnos.size() == 1 && sysAnnos.size() == 1) {
     Annotation goldAnno = goldAnnos.iterator().next();
     Annotation sysAnno = sysAnnos.iterator().next();
     if (goldAnno.getBegin() == sysAnno.getBegin() && goldAnno.getEnd() == sysAnno.getEnd()) {
       printRow(
           type.getShortName(),
           "Exact",
           goldAnno.getCoveredText(),
           String.valueOf(goldAnno.getBegin()),
           sysAnno.getCoveredText(),
           String.valueOf(sysAnno.getBegin()),
           docUri);
       return;
     }
   }
   printRow(
       type.getShortName(),
       "Partial",
       Joiner.on(" /// ").join(transform(goldAnnos, annoToTxt)),
       Joiner.on(", ").join(transform(goldAnnos, annoToOffset)),
       Joiner.on(" /// ").join(transform(sysAnnos, annoToTxt)),
       Joiner.on(", ").join(transform(sysAnnos, annoToOffset)),
       docUri);
 }
  @VisibleForTesting
  static StripCapabilitiesResult stripCapabilities(
      XmlElement configElement, Set<String> allCapabilitiesFromHello) {
    // collect all namespaces
    Set<String> foundNamespacesInXML = getNamespaces(configElement);
    LOG.trace(
        "All capabilities {}\nFound namespaces in XML {}",
        allCapabilitiesFromHello,
        foundNamespacesInXML);
    // required are referenced both in xml and hello
    SortedSet<String> requiredCapabilities = new TreeSet<>();
    // can be removed
    SortedSet<String> obsoleteCapabilities = new TreeSet<>();
    for (String capability : allCapabilitiesFromHello) {
      String namespace = capability.replaceAll("\\?.*", "");
      if (foundNamespacesInXML.contains(namespace)) {
        requiredCapabilities.add(capability);
      } else {
        obsoleteCapabilities.add(capability);
      }
    }

    LOG.trace(
        "Required capabilities {}, \nObsolete capabilities {}",
        requiredCapabilities,
        obsoleteCapabilities);

    return new StripCapabilitiesResult(requiredCapabilities, obsoleteCapabilities);
  }
  private void fillMap(
      Resource s, Model model, Map<Resource, SortedSet<Statement>> resource2Statements) {

    // get all statements with subject s
    ExtendedIterator<Statement> it = model.listStatements(s, null, (RDFNode) null);

    // filter statement if necessary
    if (!dropFilters.isEmpty()) {
      Iterator<Filter<Statement>> iter = dropFilters.iterator();
      Filter<Statement> keepFilter = iter.next();
      it = it.filterKeep(keepFilter);
      while (iter.hasNext()) {
        it = it.filterKeep(iter.next());
        //				keepFilter = keepFilter.and(iter.next());
      }
      //			it = it.filterKeep(keepFilter);
    }

    SortedSet<Statement> statements = resource2Statements.get(s);
    if (statements == null) {
      statements = new TreeSet<Statement>(comparator);
      resource2Statements.put(s, statements);
    }

    while (it.hasNext()) {
      Statement st = it.next();
      statements.add(st);
      if ((st.getObject().isResource()) && !resource2Statements.containsKey(st.getObject())) {
        fillMap(st.getObject().asResource(), model, resource2Statements);
      }
    }
  }
Example #7
0
  public static Map<Package, ClassLoader[]> getPackageMap(
      List<ClassLoader> classLoaders, Set<String> ignorePackages) {
    Map<Package, ClassLoader[]> answer = new HashMap<Package, ClassLoader[]>();

    ClassLoader[] globalClassLoaders = {
      Thread.currentThread().getContextClassLoader(), ClassScanner.class.getClassLoader()
    };

    Set<Package> packages = new HashSet<Package>();
    add(answer, Package.getPackages(), globalClassLoaders, ignorePackages);

    ClassLoader[] classLoaderArray = new ClassLoader[classLoaders.size()];
    classLoaders.toArray(classLoaderArray);

    for (ClassLoader classLoader : classLoaders) {
      Package[] loaderPackages = findPackagesForClassLoader(classLoader);
      add(answer, loaderPackages, classLoaderArray, ignorePackages);
    }
    SortedSet<String> names = new TreeSet<String>();
    for (Package aPackage : packages) {
      names.add(aPackage.getName());
    }
    for (String name : names) {
      LOG.info("Got package " + name);
    }
    return answer;
  }
Example #8
0
  /**
   * Queries the given customer's orders.
   *
   * @param alias the customer alias
   * @param passwordHash the customer password-hash
   * @return the customer's orders
   * @throws IllegalStateException if the login data is invalid
   * @throws SQLException if there is a problem with the underlying JDBC connection
   */
  public SortedSet<Order> queryOrders(final String alias, final byte[] passwordHash)
      throws SQLException {
    final SortedSet<Order> orders = new TreeSet<Order>();
    final Customer customer = this.queryCustomer(alias, passwordHash);

    synchronized (this.connection) {
      try (PreparedStatement statement = this.connection.prepareStatement(SQL_SELECT_PURCHASES)) {
        statement.setLong(1, customer.getIdentity());

        try (ResultSet resultSet = statement.executeQuery()) {
          while (resultSet.next()) {
            final Order purchase = new Order();
            purchase.setIdentity(resultSet.getLong("identity"));
            purchase.setCustomerIdentity(resultSet.getLong("customerIdentity"));
            purchase.setCreationTimestamp(resultSet.getLong("creationTimestamp"));
            purchase.setTaxRate(resultSet.getDouble("taxRate"));
            orders.add(purchase);
          }
        }
      }
    }

    for (final Order purchase : orders) {
      this.populateOrderItems(purchase);
    }

    return orders;
  }
  /**
   * @param definitions
   * @return
   */
  private static FontDefinition[] addDefaulted(FontDefinition[] definitions) {
    IThemeRegistry registry = WorkbenchPlugin.getDefault().getThemeRegistry();
    FontDefinition[] allDefs = registry.getFonts();

    SortedSet set = addDefaulted(definitions, allDefs);
    return (FontDefinition[]) set.toArray(new FontDefinition[set.size()]);
  }
 @Test(timeout = 5 * 60 * 1000)
 public void testConcurrentAssignmentPerformance() throws Exception {
   // make a table with a lot of splits
   String tableName = getUniqueNames(1)[0];
   Connector c = getConnector();
   c.tableOperations().create(tableName);
   SortedSet<Text> splits = new TreeSet<Text>();
   for (int i = 0; i < 4000; i++) {
     splits.add(new Text(randomHex(8)));
   }
   c.tableOperations().addSplits(tableName, splits);
   c.tableOperations().offline(tableName, true);
   // time how long it takes to load
   long now = System.currentTimeMillis();
   c.tableOperations().online(tableName, true);
   long diff = System.currentTimeMillis() - now;
   log.debug("Loaded " + splits.size() + " tablets in " + diff + " ms");
   c.instanceOperations().setProperty(Property.TSERV_ASSIGNMENT_MAXCONCURRENT.getKey(), "20");
   now = System.currentTimeMillis();
   c.tableOperations().offline(tableName, true);
   // wait >10 seconds for thread pool to update
   UtilWaitThread.sleep(Math.max(0, now + 11 * 1000 - System.currentTimeMillis()));
   now = System.currentTimeMillis();
   c.tableOperations().online(tableName, true);
   long diff2 = System.currentTimeMillis() - now;
   log.debug("Loaded " + splits.size() + " tablets in " + diff2 + " ms");
   assertTrue(diff2 < diff);
 }
  /**
   * Checks to see if there are any "unseen" messages or delivery reports. Shows the most recent
   * notification if there is one.
   *
   * @param context the context to use
   * @param isNew if notify a new message comes, it should be true, otherwise, false.
   */
  public static void blockingUpdateNewMessageIndicator(
      Context context, boolean isNew, boolean isStatusMessage) {
    SortedSet<MmsSmsNotificationInfo> accumulator =
        new TreeSet<MmsSmsNotificationInfo>(INFO_COMPARATOR);
    MmsSmsDeliveryInfo delivery = null;
    Set<Long> threads = new HashSet<Long>(4);

    int count = 0;
    count +=
        accumulateNotificationInfo(accumulator, getMmsNewMessageNotificationInfo(context, threads));
    count +=
        accumulateNotificationInfo(accumulator, getSmsNewMessageNotificationInfo(context, threads));

    cancelNotification(context, NOTIFICATION_ID);
    if (!accumulator.isEmpty()) {
      if (Log.isLoggable(LogTag.APP, Log.VERBOSE)) {
        Log.d(TAG, "blockingUpdateNewMessageIndicator: count=" + count + ", isNew=" + isNew);
      }
      accumulator.first().deliver(context, isNew, count, threads.size());
    }

    // And deals with delivery reports (which use Toasts). It's safe to call in a worker
    // thread because the toast will eventually get posted to a handler.
    delivery = getSmsNewDeliveryInfo(context);
    if (delivery != null) {
      delivery.deliver(context, isStatusMessage);
    }
  }
  public PageSet<ObjectInfo> apply(InputStream stream) {
    checkState(args != null, "request should be initialized at this point");
    Type listType = new TypeToken<SortedSet<ObjectInfoImpl>>() {}.getType();

    try {
      SortedSet<ObjectInfoImpl> list = apply(stream, listType);
      SortedSet<ObjectInfo> returnVal =
          Sets.newTreeSet(
              Iterables.transform(
                  list,
                  new Function<ObjectInfoImpl, ObjectInfo>() {
                    public ObjectInfo apply(ObjectInfoImpl from) {
                      return from.toBuilder()
                          .container(container)
                          .uri(
                              uriBuilder(request.getEndpoint())
                                  .clearQuery()
                                  .appendPath(from.getName())
                                  .build())
                          .build();
                    }
                  }));
      boolean truncated = options.getMaxResults() == returnVal.size();
      String marker = truncated ? returnVal.last().getName() : null;
      return new PageSetImpl<ObjectInfo>(returnVal, marker);
    } catch (IOException e) {
      throw new RuntimeException("problem reading response from request: " + request, e);
    }
  }
Example #13
0
  /**
   * Handles the configuration submission.
   *
   * <p>Load view-specific properties here.
   */
  @Override
  protected void submit(StaplerRequest req) throws ServletException, FormException, IOException {
    jobNames.clear();
    for (TopLevelItem item : Hudson.getInstance().getItems()) {
      if (req.getParameter(item.getName()) != null) jobNames.add(item.getName());
    }

    if (req.getParameter("useincluderegex") != null) {
      includeRegex = Util.nullify(req.getParameter("includeRegex"));
      if (includeRegex == null) includePattern = null;
      else includePattern = Pattern.compile(includeRegex);
    } else {
      includeRegex = null;
      includePattern = null;
    }

    if (columns == null) {
      columns = new DescribableList<ListViewColumn, Descriptor<ListViewColumn>>(Saveable.NOOP);
    }
    columns.rebuildHetero(req, req.getSubmittedForm(), ListViewColumn.all(), "columns");

    if (jobFilters == null) {
      jobFilters = new DescribableList<ViewJobFilter, Descriptor<ViewJobFilter>>(Saveable.NOOP);
    }
    jobFilters.rebuildHetero(req, req.getSubmittedForm(), ViewJobFilter.all(), "jobFilters");

    String filter = Util.fixEmpty(req.getParameter("statusFilter"));
    statusFilter = filter != null ? "1".equals(filter) : null;
  }
Example #14
0
  /**
   * Returns a read-only view of all {@link Job}s in this view.
   *
   * <p>This method returns a separate copy each time to avoid concurrent modification issue.
   */
  public synchronized List<TopLevelItem> getItems() {
    SortedSet<String> names = new TreeSet<String>(jobNames);

    if (includePattern != null) {
      for (TopLevelItem item : Hudson.getInstance().getItems()) {
        String itemName = item.getName();
        if (includePattern.matcher(itemName).matches()) {
          names.add(itemName);
        }
      }
    }

    List<TopLevelItem> items = new ArrayList<TopLevelItem>(names.size());
    for (String n : names) {
      TopLevelItem item = Hudson.getInstance().getItem(n);
      // Add if no status filter or filter matches enabled/disabled status:
      if (item != null
          && (statusFilter == null
              || !(item instanceof AbstractProject)
              || ((AbstractProject) item).isDisabled() ^ statusFilter)) items.add(item);
    }

    // check the filters
    Iterable<ViewJobFilter> jobFilters = getJobFilters();
    List<TopLevelItem> allItems = Hudson.getInstance().getItems();
    for (ViewJobFilter jobFilter : jobFilters) {
      items = jobFilter.filter(items, allItems, this);
    }

    return items;
  }
  /**
   * aggregates all collected neg examples CAVE: it is necessary to call one of the make functions
   * before calling this OTHERWISE it will choose random examples
   *
   * @param neglimit size of negative Example set, 0 means all, which can be quite large
   * @param stable decides whether neg Examples are randomly picked, default false, faster for
   *     developing, since the cache can be used
   * @param forceNegLimit forces that exactly neglimit instances are returned by adding more
   *     instances
   */
  public SortedSet<OWLIndividual> getNegativeExamples(
      int neglimit, boolean stable, boolean forceNegLimit) {
    SortedSet<OWLIndividual> negatives = new TreeSet<OWLIndividual>();
    negatives.addAll(fromParallelClasses);
    negatives.addAll(fromRelated);
    negatives.addAll(fromSuperclasses);
    if (negatives.size() < neglimit) {
      makeNegativeExamplesFromAllOtherInstances();

      negatives.addAll(SetManipulation.stableShrinkInd(fromAllOther, neglimit - negatives.size()));
    }

    if (neglimit <= 0) {
      logger.debug("neg Example size NO shrinking: " + negatives.size());
      return negatives;
    }

    logger.debug("neg Example size before shrinking: " + negatives.size());
    if (stable) {
      negatives = SetManipulation.stableShrinkInd(negatives, neglimit);
    } else {
      negatives = SetManipulation.fuzzyShrinkInd(negatives, neglimit);
    }
    logger.debug("neg Example size after shrinking: " + negatives.size());
    return negatives;
  }
 /* (non-Javadoc)
  * @see java.lang.Object#toString()
  */
 public String toString() {
   final StringBuilder sb = new StringBuilder();
   SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet());
   union.addAll(dependenciesResolvedOptionMap.keySet());
   union.addAll(commandLineOptionMap.keySet());
   union.addAll(optionFileOptionMap.keySet());
   for (Option option : union) {
     Object value = null;
     for (int i = OptionContainer.SAVEDOPTION; i <= OptionContainer.OPTIONFILE; i++) {
       if (i == OptionContainer.SAVEDOPTION) {
         value = savedOptionMap.get(option);
       } else if (i == OptionContainer.DEPENDENCIES_RESOLVED) {
         value = dependenciesResolvedOptionMap.get(option);
       } else if (i == OptionContainer.COMMANDLINE) {
         value = commandLineOptionMap.get(option);
       } else if (i == OptionContainer.OPTIONFILE) {
         value = optionFileOptionMap.get(option);
       }
       if (value != null) {
         break;
       }
     }
     sb.append(option.getGroup().getName() + "\t" + option.getName() + "\t" + value + "\n");
   }
   return sb.toString();
 }
Example #17
0
    /**
     * create a file chooser populated with file filters for the given pathway importers / exporters
     */
    private void createFileFilters(Set<? extends PathwayIO> set) {
      jfc.setAcceptAllFileFilterUsed(false);

      SortedSet<PathwayIO> exporters =
          new TreeSet<PathwayIO>(
              new Comparator<PathwayIO>() {
                public int compare(PathwayIO o1, PathwayIO o2) {
                  return o1.getName().compareTo(o2.getName());
                }
              });
      exporters.addAll(set);

      PathwayFileFilter selectedFilter = null;
      for (PathwayIO exp : exporters) {
        PathwayFileFilter ff = new PathwayFileFilter(exp);
        jfc.addChoosableFileFilter(ff);
        if (exp instanceof GpmlFormat) {
          selectedFilter = ff;
        }
      }
      if (selectedFilter != null) {
        jfc.setFileFilter(selectedFilter);
        fileDialog.setFilenameFilter(selectedFilter);
      }
    }
Example #18
0
 /**
  * @return Returns the {@link MonthlyWage}s from this class sorted by the person ids. The person
  *     ids are assumed to be numbers. If there are ids that are not numbers, those are sorted to
  *     the end of the collection.
  */
 public SortedSet<MonthlyWage> getSortedWages() {
   SortedSet<MonthlyWage> sortedWages =
       new TreeSet<>(
           (wage1, wage2) -> {
             Integer id1 = null, id2 = null;
             try {
               id1 = Integer.parseInt(wage1.getPerson().getId());
             } catch (NumberFormatException e) {
             }
             try {
               id2 = Integer.parseInt(wage2.getPerson().getId());
             } catch (NumberFormatException e) {
             }
             if (id1 != null && id2 != null) {
               return id1.compareTo(id2);
             } else if (id1 != null && id2 == null) {
               return -1;
             } else if (id1 == null && id2 != null) {
               return 1;
             } else {
               return wage1.getPerson().getId().compareTo(wage2.getPerson().getId());
             }
           });
   sortedWages.addAll(this.getWages());
   return sortedWages;
 }
  /**
   * @returns the neighbour IDs
   * @param userId - the numeric ID of the target user
   * @param itemId - the numerid ID of the target item
   * @param itemProfileMap - a map containing item profiles
   * @param simMap - a map containing user-user similarities
   */
  public ArrayList<Integer> getNeighbours(
      final Integer itemId,
      final Integer userId,
      final Map<Integer, Profile> userProfileMap,
      final SimilarityMap simMap) {
    SortedSet<ScoredThingDsc> ss =
        new TreeSet<
            ScoredThingDsc>(); // store all user IDs in order of descending similarity in a sorted
                               // set

    if (userProfileMap.containsKey(userId)) {
      for (Iterator<Integer> it = userProfileMap.get(userId).getIds().iterator();
          it.hasNext(); ) // iterate over each user in the item profile
      {
        Integer id = it.next();
        double sim = simMap.getSimilarity(itemId, id);
        if (sim > 0) ss.add(new ScoredThingDsc(sim, id));
      }
    }

    ArrayList<Integer> neighbours = new ArrayList<Integer>(); // get the k most similar neighbours

    int kCounter = 0;
    for (Iterator<ScoredThingDsc> it = ss.iterator(); it.hasNext(); ) {
      kCounter++;

      ScoredThingDsc st = it.next();
      neighbours.add((Integer) st.thing);

      if (kCounter > k) break;
    }

    return neighbours;
  }
Example #20
0
 @Override
 public List<Invocation> getMatches() {
   SortedSet<Invocation> set = new TreeSet<Invocation>(Invocation.COMPARATOR);
   set.addAll(keep.getMatches());
   set.removeAll(remove.getMatches());
   return new ArrayList<Invocation>(set);
 }
Example #21
0
  public String toString() {
    StringBuilder buffer = new StringBuilder();

    buffer.append("Hosts:     ").append(this.getHosts().size()).append("\n");
    buffer.append("Sites:     ").append(this.sites.size()).append("\n");
    buffer.append("Fragments: ").append(this.fragments.size()).append("\n");

    SortedSet<String> hosts = new TreeSet<String>();
    hosts.addAll(this.getHosts());

    for (String host_key : hosts) {
      buffer.append("\nHost ").append(CatalogKey.getNameFromKey(host_key)).append("\n");
      for (SiteEntry site : this.host_site_xref.get(host_key)) {
        buffer.append(SPACER).append("Site ").append(site.getId()).append("\n");
        for (FragmentEntry fragment : site.getFragments()) {
          buffer
              .append(SPACER)
              .append(SPACER)
              .append("Fragment ")
              .append(fragment)
              .append(" Size=")
              .append(fragment.getEstimatedSize())
              .append(" Heat=")
              .append(fragment.getEstimatedHeat())
              .append("\n");
        } // FOR
      } // FOR
      buffer.append("--------------------");
    } // FOR
    return (buffer.toString());
  }
Example #22
0
  /** Fluffs the given nodeset and accepts it. */
  public boolean filter(MutableNodeSet nodeSet) {
    IntArray toAdd = new IntArray();
    Graph graph = nodeSet.getGraph();

    /* We won't fluff clusters smaller than five elements,
     * there's not enough evidence to extend it more.
     */
    if (nodeSet.size() < 5) return true;

    do {
      int minCount = (int) Math.floor(2.0 * nodeSet.size() / 3.0);
      SortedSet<Integer> members = nodeSet.getMembers();
      toAdd.clear();

      for (int node : nodeSet.getExternalBoundaryNodes()) {
        int[] neis = graph.getAdjacentNodeIndicesArray(node, Directedness.ALL);

        int intersectionSize = 0;
        for (int neighbor : neis) if (members.contains(neighbor)) intersectionSize++;

        if (intersectionSize >= minCount) toAdd.add(node);
      }

      nodeSet.add(toAdd.toArray());
    } while (iterative && toAdd.size() > 0);

    return true;
  }
Example #23
0
  public static SortedSet<File> flattenAndSort(Iterable<File> files) throws IOException {

    final SortedSet<File> sortedFiles = new TreeSet<>(new FileComparator());

    for (File file : files) {
      if (file.isDirectory()) {
        Files.walkFileTree(
            file.toPath(),
            new SimpleFileVisitor<Path>() {

              @Override
              public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttributes)
                  throws IOException {

                sortedFiles.add(path.toFile());

                return FileVisitResult.CONTINUE;
              }
            });
      } else {
        sortedFiles.add(file);
      }
    }

    return sortedFiles;
  }
  @Override
  public void handle(Page page, TemplateContext local, TemplateContext global) {
    Homepage homepage = homepage(page.getSite());
    if (homepage == null || !homepage.isHomepageActivated()) {
      return; // TODO we might want 404 here
    }

    global.put("homepage", homepage);
    Person owner = homepage.getPerson();
    global.put("owner", owner);

    if (homepage.getShowCurrentAttendingExecutionCourses()) {
      SortedSet<Attends> attendedCoursesByName =
          new TreeSet<Attends>(Attends.ATTENDS_COMPARATOR_BY_EXECUTION_COURSE_NAME);
      attendedCoursesByName.addAll(homepage.getPerson().getCurrentAttends());
      global.put("attendingCourses", attendedCoursesByName);
    }

    List<? extends PartyContact> emails = owner.getEmailAddresses();
    global.put("visibleEmails", getSortedFilteredContacts(emails));

    List<? extends PartyContact> phones = owner.getPhones();
    global.put(
        "visiblePersonalPhones", getSortedFilteredContacts(phones, PartyContactType.PERSONAL));
    global.put("visibleWorkPhones", getSortedFilteredContacts(phones, PartyContactType.WORK));

    List<? extends PartyContact> mobilePhones = owner.getMobilePhones();
    global.put("visibleMobilePhones", getSortedFilteredContacts(mobilePhones));

    List<? extends PartyContact> websites = owner.getWebAddresses();
    global.put("visibleWebsites", getSortedFilteredContacts(websites));
  }
Example #25
0
  public static void RetrieveTrainMatrix() {
    try {
      BufferedReader flrdr =
          new BufferedReader(
              new FileReader("D:\\IR\\Assignment7\\Pytest\\part2\\output\\train_matrix.txt"));
      String line = "";
      int doc_count = 0;

      while ((line = flrdr.readLine()) != null) {
        SortedSet<Integer> word_ids = new TreeSet<Integer>();
        int val_count = 0;

        String[] key_value = line.split(" :: ");
        key_value[1] = key_value[1].substring(1, key_value[1].length() - 2);
        String[] values = key_value[1].split(",");

        FeatureNode[] node = new FeatureNode[values.length];

        for (String val : values) word_ids.add(Integer.parseInt(val.trim()));

        for (int val : word_ids) node[val_count++] = new FeatureNode(val, 1);

        if (spam_docs.contains(key_value[0].trim())) ylable[doc_count] = 1;
        else ylable[doc_count] = 0;

        train_matrix[doc_count++] = node;
      }
      flrdr.close();
    } catch (Exception e) {
      e.printStackTrace();
      System.exit(0);
    }
  }
Example #26
0
 @Transactional
 public void update(Node node, Integer[] viewOrgIds) {
   if (viewOrgIds == null) {
     viewOrgIds = new Integer[0];
   }
   SortedSet<NodeOrg> nodeOrgs = node.getNodeOrgs();
   if (nodeOrgs == null) {
     nodeOrgs = new TreeSet<NodeOrg>(new NodeOrgComparator());
     node.setNodeOrgs(nodeOrgs);
   }
   // 先更新
   for (NodeOrg nodeOrg : nodeOrgs) {
     if (ArrayUtils.contains(viewOrgIds, nodeOrg.getOrg().getId())) {
       nodeOrg.setViewPerm(true);
     } else {
       nodeOrg.setViewPerm(false);
     }
   }
   // 再新增
   for (Integer viewOrgId : viewOrgIds) {
     boolean contains = false;
     for (NodeOrg nodeOrg : nodeOrgs) {
       if (nodeOrg.getOrg().getId().equals(viewOrgId)) {
         contains = true;
         break;
       }
     }
     if (!contains) {
       nodeOrgs.add(save(node, viewOrgId, true));
     }
   }
 }
Example #27
0
 public static SortedSet<String> getClassNames(final SortedSet<ClassStats> classes) {
   final SortedSet<String> names = new TreeSet<>();
   for (final ClassStats c : classes) {
     names.add(c.classname);
   }
   return names;
 }
 public void sortReadTriples() {
   final SortedSet<Triple> sst =
       new TreeSet<Triple>(new TripleComparator(RDF3XIndexScan.CollationOrder.SPO));
   sst.addAll(readTriples);
   readTriples.clear();
   readTriples.addAll(sst);
 }
 /**
  * Returns the number of option values amongst all internal option containers.
  *
  * @return the number of option values amongst all internal option containers
  */
 public int getNumberOfOptionValues() {
   SortedSet<Option> union = new TreeSet<Option>(savedOptionMap.keySet());
   union.addAll(dependenciesResolvedOptionMap.keySet());
   union.addAll(commandLineOptionMap.keySet());
   union.addAll(optionFileOptionMap.keySet());
   return union.size();
 }
  /**
   * NOT IMPLEMENTED YET, DO NOT USE see <code> makeNegativeExamplesFromParallelClasses</code>
   *
   * @param positiveSet
   */
  @SuppressWarnings("unused")
  private void makeNegativeExamplesFromClassesOfInstances(SortedSet<OWLIndividual> positiveSet) {
    logger.debug("making neg Examples from parallel classes");
    SortedSet<OWLClassExpression> classes = new TreeSet<OWLClassExpression>();
    this.fromParallelClasses.clear();

    for (OWLIndividual instance : positiveSet) {
      try {
        // realization is not implemented in reasoningservice
        // classes.addAll(reasoningService.realize()
      } catch (Exception e) {
        logger.warn("not implemented in " + this.getClass());
      }
    }
    logger.debug("getting negExamples from " + classes.size() + " parallel classes");
    for (OWLClassExpression oneClass : classes) {
      logger.debug(oneClass);
      // rsc = new
      // JenaResultSetConvenience(queryConcept("\""+oneClass+"\"",limit));
      try {
        this.fromParallelClasses.addAll(reasoningService.getIndividuals(oneClass));
      } catch (Exception e) {
        logger.warn("not implemented in " + this.getClass());
      }
    }

    fromParallelClasses.removeAll(fullPositiveSet);
    logger.debug("|-neg Example size from parallelclass: " + fromParallelClasses.size());
    throw new RuntimeException(
        "not implemented in " + this.getClass() + "method makeNegativeExamplesFromParallelClasses");
  }