@Override protected NodeTuple representJavaBeanProperty( Object javaBean, Property property, Object propertyValue, Tag customTag) { NodeTuple tuple = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag); Node valueNode = tuple.getValueNode(); if (Tag.NULL.equals(valueNode.getTag())) { return null; // skip 'null' values } if (valueNode instanceof CollectionNode) { if (Tag.SEQ.equals(valueNode.getTag())) { SequenceNode seq = (SequenceNode) valueNode; if (seq.getValue().isEmpty()) { return null; // skip empty lists } } if (Tag.MAP.equals(valueNode.getTag())) { MappingNode seq = (MappingNode) valueNode; if (seq.getValue().isEmpty()) { return null; // skip empty maps } } } return tuple; }
private Node composeSequenceNode(String anchor) { SequenceStartEvent startEvent = (SequenceStartEvent) this.parser.getEvent(); String tag = startEvent.getTag(); boolean resolved = false; Tag nodeTag; if ((tag == null) || (tag.equals("!"))) { Tag nodeTag = this.resolver.resolve(NodeId.sequence, null, startEvent.getImplicit()); resolved = true; } else { nodeTag = new Tag(tag); } ArrayList<Node> children = new ArrayList(); SequenceNode node = new SequenceNode( nodeTag, resolved, children, startEvent.getStartMark(), null, startEvent.getFlowStyle()); if (anchor != null) { this.anchors.put(anchor, node); } while (!this.parser.checkEvent(Event.ID.SequenceEnd)) { children.add(composeNode(node)); } Event endEvent = this.parser.getEvent(); node.setEndMark(endEvent.getEndMark()); return node; }
private SequenceNode cloneSequenceNode(SequenceNode node, Map<String, String> parameters) { List<Node> nodes = new ArrayList<Node>(); for (Node item : node.getValue()) { nodes.add(cloneNode(item, parameters)); } return new SequenceNode(node.getTag(), nodes, node.getFlowStyle()); }
private void loopTemplateSequence( SequenceNode templateSequence, String templateType, List<ValidationResult> validationResults) { List<Node> prunedTemplates = new ArrayList<Node>(); for (int j = 0; j < templateSequence.getValue().size(); j++) { Node template = templateSequence.getValue().get(j); if (template.getNodeId() == scalar) { if (!template.getTag().equals(INCLUDE_TAG)) { validationResults.add( createErrorResult( "Mapping or !include expected", templateSequence.getStartMark(), templateSequence.getEndMark())); } template = includeResolver.resolve(template, resourceLoader, nodeNandler); } for (NodeTuple tuple : ((MappingNode) template).getValue()) { if (tuple.getKeyNode().getNodeId() != scalar) { validationResults.add(createErrorResult(NON_SCALAR_KEY_MESSAGE, tuple.getKeyNode())); continue; } String templateKey = ((ScalarNode) tuple.getKeyNode()).getValue(); Node templateValue = tuple.getValueNode(); if (templateValue.getNodeId() != mapping) { validationResults.add( createErrorResult( "Mapping expected", templateValue.getStartMark(), templateValue.getEndMark())); continue; } if (templateType.equals("resourceTypes")) { resourceTypesMap.put(templateKey, (MappingNode) templateValue); } if (templateType.equals("traits")) { traitsMap.put(templateKey, (MappingNode) templateValue); } prunedTemplates.add(getFakeTemplateNode(tuple.getKeyNode())); } } templateSequence.getValue().clear(); templateSequence.getValue().addAll(prunedTemplates); }
protected NodeTuple representJavaBeanProperty( Object javaBean, Property property, Object propertyValue, Tag customTag) { final NodeTuple tuple = super.representJavaBeanProperty(javaBean, property, propertyValue, customTag); final Node valueNode = tuple.getValueNode(); if (valueNode instanceof CollectionNode) { // Removed null check if (Tag.SEQ.equals(valueNode.getTag())) { final SequenceNode seq = (SequenceNode) valueNode; if (seq.getValue().isEmpty()) { return null; // skip empty lists } } if (Tag.MAP.equals(valueNode.getTag())) { final MappingNode seq = (MappingNode) valueNode; if (seq.getValue().isEmpty()) { return null; // skip empty maps } } } return tuple; }
private void applyTraitsToActions( SequenceNode traits, Map<String, Node> actionNodes, String actionName) { for (Node ref : traits.getValue()) { if (actionName == null) { for (Map.Entry<String, Node> actionEntry : actionNodes.entrySet()) { currentAction = actionEntry.getKey(); MappingNode templateNode = cloneTemplate(ref, TemplateType.TRAIT); if (templateNode != null) { mergeNodes(actionEntry.getValue(), templateNode, Action.class); } } } else { currentAction = actionName; MappingNode templateNode = cloneTemplate(ref, TemplateType.TRAIT); if (templateNode != null) { mergeNodes(actionNodes.get(actionName), templateNode, Action.class); } } } }
@SuppressWarnings("unchecked") public Object construct(Node node) { SequenceNode snode = (SequenceNode) node; if (Set.class.isAssignableFrom(node.getType())) { if (node.isTwoStepsConstruction()) { throw new YAMLException("Set cannot be recursive."); } else { return constructSet(snode); } } else if (Collection.class.isAssignableFrom(node.getType())) { if (node.isTwoStepsConstruction()) { return createDefaultList(snode.getValue().size()); } else { return constructSequence(snode); } } else if (node.getType().isArray()) { if (node.isTwoStepsConstruction()) { return createArray(node.getType(), snode.getValue().size()); } else { return constructArray(snode); } } else { // create immutable object List<java.lang.reflect.Constructor<?>> possibleConstructors = new ArrayList<java.lang.reflect.Constructor<?>>(snode.getValue().size()); for (java.lang.reflect.Constructor<?> constructor : node.getType().getConstructors()) { if (snode.getValue().size() == constructor.getParameterTypes().length) { possibleConstructors.add(constructor); } } if (!possibleConstructors.isEmpty()) { if (possibleConstructors.size() == 1) { Object[] argumentList = new Object[snode.getValue().size()]; java.lang.reflect.Constructor<?> c = possibleConstructors.get(0); int index = 0; for (Node argumentNode : snode.getValue()) { Class<?> type = c.getParameterTypes()[index]; // set runtime classes for arguments argumentNode.setType(type); argumentList[index++] = constructObject(argumentNode); } try { return c.newInstance(argumentList); } catch (Exception e) { throw new YAMLException(e); } } // use BaseConstructor List<Object> argumentList = (List<Object>) constructSequence(snode); Class<?>[] parameterTypes = new Class[argumentList.size()]; int index = 0; for (Object parameter : argumentList) { parameterTypes[index] = parameter.getClass(); index++; } for (java.lang.reflect.Constructor<?> c : possibleConstructors) { Class<?>[] argTypes = c.getParameterTypes(); boolean foundConstructor = true; for (int i = 0; i < argTypes.length; i++) { if (!wrapIfPrimitive(argTypes[i]).isAssignableFrom(parameterTypes[i])) { foundConstructor = false; break; } } if (foundConstructor) { try { return c.newInstance(argumentList.toArray()); } catch (Exception e) { throw new YAMLException(e); } } } } throw new YAMLException( "No suitable constructor with " + String.valueOf(snode.getValue().size()) + " arguments found for " + node.getType()); } }
protected Object constructJavaBean2ndStep(MappingNode node, Object object) { flattenMapping(node); Class<? extends Object> beanType = node.getType(); List<NodeTuple> nodeValue = node.getValue(); for (NodeTuple tuple : nodeValue) { ScalarNode keyNode; if (tuple.getKeyNode() instanceof ScalarNode) { // key must be scalar keyNode = (ScalarNode) tuple.getKeyNode(); } else { throw new YAMLException("Keys must be scalars but found: " + tuple.getKeyNode()); } Node valueNode = tuple.getValueNode(); // keys can only be Strings keyNode.setType(String.class); String key = (String) constructObject(keyNode); try { Property property = getProperty(beanType, key); valueNode.setType(property.getType()); TypeDescription memberDescription = typeDefinitions.get(beanType); boolean typeDetected = false; if (memberDescription != null) { switch (valueNode.getNodeId()) { case sequence: SequenceNode snode = (SequenceNode) valueNode; Class<? extends Object> memberType = memberDescription.getListPropertyType(key); if (memberType != null) { snode.setListType(memberType); typeDetected = true; } else if (property.getType().isArray()) { snode.setListType(property.getType().getComponentType()); typeDetected = true; } break; case mapping: MappingNode mnode = (MappingNode) valueNode; Class<? extends Object> keyType = memberDescription.getMapKeyType(key); if (keyType != null) { mnode.setTypes(keyType, memberDescription.getMapValueType(key)); typeDetected = true; } break; default: // scalar } } if (!typeDetected && valueNode.getNodeId() != NodeId.scalar) { // only if there is no explicit TypeDescription Class<?>[] arguments = property.getActualTypeArguments(); if (arguments != null) { // type safe (generic) collection may contain the // proper class if (valueNode.getNodeId() == NodeId.sequence) { Class<?> t = arguments[0]; SequenceNode snode = (SequenceNode) valueNode; snode.setListType(t); } else if (valueNode.getTag().equals(Tag.SET)) { Class<?> t = arguments[0]; MappingNode mnode = (MappingNode) valueNode; mnode.setOnlyKeyType(t); mnode.setUseClassConstructor(true); } else if (property.getType().isAssignableFrom(Map.class)) { Class<?> ketType = arguments[0]; Class<?> valueType = arguments[1]; MappingNode mnode = (MappingNode) valueNode; mnode.setTypes(ketType, valueType); mnode.setUseClassConstructor(true); } else { // the type for collection entries cannot be // detected } } } Object value = constructObject(valueNode); property.set(object, value); } catch (Exception e) { throw new YAMLException( "Cannot create property=" + key + " for JavaBean=" + object + "; " + e.getMessage(), e); } } return object; }