- private void resolveLengths(List<LengthConstraint> lengths,
- TypeDefinitionBuilder targetType,
- Map<String, TreeMap<Date, ModuleBuilder>> modules,
- ModuleBuilder builder) {
- if (lengths != null && lengths.size() > 0) {
- Long min = lengths.get(0).getMin();
- Long max = lengths.get(lengths.size() - 1).getMax();
- // if length contains one of the special values 'min' or 'max'
- if (min.equals(Long.MIN_VALUE) || max.equals(Long.MAX_VALUE)) {
- Long[] values = parseRangeConstraint(targetType, modules,
- builder);
- if (min.equals(Long.MIN_VALUE)) {
- min = values[0];
- LengthConstraint oldFirst = lengths.get(0);
- LengthConstraint newFirst = BaseConstraints
- .lengthConstraint(min, oldFirst.getMax(),
- oldFirst.getDescription(),
- oldFirst.getReference());
- lengths.set(0, newFirst);
- }
- if (max.equals(Long.MAX_VALUE)) {
- max = values[1];
- LengthConstraint oldLast = lengths.get(lengths.size() - 1);
- LengthConstraint newLast = BaseConstraints
- .lengthConstraint(oldLast.getMin(), max,
- oldLast.getDescription(),
- oldLast.getReference());
- lengths.set(lengths.size() - 1, newLast);
+ private Builder getRefineTargetBuilder(final String groupingPath,
+ final RefineHolder refine,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module) {
+ Builder result = null;
+ final Builder lookedUpBuilder = findRefineTargetBuilder(groupingPath,
+ refine.getName(), modules, module);
+ if (lookedUpBuilder instanceof LeafSchemaNodeBuilder) {
+ result = ParserUtils
+ .copyLeafBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof ContainerSchemaNodeBuilder) {
+ result = ParserUtils
+ .copyContainerBuilder((ContainerSchemaNodeBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof ListSchemaNodeBuilder) {
+ result = ParserUtils
+ .copyListBuilder((ListSchemaNodeBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof LeafListSchemaNodeBuilder) {
+ result = ParserUtils
+ .copyLeafListBuilder((LeafListSchemaNodeBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof ChoiceBuilder) {
+ result = ParserUtils
+ .copyChoiceBuilder((ChoiceBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof AnyXmlBuilder) {
+ result = ParserUtils
+ .copyAnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
+ } else {
+ throw new YangParseException("Target '" + refine.getName()
+ + "' can not be refined");
+ }
+ return result;
+ }
+
+ /**
+ * Find builder of refine node.
+ *
+ * @param groupingPath
+ * path to grouping which contains node to refine
+ * @param refineNodeName
+ * name of node to be refined
+ * @param modules
+ * all loaded modules
+ * @param module
+ * current module
+ * @return Builder object of refine node if it is present in grouping, null
+ * otherwise
+ */
+ private Builder findRefineTargetBuilder(final String groupingPath,
+ final String refineNodeName,
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module) {
+ final SchemaPath path = ParserUtils.parseUsesPath(groupingPath);
+ final List<String> builderPath = new ArrayList<String>();
+ String prefix = null;
+ for (QName qname : path.getPath()) {
+ builderPath.add(qname.getLocalName());
+ prefix = qname.getPrefix();
+ }
+ if (prefix == null) {
+ prefix = module.getPrefix();
+ }
+
+ final ModuleBuilder dependentModule = findDependentModule(modules,
+ module, prefix);
+ builderPath.add(0, "grouping");
+ builderPath.add(0, dependentModule.getName());
+ final GroupingBuilder builder = (GroupingBuilder) dependentModule
+ .getNode(builderPath);
+
+ return builder.getChildNode(refineNodeName);
+ }
+
+ private QName findFullQName(
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module, final IdentityrefTypeBuilder idref) {
+ QName result = null;
+ String baseString = idref.getBaseString();
+ if (baseString.contains(":")) {
+ String[] splittedBase = baseString.split(":");
+ if (splittedBase.length > 2) {
+ throw new YangParseException(
+ "Failed to parse identityref base: " + baseString);
+ }
+ String prefix = splittedBase[0];
+ String name = splittedBase[1];
+ ModuleBuilder dependentModule = findDependentModule(modules,
+ module, prefix);
+ result = new QName(dependentModule.getNamespace(),
+ dependentModule.getRevision(), prefix, name);
+ } else {
+ result = new QName(module.getNamespace(), module.getRevision(),
+ module.getPrefix(), baseString);
+ }
+ return result;
+ }
+
+ private void resolveUnknownNodes(
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ final ModuleBuilder module) {
+ for (UnknownSchemaNodeBuilder usnb : module.getAddedUnknownNodes()) {
+ QName nodeType = usnb.getNodeType();
+ if (nodeType.getNamespace() == null
+ || nodeType.getRevision() == null) {
+ try {
+ ModuleBuilder dependentModule = findDependentModule(
+ modules, module, nodeType.getPrefix());
+ QName newNodeType = new QName(
+ dependentModule.getNamespace(),
+ dependentModule.getRevision(),
+ nodeType.getPrefix(), nodeType.getLocalName());
+ usnb.setNodeType(newNodeType);
+ } catch (YangParseException e) {
+ logger.debug("Failed to find unknown node type: "
+ + nodeType);