public void add(final OIdentifiable identifiable) {
    if (identifiable == null)
      throw new NullPointerException("Impossible to add a null identifiable in a ridbag");
    if (identifiable.getIdentity().isValid()) {
      Change counter = changes.get(identifiable);
      if (counter == null) changes.put(identifiable, new DiffChange(1));
      else {
        if (counter.isUndefined()) {
          counter = getAbsoluteValue(identifiable);
          changes.put(identifiable, counter);
        }
        counter.increment();
      }
    } else {
      final OModifiableInteger counter = newEntries.get(identifiable);
      if (counter == null) newEntries.put(identifiable, new OModifiableInteger(1));
      else counter.increment();
    }

    if (size >= 0) size++;

    if (this.owner != null) ORecordInternal.track(this.owner, identifiable);

    if (updateOwner)
      fireCollectionChangedEvent(
          new OMultiValueChangeEvent<OIdentifiable, OIdentifiable>(
              OMultiValueChangeEvent.OChangeType.ADD, identifiable, identifiable, null, false));
  }
示例#2
0
  protected void forwardToCoord(long seqno, Message msg) {
    if (is_coord) {
      forward(msg, seqno, false);
      return;
    }

    if (!running || flushing) {
      forward_table.put(seqno, msg);
      return;
    }

    if (!ack_mode) {
      forward_table.put(seqno, msg);
      forward(msg, seqno, false);
      return;
    }

    send_lock.lock();
    try {
      forward_table.put(seqno, msg);
      while (running && !flushing) {
        ack_promise.reset();
        forward(msg, seqno, true);
        if (!ack_mode || !running || flushing) break;
        Long ack = ack_promise.getResult(500);
        if ((Objects.equals(ack, seqno)) || !forward_table.containsKey(seqno)) break;
      }
    } finally {
      send_lock.unlock();
    }
  }
示例#3
0
  public NavigableMap<Number640, Data> removeReturnData(
      Number640 from, Number640 to, PublicKey publicKey) {
    RangeLock<Number640>.Range lock = rangeLock.lock(from, to);
    try {
      Map<Number640, Data> tmp = backend.subMap(from, to);
      NavigableMap<Number640, Data> result = new TreeMap<Number640, Data>();

      for (Number640 key : tmp.keySet()) {
        // fail fast, as soon as we want to remove 1 domain that we
        // cannot, abort
        if (!canClaimDomain(key.locationAndDomainKey(), publicKey)) {
          result.put(key, null);
        } else if (!canClaimEntry(key.locationAndDomainAndContentKey(), publicKey)) {
          result.put(key, null);
        } else {
          Data toRemove = backend.get(key);
          if (toRemove != null
              && (toRemove.publicKey() == null || toRemove.publicKey().equals(publicKey))) {
            backend.removeTimeout(key);
            Data removed = backend.remove(key, true);
            result.put(key, removed);
          }
        }
      }
      return result;
    } finally {
      lock.unlock();
    }
  }
 @Override
 protected SortedMap<String, Integer> makePopulatedMap() {
   NavigableMap<String, Integer> map = new SafeTreeMap<String, Integer>();
   map.put("one", 1);
   map.put("two", 2);
   map.put("three", 3);
   return SerializableTester.reserialize(map);
 }
示例#5
0
  private NavigableMap<byte[], byte[]> recordMap(final Class<?> idType, final boolean principal) {
    String ownerString = SOME_PRINCIPAL + ":" + principal;

    NavigableMap<byte[], byte[]> recordMap = new TreeMap<byte[], byte[]>(Bytes.BYTES_COMPARATOR);
    recordMap.put(HBaseACLRepository.ACL_ID_TYPE_QUALIFIER, idType.getName().getBytes());
    recordMap.put(HBaseACLRepository.ACL_TYPE_QUALIFIER, TYPE.getBytes());
    recordMap.put(HBaseACLRepository.ACL_OWNER_QUALIFIER, ownerString.getBytes());
    return recordMap;
  }
 @Override
 protected NavigableMap<String, ZoneRules> provideVersions(String zoneId) {
   NavigableMap<String, ZoneRules> result = new TreeMap<>();
   result.put("DynamicVersion1", BASE);
   if (count > 2) {
     result.put("DynamicVersion2", ALTERNATE);
   }
   return result;
 }
 public void testStandardLastEntry() {
   NavigableMap<String, Integer> forwarding =
       new StandardLastEntryForwardingNavigableMap<String, Integer>(
           new SafeTreeMap<String, Integer>());
   assertNull(forwarding.lastEntry());
   forwarding.put("b", 2);
   assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
   forwarding.put("c", 3);
   assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
   forwarding.put("a", 1);
   assertEquals(immutableEntry("c", 3), forwarding.lastEntry());
   forwarding.remove("c");
   assertEquals(immutableEntry("b", 2), forwarding.lastEntry());
 }
  public void remove(OIdentifiable identifiable) {
    if (removeFromNewEntries(identifiable)) {
      if (size >= 0) size--;
    } else {
      final Change counter = changes.get(identifiable);
      if (counter == null) {
        // Not persistent keys can only be in changes or newEntries
        if (identifiable.getIdentity().isPersistent()) {
          changes.put(identifiable, new DiffChange(-1));
          size = -1;
        } else
          // Return immediately to prevent firing of event
          return;
      } else {
        counter.decrement();

        if (size >= 0)
          if (counter.isUndefined()) size = -1;
          else size--;
      }
    }

    if (this.owner != null) ORecordInternal.unTrack(this.owner, identifiable);

    if (updateOwner)
      fireCollectionChangedEvent(
          new OMultiValueChangeEvent<OIdentifiable, OIdentifiable>(
              OMultiValueChangeEvent.OChangeType.REMOVE, identifiable, null, identifiable, false));
  }
示例#9
0
  /**
   * Load all elements of this type from the TMC LocationCodeList.
   *
   * @param aDirectory the directioy where the location-list is stored.
   * @param aLocationTable the top-level class we are working for
   * @return all elements indexed by LocationCode
   * @throws IOException if we cannot read
   */
  public static NavigableMap<Integer, TMCAdminArea> loadAll(
      final File aDirectory, final TMCLocationTable aLocationTable) throws IOException {
    NavigableMap<Integer, TMCAdminArea> retval =
        new TreeMap<Integer, TMCAdminArea>(new AdminAreaComparator());

    File inFile = new File(aDirectory, "ADMINISTRATIVEAREA.DAT");
    BufferedReader in =
        new BufferedReader(new InputStreamReader(new FileInputStream(inFile), "ISO8859-15"));
    in.readLine(); // header;
    String line = in.readLine();
    while (line != null) {
      String[] split = (line + " ").split(";");
      line = in.readLine();
      int i = 0;
      TMCAdminArea point =
          new TMCAdminArea(
              Integer.parseInt(split[i++]), // CID;
              Integer.parseInt(split[i++]), // TABCD;
              Integer.parseInt(split[i++]), // LCD;
              split[i++].charAt(0), // CLASS;
              Integer.parseInt(split[i++]), // TCD;
              Integer.parseInt(split[i++]), // STCD;
              parseOptionalInteger(split[i++]), // NID;
              parseOptionalInteger(split[i++]), // POL_LCD;
              aLocationTable);
      retval.put(point.getLCD(), point);
    }
    return retval;
  }
示例#10
0
  /**
   * Creates (if not already existing) and returns the partition in which the instant,value should
   * be written. instant can be invalid (in case value only or no partitioning) value can be null
   * (in case
   *
   * @return a Partition
   */
  public synchronized Partition createAndGetPartition(long instant, Object value)
      throws IOException {
    Partition partition;
    if (partitioningSpec.timeColumn != null) {
      if ((pcache == null) || (pcache.start > instant) || (pcache.getEnd() <= instant)) {

        Entry<Long, Interval> entry = intervals.floorEntry(instant);
        if ((entry != null) && (instant < entry.getValue().getEnd())) {
          pcache = entry.getValue();
        } else { // no partition in this interval.
          PartitionInfo pinfo = partitioningSpec.timePartitioningSchema.getPartitionInfo(instant);
          pcache = new Interval(pinfo.partitionStart, pinfo.partitionEnd);
          intervals.put(pcache.start, pcache);
        }
      }
    }
    partition = pcache.get(value);
    if (partition == null) {
      if (partitioningSpec.timeColumn != null) {
        PartitionInfo pinfo = partitioningSpec.timePartitioningSchema.getPartitionInfo(instant);
        partition = createPartition(pinfo, value);
      } else {
        partition = createPartition(value);
      }
      pcache.add(value, partition);
    }
    return partition;
  }
示例#11
0
 /**
  * Create a snapshot of current map.
  *
  * @return a snapshot of current map.
  */
 public NavigableMap<K, V> snapshot() {
   this.lock.writeLock().lock();
   try {
     if (updates.isEmpty()) {
       return snapshot;
     }
     // put updates for merge to snapshot
     updatesToMerge = updates;
     updates = new ConcurrentHashMap<K, V>();
   } finally {
     this.lock.writeLock().unlock();
   }
   // merging the updates to snapshot
   for (Map.Entry<K, V> entry : updatesToMerge.entrySet()) {
     snapshot.put(entry.getKey(), entry.getValue());
   }
   // clear updatesToMerge
   this.lock.writeLock().lock();
   try {
     updatesToMerge = new ConcurrentHashMap<K, V>();
   } finally {
     this.lock.writeLock().unlock();
   }
   return snapshot;
 }
示例#12
0
 /**
  * @param catalogTracker
  * @param serverName
  * @return List of user regions installed on this server (does not include catalog regions).
  * @throws IOException
  */
 public static NavigableMap<HRegionInfo, Result> getServerUserRegions(
     CatalogTracker catalogTracker, final ServerName serverName) throws IOException {
   final NavigableMap<HRegionInfo, Result> hris = new TreeMap<HRegionInfo, Result>();
   // Fill the above hris map with entries from .META. that have the passed
   // servername.
   CollectingVisitor<Result> v =
       new CollectingVisitor<Result>() {
         @Override
         void add(Result r) {
           if (r == null || r.isEmpty()) return;
           ServerName sn = getServerNameFromCatalogResult(r);
           if (sn != null && sn.equals(serverName)) this.results.add(r);
         }
       };
   fullScan(catalogTracker, v);
   List<Result> results = v.getResults();
   if (results != null && !results.isEmpty()) {
     // Convert results to Map keyed by HRI
     for (Result r : results) {
       Pair<HRegionInfo, ServerName> p = parseCatalogResult(r);
       if (p != null && p.getFirst() != null) hris.put(p.getFirst(), r);
     }
   }
   return hris;
 }
示例#13
0
 public void testHandleToFileAndFileToHandle() {
   final PersistentEntityStoreImpl store = getEntityStore();
   final PersistentStoreTransaction txn = getStoreTransaction();
   store.getConfig().setMaxInPlaceBlobSize(0); // no in-lace blobs
   final int count = 1000;
   for (int i = 0; i < count; ++i) {
     txn.newEntity("E").setBlob("b", new ByteArrayInputStream("content".getBytes()));
   }
   Assert.assertTrue(txn.flush());
   final FileSystemBlobVault blobVault = (FileSystemBlobVault) store.getBlobVault();
   final NavigableMap<Long, File> handlesToFiles = new TreeMap<>();
   for (final BackupStrategy.FileDescriptor fd : blobVault.getBackupStrategy().listFiles()) {
     final File file = fd.getFile();
     if (file.isFile() && !file.getName().equals(FileSystemBlobVaultOld.VERSION_FILE)) {
       final long handle = blobVault.getBlobHandleByFile(file);
       Assert.assertFalse(handlesToFiles.containsKey(handle));
       handlesToFiles.put(handle, file);
       Assert.assertEquals(file, blobVault.getBlobLocation(handle));
     }
   }
   final long min = handlesToFiles.navigableKeySet().iterator().next();
   Assert.assertEquals(0L, min);
   final long max = handlesToFiles.descendingKeySet().iterator().next();
   Assert.assertEquals((long) (count - 1), max);
 }
  @Test
  public void insertZeroDataPointsNothingBetween() {
    NavigableMap<TimeAxisKey, DiffStat> diffStats = new TreeMap<>();
    YearMonthDay firstKey = new YearMonthDay((short) 2012, (byte) 1, (byte) 2);
    YearMonthDay secondKey = new YearMonthDay((short) 2012, (byte) 1, (byte) 3);

    diffStats.put(firstKey, new DiffStat(1, 1));
    diffStats.put(secondKey, new DiffStat(2, 2));
    // TODO fix hamcrest
    assertEquals(2, diffStats.size());

    DiffStatGenerator.insertZeroDataPoints(diffStats);
    assertEquals(2, diffStats.size());
    assertEquals(new DiffStat(1, 1), diffStats.get(firstKey));
    assertEquals(new DiffStat(2, 2), diffStats.get(secondKey));
  }
  public static void addtoMinheap() {

    for (RankedDoc i : R) {
      lminheap.put(i.novelty, Integer.toString(i.DOC));
    }

    lminheap = lminheap.descendingMap();
  }
示例#16
0
  private NavigableMap<String, Integer> reduce(List<Result> list) {

    NavigableMap<String, Integer> reducedMap = new ConcurrentSkipListMap<String, Integer>();

    Iterator<Result> iter = list.iterator();
    while (iter.hasNext()) {
      Result result = iter.next();
      if (reducedMap.containsKey(result.getWord())) {
        Integer value = (Integer) reducedMap.get(result.getWord());
        value++;
        reducedMap.put(result.getWord(), value);
      } else {
        reducedMap.put(result.getWord(), Integer.valueOf(1));
      }
    }
    return reducedMap;
  }
示例#17
0
 public PartitionManager(TableDefinition tableDefinition) {
   this.tableDefinition = tableDefinition;
   this.partitioningSpec = tableDefinition.getPartitioningSpec();
   if (partitioningSpec.type == _type.NONE
       || partitioningSpec.type == _type.VALUE) { // pcache never changes in this case
     pcache = new Interval(TimeEncoding.MIN_INSTANT, TimeEncoding.MAX_INSTANT);
     intervals.put(TimeEncoding.MIN_INSTANT, pcache);
   }
 }
示例#18
0
 private void addParametersFromQueryString(String queryString) {
   if (queryString == null || queryString.length() == 0) {
     return;
   }
   final StringTokenizer params = new StringTokenizer(queryString, "&", false);
   while (params.hasMoreTokens()) {
     final String rawEntry = params.nextToken();
     final int ndx = rawEntry.indexOf('=');
     if (ndx < 0) {
       final String key = decode(rawEntry);
       parameters.put(key, "");
     } else {
       final String key = decode(rawEntry.substring(0, ndx));
       final String value = decode(rawEntry.substring(ndx + 1));
       parameters.put(key, value);
     }
   }
 }
  public void testBackwardIteration() throws IOException {
    final int records = 10000;

    long seed = System.currentTimeMillis();
    MersenneTwisterFast mersenneTwisterFast = new MersenneTwisterFast(1381162033616L);
    System.out.println("testBackwardIteration seed : " + seed);

    NavigableMap<OClusterPosition, byte[]> positionRecordMap = new TreeMap<OClusterPosition, byte[]>();

    ORecordVersion recordVersion = OVersionFactory.instance().createVersion();
    recordVersion.increment();
    recordVersion.increment();

    for (int i = 0; i < records; i++) {
      int recordSize = mersenneTwisterFast.nextInt(2 * OClusterPage.MAX_RECORD_SIZE) + 1;
      byte[] record = new byte[recordSize];
      mersenneTwisterFast.nextBytes(record);

      final OPhysicalPosition physicalPosition = paginatedCluster.createRecord(record, recordVersion, (byte) 2);
      positionRecordMap.put(physicalPosition.clusterPosition, record);
    }

    Iterator<OClusterPosition> positionIterator = positionRecordMap.keySet().iterator();
    while (positionIterator.hasNext()) {
      OClusterPosition clusterPosition = positionIterator.next();
      if (mersenneTwisterFast.nextBoolean()) {
        Assert.assertTrue(paginatedCluster.deleteRecord(clusterPosition));
        positionIterator.remove();
      }
    }

    OPhysicalPosition physicalPosition = new OPhysicalPosition();
    physicalPosition.clusterPosition = OClusterPositionFactory.INSTANCE.valueOf(Long.MAX_VALUE);

    OPhysicalPosition[] positions = paginatedCluster.floorPositions(physicalPosition);
    Assert.assertTrue(positions.length > 0);

    positionIterator = positionRecordMap.descendingKeySet().iterator();
    int counter = 0;
    while (positionIterator.hasNext()) {
      Assert.assertTrue(positions.length > 0);

      OClusterPosition testedPosition = positionIterator.next();
      Assert.assertEquals(positions[positions.length - 1].clusterPosition, testedPosition);

      OPhysicalPosition positionToFind = positions[positions.length - 1];
      positions = paginatedCluster.lowerPositions(positionToFind);

      counter++;
    }

    Assert.assertEquals(paginatedCluster.getEntries(), counter);

    Assert.assertEquals(paginatedCluster.getFirstPosition(), positionRecordMap.firstKey());
    Assert.assertEquals(paginatedCluster.getLastPosition(), positionRecordMap.lastKey());
  }
示例#20
0
 public IndexRateSource update(Collection<IndexRate> indexRates) {
   for (IndexRate indexRate : indexRates) {
     if (!data.containsKey(indexRate.indexId)) {
       data.put(indexRate.indexId, new ConcurrentSkipListMap<>());
     }
     NavigableMap<LocalDate, IndexRate> dateMap = data.get(indexRate.indexId);
     dateMap.put(indexRate.date, indexRate);
   }
   return this;
 }
示例#21
0
    @Override
    public void remove() {
      if (currentRemoved)
        throw new IllegalStateException("Current element has already been removed");

      if (currentValue == null)
        throw new IllegalStateException("Next method was not called for given iterator");

      if (removeFromNewEntries(currentValue)) {
        if (size >= 0) size--;
      } else {
        Change counter = changedValues.get(currentValue);
        if (counter != null) {
          counter.decrement();
          if (size >= 0)
            if (counter.isUndefined()) size = -1;
            else size--;
        } else {
          if (nextChange != null) {
            changedValues.put(currentValue, new DiffChange(-1));
            changedValuesIterator =
                changedValues.tailMap(nextChange.getKey(), false).entrySet().iterator();
          } else {
            changedValues.put(currentValue, new DiffChange(-1));
          }

          size = -1;
        }
      }

      if (OSBTreeRidBag.this.owner != null)
        ORecordInternal.unTrack(OSBTreeRidBag.this.owner, currentValue);

      if (updateOwner)
        fireCollectionChangedEvent(
            new OMultiValueChangeEvent<OIdentifiable, OIdentifiable>(
                OMultiValueChangeEvent.OChangeType.REMOVE,
                currentValue,
                null,
                currentValue,
                false));
      currentRemoved = true;
    }
示例#22
0
  @Override
  public void put(Bitmap bitmap) {
    int size = Util.getBitmapByteSize(bitmap);
    Key key = keyPool.get(size, bitmap.getConfig());

    groupedMap.put(key, bitmap);

    NavigableMap<Integer, Integer> sizes = getSizesForConfig(bitmap.getConfig());
    Integer current = sizes.get(key.size);
    sizes.put(key.size, current == null ? 1 : current + 1);
  }
 private void addFunction(
     List<IParameter> plist,
     List<AFunction> flist,
     NavigableMap<Integer, AFunction> fmap,
     AFunction function) {
   int psize = plist.size();
   flist.add(function);
   fmap.put(psize, function);
   for (IParameter p : function.parameters) {
     plist.add(p);
   }
 }
 public void constructCache(DefaultSolverScope solverScope) {
   cachedEntityMap = new TreeMap<Double, Object>();
   ScoreDirector scoreDirector = solverScope.getScoreDirector();
   double probabilityWeightOffset = 0L;
   for (Object value : childValueSelector) {
     double probabilityWeight =
         valueProbabilityWeightFactory.createProbabilityWeight(scoreDirector, value);
     cachedEntityMap.put(probabilityWeightOffset, value);
     probabilityWeightOffset += probabilityWeight;
   }
   probabilityWeightTotal = probabilityWeightOffset;
 }
示例#25
0
 String decode(Integer textLength, Double number) {
   String str = "";
   NavigableMap<Double, Character> sortedMap = new TreeMap<>();
   rangeTable.forEach((k, v) -> sortedMap.put(v.getLow(), k));
   for (int i = 0; i < textLength; i++) {
     Character value = sortedMap.floorEntry(number).getValue();
     str = str.concat(String.valueOf(value));
     Range range = rangeTable.get(value);
     number = (number - range.getLow()) / (range.getHigh() - range.getLow());
   }
   return str;
 }
 public void constructCache(DefaultSolverScope solverScope) {
   cachedEntityMap = new TreeMap<Double, Object>();
   ScoreDirector scoreDirector = solverScope.getScoreDirector();
   double probabilityWeightOffset = 0L;
   // TODO Fail-faster if a non FromSolutionPropertyValueSelector is used
   for (Object value : childValueSelector) {
     double probabilityWeight =
         probabilityWeightFactory.createProbabilityWeight(scoreDirector, value);
     cachedEntityMap.put(probabilityWeightOffset, value);
     probabilityWeightOffset += probabilityWeight;
   }
   probabilityWeightTotal = probabilityWeightOffset;
 }
示例#27
0
 private NavigableMap<Number640, Data> getLatestInternalOrig(NavigableMap<Number640, Data> input) {
   // delete all predecessors
   NavigableMap<Number640, Data> result = new TreeMap<Number640, Data>();
   while (!input.isEmpty()) {
     // first entry is a latest version
     Entry<Number640, Data> latest = input.lastEntry();
     // store in results list
     result.put(latest.getKey(), latest.getValue());
     // delete all predecessors of latest entry
     deletePredecessors(latest.getKey(), input);
   }
   return result;
 }
 /** {@inheritDoc} */
 @Override
 public KijiTableKeyValueDatabase putValue(String table, String key, byte[] value)
     throws IOException {
   NavigableMap<String, byte[]> keyValueMap;
   if (mMetaMap.containsKey(table)) {
     keyValueMap = mMetaMap.get(table);
   } else {
     keyValueMap = new TreeMap<String, byte[]>();
   }
   keyValueMap.put(key, value);
   mMetaMap.put(table, keyValueMap);
   return this;
 }
  private void addRequestEndPointUsingPath(
      ContextMeta context,
      ServiceMeta service,
      ServiceMethodMeta method,
      RequestMeta requestMeta,
      String path) {
    RequestMetaData metaData = new RequestMetaData(path, context, requestMeta, method, service);

    if (requestMeta.getCallType() == CallType.ADDRESS) {
      metaDataMap.put(path, metaData);
    } else {
      treeMap.put(path, metaData);
    }
  }
示例#30
0
  @Override
  protected ApacheLogEntry prefetch() throws Exception {
    while (sortedBuffer.size() < maxSortedBufferSize) {
      if (itEntry == null) {
        if (itFile.hasNext()) {
          itEntry = new ApacheLogEntryIterator(LogDirectory.open(itFile.next().getValue()), true);
        } else {
          break;
        }
      }

      if (!itEntry.hasNext()) {
        itEntry = null;
        continue;
      }

      ApacheLogEntry entry = itEntry.next();

      if (low != null) {
        int d = entry.getDate().compareTo(low);
        if (d < 0 || (d == 0 && !lowInclusive)) {
          continue;
        }
      }

      sortedBuffer.put(entry.getDate(), entry);
    }

    if (!sortedBuffer.isEmpty()) {
      ApacheLogEntry entry = sortedBuffer.pollFirstEntry().getValue();

      if (sanityCheckMonotonictyDate != null) {
        if (sanityCheckMonotonictyDate.compareTo(entry.getDate()) > 0) {
          throw new RuntimeException("Dates are not monoton");
        }
      }
      sanityCheckMonotonictyDate = entry.getDate();

      if (high != null) {
        int d = high.compareTo(entry.getDate());
        if (d < 0 || (d == 0 && !highInclusive)) {
          return finish();
        }
      }

      return entry;
    }

    return finish();
  }