use of java.util.Map.Entry in project pcgen by PCGen.
the class StatMinValueFacet method getStatMinValue.
/**
* Returns the numerical minimum value for the given PCStat which has had a
* min value set for the Player Character identified by the given CharID.
* Returns null if no min value StatLock exists on the Player Character for
* the given PCStat.
*
* @param id
* The CharID identifying the Player Character for which the
* minimum stat value is to be returned
* @param stat
* The PCStat for which the numerical lock value is to be
* returned
* @return The numerical value for the given PCStat which has been locked
* for the Player Character identified by the given CharID; null if
* no StatLock exists on the Player Character for the given PCStat
*/
public Number getStatMinValue(CharID id, PCStat stat) {
Number max = Double.NEGATIVE_INFINITY;
boolean hit = false;
Map<StatLock, Set<Object>> componentMap = getCachedMap(id);
if (componentMap != null) {
for (Iterator<Map.Entry<StatLock, Set<Object>>> it = componentMap.entrySet().iterator(); it.hasNext(); ) {
Entry<StatLock, Set<Object>> me = it.next();
Set<Object> set = me.getValue();
StatLock lock = me.getKey();
if (lock.getLockedStat().equals(stat)) {
for (Object source : set) {
String sourceString = (source instanceof CDOMObject) ? ((CDOMObject) source).getQualifiedKey() : "";
Number val = formulaResolvingFacet.resolve(id, lock.getLockValue(), sourceString);
if (val.doubleValue() > max.doubleValue()) {
hit = true;
max = val;
}
}
}
}
}
return hit ? max : null;
}
use of java.util.Map.Entry in project midpoint by Evolveum.
the class AbstractLexicalProcessorTest method assertUserJackXNodeOrdering.
protected void assertUserJackXNodeOrdering(String message, XNode xnode) {
if (xnode instanceof RootXNode) {
xnode = ((RootXNode) xnode).getSubnode();
}
MapXNode xmap = getAssertXNode(message + ": top", xnode, MapXNode.class);
Set<Entry<QName, XNode>> reTopMapEntrySet = xmap.entrySet();
Iterator<Entry<QName, XNode>> reTopMapEntrySetIter = reTopMapEntrySet.iterator();
Entry<QName, XNode> reTopMapEntry0 = reTopMapEntrySetIter.next();
assertEquals(message + ": Wrong entry 0, the xnodes were shuffled", "oid", reTopMapEntry0.getKey().getLocalPart());
Entry<QName, XNode> reTopMapEntry1 = reTopMapEntrySetIter.next();
assertEquals(message + ": Wrong entry 1, the xnodes were shuffled", "version", reTopMapEntry1.getKey().getLocalPart());
Entry<QName, XNode> reTopMapEntry2 = reTopMapEntrySetIter.next();
assertEquals(message + ": Wrong entry 2, the xnodes were shuffled", UserType.F_NAME, reTopMapEntry2.getKey());
Entry<QName, XNode> reTopMapEntry3 = reTopMapEntrySetIter.next();
assertEquals(message + ": Wrong entry 3, the xnodes were shuffled", UserType.F_DESCRIPTION, reTopMapEntry3.getKey());
}
use of java.util.Map.Entry in project midpoint by Evolveum.
the class BeanUnmarshaller method unmarshalEntry.
/**
* Parses either a map entry, or a fictitious heterogeneous list property.
*
* It makes sure that a 'key' property is inserted into 'bean' object, being sourced from 'node' structure.
* Node itself can be single-valued or multi-valued, corresponding to single or multi-valued 'key' property.
* ---
* A notable (and quite ugly) exception is processing of fictitious heterogeneous lists.
* In this case we have a ListXNode that should be interpreted as a MapXNode, inserting fictitious property
* named after abstract multivalued property in the parent bean.
*
* For example, when we have (embedded in ExecuteScriptType):
* {
* pipeline: *[
* { element: search, ... },
* { element: sequence, ... }
* ]
* }
*
* ...it should be, in fact, read as if it would be:
*
* {
* pipeline: {
* scriptingExpression: [
* { type: SearchExpressionType, ... },
* { type: ExpressionSequenceType, ... }
* ]
* }
* }
*
* (The only difference is in element names, which are missing in the latter snippet, but let's ignore that here.)
*
* Fictitious heterogeneous list entry here is "scriptingExpression", a property of pipeline (ExpressionPipelineType).
*
* We have to create the following data structure (corresponding to latter snippet):
*
* instance of ExecuteScriptType:
* scriptingExpression = instance of JAXBElement(pipeline, ExpressionPipelineType): [1]
* scriptingExpression = List of [2]
* - JAXBElement(search, SearchExpressionType)
* - JAXBElement(sequence, ExpressionSequenceType)
*
* We in fact invoke this method twice with the same node (a two-entry list, marked as '*' in the first snippet):
* 1) bean=ExecuteScriptType, key=pipeline, node=HList(*), isHeteroListProperty=false
* 2) bean=ExpressionPipelineType, key=scriptingExpression, node=HList(*), isHeteroListProperty=true <<<
*
* During the first call we fill in scriptingExpression (single value) in ExecuteScriptType [1]; during the second one
* we fill in scriptingExpression (multivalued) in ExpressionPipelineType [2].
*
* Now let's expand the sample.
*
* This XNode tree:
* {
* pipeline: *[
* { element: search, type: RoleType, searchFilter: {...}, action: log },
* { element: sequence, value: **[
* { element: action, type: delete },
* { element: action, type: assign, parameter: {...} },
* { element: search, type: UserType }
* ] }
* ]
* }
*
* Should be interpreted as:
* {
* pipeline: {
* scriptingExpression: [
* { type: SearchExpressionType, type: RoleType, searchFilter: {...}, action: log }
* { type: ExpressionSequenceType, scriptingExpression: [
* { type: ActionExpressionType, type: delete },
* { type: ActionExpressionType, type: assign, parameter: {...} },
* { type: SearchExpressionType, type: UserType }
* ] }
* ]
* }
* }
*
* Producing the following data:
*
* instance of ExecuteScriptType:
* scriptingExpression = instance of JAXBElement(pipeline, ExpressionPipelineType): [1]
* scriptingExpression = List of [2]
* - JAXBElement(search, instance of SearchExpressionType):
* type: RoleType,
* searchFilter: (...),
* action: log,
* - JAXBElement(sequence, instance of ExpressionSequenceType):
* scriptingExpression = List of
* - JAXBElement(action, instance of ActionExpressionType):
* type: delete
* - JAXBElement(action, instance of ActionExpressionType):
* type: assign
* parameter: (...),
* - JAXBElement(search, instance of SearchExpressionType):
* type: UserType
*
* Invocations of this method will be:
* 1) bean=ExecuteScriptType, key=pipeline, node=HList(*), isHeteroListProperty=false
* 2) bean=ExpressionPipelineType, key=scriptingExpression, node=HList(*), isHeteroListProperty=true <<<
* 3) bean=SearchExpressionType, key=type, node='type: c:RoleType', isHeteroListProperty=false
* 4) bean=SearchExpressionType, key=searchFilter, node=XNode(map:1 entries), isHeteroListProperty=false
* 5) bean=SearchExpressionType, key=action, node=XNode(map:1 entries), isHeteroListProperty=false
* 6) bean=ActionExpressionType, key=type, node='type: log', isHeteroListProperty=false
* 7) bean=ExpressionSequenceType, key=scriptingExpression, node=HList(**), isHeteroListProperty=true <<<
* 8) bean=ActionExpressionType, key=type, node='type: delete', isHeteroListProperty=false
* 9) bean=ActionExpressionType, key=type, node='type: assign', isHeteroListProperty=false
* 10) bean=ActionExpressionType, key=parameter, node=XNode(map:2 entries), isHeteroListProperty=false
* 11) bean=ActionParameterValueType, key=name, node='name: role', isHeteroListProperty=false
* 12) bean=ActionParameterValueType, key=value, node='value: rome555c-7797-11e2-94a6-001e8c717e5b', isHeteroListProperty=false
* 13) bean=SearchExpressionType, key=type, node='type: UserType', isHeteroListProperty=false
*
* Here we have 2 calls with isHeteroListProperty=true; first for pipeline.scriptingExpression, second for
* sequence.scriptingExpression.
*/
private <T> void unmarshalEntry(@NotNull T bean, @NotNull Class<T> beanClass, @NotNull QName key, @NotNull XNode node, @NotNull XNode containingNode, boolean isHeteroListProperty, @NotNull ParsingContext pc) throws SchemaException {
//System.out.println("bean=" + bean.getClass().getSimpleName() + ", key=" + key.getLocalPart() + ", node=" + node + ", isHeteroListProperty=" + isHeteroListProperty);
final String propName = key.getLocalPart();
// this code is just to keep this method reasonably short
PropertyAccessMechanism mechanism = new PropertyAccessMechanism();
if (!mechanism.compute(bean, beanClass, propName, key, node, pc)) {
return;
}
final String actualPropertyName = mechanism.actualPropertyName;
final boolean storeAsRawType = mechanism.storeAsRawType;
final Method getter = mechanism.getter;
final Method setter = mechanism.setter;
final boolean wrapInJaxbElement = mechanism.wrapInJaxbElement;
if (Element.class.isAssignableFrom(mechanism.paramType)) {
throw new IllegalArgumentException("DOM not supported in field " + actualPropertyName + " in " + beanClass);
}
// The type T that is expected by the bean, i.e. either by
// - setMethod(T value), or
// - Collection<T> getMethod()
// We use it to retrieve the correct value when parsing the node.
// We might specialize it using the information derived from the node (to deal with inclusive polymorphism,
// i.e. storing ExclusionPolicyConstraintType where AbstractPolicyConstraintType is expected).
@NotNull Class<?> paramType;
if (!storeAsRawType && !isHeteroListProperty) {
Class<?> t = specializeParamType(node, mechanism.paramType, pc);
if (t == null) {
// indicates a problem
return;
} else {
paramType = t;
}
} else {
paramType = mechanism.paramType;
}
if (!(node instanceof ListXNode) && Object.class.equals(paramType) && !storeAsRawType) {
throw new IllegalArgumentException("Object property (without @Raw) not supported in field " + actualPropertyName + " in " + beanClass);
}
// String paramNamespace = inspector.determineNamespace(paramType);
boolean problem = false;
Object propValue = null;
Collection<Object> propValues = null;
// (instead of list) and process it as a single value. Only when
if (node instanceof ListXNode && (!node.isHeterogeneousList() || isHeteroListProperty)) {
ListXNode xlist = (ListXNode) node;
if (setter != null) {
try {
Object value = unmarshalSinglePropValue(node, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
if (wrapInJaxbElement) {
propValue = wrapInJaxbElement(value, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
} else {
propValue = value;
}
} catch (SchemaException e) {
problem = processSchemaException(e, node, pc);
}
} else {
// No setter, we have to use collection getter
propValues = new ArrayList<>(xlist.size());
for (XNode xsubsubnode : xlist) {
try {
Object valueToAdd;
Object value = unmarshalSinglePropValue(xsubsubnode, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
if (value != null) {
if (isHeteroListProperty) {
QName elementName = xsubsubnode.getElementName();
if (elementName == null) {
// TODO better error handling
throw new SchemaException("Heterogeneous list with a no-elementName node: " + xsubsubnode);
}
Class valueClass = value.getClass();
QName jaxbElementName;
if (QNameUtil.hasNamespace(elementName)) {
jaxbElementName = elementName;
} else {
// Approximate solution: find element in schema registry - check for type compatibility
// in order to exclude accidental name matches (like c:expression/s:expression).
Optional<ItemDefinition> itemDefOpt = getSchemaRegistry().findItemDefinitionsByElementName(elementName).stream().filter(def -> getSchemaRegistry().findTypeDefinitionsByType(def.getTypeName()).stream().anyMatch(typeDef -> typeDef.getCompileTimeClass() != null && typeDef.getCompileTimeClass().isAssignableFrom(valueClass))).findFirst();
if (itemDefOpt.isPresent()) {
jaxbElementName = itemDefOpt.get().getName();
} else {
LOGGER.warn("Heterogeneous list member with unknown element name '" + elementName + "': " + value);
// unqualified
jaxbElementName = elementName;
}
}
@SuppressWarnings("unchecked") JAXBElement jaxbElement = new JAXBElement<>(jaxbElementName, valueClass, value);
valueToAdd = jaxbElement;
} else {
if (wrapInJaxbElement) {
valueToAdd = wrapInJaxbElement(value, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
} else {
valueToAdd = value;
}
}
propValues.add(valueToAdd);
}
} catch (SchemaException e) {
problem = processSchemaException(e, xsubsubnode, pc);
}
}
}
} else {
try {
propValue = unmarshalSinglePropValue(node, actualPropertyName, paramType, storeAsRawType, beanClass, pc);
if (wrapInJaxbElement) {
propValue = wrapInJaxbElement(propValue, mechanism.objectFactory, mechanism.elementFactoryMethod, propName, beanClass, pc);
}
} catch (SchemaException e) {
problem = processSchemaException(e, node, pc);
}
}
if (setter != null) {
try {
setter.invoke(bean, propValue);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new SystemException("Cannot invoke setter " + setter + " on bean of type " + beanClass + ": " + e.getMessage(), e);
}
} else if (getter != null) {
Object getterReturn;
Collection<Object> col;
try {
getterReturn = getter.invoke(bean);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
throw new SystemException("Cannot invoke getter " + getter + " on bean of type " + beanClass + ": " + e.getMessage(), e);
}
try {
col = (Collection<Object>) getterReturn;
} catch (ClassCastException e) {
throw new SystemException("Getter " + getter + " on bean of type " + beanClass + " returned " + getterReturn + " instead of collection");
}
if (propValue != null) {
col.add(propValue);
} else if (propValues != null) {
for (Object propVal : propValues) {
col.add(propVal);
}
} else if (!problem) {
throw new IllegalStateException("Strange. Multival property " + propName + " in " + beanClass + " produced null values list, parsed from " + containingNode);
}
if (!isHeteroListProperty) {
checkJaxbElementConsistence(col, pc);
}
} else {
throw new IllegalStateException("Uh? No setter nor getter.");
}
}
use of java.util.Map.Entry in project pcgen by PCGen.
the class StatBonusFacet method getStatBonusTo.
/**
* Returns the aggregate Bonus value for the given Bonus type and given
* Bonus name which are applied by PCStat objects to the Player Character
* identified by the given CharID.
*
* @param id
* The CharID identifying the Player Character for which the
* aggregate Bonus value is to be calculated
* @param type
* The Bonus type for which the aggregate Bonus value is to be
* calculated
* @param name
* The Bonus name for which the aggregate Bonus value is to be
* calculated
* @return The aggregate Bonus value for the given Bonus type and given
* Bonus name which are applied by PCStat objects to the Player
* Character identified by the given CharID
*/
public double getStatBonusTo(CharID id, String type, String name) {
final Map<BonusObj, PCStat> map = getBonusListOfType(id, type.toUpperCase(), name.toUpperCase());
for (Iterator<Map.Entry<BonusObj, PCStat>> it = map.entrySet().iterator(); it.hasNext(); ) {
Entry<BonusObj, PCStat> me = it.next();
BonusObj bo = me.getKey();
if (!prerequisiteFacet.qualifies(id, bo, me.getValue())) {
it.remove();
}
}
return bonusCheckingFacet.calcBonus(id, map);
}
use of java.util.Map.Entry in project pcgen by PCGen.
the class CharacterFacadeImpl method export.
/**
* @see pcgen.core.facade.CharacterFacade#export(pcgen.io.ExportHandler, java.io.BufferedWriter)
*/
@Override
public void export(ExportHandler theHandler, BufferedWriter buf) throws ExportException {
final int maxRetries = 3;
for (int i = 0; i < maxRetries; i++) {
try {
Logging.log(Logging.DEBUG, "Starting export at serial " + theCharacter.getSerial() + " to " + theHandler.getTemplateFile());
PlayerCharacter exportPc = getExportCharacter();
//PlayerCharacter exportPc = theCharacter;
theHandler.write(exportPc, buf);
Logging.log(Logging.DEBUG, "Finished export at serial " + theCharacter.getSerial() + " to " + theHandler.getTemplateFile());
return;
} catch (ConcurrentModificationException e) {
Map<Thread, StackTraceElement[]> allStackTraces = Thread.getAllStackTraces();
for (Entry<Thread, StackTraceElement[]> threadEntry : allStackTraces.entrySet()) {
if (threadEntry.getValue().length > 1) {
StringBuilder sb = new StringBuilder("Thread: " + threadEntry.getKey() + "\n");
for (StackTraceElement elem : threadEntry.getValue()) {
sb.append(" ");
sb.append(elem.toString());
sb.append("\n");
}
Logging.log(Logging.INFO, sb.toString());
}
}
Logging.log(Logging.WARNING, "Retrying export after ConcurrentModificationException", e);
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
Logging.errorPrint("Interrupted sleep - probably closing.");
return;
}
}
}
Logging.errorPrint("Unable to export using " + theHandler.getTemplateFile() + " due to concurrent modifications.");
}
Aggregations