下面列出了java.util.Map.Entry#getValue ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
private void populateClassMap(IClassRegistry registry) throws ClassRegistryDuplicateIdException {
Map<String, Class<?>> registryIdToClassMap = registry.getIdToClassMap();
for (Entry<String, Class<?>> entry : registryIdToClassMap.entrySet()) {
Class<?> prevVal = null;
prevVal = idToClassMap.put(entry.getKey(), entry.getValue());
// prevVal stores previous value, if there is one
if ((prevVal != null) && (prevVal != entry.getValue())){
String message = "Class id clash with registry: " + registry.toString() +
". Previous value for id " + entry.getKey() + " is " + prevVal +
". Overwriting value is: " + entry.getValue() + ".";
throw new ClassRegistryDuplicateIdException(message);
}
}
}
/**
* rebuildToolSessions() expects to find a Map of Maps. The outer map contains
* the ToolSession ID's, and for each ToolSessionId, the inner map contains the
* attributes of that tool session
* @param mySession a Session that can be resolved to a MySession, giving access to the ToolSession property
* @param toolSessionMap a Serialized map of maps. The outer map containing the ToolSession ID, and the inner
* map containing the details of the ToolSession
*/
private void rebuildToolSessions(MySession mySession, Map<String, Serializable> toolSessionMap) {
for (Entry<String, Serializable> entry : toolSessionMap.entrySet()) {
String toolSessionKey = entry.getKey();
// if a tool session doesn't exist for this key, a new one will be created automatically
MyLittleSession toolSession = (MyLittleSession) mySession.getToolSession(toolSessionKey);
Serializable serializable = entry.getValue();
if (!(serializable instanceof Map)) {
log.warn("inner object for toolSession [" + toolSessionKey
+ "] should be [Map], found ["
+ serializable.getClass().getName() + "]");
continue;
}
@SuppressWarnings("unchecked")
Map<String, Serializable> toolAttributes = (Map<String, Serializable>) serializable;
processMLSessionMap(toolSession, toolAttributes);
}
}
protected Object grainsResponse(String body) throws IOException {
ApplyResponse applyResponse = new ApplyResponse();
List<Map<String, JsonNode>> responseList = new ArrayList<>();
Map<String, JsonNode> hostMap = new HashMap<>();
for (Entry<String, CloudVmMetaDataStatus> stringCloudVmMetaDataStatusEntry : instanceMap.entrySet()) {
CloudVmMetaDataStatus cloudVmMetaDataStatus = stringCloudVmMetaDataStatusEntry.getValue();
if (InstanceStatus.STARTED == cloudVmMetaDataStatus.getCloudVmInstanceStatus().getStatus()) {
String privateIp = cloudVmMetaDataStatus.getMetaData().getPrivateIp();
String hostname = "host-" + privateIp.replace(".", "-") + ".example.com";
if (grains.containsKey(hostname)) {
Matcher argMatcher = Pattern.compile(".*(arg=([^&]+)).*").matcher(body);
if (argMatcher.matches()) {
hostMap.put(hostname, objectMapper.valueToTree(grains.get(hostname).get(argMatcher.group(2))));
}
}
}
}
responseList.add(hostMap);
applyResponse.setResult(responseList);
return objectMapper.writeValueAsString(applyResponse);
}
/**
* Add cluster configuration data to the monitor, which it will use when determining if configuration has changed.
*
* @param cluster An AmbariCluster object.
* @param discoveryConfig The discovery configuration associated with the cluster.
*/
void addClusterConfigVersions(AmbariCluster cluster, ServiceDiscoveryConfig discoveryConfig) {
String clusterName = cluster.getName();
// Register the cluster discovery configuration for the monitor connections
persistDiscoveryConfiguration(clusterName, discoveryConfig);
addDiscoveryConfig(clusterName, discoveryConfig);
// Build the set of configuration versions
Map<String, String> configVersions = new HashMap<>();
Map<String, Map<String, AmbariCluster.ServiceConfiguration>> serviceConfigs = cluster.getServiceConfigurations();
for (Entry<String, Map<String, AmbariCluster.ServiceConfiguration>> serviceConfig : serviceConfigs.entrySet()) {
Map<String, AmbariCluster.ServiceConfiguration> configTypeVersionMap = serviceConfig.getValue();
for (AmbariCluster.ServiceConfiguration config : configTypeVersionMap.values()) {
String configType = config.getType();
String version = config.getVersion();
configVersions.put(configType, version);
}
}
persistClusterVersionData(discoveryConfig.getAddress(), clusterName, configVersions);
addClusterConfigVersions(discoveryConfig.getAddress(), clusterName, configVersions);
}
/**
* Makes a deep copy of a <code>FastHashMap</code> if the values
* are <code>Msg</code>, <code>Arg</code>,
* or <code>Var</code>. Otherwise it is a shallow copy.
*
* @param map <code>FastHashMap</code> to copy.
* @return FastHashMap A copy of the <code>FastHashMap</code> that was
* passed in.
* @deprecated This method is not part of Validator's public API. Validator
* will use it internally until FastHashMap references are removed. Use
* copyMap() instead.
*/
@Deprecated
public static FastHashMap copyFastHashMap(FastHashMap map) {
FastHashMap results = new FastHashMap();
@SuppressWarnings("unchecked") // FastHashMap is not generic
Iterator<Entry<String, ?>> i = map.entrySet().iterator();
while (i.hasNext()) {
Entry<String, ?> entry = i.next();
String key = entry.getKey();
Object value = entry.getValue();
if (value instanceof Msg) {
results.put(key, ((Msg) value).clone());
} else if (value instanceof Arg) {
results.put(key, ((Arg) value).clone());
} else if (value instanceof Var) {
results.put(key, ((Var) value).clone());
} else {
results.put(key, value);
}
}
results.setFast(true);
return results;
}
/**
* we need to check low replication in period, see HBASE-18132
*/
private void checkLowReplication(long now) {
try {
for (Entry<WAL, Boolean> entry : walNeedsRoll.entrySet()) {
WAL wal = entry.getKey();
boolean needRollAlready = entry.getValue();
if (needRollAlready || !(wal instanceof AbstractFSWAL)) {
continue;
}
((AbstractFSWAL<?>) wal).checkLogLowReplication(checkLowReplicationInterval);
}
} catch (Throwable e) {
LOG.warn("Failed checking low replication", e);
}
}
/**
* @serialData Null terminated list of <code>VetoableChangeListeners</code>.
* <p>
* At serialization time we skip non-serializable listeners and
* only serialize the serializable listeners.
*/
private void writeObject(ObjectOutputStream s) throws IOException {
Hashtable<String, VetoableChangeSupport> children = null;
VetoableChangeListener[] listeners = null;
synchronized (this.map) {
for (Entry<String, VetoableChangeListener[]> entry : this.map.getEntries()) {
String property = entry.getKey();
if (property == null) {
listeners = entry.getValue();
} else {
if (children == null) {
children = new Hashtable<>();
}
VetoableChangeSupport vcs = new VetoableChangeSupport(this.source);
vcs.map.set(null, entry.getValue());
children.put(property, vcs);
}
}
}
ObjectOutputStream.PutField fields = s.putFields();
fields.put("children", children);
fields.put("source", this.source);
fields.put("vetoableChangeSupportSerializedDataVersion", 2);
s.writeFields();
if (listeners != null) {
for (VetoableChangeListener l : listeners) {
if (l instanceof Serializable) {
s.writeObject(l);
}
}
}
s.writeObject(null);
}
/**
* Internal helper to clear the temporary request parameter and file maps. Will delete all uploaded files if they have not been removed by the responsible FormItem.
*/
private void doClearRequestParameterAndMultipartData() {
for (Entry<String, File> entry : requestMultipartFiles.entrySet()) {
File tmpFile = entry.getValue();
if (tmpFile.exists())
tmpFile.delete();
}
requestMultipartFiles.clear();
requestMultipartFileNames.clear();
requestMultipartFileMimeTypes.clear();
requestParams.clear();
requestError = REQUEST_ERROR_NO_ERROR;
}
private static Properties extractProperties(JsonObject json, String fieldName) {
Properties props = new Properties();
// Extract any other grpc options
JsonObject options = getJsonObject(json, fieldName);
if (options != null) {
for (Entry<String, JsonValue> entry : options.entrySet()) {
String key = entry.getKey();
JsonValue value = entry.getValue();
props.setProperty(key, getJsonValue(value));
}
}
return props;
}
protected boolean isPrimitiveTypeMap(Object o) {
if (!(o instanceof Map<?, ?>))
return false;
Map<?, ?> m = (Map<?, ?>) o;
Set<?> eset = m.entrySet();
for (Object entry : eset) {
Entry<?, ?> e = (Entry<?, ?>) entry;
if (e.getValue() != null && !isPrimitiveType(e.getValue().getClass().getName()))
return false;
}
return true;
}
public int getTotalHits(HashMap<String, Integer> countsMap){
int total = 0;
Iterator<Entry<String, Integer>> hitsIterator = countsMap.entrySet().iterator();
while(hitsIterator.hasNext()){
Entry<String, Integer> next = hitsIterator.next();
total += next.getValue();
}
return total;
}
private boolean handleFailToReset(@NotNull WatchKey key) {
Path path = (Path) key.watchable();
key.cancel();
for (Iterator<Entry<WatchKey, Path>> it = map.entrySet().iterator(); it.hasNext(); ) {
Entry<WatchKey, Path> e = it.next();
WatchKey eKey = e.getKey();
Path ePath = e.getValue();
if (ePath.getParent().equals(path)) {
eKey.cancel();
it.remove();
}
}
return path.equals(basePath);
}
private IDBNode[] fetchChildrenFromMap(
Map<String, TablesAndProcedures> schemas, int maxSchemaCount )
{
List<SchemaNode> result = new ArrayList<SchemaNode>( );
int count = 0;
for ( Entry<String, TablesAndProcedures> entry : schemas.entrySet( ) )
{
if ( count >= maxSchemaCount )
{
break;
}
SchemaNode schema = new SchemaNode( entry.getKey( ) );
TablesAndProcedures tap = entry.getValue( );
List<IDBNode> children = new ArrayList<IDBNode>( );
children.addAll( Arrays.asList( tap.getTables( ) ) );
if ( tap.getProcedureCount( ) > 0 )
{
ProcedureFlagNode procedureFlagNode = new ProcedureFlagNode( entry.getKey( ) );
procedureFlagNode.setChildren( tap.getProcedures( ) );
children.add( procedureFlagNode );
}
schema.setChildren( children.toArray( new IDBNode[0] ) );
result.add( schema );
++count;
}
if ( result.size( ) == 1 && result.get( 0 ).getSchemaName( ) == null )
{
//not support schema;
return result.get( 0 ).getChildren( );
}
else
{
Collections.sort( result );
return result.toArray( new IDBNode[0] );
}
}
public void addExample(SID instanceID, SparseVector featureVector, double label) {
for (Entry<SID, Cell> entry : featureVector) {
SID feautreID = entry.getKey();
double value = entry.getValue().value;
addExample(instanceID, feautreID, value, label);
}
}
@Override
protected void performEnrolments(Map<EnrolmentResultType, List<IDegreeModuleToEvaluate>> degreeModulesToEnrolMap) {
for (final Entry<EnrolmentResultType, List<IDegreeModuleToEvaluate>> entry : degreeModulesToEnrolMap.entrySet()) {
for (final IDegreeModuleToEvaluate degreeModuleToEvaluate : entry.getValue()) {
if (degreeModuleToEvaluate.isEnroling() && degreeModuleToEvaluate.getDegreeModule().isCurricularCourse()) {
final CurricularCourse curricularCourse = (CurricularCourse) degreeModuleToEvaluate.getDegreeModule();
checkIDegreeModuleToEvaluate(curricularCourse);
new Enrolment(getStudentCurricularPlan(), degreeModuleToEvaluate.getCurriculumGroup(), curricularCourse,
getExecutionSemester(), EnrollmentCondition.VALIDATED, getResponsiblePerson().getUsername());
}
}
}
getRegistration().updateEnrolmentDate(getExecutionYear());
}
private boolean consumeRecipeItems(boolean simulate) {
for (Entry<ItemStackKey, Integer> entry : requiredItems.entrySet()) {
ItemStackKey itemStackKey = entry.getKey();
if (itemSourceList.extractItem(itemStackKey, entry.getValue(), simulate) != entry.getValue()) {
return false;
}
}
return true;
}
/**
* A utility function to simplify various sequences of intermixed updates to the checkpointer, and calls to
* checpoint() and checkpoint(sequenceNumber). Takes a map where the key is a new sequence number to set in the
* checkpointer and the value is a CheckpointAction indicating an action to take: NONE -> Set the sequence number,
* don't do anything else NO_SEQUENCE_NUMBER -> Set the sequence number and call checkpoint() WITH_SEQUENCE_NUMBER
* -> Set the sequence number and call checkpoint(sequenceNumber) with that sequence number
*
* @param processingCheckpointer
* @param checkpointValueAndAction
* A map describing which checkpoint value to set in the checkpointer, and what action to take
* @throws Exception
*/
private void testMixedCheckpointCalls(ShardRecordProcessorCheckpointer processingCheckpointer,
LinkedHashMap<String, CheckpointAction> checkpointValueAndAction,
CheckpointerType checkpointerType) throws Exception {
for (Entry<String, CheckpointAction> entry : checkpointValueAndAction.entrySet()) {
PreparedCheckpointer preparedCheckpoint = null;
ExtendedSequenceNumber lastCheckpointValue = processingCheckpointer.lastCheckpointValue();
if (SentinelCheckpoint.SHARD_END.toString().equals(entry.getKey())) {
// Before shard end, we will pretend to do what we expect the shutdown task to do
processingCheckpointer.sequenceNumberAtShardEnd(processingCheckpointer
.largestPermittedCheckpointValue());
}
// Advance the largest checkpoint and check that it is updated.
processingCheckpointer.largestPermittedCheckpointValue(new ExtendedSequenceNumber(entry.getKey()));
assertThat("Expected the largest checkpoint value to be updated after setting it",
processingCheckpointer.largestPermittedCheckpointValue(),
equalTo(new ExtendedSequenceNumber(entry.getKey())));
switch (entry.getValue()) {
case NONE:
// We were told to not checkpoint, so lets just make sure the last checkpoint value is the same as
// when this block started then continue to the next instruction
assertThat("Expected the last checkpoint value to stay the same if we didn't checkpoint",
processingCheckpointer.lastCheckpointValue(), equalTo(lastCheckpointValue));
continue;
case NO_SEQUENCE_NUMBER:
switch (checkpointerType) {
case CHECKPOINTER:
processingCheckpointer.checkpoint();
break;
case PREPARED_CHECKPOINTER:
preparedCheckpoint = processingCheckpointer.prepareCheckpoint();
preparedCheckpoint.checkpoint();
case PREPARE_THEN_CHECKPOINTER:
preparedCheckpoint = processingCheckpointer.prepareCheckpoint();
processingCheckpointer.checkpoint(
preparedCheckpoint.pendingCheckpoint().sequenceNumber(),
preparedCheckpoint.pendingCheckpoint().subSequenceNumber());
}
break;
case WITH_SEQUENCE_NUMBER:
switch (checkpointerType) {
case CHECKPOINTER:
processingCheckpointer.checkpoint(entry.getKey());
break;
case PREPARED_CHECKPOINTER:
preparedCheckpoint = processingCheckpointer.prepareCheckpoint(entry.getKey());
preparedCheckpoint.checkpoint();
case PREPARE_THEN_CHECKPOINTER:
preparedCheckpoint = processingCheckpointer.prepareCheckpoint(entry.getKey());
processingCheckpointer.checkpoint(
preparedCheckpoint.pendingCheckpoint().sequenceNumber(),
preparedCheckpoint.pendingCheckpoint().subSequenceNumber());
}
break;
}
// We must have checkpointed to get here, so let's make sure our last checkpoint value is up to date
assertThat("Expected the last checkpoint value to change after checkpointing",
processingCheckpointer.lastCheckpointValue(), equalTo(new ExtendedSequenceNumber(entry.getKey())));
assertThat("Expected the largest checkpoint value to remain the same since the last set",
processingCheckpointer.largestPermittedCheckpointValue(),
equalTo(new ExtendedSequenceNumber(entry.getKey())));
assertThat(checkpoint.getCheckpoint(shardId), equalTo(new ExtendedSequenceNumber(entry.getKey())));
assertThat(checkpoint.getCheckpointObject(shardId).checkpoint(),
equalTo(new ExtendedSequenceNumber(entry.getKey())));
assertThat(checkpoint.getCheckpointObject(shardId).pendingCheckpoint(), nullValue());
}
}
@Override
public int estimateParallelism(TezOperPlan plan, TezOperator tezOper, Configuration conf) throws IOException {
if (tezOper.isVertexGroup()) {
return -1;
}
boolean intermediateReducer = TezCompilerUtil.isIntermediateReducer(tezOper);
// TODO: If map opts and reduce opts are same estimate higher parallelism
// for tasks based on the count of number of map tasks else be conservative as now
maxTaskCount = conf.getInt(PigReducerEstimator.MAX_REDUCER_COUNT_PARAM,
PigReducerEstimator.DEFAULT_MAX_REDUCER_COUNT_PARAM);
// If parallelism is set explicitly, respect it
if (!intermediateReducer && tezOper.getRequestedParallelism()!=-1) {
return tezOper.getRequestedParallelism();
}
// If we have already estimated parallelism, use that one
if (tezOper.getEstimatedParallelism()!=-1) {
return tezOper.getEstimatedParallelism();
}
List<TezOperator> preds = plan.getPredecessors(tezOper);
if (preds==null) {
throw new IOException("Cannot estimate parallelism for source vertex");
}
double estimatedParallelism = 0;
for (Entry<OperatorKey, TezEdgeDescriptor> entry : tezOper.inEdges.entrySet()) {
TezOperator pred = getPredecessorWithKey(plan, tezOper, entry.getKey().toString());
// Don't include broadcast edge, broadcast edge is used for
// replicated join (covered in TezParallelismFactorVisitor.visitFRJoin)
// and sample/scalar (does not impact parallelism)
if (entry.getValue().dataMovementType==DataMovementType.SCATTER_GATHER ||
entry.getValue().dataMovementType==DataMovementType.ONE_TO_ONE) {
double predParallelism = pred.getEffectiveParallelism();
if (predParallelism==-1) {
throw new IOException("Cannot estimate parallelism for " + tezOper.getOperatorKey().toString()
+ ", effective parallelism for predecessor " + tezOper.getOperatorKey().toString()
+ " is -1");
}
//For cases like Union we can just limit to sum of pred vertices parallelism
boolean applyFactor = !tezOper.isUnion();
if (pred.plan!=null && applyFactor) { // pred.plan can be null if it is a VertexGroup
TezParallelismFactorVisitor parallelismFactorVisitor = new TezParallelismFactorVisitor(pred.plan, tezOper.getOperatorKey().toString());
parallelismFactorVisitor.visit();
predParallelism = predParallelism * parallelismFactorVisitor.getFactor();
}
estimatedParallelism += predParallelism;
}
}
int roundedEstimatedParallelism = (int)Math.ceil(estimatedParallelism);
if (intermediateReducer && tezOper.isOverrideIntermediateParallelism()) {
// Estimated reducers should not be more than the configured limit
roundedEstimatedParallelism = Math.min(roundedEstimatedParallelism, maxTaskCount);
int userSpecifiedParallelism = pc.defaultParallel;
if (tezOper.getRequestedParallelism() != -1) {
userSpecifiedParallelism = tezOper.getRequestedParallelism();
}
int intermediateParallelism = Math.max(userSpecifiedParallelism, roundedEstimatedParallelism);
if (userSpecifiedParallelism != -1 &&
(intermediateParallelism > 200 && intermediateParallelism > (2 * userSpecifiedParallelism))) {
// Estimated reducers shall not be more than 2x of requested parallelism
// if greater than 200 and we are overriding user specified values
intermediateParallelism = 2 * userSpecifiedParallelism;
}
roundedEstimatedParallelism = intermediateParallelism;
} else {
roundedEstimatedParallelism = Math.min(roundedEstimatedParallelism, maxTaskCount);
}
return roundedEstimatedParallelism;
}
/**
* Run the CacheCleaner thread.
*
* Whenever a thread requests a ShortCircuitReplica object, we will make
* sure it gets one. That ShortCircuitReplica object can then be re-used
* when another thread requests a ShortCircuitReplica object for the same
* block. So in that sense, there is no maximum size to the cache.
*
* However, when a ShortCircuitReplica object is unreferenced by the
* thread(s) that are using it, it becomes evictable. There are two
* separate eviction lists-- one for mmaped objects, and another for
* non-mmaped objects. We do this in order to avoid having the regular
* files kick the mmaped files out of the cache too quickly. Reusing
* an already-existing mmap gives a huge performance boost, since the
* page table entries don't have to be re-populated. Both the mmap
* and non-mmap evictable lists have maximum sizes and maximum lifespans.
*/
@Override
public void run() {
ShortCircuitCache.this.lock.lock();
try {
if (ShortCircuitCache.this.closed) return;
long curMs = Time.monotonicNow();
if (LOG.isDebugEnabled()) {
LOG.debug(this + ": cache cleaner running at " + curMs);
}
int numDemoted = demoteOldEvictableMmaped(curMs);
int numPurged = 0;
Long evictionTimeNs = Long.valueOf(0);
while (true) {
Entry<Long, ShortCircuitReplica> entry =
evictable.ceilingEntry(evictionTimeNs);
if (entry == null) break;
evictionTimeNs = entry.getKey();
long evictionTimeMs =
TimeUnit.MILLISECONDS.convert(evictionTimeNs, TimeUnit.NANOSECONDS);
if (evictionTimeMs + maxNonMmappedEvictableLifespanMs >= curMs) break;
ShortCircuitReplica replica = entry.getValue();
if (LOG.isTraceEnabled()) {
LOG.trace("CacheCleaner: purging " + replica + ": " +
StringUtils.getStackTrace(Thread.currentThread()));
}
purge(replica);
numPurged++;
}
if (LOG.isDebugEnabled()) {
LOG.debug(this + ": finishing cache cleaner run started at " +
curMs + ". Demoted " + numDemoted + " mmapped replicas; " +
"purged " + numPurged + " replicas.");
}
} finally {
ShortCircuitCache.this.lock.unlock();
}
}
/**
* Creates an entry representing the same mapping as the
* specified entry.
*
* @param entry the entry to copy
*/
public SimpleEntry(Entry<? extends K, ? extends V> entry) {
this.key = entry.getKey();
this.value = entry.getValue();
}