Esempio n. 1
0
  /**
   * Saves value to raster
   *
   * @param dLat Latitude.
   * @param dLon Longitude.
   * @param dValue Value to be written
   */
  public void put(double dLat, double dLon, double dValue) {

    // ico1 = indices

    IndexCoordinate ico1;

    // checking mask
    // if(plyMask!=null && !plyMask.contains(dLat, dLon)){
    //	return;
    // }

    // updating index maps
    if (!mapDate.containsKey(tim1)) {
      mapDate.put(tim1, iDateIndex);
      iDateIndex++;
    }
    if (!mapVert.containsKey(dVert)) {
      mapVert.put(dVert, iVertIndex);
      iVertIndex++;
    }

    // saving value
    ico1 = convertGeoCoordinateToIndexCoordinate(new GeoCoordinate(dLat, dLon, tim1, dVert));
    this.put(ico1.iLat, ico1.iLon, ico1.iTime, ico1.iVert, dValue);

    // updating list of coordinates
    lstCoords.add(new GeoCoordinate(mapLat.floorKey(dLat), mapLon.floorKey(dLon), tim1, dVert));
  }
 private void extractVocabulary(String directoryPath, int classID) throws IOException {
   File dir = new File(directoryPath);
   File[] directoryListing = dir.listFiles();
   numDocs += directoryListing.length;
   numDocsOfEachClass[classID] = directoryListing.length;
   TreeMap<String, Integer> thisClassVocab = new TreeMap<String, Integer>();
   if (directoryListing != null) {
     for (File child : directoryListing) {
       System.out.print(".");
       FileInputStream fis = new FileInputStream(child);
       BufferedReader br = new BufferedReader(new InputStreamReader(fis));
       String wholeFile = "";
       String line = "";
       while (line != null) {
         line = br.readLine();
         wholeFile += line + " ";
       }
       for (String term : Utils.tokenizeString(wholeFile)) {
         if (!term.matches(".*\\d+.*")) {
           if (!vocabulary.contains(term)) vocabulary.add(term);
           if (!thisClassVocab.containsKey(term)) {
             thisClassVocab.put(term, 1);
           } else if (thisClassVocab.containsKey(term)) {
             int temp = thisClassVocab.get(term) + 1;
             thisClassVocab.put(term, new Integer(temp));
           }
         }
       }
       br.close();
     }
   }
   vocabOfClasses.add(thisClassVocab);
 }
Esempio n. 3
0
  public static void findMoreCiteds(String text) {
    String[] words = text.split(" ");
    TreeMap<String, Integer> calculatedsMap = new TreeMap<>();
    for (int i = 0; i < words.length; i++) {
      String word = words[i];
      if (!calculatedsMap.containsKey(word)) {
        calculatedsMap.put(word, 1);
      } else {
        calculatedsMap.put(word, calculatedsMap.get(word) + 1);
      }
    }

    // TODO otimizar
    System.out.println("Termos mais utilizados:");
    String bigger = calculatedsMap.firstKey();
    int i = 0;
    while (i < 10) {
      for (String s : calculatedsMap.keySet()) {
        if ((calculatedsMap.containsKey(bigger) && calculatedsMap.containsKey(s))
            && calculatedsMap.get(bigger) < calculatedsMap.get(s)) {
          bigger = s;
        }
      }
      // TODO verificar se podemos ignorar caracteres aleatórios
      if (bigger.length() > 2) {
        System.out.println((++i) + ": " + bigger + " - " + calculatedsMap.get(bigger));
      }
      calculatedsMap.remove(bigger);
      bigger = calculatedsMap.firstKey();
    }
  }
Esempio n. 4
0
  @Override
  public void doGet(TreeMap<String, Integer> treeMap, String gId, String from, String to) {
    // TODO Auto-generated method stub
    FacebookManager facebookManager = new FacebookManager();
    List<models.Post> posts = facebookManager.getPostsFQL(gId, from, to);
    for (models.Post post : posts) {
      String userId = post.actor_id;
      int count = post.likes.findValue("count").asInt();
      if (!treeMap.containsKey(userId)) {
        treeMap.put(userId, count);
      } else {
        int value = (int) treeMap.get(userId) + count;
        treeMap.put(userId, value);
      }
    }

    List<models.Comment> comments = facebookManager.getPostsCommentsFQL(gId, from, to);
    for (models.Comment comment : comments) {
      String userId = comment.fromid;
      int count = comment.likes;
      if (!treeMap.containsKey(userId)) {
        treeMap.put(userId, count);
      } else {
        int value = (int) treeMap.get(userId) + count;
        treeMap.put(userId, value);
      }
    }
  }
  private void addStartEndKeysForTest(TreeMap<byte[], Integer> map, byte[] first, byte[] last) {
    Integer value = map.containsKey(first) ? map.get(first) : 0;
    map.put(first, value + 1);

    value = map.containsKey(last) ? map.get(last) : 0;
    map.put(last, value - 1);
  }
Esempio n. 6
0
  public void restore() {
    _listByIndex.clear();
    _listByClassId.clear();
    List<SubClass> subclasses = CharacterSubclassDAO.getInstance().restore(_owner);
    int lastFreeIndex = 2;
    for (SubClass sub : subclasses) {
      if (sub == null) // Невозможно, но хай будет.
      continue;

      if (size() >= MAX_SUB_COUNT) {
        _log.warn(
            "SubClassList:restore: Limit is subclass! Player: "
                + _owner.getName()
                + "("
                + _owner.getObjectId()
                + ")");
        break;
      }

      if (sub.isActive()) {
        _activeSubClass = sub;
      }

      if (sub.isBase()) {
        _baseSubClass = sub;
        sub.setIndex(1);
      } else {
        sub.setIndex(lastFreeIndex);
        lastFreeIndex++;
      }

      if (_listByIndex.containsKey(sub.getIndex()))
        _log.warn(
            "SubClassList:restore: Duplicate index in player subclasses! Player: "
                + _owner.getName()
                + "("
                + _owner.getObjectId()
                + ")");
      _listByIndex.put(sub.getIndex(), sub);

      if (_listByClassId.containsKey(sub.getClassId()))
        _log.warn(
            "SubClassList:restore: Duplicate class_id in player subclasses! Player: "
                + _owner.getName()
                + "("
                + _owner.getObjectId()
                + ")");
      _listByClassId.put(sub.getClassId(), sub);
    }

    _lastFreeIndex = lastFreeIndex;

    if (_listByIndex.size() != _listByClassId.size()) // Невозможно, но хай будет.
    _log.warn(
          "SubClassList:restore: The size of the lists do not match! Player: "
              + _owner.getName()
              + "("
              + _owner.getObjectId()
              + ")");
  }
 /** 获取TOKEN,一天最多获取200次,需要所有用户共享值 */
 public String GetToken() {
   String requestUrl =
       tokenUrl + "?grant_type=client_credential&appid=" + appid + "&secret=" + appsecret;
   TenpayHttpClient httpClient = new TenpayHttpClient();
   httpClient.setReqContent(requestUrl);
   if (httpClient.call()) {
     String res = httpClient.getResContent();
     Gson gson = new Gson();
     TreeMap map = gson.fromJson(res, TreeMap.class);
     // 在有效期内直接返回access_token
     if (map.containsKey("access_token")) {
       String s = map.get("access_token").toString();
     }
     // 如果请求成功
     if (null != map) {
       try {
         if (map.containsKey("access_token")) {
           Token = map.get("access_token").toString();
           return this.Token;
         }
       } catch (Exception e) {
         // 获取token失败
         System.out.println("失败:" + map.get("errmsg"));
       }
     }
   }
   return "";
 }
Esempio n. 8
0
 /**
  * Checks if the class contains the given element.
  *
  * @param element A Method or Field
  * @return
  */
 public boolean contains(FSTModelElement element) {
   if (element instanceof FSTMethod) {
     return methods.containsKey(((FSTMethod) element).getIdentifier());
   } else if (element instanceof FSTField) {
     return fields.containsKey(((FSTField) element).getIdentifier());
   }
   return false;
 }
Esempio n. 9
0
  @Override
  public List<Span> getSpansInRange(long start, long end) {
    /*
     * We first find the book-end files (first and last) whose Spans may
     * or may not fit in the the range. Intermediary files can be directly
     * passed, since they are completely within the time range.
     *
     *       [                            ]   <-- Time range
     *
     * |-----++|+++++++|+++++++|+++++++|+++----|-------|--->
     *  \     /                         \     /
     *   start                            end
     *   file                             file
     *
     */
    List<Span> out = new ArrayList<Span>();
    List<Long> middleFiles = new LinkedList<Long>();

    long startSecond = start / SpanStorage.NANOS_PER_SECOND;
    long endSecond = end / SpanStorage.NANOS_PER_SECOND;

    int numFiles = (int) (endSecond - startSecond) / secondsPerFile;
    for (int i = 1; i < (numFiles); i++) {
      middleFiles.add(startSecond + i * secondsPerFile);
    }

    synchronized (this.files) {
      for (Long l : middleFiles) {
        if (files.containsKey(l)) {
          try {
            readFileSpans(files.get(l), out);
          } catch (IOException e) {
            LOG.warn("Error reading file: " + files.get(l).getAbsolutePath());
          }
        }
      }

      // Start file
      if (files.containsKey(startSecond)) {
        try {
          readFileSpans(files.get(startSecond), out, start, end);
        } catch (IOException e) {
          LOG.warn("Error reading file: " + files.get(startSecond).getAbsolutePath());
        }
      }

      // End file
      if (files.containsKey(endSecond)) {
        try {
          readFileSpans(files.get(endSecond), out, start, end);
        } catch (IOException e) {
          LOG.warn("Error reading file: " + files.get(endSecond).getAbsolutePath());
        }
      }
    }
    return out;
  }
Esempio n. 10
0
 private void addFamixPackage(FamixObject famixObject) {
   if (!packages.containsKey(((FamixEntity) famixObject).uniqueName)) {
     packages.put(((FamixEntity) famixObject).uniqueName, (FamixPackage) famixObject);
     String parentUniqueName = ((FamixPackage) famixObject).belongsToPackage;
     FamixPackage parent = null;
     if (!parentUniqueName.equals("") && (packages.containsKey(parentUniqueName))) {
       parent = packages.get(parentUniqueName);
       parent.children.add(((FamixEntity) famixObject).uniqueName);
     }
   }
 }
Esempio n. 11
0
  public boolean changeSubClassId(int oldClassId, int newClassId) {
    if (!_listByClassId.containsKey(oldClassId)) return false;

    if (_listByClassId.containsKey(newClassId)) return false;

    SubClass sub = _listByClassId.get(oldClassId);
    sub.setClassId(newClassId);
    _listByClassId.remove(oldClassId);
    _listByClassId.put(sub.getClassId(), sub);
    return true;
  }
Esempio n. 12
0
  protected String fixSpelling(String turn) {

    String split[] = turn.split(" ");
    String result = "";
    for (int i = 0; i < split.length; i++) {

      String w = split[i];

      String lowerCase = w.toLowerCase();
      Pattern p =
          Pattern.compile(
              "([\\\\/\\.\\?!,;\\(\\)]*)([^\\\\/\\.\\?!,;\\(\\)]+)([\\\\/\\.\\?!,;\\(\\)]*)");
      Pattern p1 =
          Pattern.compile(
              "([\\\\/\\.\\?!,;\\(\\)]*)([^\\\\/\\.\\?!,;\\(\\)]+)([\\\\/\\.\\?!,;\\(\\)]+)([^\\\\/\\.\\?!,;\\(\\)]+)([\\\\/\\.\\?!,;\\(\\)]*)");
      Matcher m = p.matcher(lowerCase);
      Matcher m1 = p1.matcher(lowerCase);
      if (m.matches()) {
        if (misspellings.containsKey(m.group(2))) {
          String replacement = misspellings.get(m.group(2));
          result += m.group(1) + replacement + m.group(3) + " ";
        } else {
          result += m.group(1) + m.group(2) + m.group(3) + " ";
        }
      } else if (m1.matches()) {

        result +=
            m1.group(1)
                + (misspellings.containsKey(m1.group(2))
                    ? misspellings.get(m1.group(2))
                    : m1.group(2))
                + m1.group(3)
                + (misspellings.containsKey(m1.group(4))
                    ? misspellings.get(m1.group(4))
                    : m1.group(4))
                + m1.group(5)
                + " ";

      } else {
        if (misspellings.containsKey(lowerCase)) {

          String replacement = misspellings.get(lowerCase);

          result += replacement + " ";
        } else {
          if (!w.matches("[A-Z][a-z]*")) result += lowerCase + " ";
          else result += w + " ";
        }
      }
    }
    return result.trim();
  }
Esempio n. 13
0
  /**
   * Checks to see if this property has a match in the Lazy list to return if enabled or disabled.
   *
   * @param state
   * @return t/f
   */
  private boolean isXToXLazyEnabledByConfig(TreeMap<String, Boolean> state) {

    String classPackage = this.getClazz().getClassPackage();
    String className = this.getClazz().getClassName();

    boolean match =
        state.containsKey("*.*.*")
            || state.containsKey("*." + className + ".*")
            || state.containsKey("*." + className + "." + propertyName)
            || state.containsKey(classPackage + ".*." + propertyName)
            || state.containsKey(classPackage + ".*.*")
            || state.containsKey(classPackage + "." + className + ".*")
            || state.containsKey("*.*." + propertyName)
            || state.containsKey(classPackage + "." + className + "." + propertyName);

    // get the default
    boolean enableLazy = state.get("*");

    if (match) {
      // we're using: default... EXCEPT
      enableLazy = !enableLazy;
    }

    return enableLazy;
  }
  private void sync() {
    // note that sometimes the tuples active may be less than max_spout_pending, e.g.
    // max_spout_pending = 3
    // tx 1, 2, 3 active, tx 2 is acked. there won't be a commit for tx 2 (because tx 1 isn't
    // committed yet),
    // and there won't be a batch for tx 4 because there's max_spout_pending tx active
    TransactionStatus maybeCommit = _activeTx.get(_currTransaction);
    if (maybeCommit != null && maybeCommit.status == AttemptStatus.PROCESSED) {
      maybeCommit.status = AttemptStatus.COMMITTING;
      _collector.emit(
          TRANSACTION_COMMIT_STREAM_ID, new Values(maybeCommit.attempt), maybeCommit.attempt);
    }

    try {
      if (_activeTx.size() < _maxTransactionActive) {
        BigInteger curr = _currTransaction;
        for (int i = 0; i < _maxTransactionActive; i++) {
          if ((_coordinatorState.hasCache(curr) || _coordinator.isReady())
              && !_activeTx.containsKey(curr)) {
            TransactionAttempt attempt = new TransactionAttempt(curr, _rand.nextLong());
            Object state = _coordinatorState.getState(curr, _initializer);
            _activeTx.put(curr, new TransactionStatus(attempt));
            _collector.emit(
                TRANSACTION_BATCH_STREAM_ID,
                new Values(attempt, state, previousTransactionId(_currTransaction)),
                attempt);
          }
          curr = nextTransactionId(curr);
        }
      }
    } catch (FailedException e) {
      LOG.warn("Failed to get metadata for a transaction", e);
    }
  }
Esempio n. 15
0
  public StreamElement(TreeMap<String, Serializable> output, DataField[] fields) {
    int nbFields = output.keySet().size();
    if (output.containsKey("timed")) nbFields--;
    String fieldNames[] = new String[nbFields];
    Byte fieldTypes[] = new Byte[nbFields];
    Serializable fieldValues[] = new Serializable[nbFields];
    TreeMap<String, Integer> indexedFieldNames =
        new TreeMap<String, Integer>(new CaseInsensitiveComparator());
    int idx = 0;

    long timestamp = System.currentTimeMillis();
    for (String key : output.keySet()) {
      Serializable value = output.get(key);

      if (key.equalsIgnoreCase("timed")) timestamp = (Long) value;
      else {
        fieldNames[idx] = key;
        fieldValues[idx] = value;
        for (int i = 0; i < fields.length; i++) {
          if (fields[i].getName().equalsIgnoreCase(key))
            fieldTypes[idx] = fields[i].getDataTypeID();
        }
        indexedFieldNames.put(key, idx);
        idx++;
      }
    }
    this.fieldNames = fieldNames;
    this.fieldTypes = fieldTypes;
    this.fieldValues = fieldValues;
    this.indexedFieldNames = indexedFieldNames;
    this.timeStamp = timestamp;
  }
Esempio n. 16
0
 public void addNeighbour(String neighbour) {
   if (!addNeighbours) return;
   if (!instanceNeighbourMap.containsKey(neighbour)) return;
   this.instanceNeighbourMap.put(neighbour, "1");
   if (stripEmpty) neighbourMap.put(neighbour, "1");
   logger.debug(name + ": has neighbours: " + instanceNeighbourMap.toString());
 }
  /**
   * Compute which element should be quizzed next from the given set of elements UID, according to
   * the statistics of each elements.
   *
   * @param elementsUID Set of elementsUID from which to found the next element.
   * @return String Element Unique ID
   */
  public String getNextElement(Vector<String> elementsUID) {
    String currentElementUID = null;
    float bestScore = Float.NEGATIVE_INFINITY;
    float currentScore = bestScore;
    Vector<String> bestsUIDs = new Vector<String>();

    Iterator<String> itElements = elementsUID.iterator();
    while (itElements.hasNext()) {
      currentElementUID = itElements.next();

      if (!statistics.containsKey(currentElementUID)) {
        KanjiNoSensei.log(
            Level.WARNING,
            Messages.getString("LearningProfile.LearningProfile.WarningNeverSeenElement")
                + " : \""
                + currentElementUID
                + "\""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
        return currentElementUID;
      }

      currentScore = statistics.get(currentElementUID).getNeedScore();
      if (currentScore > bestScore) {
        bestsUIDs.removeAllElements();
        bestsUIDs.add(currentElementUID);
        bestScore = currentScore;
      } else if (currentScore == bestScore) {
        bestsUIDs.add(currentElementUID);
      }
    }

    return bestsUIDs.get(random.nextInt(bestsUIDs.size()));
  }
  public static void main(String[] args) throws IOException {
    br = new BufferedReader(new InputStreamReader(System.in));
    pr = new PrintWriter(new OutputStreamWriter(System.out));
    // br = new BufferedReader(new FileReader("in.txt"));
    // pr = new PrintWriter(new FileWriter("out.txt"));

    int n = readInt();
    int k = readInt();
    int[] boy = new int[n];
    TreeMap<Integer, Integer> girl = new TreeMap<Integer, Integer>();
    for (int i = 0; i < n; i++) {
      boy[i] = readInt();
    }
    for (int i = 0; i < n; i++) {
      int in = readInt();
      if (!girl.containsKey(in)) girl.put(in, 0);
      girl.put(in, girl.get(in) + 1);
    }
    Arrays.sort(boy);
    int ans = 0;
    for (int i = 0; i < n; i++) {
      Integer next = girl.ceilingKey(boy[i] - k);
      if (next != null && Math.abs(next - boy[i]) <= k) {
        ans++;
        girl.put(next, girl.get(next) - 1);
        if (girl.get(next) == 0) girl.remove(next);
      }
    }
    System.out.println(ans);

    pr.close();
  }
Esempio n. 19
0
  /**
   * this method draws a sample of size endPercent-startPercent and returns the size of this sample
   * which corresponds to the number of content items
   */
  public static double drawSample(int forumID, int startPercent, int endPercent) {
    if (!distributionsPerForumMap.containsKey(
        String.valueOf(forumID) + String.valueOf(startPercent) + String.valueOf(endPercent))) {
      ForumDistribution sampledForumDistribution = new ForumDistribution();
      ArrayList<Integer> threadLengths = threadsPerForumMap.get(forumID);
      Integer numberOfThreads = threadLengths.size();
      Integer startIndex;
      if (startPercent == 0.0) {
        startIndex = 0;
      } else {
        startIndex = (int) Math.round((startPercent / (double) 100) * numberOfThreads) - 1;
      }
      Integer endIndex = (int) Math.round((endPercent / (double) 100) * numberOfThreads) - 1;

      for (int i = startIndex; i <= endIndex; i++) {
        sampledForumDistribution.addThread(threadLengths.get(i));
      }

      distributionsPerForumMap.put(
          String.valueOf(forumID) + String.valueOf(startPercent) + String.valueOf(endPercent),
          sampledForumDistribution);
      dumpDistributionToFile(sampledForumDistribution, forumID, startPercent, endPercent);

      return (double) sampledForumDistribution.getNumberOfContentItems();
    } else {
      return (double)
          distributionsPerForumMap
              .get(
                  String.valueOf(forumID)
                      + String.valueOf(startPercent)
                      + String.valueOf(endPercent))
              .getNumberOfContentItems();
    }
  }
Esempio n. 20
0
  public TreeMap<String, Integer> getOccurrencesOfTagsAfterTurnLength(int min) throws IOException {
    TreeMap<String, Integer> occurrences = new TreeMap<String, Integer>();

    File[] files = inputDir.listFiles();
    int totalTurns = 0;
    for (File curFile : files) {
      if (!curFile.getName().endsWith(datafileExtension)) continue;
      System.out.print("Processing file: " + curFile + " ...");
      BufferedReader in = new BufferedReader(new FileReader(curFile));
      String line = in.readLine();

      while ((line = in.readLine()) != null) {
        String[] values = line.split("\\|", -1);
        if (values[0].equalsIgnoreCase("server")
            || values[1].equalsIgnoreCase("server")
            || values[2].equalsIgnoreCase("server")
            || values[9].isEmpty()) continue;
        String curTurn = values[8];

        String spellingCorrected = fixSpelling(curTurn);
        float distance = 0.0f;

        if (spellingCorrected.trim().isEmpty()) {
          //   System.out.println("EMPTY. SKIPPING THIS.");
          continue;
        }
        List<ArrayList<? extends HasWord>> sentences =
            MaxentTagger.tokenizeText(new StringReader(spellingCorrected));
        if (sentences.isEmpty()) {

          continue;
        }
        totalTurns++;
        for (ArrayList<? extends HasWord> sent : sentences) {
          ArrayList<TaggedWord> taggedSentence = tagger.tagSentence(sent);
          boolean lastSentence = (sent == sentences.get(sentences.size() - 1));
          if (lastSentence) {
            taggedSentence.add(new TaggedWord("", "EOT"));
          }

          for (int i = 0; i < taggedSentence.size(); i++) {
            TaggedWord cur = taggedSentence.get(i);
            distance++;
            if (distance >= min) {
              if (occurrences.containsKey(cur.tag())) {
                occurrences.put(cur.tag(), occurrences.get(cur.tag()) + 1);

              } else {
                occurrences.put(cur.tag(), 1);
              }
            }
          }
        }
      }
    }

    System.out.println("there were " + totalTurns + " turns in total.");

    return occurrences;
  }
Esempio n. 21
0
  /**
   * Get a message from out I18n data file.
   *
   * @param message - message title. Such as 'noPlayer'
   * @return - What the set message really is
   */
  public String getColoredMessage(final String message) {

    if (messageCache.containsKey(message)) {
      return messageCache.get(message);
    }

    try {

      try {

        final String translatedMessage =
            ChatColor.translateAlternateColorCodes(colorCode, customMessages.getString(message));

        messageCache.put(message, translatedMessage);

        return translatedMessage;

      } catch (final MissingResourceException ex) {

        final String translatedMessage =
            ChatColor.translateAlternateColorCodes(colorCode, messages.getString(message));

        messageCache.put(message, translatedMessage);

        return translatedMessage;
      }

    } catch (final MissingResourceException ex) {
      return defaultBundle.getString(message);
    }
  }
Esempio n. 22
0
  public SymbolTableEntry addSymbol(String theSymbol) {
    if (!table.containsKey(theSymbol)) {
      return table.put(theSymbol, new SymbolTableEntry(theSymbol));
    }

    return null;
  }
Esempio n. 23
0
  public void removeByClassId(int classId) {
    if (!_listByClassId.containsKey(classId)) return;

    int index = _listByClassId.get(classId).getIndex();
    _listByIndex.remove(index);
    _listByClassId.remove(classId);
  }
Esempio n. 24
0
 public String getNextAddress() {
   if (nodes.containsKey(this.nextId)) {
     return nodes.get(this.nextId);
   } else {
     return "255.255.255.255";
   }
 }
Esempio n. 25
0
  // TODO
  private void update(File[] files) throws IOException {
    InputStream in;
    TarInputStream tin;
    TarEntry entry;
    TreeMap<String, Long> entries = new TreeMap<String, Long>();

    if ((in = openFileRead(archive)) == null) {
      fatal(" ", 1);
    }
    if (decompress != 0) {
      in = wrapInputStream(in);
    }

    tin = new TarInputStream(in);

    while ((entry = tin.getNextEntry()) != null) {
      entries.put(entry.getName(), entry.getModTime().getTime());
    }
    tin.close();

    long etime, ftime;
    ArrayList<File> list = new ArrayList<File>();
    for (File file : files) {
      if (entries.containsKey(file.getPath())) {
        etime = entries.get(file.getPath());
        ftime = file.lastModified();
        if (etime >= ftime) {
          continue;
        }
      }
      list.add(file);
    }

    insert(list.toArray(files));
  }
Esempio n. 26
0
  public void insert(String s) {
    // Start from root
    TrieNode current = root;
    int i = 0;
    // Till end of string
    while (i < s.length()) {
      // Get the next character
      char c = s.charAt(i++);
      TreeMap<Character, TrieNode> childrenMap = (TreeMap) current.getChildren();

      // Check if the current node has it in its children
      if (childrenMap.containsKey((Character) c)) {
        // Get the child node matching the current character
        current = childrenMap.get((Character) c);

      } else {
        // Create a temporary node and add it to current nodes children
        TrieNode n = new TrieNode(c);
        childrenMap.put((Character) c, n);
        current = n;
      }
    }

    current.setEnd(true);
  }
Esempio n. 27
0
  /**
   * Read callback implementation
   *
   * @param rc return code
   * @param ledgerId Ledger identifier
   * @param entryId Entry identifier
   * @param bb Data
   * @param ctx Control object
   */
  public void readEntryComplete(int rc, long ledgerId, long entryId, ByteBuffer bb, Object ctx) {
    if (rc == 0) {
      bb.rewind();

      /*
       * Collect new vote
       */
      if (!votes.containsKey(entryId)) {
        votes.put(entryId, new ArrayList<ByteBuffer>());
      }
      votes.get(entryId).add(bb);

      /*
       * Extract hint
       */

      bb.position(16);
      long hint = bb.getLong();

      LOG.info("Received a response: " + rc + ", " + entryId + ", " + hint);

      if (!hints.containsKey(hint)) {
        hints.put(hint, 0);
      }
      hints.put(hint, hints.get(hint) + 1);

      synchronized (counter) {
        if (counter.incrementAndGet() >= minimum) ;
        counter.notify();
      }
    } else {
      LOG.debug("rc != 0");
    }
  }
Esempio n. 28
0
 /* (non-Javadoc)
  * @see org.exist.xquery.Module#resolveVariable(org.exist.dom.QName)
  */
 public Variable resolveVariable(QName qname) throws XPathException {
   VariableDeclaration decl = (VariableDeclaration) mGlobalVariables.get(qname);
   if (decl != null && !mStaticVariables.containsKey(qname)) {
     decl.eval(null);
   }
   return (Variable) mStaticVariables.get(qname);
 }
Esempio n. 29
0
  public String longestPrefix(String s) {
    if (root == null) return "";
    TrieNode current = root;
    String p = new String("");
    int prevWordEnd = 0;

    for (int i = 0; i < s.length(); i++) {
      TreeMap<Character, TrieNode> childrenMap =
          (TreeMap<Character, TrieNode>) current.getChildren();
      char c = s.charAt(i);
      if (childrenMap.containsKey((Character) c)) {
        p += c;
        current = childrenMap.get((Character) c);
        if (current.isEnd()) {
          prevWordEnd = i + 1;
        }

      } else {
        break;
      }
    }

    if (current.isEnd()) {
      return p;
    } else {
      return s.substring(0, prevWordEnd);
    }
  }
Esempio n. 30
0
 public void addContainer(UMOContainerContext container) {
   if (containers.containsKey(container.getName())) {
     throw new IllegalArgumentException(
         CoreMessages.containerAlreadyRegistered(container.getName()).toString());
   }
   containers.put(container.getName(), container);
 }