Java MutableBoolean.booleanValue方法代码示例

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@Override
protected ActivityResultContext execute() throws Exception {

    // on attend sur un lock, si nécessaire
    final String lockKey = getStringVariable(WAIT_LOCK_KEY);
    if (lockKey != null) {
        final MutableBoolean lock = (MutableBoolean) datastore.get(lockKey);
        if (lock != null) {
            //noinspection SynchronizationOnLocalVariableOrMethodParameter
            synchronized (lock) {
                while (lock.booleanValue()) {
                    lock.wait();
                }
            }
        }
    }

    // on stocke un pseudo-résultat dans le datastore global (pour simuler la database dans le cas ordinaire)
    final String key = getStringVariable(RESULTS_KEY);
    datastore.put(key, true);

    return new FinishedActivityResultContext();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@Test
public void testCallTwice() throws Exception {
    final MutableInt callCount = new MutableInt(0);
    final MutableBoolean called = new MutableBoolean(false);
    Polling p = new Polling() {
        @Override
        public Boolean call() throws Exception {
            callCount.increment();
            boolean b = called.booleanValue();
            called.setTrue();
            return b;
        }
    };
    p.poll(500, 10);

    assertEquals(2, callCount.intValue());
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@Test
public void testCallableTwice() throws Exception {
    final MutableInt callCount = new MutableInt(0);
    final MutableBoolean called = new MutableBoolean(false);
    Polling p = new Polling(new Callable<Boolean>() {
        @Override
        public Boolean call() throws Exception {
            callCount.increment();
            boolean b = called.booleanValue();
            called.setTrue();
            return b;
        }
    });
    p.poll(500, 10);

    assertEquals(2, callCount.intValue());
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@Override
public boolean isBlank() {
  CsvGridSheetPane gridSheet = getGridSheet();
  MutableBoolean result = new MutableBoolean(true);
  forEachCell(new ICellConsumer() {
    @Override
    public boolean accept(int r, int c) {
      Object val = gridSheet.getValueAt(r, c);
      if (val != null && !val.toString().isEmpty()) {
        result.setFalse();
        return false;
      }
      return true;
    }
  });
  return result.booleanValue();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private String decodeString(ByteBuf in) throws ProtocolException {
    final StringBuilder buffer = new StringBuilder();
    final MutableBoolean reachCRLF = new MutableBoolean(false);
    setReaderIndex(in, in.forEachByte(new ByteBufProcessor() {

        @Override
        public boolean process(byte value) throws Exception {
            if (value == '\n') {
                if ((byte) buffer.charAt(buffer.length() - 1) != '\r') {
                    throw new ProtocolException("Response is not ended by CRLF");
                } else {
                    buffer.setLength(buffer.length() - 1);
                    reachCRLF.setTrue();
                    return false;
                }
            } else {
                buffer.append((char) value);
                return true;
            }
        }
    }));
    return reachCRLF.booleanValue() ? buffer.toString() : null;
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private static <T> VlanAllocation of(Collection<T> ports, Function<T, Optional<Integer>> sVlanId, Function<T, Optional<Vlan>> vlan) {
  MutableBoolean overlappingVlan = new MutableBoolean(false);
  Map<Optional<Integer>, Vlan> allocationsPerSVlan = ports.stream().collect(Collectors.toMap(
      sVlanId,
      port -> vlan.apply(port).orElse(Vlan.none()),
      (a, b) -> {
        if (a.overlaps(b)) {
          overlappingVlan.setTrue();
        }
        return a.union(b);
      }));
  Vlan allocatedSVlans = ports.stream()
      .map(port -> sVlanId.apply(port).map(Vlan::singleton).orElse(Vlan.none()))
      .reduce(Vlan.none(), Vlan::union);
  if (!overlappingVlan.booleanValue() && allocatedSVlans.overlaps(allocationsPerSVlan.getOrDefault(Optional.empty(), Vlan.none()))) {
    overlappingVlan.setTrue();
  };
  return new VlanAllocation(overlappingVlan.booleanValue(), allocationsPerSVlan, allocatedSVlans);
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private static boolean writeBytesForView(
        CountingOutputStream countingOutputStream, byte[] bytes, int maxLength, MutableBoolean truncated) {
    if (truncated.booleanValue()) {
        return false;
    }

    if (countingOutputStream.getTotalWrittenByteCount() + bytes.length > maxLength) {
        truncated.setTrue();
        return false;
    } else {
        try {
            countingOutputStream.write(bytes);
            return true;
        } catch (IOException ignored) {
            truncated.setTrue();
            return false;
        }
    }
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
public boolean createOrAssociate(final Changeset changeset, final Set<String> extractedIssues)
{
    final MutableBoolean wasCreated = new MutableBoolean(false);
    ChangesetMapping changesetMapping = activeObjects.executeInTransaction(new TransactionCallback<ChangesetMapping>()
    {
        @Override
        public ChangesetMapping doInTransaction()
        {
            ChangesetMapping chm = getChangesetMapping(changeset);
            if (chm == null)
            {
                chm = activeObjects.create(ChangesetMapping.class);
                fillProperties(changeset, chm);
                chm.save();
                wasCreated.setValue(true);
            }

            associateRepositoryToChangeset(chm, changeset.getRepositoryId());
            if (extractedIssues != null)
            {
                associateIssuesToChangeset(chm, extractedIssues);
            }

            return chm;
        }
    });

    changeset.setId(changesetMapping.getID());
    return wasCreated.booleanValue();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private boolean putInternal(K key, V value, Timestamp timestamp) {
    counter.incrementCount();
    Timestamp removed = removedItems.get(key);
    if (removed != null && removed.isNewerThan(timestamp)) {
        log.debug("ecmap - removed was newer {}", value);
        return false;
    }

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(key, (k, existing) -> {
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existing;
        } else {
            updated.setTrue();
            return new Timestamped<>(value, timestamp);
        }
        });

    boolean success = updated.booleanValue();
    if (!success) {
        log.debug("ecmap - existing was newer {}", value);
    }

    if (success && removed != null) {
        removedItems.remove(key, removed);
    }

    if (success && persistent) {
        persistentStore.put(key, value, timestamp);
    }

    return success;
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private void putInternal(K key, V value, Timestamp timestamp) {
    byte[] keyBytes = serializer.encode(key);
    byte[] removedBytes = tombstones.get(keyBytes);

    Timestamp removed = removedBytes == null ? null :
                        serializer.decode(removedBytes);
    if (removed != null && removed.isNewerThan(timestamp)) {
        return;
    }

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(keyBytes, (k, existingBytes) -> {
        Timestamped<V> existing = existingBytes == null ? null :
                                  serializer.decode(existingBytes);
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existingBytes;
        } else {
            updated.setTrue();
            return serializer.encode(new Timestamped<>(value, timestamp));
        }
    });

    boolean success = updated.booleanValue();

    if (success && removed != null) {
        tombstones.remove(keyBytes, removedBytes);
    }

    database.commit();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private void removeInternal(K key, Timestamp timestamp) {
    byte[] keyBytes = serializer.encode(key);

    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(keyBytes, (k, existingBytes) -> {
        Timestamp existing = existingBytes == null ? null :
                             serializer.decode(existingBytes);
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existingBytes;
        } else {
            updated.setTrue();
            // remove from items map
            return null;
        }
    });

    if (!updated.booleanValue()) {
        return;
    }

    byte[] timestampBytes = serializer.encode(timestamp);
    byte[] removedBytes = tombstones.get(keyBytes);

    Timestamp removedTimestamp = removedBytes == null ? null :
                                 serializer.decode(removedBytes);
    if (removedTimestamp == null) {
        tombstones.putIfAbsent(keyBytes, timestampBytes);
    } else if (timestamp.isNewerThan(removedTimestamp)) {
        tombstones.replace(keyBytes, removedBytes, timestampBytes);
    }

    database.commit();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
public static <T> Iterable<T> iterable(Iterator<T> seq) {
    final MutableBoolean used = new MutableBoolean(false);
    return new Iterable<T>() {

        @Override
        public Iterator<T> iterator() {
            if (!used.booleanValue()) {
                used.setValue(true);
                return seq;
            } else {
                throw new IllegalStateException("only allowed to iterate this iterable once");
            }
        }
    };
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@SuppressWarnings({"AccessingNonPublicFieldOfAnotherObject", "OverlyComplexMethod"})
private static boolean shouldSkipField(
        @Nullable String stringValue, ToStringOptions options, MutableBoolean quoted) {
    if (options.skipNulls && stringValue == null) {
        return true;
    }

    if (options.skipEmptyStrings) {
        if (quoted != null && quoted.booleanValue()) {
            if ("''".equals(stringValue) || "\"\"".equals(stringValue)) {
                return true;
            }
        } else {
            if (isEmpty(stringValue)) {
                return true;
            }
        }
    }

    if (options.skipBlankStrings) {
        if (quoted != null && quoted.booleanValue()) {
            return isBlank(stringValue) || isBlank(stringValue.substring(1, stringValue.length() - 1));
        } else {
            return isBlank(stringValue);
        }
    }

    return false;
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
private boolean removeInternal(K key, Timestamp timestamp) {
    if (timestamp == null) {
        return false;
    }

    counter.incrementCount();
    final MutableBoolean updated = new MutableBoolean(false);

    items.compute(key, (k, existing) -> {
        if (existing != null && existing.isNewerThan(timestamp)) {
            updated.setFalse();
            return existing;
        } else {
            updated.setTrue();
            // remove from items map
            return null;
        }
    });

    if (updated.isFalse()) {
        return false;
    }

    boolean updatedTombstone = false;

    if (!tombstonesDisabled) {
        Timestamp removedTimestamp = removedItems.get(key);
        if (removedTimestamp == null) {
            //Timestamp removed = removedItems.putIfAbsent(key, timestamp);
            updatedTombstone = (removedItems.putIfAbsent(key, timestamp) == null);
        } else if (timestamp.isNewerThan(removedTimestamp)) {
            updatedTombstone = removedItems.replace(key, removedTimestamp, timestamp);
        }
    }

    if (updated.booleanValue() && persistent) {
        persistentStore.remove(key, timestamp);
    }

    return (!tombstonesDisabled && updatedTombstone) || updated.booleanValue();
}
 

import org.apache.commons.lang3.mutable.MutableBoolean; //导入方法依赖的package包/类
@Test
public void test() throws IOException, InterruptedException {
  final HRegionServer rs = testUtil.getRSForFirstRegionInTable(tableName);
  final HRegion region = (HRegion) rs.getRegions(tableName).get(0);
  HRegion spiedRegion = spy(region);
  final MutableBoolean flushed = new MutableBoolean(false);
  final MutableBoolean reported = new MutableBoolean(false);
  doAnswer(new Answer<FlushResult>() {
    @Override
    public FlushResult answer(InvocationOnMock invocation) throws Throwable {
      synchronized (flushed) {
        flushed.setValue(true);
        flushed.notifyAll();
      }
      synchronized (reported) {
        while (!reported.booleanValue()) {
          reported.wait();
        }
      }
      rs.getWAL(region.getRegionInfo()).abortCacheFlush(
        region.getRegionInfo().getEncodedNameAsBytes());
      throw new DroppedSnapshotException("testcase");
    }
  }).when(spiedRegion).internalFlushCacheAndCommit(Matchers.<WAL> any(),
    Matchers.<MonitoredTask> any(), Matchers.<PrepareFlushResult> any(),
    Matchers.<Collection<HStore>> any());
  // Find region key; don't pick up key for hbase:meta by mistake.
  String key = null;
  for (Map.Entry<String, HRegion> entry: rs.onlineRegions.entrySet()) {
    if (entry.getValue().getRegionInfo().getTable().equals(this.tableName)) {
      key = entry.getKey();
      break;
    }
  }
  rs.onlineRegions.put(key, spiedRegion);
  Connection conn = testUtil.getConnection();

  try (Table table = conn.getTable(tableName)) {
    table.put(new Put(Bytes.toBytes("row0"))
            .addColumn(family, qualifier, Bytes.toBytes("val0")));
  }
  long oldestSeqIdOfStore = region.getOldestSeqIdOfStore(family);
  LOG.info("CHANGE OLDEST " + oldestSeqIdOfStore);
  assertTrue(oldestSeqIdOfStore > HConstants.NO_SEQNUM);
  rs.cacheFlusher.requestFlush(spiedRegion, false, FlushLifeCycleTracker.DUMMY);
  synchronized (flushed) {
    while (!flushed.booleanValue()) {
      flushed.wait();
    }
  }
  try (Table table = conn.getTable(tableName)) {
    table.put(new Put(Bytes.toBytes("row1"))
            .addColumn(family, qualifier, Bytes.toBytes("val1")));
  }
  long now = EnvironmentEdgeManager.currentTime();
  rs.tryRegionServerReport(now - 500, now);
  synchronized (reported) {
    reported.setValue(true);
    reported.notifyAll();
  }
  while (testUtil.getRSForFirstRegionInTable(tableName) == rs) {
    Thread.sleep(100);
  }
  try (Table table = conn.getTable(tableName)) {
    Result result = table.get(new Get(Bytes.toBytes("row0")));
    assertArrayEquals(Bytes.toBytes("val0"), result.getValue(family, qualifier));
  }
}