*/
package org.opendaylight.controller.yang.parser.util;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.yang.model.api.MustDefinition;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BinaryTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BooleanTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.DecimalTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EmptyTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
+import org.opendaylight.controller.yang.model.api.type.IdentityrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
+import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
+import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
+import org.opendaylight.controller.yang.model.api.type.StringTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
+import org.opendaylight.controller.yang.model.util.BinaryType;
+import org.opendaylight.controller.yang.model.util.BitsType;
+import org.opendaylight.controller.yang.model.util.BooleanType;
+import org.opendaylight.controller.yang.model.util.Decimal64;
+import org.opendaylight.controller.yang.model.util.EmptyType;
+import org.opendaylight.controller.yang.model.util.EnumerationType;
+import org.opendaylight.controller.yang.model.util.IdentityrefType;
+import org.opendaylight.controller.yang.model.util.InstanceIdentifier;
+import org.opendaylight.controller.yang.model.util.Int16;
+import org.opendaylight.controller.yang.model.util.Int32;
+import org.opendaylight.controller.yang.model.util.Int64;
+import org.opendaylight.controller.yang.model.util.Int8;
+import org.opendaylight.controller.yang.model.util.Leafref;
+import org.opendaylight.controller.yang.model.util.StringType;
+import org.opendaylight.controller.yang.model.util.UnionType;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.controller.yang.parser.builder.api.ChildNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.Builder;
+import org.opendaylight.controller.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ConstraintsBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl;
public final class ParserUtils {
*/
public static void fillAugmentTarget(
final AugmentationSchemaBuilder augment,
- final ChildNodeBuilder target) {
+ final DataNodeContainerBuilder target) {
for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
builder.setAugmenting(true);
- correctPath(augment, target.getPath());
+ correctAugmentChildPath(augment, target.getPath());
target.addChildNode(builder);
}
}
- private static void correctPath(final ChildNodeBuilder node,
+ public static void fillAugmentTarget(
+ final AugmentationSchemaBuilder augment,
+ final ChoiceBuilder target) {
+ for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
+ builder.setAugmenting(true);
+ correctAugmentChildPath(augment, target.getPath());
+ target.addChildNode(builder);
+ }
+ }
+
+ private static void correctAugmentChildPath(final DataNodeContainerBuilder node,
final SchemaPath parentSchemaPath) {
- for(DataSchemaNodeBuilder builder : node.getChildNodes()) {
+ for (DataSchemaNodeBuilder builder : node.getChildNodes()) {
// add correct path
- SchemaPath targetNodeSchemaPath = parentSchemaPath;
- List<QName> targetNodePath = new ArrayList<QName>(targetNodeSchemaPath.getPath());
+ List<QName> targetNodePath = new ArrayList<QName>(
+ parentSchemaPath.getPath());
targetNodePath.add(builder.getQName());
builder.setPath(new SchemaPath(targetNodePath, true));
- if(builder instanceof ChildNodeBuilder) {
- ChildNodeBuilder cnb = (ChildNodeBuilder)builder;
- correctPath(cnb, builder.getPath());
+ if (builder instanceof DataNodeContainerBuilder) {
+ DataNodeContainerBuilder cnb = (DataNodeContainerBuilder) builder;
+ correctAugmentChildPath(cnb, builder.getPath());
+ }
+
+ // if child can contains type, correct path for this type too
+ if (builder instanceof TypeAwareBuilder) {
+ TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) builder;
+ QName nodeBuilderQName = nodeBuilder.getQName();
+ TypeDefinition<?> nodeBuilderType = nodeBuilder.getType();
+ if (nodeBuilderType != null) {
+ TypeDefinition<?> newType = createCorrectTypeDefinition(
+ parentSchemaPath, nodeBuilderQName, nodeBuilderType);
+ nodeBuilder.setType(newType);
+ } else {
+ TypeDefinitionBuilder nodeBuilderTypedef = nodeBuilder
+ .getTypedef();
+ SchemaPath newSchemaPath = createNewSchemaPath(
+ nodeBuilderTypedef.getPath(), nodeBuilderQName,
+ nodeBuilderTypedef.getQName());
+ nodeBuilderTypedef.setPath(newSchemaPath);
+ }
+ }
+ }
+ }
+
+ private static TypeDefinition<?> createCorrectTypeDefinition(
+ SchemaPath parentSchemaPath, QName nodeQName,
+ TypeDefinition<?> nodeType) {
+ TypeDefinition<?> result = null;
+ SchemaPath newSchemaPath = null;
+ if (nodeType != null) {
+ if (nodeType instanceof BinaryTypeDefinition) {
+ BinaryTypeDefinition binType = (BinaryTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, binType.getQName());
+ List<Byte> bytes = (List<Byte>) binType.getDefaultValue();
+ result = new BinaryType(newSchemaPath, bytes,
+ binType.getLengthConstraints(), binType.getUnits());
+ } else if (nodeType instanceof BitsTypeDefinition) {
+ BitsTypeDefinition bitsType = (BitsTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, nodeType.getQName());
+ result = new BitsType(newSchemaPath, bitsType.getBits(),
+ bitsType.getUnits());
+ } else if (nodeType instanceof BooleanTypeDefinition) {
+ BooleanTypeDefinition booleanType = (BooleanTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, booleanType.getQName());
+ result = new BooleanType(newSchemaPath,
+ (Boolean) booleanType.getDefaultValue(),
+ booleanType.getUnits());
+ } else if (nodeType instanceof DecimalTypeDefinition) {
+ DecimalTypeDefinition decimalType = (DecimalTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, decimalType.getQName());
+ BigDecimal defaultValue = (BigDecimal) decimalType
+ .getDefaultValue();
+ result = new Decimal64(newSchemaPath, decimalType.getUnits(),
+ defaultValue, decimalType.getRangeStatements(),
+ decimalType.getFractionDigits());
+ } else if (nodeType instanceof EmptyTypeDefinition) {
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, nodeType.getQName());
+ result = new EmptyType(newSchemaPath);
+ } else if (nodeType instanceof EnumTypeDefinition) {
+ EnumTypeDefinition enumType = (EnumTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, enumType.getQName());
+ result = new EnumerationType(newSchemaPath,
+ (EnumPair) enumType.getDefaultValue(),
+ enumType.getValues(), enumType.getUnits());
+ } else if (nodeType instanceof IdentityrefTypeDefinition) {
+ IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, idrefType.getQName());
+ result = new IdentityrefType(idrefType.getIdentity(),
+ newSchemaPath);
+ } else if (nodeType instanceof InstanceIdentifierTypeDefinition) {
+ InstanceIdentifierTypeDefinition instIdType = (InstanceIdentifierTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, instIdType.getQName());
+ return new InstanceIdentifier(newSchemaPath,
+ instIdType.getPathStatement(),
+ instIdType.requireInstance());
+ } else if (nodeType instanceof StringTypeDefinition) {
+ result = copyStringType(parentSchemaPath, nodeQName,
+ (StringTypeDefinition) nodeType);
+ } else if (nodeType instanceof IntegerTypeDefinition) {
+ result = copyIntType(parentSchemaPath, nodeQName,
+ (IntegerTypeDefinition) nodeType);
+ } else if (nodeType instanceof UnsignedIntegerTypeDefinition) {
+ result = copyUIntType(parentSchemaPath, nodeQName,
+ (UnsignedIntegerTypeDefinition) nodeType);
+ } else if (nodeType instanceof LeafrefTypeDefinition) {
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, nodeType.getQName());
+ result = new Leafref(newSchemaPath,
+ ((LeafrefTypeDefinition) nodeType).getPathStatement());
+ } else if (nodeType instanceof UnionTypeDefinition) {
+ UnionTypeDefinition unionType = (UnionTypeDefinition) nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath,
+ nodeQName, unionType.getQName());
+ return new UnionType(newSchemaPath, unionType.getTypes());
+ }
+ }
+ return result;
+ }
+
+ private static TypeDefinition<?> copyStringType(SchemaPath schemaPath,
+ QName nodeQName, StringTypeDefinition nodeType) {
+ List<QName> path = schemaPath.getPath();
+ List<QName> newPath = new ArrayList<QName>(path);
+ newPath.add(nodeQName);
+ newPath.add(nodeType.getQName());
+ SchemaPath newSchemaPath = new SchemaPath(newPath,
+ schemaPath.isAbsolute());
+
+ String newDefault = nodeType.getDefaultValue().toString();
+ String newUnits = nodeType.getUnits();
+ List<LengthConstraint> lengths = nodeType.getLengthStatements();
+ List<PatternConstraint> patterns = nodeType.getPatterns();
+
+ return new StringType(newSchemaPath, newDefault, lengths, patterns,
+ newUnits);
+ }
+
+ private static TypeDefinition<?> copyIntType(SchemaPath schemaPath,
+ QName nodeQName, IntegerTypeDefinition type) {
+ QName typeQName = type.getQName();
+ SchemaPath newSchemaPath = createNewSchemaPath(schemaPath, nodeQName,
+ typeQName);
+
+ String localName = typeQName.getLocalName();
+ List<RangeConstraint> ranges = type.getRangeStatements();
+ String units = type.getUnits();
+
+ if ("int8".equals(localName)) {
+ Byte defaultValue = (Byte) type.getDefaultValue();
+ return new Int8(newSchemaPath, ranges, units, defaultValue);
+ } else if ("int16".equals(localName)) {
+ Short defaultValue = (Short) type.getDefaultValue();
+ return new Int16(newSchemaPath, ranges, units, defaultValue);
+ } else if ("int32".equals(localName)) {
+ Integer defaultValue = (Integer) type.getDefaultValue();
+ return new Int32(newSchemaPath, ranges, units, defaultValue);
+ } else if ("int64".equals(localName)) {
+ Long defaultValue = (Long) type.getDefaultValue();
+ return new Int64(newSchemaPath, ranges, units, defaultValue);
+ } else {
+ return null;
+ }
+ }
+
+ private static TypeDefinition<?> copyUIntType(SchemaPath schemaPath,
+ QName nodeQName, UnsignedIntegerTypeDefinition type) {
+ QName typeQName = type.getQName();
+ SchemaPath newSchemaPath = createNewSchemaPath(schemaPath, nodeQName,
+ typeQName);
+
+ String localName = typeQName.getLocalName();
+ List<RangeConstraint> ranges = type.getRangeStatements();
+ String units = type.getUnits();
+
+ if ("uint8".equals(localName)) {
+ Byte defaultValue = (Byte) type.getDefaultValue();
+ return new Int8(newSchemaPath, ranges, units, defaultValue);
+ } else if ("uint16".equals(localName)) {
+ Short defaultValue = (Short) type.getDefaultValue();
+ return new Int16(newSchemaPath, ranges, units, defaultValue);
+ } else if ("uint32".equals(localName)) {
+ Integer defaultValue = (Integer) type.getDefaultValue();
+ return new Int32(newSchemaPath, ranges, units, defaultValue);
+ } else if ("uint64".equals(localName)) {
+ Long defaultValue = (Long) type.getDefaultValue();
+ return new Int64(newSchemaPath, ranges, units, defaultValue);
+ } else {
+ return null;
+ }
+ }
+
+ private static SchemaPath createNewSchemaPath(SchemaPath schemaPath,
+ QName currentQName, QName qname) {
+ List<QName> newPath = new ArrayList<QName>(schemaPath.getPath());
+ newPath.add(currentQName);
+ newPath.add(qname);
+ return new SchemaPath(newPath, schemaPath.isAbsolute());
+ }
+
+ public static void refineLeaf(LeafSchemaNodeBuilder leaf,
+ RefineHolder refine, int line) {
+ String defaultStr = refine.getDefaultStr();
+ Boolean mandatory = refine.isMandatory();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (defaultStr != null && !("".equals(defaultStr))) {
+ leaf.setDefaultStr(defaultStr);
+ }
+ if (mandatory != null) {
+ leaf.getConstraints().setMandatory(mandatory);
+ }
+ if (must != null) {
+ leaf.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ leaf.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineContainer(ContainerSchemaNodeBuilder container,
+ RefineHolder refine, int line) {
+ Boolean presence = refine.isPresence();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (presence != null) {
+ container.setPresence(presence);
+ }
+ if (must != null) {
+ container.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ container.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineList(ListSchemaNodeBuilder list,
+ RefineHolder refine, int line) {
+ MustDefinition must = refine.getMust();
+ Integer min = refine.getMinElements();
+ Integer max = refine.getMaxElements();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (must != null) {
+ list.getConstraints().addMustDefinition(must);
+ }
+ if (min != null) {
+ list.getConstraints().setMinElements(min);
+ }
+ if (max != null) {
+ list.getConstraints().setMaxElements(max);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ list.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineLeafList(LeafListSchemaNodeBuilder leafList,
+ RefineHolder refine, int line) {
+ MustDefinition must = refine.getMust();
+ Integer min = refine.getMinElements();
+ Integer max = refine.getMaxElements();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (must != null) {
+ leafList.getConstraints().addMustDefinition(must);
+ }
+ if (min != null) {
+ leafList.getConstraints().setMinElements(min);
+ }
+ if (max != null) {
+ leafList.getConstraints().setMaxElements(max);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ leafList.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineChoice(ChoiceBuilder choice, RefineHolder refine,
+ int line) {
+ String defaultStr = refine.getDefaultStr();
+ Boolean mandatory = refine.isMandatory();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (defaultStr != null) {
+ choice.setDefaultCase(defaultStr);
+ }
+ if (mandatory != null) {
+ choice.getConstraints().setMandatory(mandatory);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ choice.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine,
+ int line) {
+ Boolean mandatory = refine.isMandatory();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (mandatory != null) {
+ anyXml.getConstraints().setMandatory(mandatory);
+ }
+ if (must != null) {
+ anyXml.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ anyXml.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) {
+ String name = node.getQName().getLocalName();
+ int line = refine.getLine();
+
+ String defaultStr = refine.getDefaultStr();
+ Boolean mandatory = refine.isMandatory();
+ Boolean presence = refine.isPresence();
+ MustDefinition must = refine.getMust();
+ Integer min = refine.getMinElements();
+ Integer max = refine.getMaxElements();
+
+ if (node instanceof AnyXmlBuilder) {
+ checkRefineDefault(node, defaultStr, line);
+ checkRefinePresence(node, presence, line);
+ checkRefineMinMax(name, line, min, max);
+ } else if (node instanceof ChoiceBuilder) {
+ checkRefinePresence(node, presence, line);
+ checkRefineMust(node, must, line);
+ checkRefineMinMax(name, line, min, max);
+ } else if (node instanceof ContainerSchemaNodeBuilder) {
+ checkRefineDefault(node, defaultStr, line);
+ checkRefineMandatory(node, mandatory, line);
+ checkRefineMust(node, must, line);
+ checkRefineMinMax(name, line, min, max);
+ } else if (node instanceof LeafSchemaNodeBuilder) {
+ checkRefinePresence(node, presence, line);
+ checkRefineMinMax(name, line, min, max);
+ } else if (node instanceof LeafListSchemaNodeBuilder
+ || node instanceof ListSchemaNodeBuilder) {
+ checkRefineDefault(node, defaultStr, line);
+ checkRefinePresence(node, presence, line);
+ checkRefineMandatory(node, mandatory, line);
+ } else if (node instanceof GroupingBuilder
+ || node instanceof TypeDefinitionBuilder
+ || node instanceof UsesNodeBuilder) {
+ checkRefineDefault(node, defaultStr, line);
+ checkRefinePresence(node, presence, line);
+ checkRefineMandatory(node, mandatory, line);
+ checkRefineMust(node, must, line);
+ checkRefineMinMax(name, line, min, max);
+ }
+ }
+
+ private static void checkRefineDefault(SchemaNodeBuilder node,
+ String defaultStr, int line) {
+ if (defaultStr != null) {
+ throw new YangParseException(line, "Can not refine 'default' for '"
+ + node.getQName().getLocalName() + "'.");
+ }
+ }
+
+ private static void checkRefineMandatory(SchemaNodeBuilder node,
+ Boolean mandatory, int line) {
+ if (mandatory != null) {
+ throw new YangParseException(line,
+ "Can not refine 'mandatory' for '"
+ + node.getQName().getLocalName() + "'.");
+ }
+ }
+
+ private static void checkRefinePresence(SchemaNodeBuilder node,
+ Boolean presence, int line) {
+ if (presence != null) {
+ throw new YangParseException(line,
+ "Can not refine 'presence' for '"
+ + node.getQName().getLocalName() + "'.");
+ }
+ }
+
+ private static void checkRefineMust(SchemaNodeBuilder node,
+ MustDefinition must, int line) {
+ if (must != null) {
+ throw new YangParseException(line, "Can not refine 'must' for '"
+ + node.getQName().getLocalName() + "'.");
+ }
+ }
+
+ private static void checkRefineMinMax(String refineTargetName,
+ int refineLine, Integer min, Integer max) {
+ if (min != null || max != null) {
+ throw new YangParseException(refineLine,
+ "Can not refine 'min-elements' or 'max-elements' for '"
+ + refineTargetName + "'.");
+ }
+ }
+
+ /**
+ * Perform refine operation of following parameters:
+ * <ul>
+ * <li>description</li>
+ * <li>reference</li>
+ * <li>config</li>
+ * </ul>
+ *
+ * These parameters may be refined for any node.
+ *
+ * @param node
+ * node to refine
+ * @param refine
+ * refine holder containing values to refine
+ * @param line
+ * current line in yang model
+ */
+ public static void refineDefault(Builder node, RefineHolder refine, int line) {
+ Class<? extends Builder> cls = node.getClass();
+
+ String description = refine.getDescription();
+ if (description != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setDescription",
+ String.class);
+ method.invoke(node, description);
+ } catch (Exception e) {
+ throw new YangParseException(line,
+ "Cannot refine description in " + cls.getName(), e);
+ }
+ }
+
+ String reference = refine.getReference();
+ if (reference != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setReference",
+ String.class);
+ method.invoke(node, reference);
+ } catch (Exception e) {
+ throw new YangParseException(line,
+ "Cannot refine reference in " + cls.getName(), e);
+ }
+ }
+
+ Boolean config = refine.isConfig();
+ if (config != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setConfiguration",
+ Boolean.TYPE);
+ method.invoke(node, config);
+ } catch (Exception e) {
+ throw new YangParseException(line, "Cannot refine config in "
+ + cls.getName(), e);
}
}
}
final TypeDefinition<?> type = old.getType();
if (type == null) {
- copy.setType(old.getTypedef());
+ copy.setTypedef(old.getTypedef());
} else {
copy.setType(type);
}
for (GroupingBuilder grouping : old.getGroupings()) {
copy.addGrouping(grouping);
}
- for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
+ for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
copy.addTypedef(typedef);
}
for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
for (UsesNodeBuilder use : old.getUsesNodes()) {
copy.addUsesNode(use);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
for (GroupingBuilder grouping : old.getGroupings()) {
copy.addGrouping(grouping);
}
- for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
+ for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
copy.addTypedef(typedef);
}
for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
for (UsesNodeBuilder use : old.getUsesNodes()) {
copy.addUsesNode(use);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
copyConstraints(old, copy);
final TypeDefinition<?> type = old.getType();
if (type == null) {
- copy.setType(old.getTypedef());
+ copy.setTypedef(old.getTypedef());
} else {
copy.setType(type);
}
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
copy.addUnknownSchemaNode(unknown);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
}
public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) {
- final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(), old.getLine());
+ final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(),
+ old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (ChoiceCaseBuilder caseBuilder : old.getCases()) {
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
copy.addUnknownSchemaNode(unknown);
}
- for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
- copy.addTypedef(typedef);
- }
- for (UsesNodeBuilder use : old.getUsesNodes()) {
- copy.addUsesNode(use);
- }
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDefaultCase(old.getDefaultCase());
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
}
public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) {
- final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(), old.getLine());
+ final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(),
+ old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
return copy;
}
+ public static GroupingBuilder copyGroupingBuilder(final GroupingBuilder old) {
+ final GroupingBuilder copy = new GroupingBuilderImpl(old.getQName(),
+ old.getLine());
+ copy.setPath(old.getPath());
+ for (DataSchemaNodeBuilder child : old.getChildNodes()) {
+ copy.addChildNode(child);
+ }
+ for (GroupingBuilder grouping : old.getGroupings()) {
+ copy.addGrouping(grouping);
+ }
+ for (TypeDefinitionBuilder typedef : old.getTypeDefinitions()) {
+ copy.addTypedef(typedef);
+ }
+ for (UsesNodeBuilder use : old.getUses()) {
+ copy.addUsesNode(use);
+ }
+ for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
+ copy.addUnknownSchemaNode(unknown);
+ }
+ copy.setDescription(old.getDescription());
+ copy.setReference(old.getReference());
+ copy.setStatus(old.getStatus());
+ return copy;
+ }
+
+ public static TypeDefinitionBuilderImpl copyTypedefBuilder(
+ TypeDefinitionBuilderImpl old) {
+ final TypeDefinitionBuilderImpl copy = new TypeDefinitionBuilderImpl(
+ old.getQName(), old.getLine());
+ copy.setPath(old.getPath());
+ copy.setDefaultValue(old.getDefaultValue());
+ copy.setUnits(old.getUnits());
+ copy.setDescription(old.getDescription());
+ copy.setReference(old.getReference());
+ copy.setStatus(old.getStatus());
+
+ copy.setRanges(old.getRanges());
+ copy.setLengths(old.getLengths());
+ copy.setPatterns(old.getPatterns());
+ copy.setFractionDigits(old.getFractionDigits());
+
+ TypeDefinition<?> type = old.getType();
+ if (type == null) {
+ copy.setTypedef(old.getTypedef());
+ } else {
+ copy.setType(old.getType());
+ }
+ copy.setUnits(old.getUnits());
+ for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
+ copy.addUnknownSchemaNode(unknown);
+ }
+ return copy;
+ }
+
+ public static UsesNodeBuilder copyUsesNodeBuilder(UsesNodeBuilder old) {
+ final UsesNodeBuilder copy = new UsesNodeBuilderImpl(
+ old.getGroupingPathString(), old.getLine());
+ for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
+ copy.addAugment(augment);
+ }
+ copy.setAugmenting(old.isAugmenting());
+ for (SchemaNodeBuilder refineNode : old.getRefineNodes()) {
+ copy.addRefineNode(refineNode);
+ }
+ return copy;
+ }
+
private static void copyConstraints(final DataSchemaNodeBuilder oldBuilder,
final DataSchemaNodeBuilder newBuilder) {
final ConstraintsBuilder oldConstraints = oldBuilder.getConstraints();
Code Review / controller.git / blobdiff