import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.RefineUtils;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
-import org.opendaylight.yangtools.yang.parser.util.RefineUtils;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
assertEquals("Incorrect number of test files.", 1, testModels.size());
Set<UsesNodeBuilder> usesNodeBuilders = getModuleBuilder().getUsesNodeBuilders();
- List<RefineHolder> refineHolders = null;
+ List<RefineBuilder> RefineBuilders = null;
Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders = null;
for (UsesNodeBuilder usesNodeBuilder : usesNodeBuilders) {
if (usesNodeBuilder.getGroupingPathAsString().equals("grp")) {
- refineHolders = usesNodeBuilder.getRefines();
+ RefineBuilders = usesNodeBuilder.getRefines();
dataSchemaNodeBuilders = usesNodeBuilder.getParent().getChildNodeBuilders();
break;
}
}
- assertNotNull("List of refine holders wasn't initialized.", refineHolders);
- assertEquals("Incorrect number of refine holders", 4, refineHolders.size());
+ assertNotNull("List of refine holders wasn't initialized.", RefineBuilders);
+ assertEquals("Incorrect number of refine holders", 4, RefineBuilders.size());
- checkLflstRefineHolderAndSchemaNodeBuilder("lflst", refineHolders, dataSchemaNodeBuilders);
- checkChcRefineHolderAndSchemaNodeBuilder("chc", refineHolders, dataSchemaNodeBuilders);
- checkChc2RefineHolderAndSchemaNodeBuilder("chc2", refineHolders, dataSchemaNodeBuilders);
- checkAnyXmlRefineHolderAndSchemaNodeBuilder("data", refineHolders, dataSchemaNodeBuilders);
+ checkLflstRefineBuilderAndSchemaNodeBuilder("lflst", RefineBuilders, dataSchemaNodeBuilders);
+ checkChcRefineBuilderAndSchemaNodeBuilder("chc", RefineBuilders, dataSchemaNodeBuilders);
+ checkChc2RefineBuilderAndSchemaNodeBuilder("chc2", RefineBuilders, dataSchemaNodeBuilders);
+ checkAnyXmlRefineBuilderAndSchemaNodeBuilder("data", RefineBuilders, dataSchemaNodeBuilders);
}
private ModuleBuilder getModuleBuilder() {
return moduleBuilder;
}
- private void checkAnyXmlRefineHolderAndSchemaNodeBuilder(final String string, final List<RefineHolder> refineHolders,
+ private void checkAnyXmlRefineBuilderAndSchemaNodeBuilder(final String string, final List<RefineBuilder> RefineBuilders,
final Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
- RefineHolder refHolderData = getRefineHolder("data", refineHolders);
+ RefineBuilder refHolderData = getRefineBuilder("data", RefineBuilders);
QName qname = createQname();
DataSchemaNodeBuilder builderData = new AnyXmlBuilder("module", 4, qname, createSchemaPath(qname));
}
- private void checkChc2RefineHolderAndSchemaNodeBuilder(final String nodeName, final List<RefineHolder> refineHolders,
+ private void checkChc2RefineBuilderAndSchemaNodeBuilder(final String nodeName, final List<RefineBuilder> RefineBuilders,
final Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
- RefineHolder refHolderChc2 = getRefineHolder("chc2", refineHolders);
+ RefineBuilder refHolderChc2 = getRefineBuilder("chc2", RefineBuilders);
QName qname = createQname();
List<QName> path = Lists.newArrayList(qname);
assertFalse("'chc2' has incorrect value for 'mandatory'", conDefChc2.isMandatory());
}
- private void checkChcRefineHolderAndSchemaNodeBuilder(final String nodeName, final List<RefineHolder> refineHolders,
+ private void checkChcRefineBuilderAndSchemaNodeBuilder(final String nodeName, final List<RefineBuilder> RefineBuilders,
final Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
- RefineHolder refHolderChc = getRefineHolder("chc", refineHolders);
+ RefineBuilder refHolderChc = getRefineBuilder("chc", RefineBuilders);
QName qname = createQname();
List<QName> path = Lists.newArrayList(qname);
findUnknownNode(choiceBuilder, unknownNodeChcValue, unknownNodeChcName);
}
- private void checkLflstRefineHolderAndSchemaNodeBuilder(final String nodeName, final List<RefineHolder> refineHolders,
+ private void checkLflstRefineBuilderAndSchemaNodeBuilder(final String nodeName, final List<RefineBuilder> RefineBuilders,
final Set<DataSchemaNodeBuilder> dataSchemaNodeBuilders) {
- RefineHolder refHolderLflst = getRefineHolder(nodeName, refineHolders);
+ RefineBuilder refHolderLflst = getRefineBuilder(nodeName, RefineBuilders);
QName qname = createQname();
DataSchemaNodeBuilder builderLflst = new LeafListSchemaNodeBuilder("module", 4, qname, createSchemaPath(qname));
}
- private RefineHolder getRefineHolder(final String refHolderName, final List<RefineHolder> refineHolders) {
- for (RefineHolder refineHolder : refineHolders) {
- if (refineHolder.getName().equals(refHolderName)) {
- return refineHolder;
+ private RefineBuilder getRefineBuilder(final String refHolderName, final List<RefineBuilder> RefineBuilders) {
+ for (RefineBuilder RefineBuilder : RefineBuilders) {
+ if (RefineBuilder.getTargetPathString().equals(refHolderName)) {
+ return RefineBuilder;
}
}
return null;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
-import com.google.common.io.BaseEncoding;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URI;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+
import org.apache.commons.lang3.StringEscapeUtils;
import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
import org.opendaylight.yangtools.binding.generator.util.TypeConstants;
import org.opendaylight.yangtools.yang.model.util.Uint64;
import org.opendaylight.yangtools.yang.model.util.Uint8;
import org.opendaylight.yangtools.yang.model.util.UnionType;
-import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Sets;
+import com.google.common.io.BaseEncoding;
+
public final class TypeProviderImpl implements TypeProvider {
private static final Pattern NUMBERS_PATTERN = Pattern.compile("[0-9]+\\z");
for (Module modul : modules) {
modulesArray[i++] = modul;
}
- final List<Module> modulesSortedByDependency = ModuleDependencySort.sort(modulesArray);
+ final List<Module> modulesSortedByDependency = org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort.sort(modulesArray);
for (final Module module : modulesSortedByDependency) {
Map<Date, Map<String, Type>> dateTypeMap = genTypeDefsContextMap.get(module.getName());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.model.util;
import java.util.Collections;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
-final class BitImpl implements BitsTypeDefinition.Bit, Immutable {
+import com.google.common.base.Preconditions;
+
+public final class BitImpl implements BitsTypeDefinition.Bit, Immutable {
private final Long position;
private final QName qname;
private final SchemaPath schemaPath;
private final Status status;
private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
- BitImpl(final Long position, final QName qname, final SchemaPath schemaPath, final String description,
+ public BitImpl(final Long position, final QName qname, final SchemaPath schemaPath, final String description,
final String reference, final Status status, final List<UnknownSchemaNode> unknownNodes) {
- this.position = position;
- this.qname = qname;
- this.schemaPath = schemaPath;
+ this.position = Preconditions.checkNotNull(position, "Position should not be null");
+ this.qname = Preconditions.checkNotNull(qname, "QName should not be null");
+ this.schemaPath = Preconditions.checkNotNull(schemaPath, "Schema Path should not be null");
this.description = description;
this.reference = reference;
this.status = status;
public int hashCode() {
final int prime = 31;
int result = 1;
- result = prime * result + ((qname == null) ? 0 : qname.hashCode());
- result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
- result = prime * result + ((position == null) ? 0 : position.hashCode());
+ result = prime * result + qname.hashCode();
+ result = prime * result + schemaPath.hashCode();
+ result = prime * result + position.hashCode();
result = prime * result + ((unknownNodes == null) ? 0 : unknownNodes.hashCode());
return result;
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.model.util;
import java.util.Date;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.model.util;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
-final class MustDefinitionImpl implements MustDefinition {
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+/**
+ *
+ * Immutable implementation of {@link MustDefinition}
+ *
+ */
+public final class MustDefinitionImpl implements MustDefinition {
private final String mustStr;
private final String description;
private final String reference;
private final String errorAppTag;
private final String errorMessage;
- MustDefinitionImpl(String mustStr, String description, String reference, String errorAppTag, String errorMessage) {
- this.mustStr = mustStr;
+ /**
+ *
+ * Creates new Must Definition
+ *
+ * @param mustStr must string statement, Must not be null.
+ * @param description Description of condition
+ * @param reference Reference for condition
+ * @param errorAppTag error application tag which should be used for error reporting when condition fails
+ * @param errorMessage message which should be used for error reporting when condition fails
+ * @deprecated Use {@link #create(String, Optional, Optional, Optional, Optional)} instead.
+ */
+ @Deprecated
+ public MustDefinitionImpl(final String mustStr, final String description, final String reference, final String errorAppTag, final String errorMessage) {
+ this.mustStr = Preconditions.checkNotNull(mustStr);
this.description = description;
this.reference = reference;
this.errorAppTag = errorAppTag;
this.errorMessage = errorMessage;
}
+ /**
+ *
+ * Creates new Must Definition
+ *
+ * @param mustStr must string statement, Must not be null.
+ * @param description Description of condition
+ * @param reference Reference for condition
+ * @param errorAppTag error application tag which should be used for error reporting when condition fails
+ * @param errorMessage message which should be used for error reporting when condition fails
+ */
+ public static MustDefinitionImpl create(final String mustStr, final Optional<String> description, final Optional<String> reference, final Optional<String> errorAppTag, final Optional<String> errorMessage) {
+ return new MustDefinitionImpl(mustStr, description.orNull(), reference.orNull(), errorAppTag.orNull(), errorMessage.orNull());
+ }
+
@Override
public String getDescription() {
return description;
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.model.util;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Date;
import java.util.List;
+
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
public class BitImplTest {
assertFalse("biA shouldn't equal to null", biA.equals(null));
assertFalse("biA shouldn't equal to object of other type", biA.equals(new String("str")));
- // test of equals method
- // // test qname
- biA = new BitImpl(55L, null, schemaPathA, "description", "reference", Status.CURRENT, null);
- biB = new BitImpl(55L, qnameB, schemaPathA, "description", "reference", Status.CURRENT, null);
- assertFalse("biA shouldn't equal to biB", biA.equals(biB));
-
biA = new BitImpl(55L, qnameB, schemaPathA, "description", "reference", Status.CURRENT, null);
biB = new BitImpl(55L, qnameB, schemaPathA, "description", "reference", Status.CURRENT, null);
assertEquals("biA should equal to biB", biA, biB);
assertFalse("biA shouldn't equal to biB", biA.equals(biB));
// // test schemaPath
- biA = new BitImpl(55L, qnameA, null, "description", "reference", Status.CURRENT, null);
+ biA = new BitImpl(55L, qnameA, schemaPathA, "description", "reference", Status.CURRENT, null);
biB = new BitImpl(55L, qnameA, schemaPathB, "description", "reference", Status.CURRENT, null);
assertFalse("biA shouldn't equal to biB", biA.equals(biB));
biB = new BitImpl(55L, qnameA, schemaPathA, "description", "reference", Status.CURRENT, null);
assertEquals("biA should equal to biB", biA, biB);
- // test of hashCode method
- biA = new BitImpl(null, null, null, "description", "reference", Status.CURRENT, null);
- assertEquals("Incorrect hash code for biA.", 923522, biA.hashCode());
-
- List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
- SchemaPath path = org.mockito.Mockito.mock(SchemaPath.class);
- UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("module", 3, qnameB, path);
- ModuleBuilder parent = org.mockito.Mockito.mock(ModuleBuilder.class);
- usnb.setParent(parent);
-
- unknownNodes.add(usnb.build());
-
- biA = new BitImpl(55L, qnameA, schemaPathA, "description", "reference", Status.CURRENT, unknownNodes);
+ biA = new BitImpl(55L, qnameA, schemaPathA, "description", "reference", Status.CURRENT,null);
// test of getter methods
assertEquals("Incorrect value for qname.", qnameA, biA.getQName());
assertEquals("Incorrect value for description.", "description", biA.getDescription());
assertEquals("Incorrect value for reference.", "reference", biA.getReference());
assertEquals("Incorrect value for status.", Status.CURRENT, biA.getStatus());
- assertEquals("Incorrect value for unknown nodes.", unknownNodes, biA.getUnknownSchemaNodes());
+ assertEquals("Incorrect value for unknown nodes.", Collections.emptyList(), biA.getUnknownSchemaNodes());
// test of toString method
assertEquals("toString method doesn't return correct value", "Bit[name=some name, position=55]", biA.toString());
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.model.util;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import org.junit.Test;
+
+import com.google.common.base.Optional;
+
+public class MustDefinitionImplTest {
+
+ @Test
+ public void test() {
+ MustDefinitionImpl mdiA;
+ MustDefinitionImpl mdiB;
+ mdiA = MustDefinitionImpl.create("mustStrA", Optional.of("descriptionA"), Optional.of("referenceA"), Optional.of("errorAppTagA"), Optional.of("errorMessageA"));
+
+ assertEquals("mdiA should equals to itsefl", mdiA, mdiA);
+ assertFalse("mdiA shouldn't equal to null", mdiA.equals(null));
+ assertFalse("mdiA shouldn't equal to object of other type", mdiA.equals(new String("str")));
+
+ // test of equals method
+
+ Optional<String> description = Optional.of("description");
+ Optional<String> reference = Optional.of("reference");
+ Optional<String> errorAppTag = Optional.of("errorAppTag");
+ Optional<String> errorMessage = Optional.of("errorMesage");
+ // //confirmation of equality
+ mdiA = MustDefinitionImpl.create("mustStr", description, reference, errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", description, reference, errorAppTag, errorMessage);
+ assertEquals("mdiA should equal to mdiB", mdiA, mdiB);
+
+ // // mustStr
+ mdiA = MustDefinitionImpl.create("mstr", description, reference, errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", description, reference, errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ mdiA = MustDefinitionImpl.create("mustStrA", description, reference, errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStrB", description, reference, errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ // //description
+ mdiA = MustDefinitionImpl.create("mustStr", Optional.<String>absent(), reference, errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", description, reference, errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ mdiA = MustDefinitionImpl.create("mustStr", Optional.of("descriptionA"), reference, errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", Optional.of("descriptionB"), reference, errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ // //reference
+ mdiA = MustDefinitionImpl.create("mustStr", description, Optional.<String>absent(), errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", description, reference, errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ mdiA = MustDefinitionImpl.create("mustStr", description, Optional.of("referenceA"), errorAppTag, errorMessage);
+ mdiB = MustDefinitionImpl.create("mustStr", description, Optional.of("referenceB"), errorAppTag, errorMessage);
+ assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
+
+ }
+
+}
import java.util.List;
import org.opendaylight.yangtools.concepts.Mutable;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
* Parent interface for all builder interfaces.
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.builder.api;
+
+import java.util.Set;
+
+import org.opendaylight.yangtools.concepts.Builder;
+import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
+import org.opendaylight.yangtools.yang.model.api.MustDefinition;
+
+public interface ConstraintsBuilder extends Builder<ConstraintDefinition> {
+
+ /**
+ * Returns module name in which constraint is defined.
+ *
+ * @return module name
+ */
+ String getModuleName();
+
+ /**
+ *
+ * Return line on which constraints were defined.
+ *
+ * @return line
+ */
+ int getLine();
+
+ /**
+ *
+ * Returns number of minimum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @return number of minimum required elements.
+ */
+ Integer getMinElements();
+
+ /**
+ *
+ * Sets number of minimum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @param minElements
+ * number of minimum required elements.
+ */
+ void setMinElements(Integer minElements);
+
+ /**
+ *
+ * Returns number of maximum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @return number of maximum required elements.
+ */
+ Integer getMaxElements();
+
+ /**
+ *
+ * Sets number of maximum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @param minElements
+ * number of maximum required elements.
+ */
+ void setMaxElements(Integer maxElements);
+
+ /**
+ * Returns <code>must</code> definition associated with this builder.
+ *
+ * @return <code>must</code> definition associated with this builder.
+ */
+ Set<MustDefinition> getMustDefinitions();
+
+ /**
+ * Adds must definition to product of this builder.
+ *
+ * @param must
+ * <code>must</code> definition which should be associated with
+ * parent node.
+ */
+ void addMustDefinition(MustDefinition must);
+
+ /**
+ * Returns when condition associated with this constraints.
+ *
+ * @return when condition associated with this constraints.
+ */
+ String getWhenCondition();
+
+ /**
+ * Sets when condition associated with this constraints.
+ *
+ * @param whenCondition
+ * when condition.
+ */
+ void addWhenCondition(String whenCondition);
+
+ /**
+ * Returns true if associated node is mandatory.
+ *
+ *
+ * @return true if associated node is mandatory.
+ */
+ boolean isMandatory();
+
+ /**
+ * Sets mandatory status of parent node
+ *
+ * @param mandatory
+ */
+ void setMandatory(boolean mandatory);
+
+ /**
+ * Build constraint definition
+ *
+ * @return
+ */
+ ConstraintDefinition toInstance();
+
+}
\ No newline at end of file
package org.opendaylight.yangtools.yang.parser.builder.api;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
/**
* Interface for all yang data-schema nodes [anyxml, case, container, grouping,
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.builder.api;
+
+import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
+
+/**
+ * Builder for extension statement.
+ *
+ */
+public interface ExtensionBuilder extends SchemaNodeBuilder {
+
+ /**
+ * Sets argument name as was defined in YANG source
+ *
+ * @param argument argument name
+ */
+ void setArgument(String argument);
+
+ /**
+ * Sets if extension should be represented in YIN format as element.
+ *
+ *
+ * @param yin true if extension should be represented in YIN as element.
+ */
+ void setYinElement(boolean yin);
+
+ /**
+ *
+ * Builds definition of extednsion
+ *
+ */
+ @Override
+ ExtensionDefinition build();
+
+}
\ No newline at end of file
import java.util.Set;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
* Interface for builders of 'grouping' statement.
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.builder.api;
+
+import java.util.List;
+
+import org.opendaylight.yangtools.yang.model.api.MustDefinition;
+
+/**
+ * Mutable holder for information contained in <code>refine</code>
+ *
+ * Represents a local change to node introduced by uses statement
+ * e.g. change in documentation, configuration or properties.
+ *
+ *
+ */
+public interface RefineBuilder extends DocumentedNodeBuilder {
+
+ /**
+ * Get value of config statement.
+ *
+ * @return value of config statement
+ */
+ Boolean isConfiguration();
+
+ /**
+ * Set config statement to the product.
+ *
+ *
+ * @param config true if config true was set, false if config false was set.
+ */
+ void setConfiguration(Boolean config);
+
+ /**
+ * Returns mandatory state of node or NULL if state was not refined.
+ *
+ *
+ * @return mandatory state of node or NULL if state was not refined.
+ */
+ Boolean isMandatory();
+
+ void setMandatory(Boolean mandatory);
+
+ /**
+ *
+ * Returns presence state of refined container.
+ *
+ * @return Presence state of refined container.
+ */
+ Boolean isPresence();
+
+ void setPresence(Boolean presence);
+
+ /**
+ * Returns <code>must</code> definition associated with this builder.
+ *
+ * @return <code>must</code> definition associated with this builder.
+ */
+ MustDefinition getMust();
+
+ /**
+ * Adds must definition to product of this builder.
+ *
+ * @param must <code>must</code> definition which should be associated with parent node.
+ */
+ void setMust(MustDefinition must);
+
+
+ /**
+ *
+ * Returns number of minimum required elements or NULL if minimum elements was not overriden.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @return number of minimum required elements.
+ */
+ Integer getMinElements();
+
+ /**
+ *
+ * Sets number of minimum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @param minElements
+ * number of minimum required elements.
+ */
+ void setMinElements(Integer minElements);
+
+ /**
+ *
+ * Returns number of maximum elements or NULL if maximum elements was not overriden.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @return number of maximum required elements.
+ */
+ Integer getMaxElements();
+
+ /**
+ *
+ * Sets number of maximum required elements.
+ *
+ * This constraint has meaning only if associated node is list or leaf-list.
+ *
+ * @param minElements number of maximum required elements.
+ */
+ void setMaxElements(Integer maxElements);
+
+ /**
+ *
+ * Returns string representation of path to refine target, which is relative to grouping root
+ *
+ * This string representation does not need to contain prefixes, since parent uses
+ * element introduces elements with namespace local to parent module.
+ *
+ * @return string representation of path to refine target, which is relative to grouping root
+ */
+ String getTargetPathString();
+
+ /**
+ *
+ * Returns module (source) name in which refine statement was defined.
+ *
+ * @return module (source) name in which refine statement was defined.
+ */
+ String getModuleName();
+
+ /**
+ * Line on which element was defined.
+ *
+ * @return Line on which element was defined.
+ */
+ int getLine();
+
+ /**
+ * Returns list of unknown schema node builders, which are associated
+ * with refine statement.
+ *
+ * @return Set of unknown schema node builders.
+ */
+ List<UnknownSchemaNodeBuilder> getUnknownNodes();
+
+ /**
+ * Returns string representation of default value or null, if default value was not refined.
+ *
+ * @return string representation of default value or null, if default value was not refined.
+ */
+ String getDefaultStr();
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.builder.api;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
+
+public interface UnknownSchemaNodeBuilder extends SchemaNodeBuilder, DocumentedNodeBuilder {
+
+ @Override
+ SchemaPath getPath();
+
+ /**
+ * Returns true if node was added via uses statement
+ *
+ * @return true if node was added via uses statement
+ */
+ boolean isAddedByUses();
+
+ /**
+ * Sets flag if node was introduced by uses statement
+ *
+ * @param addedByUses true if node was introduced by uses, false otherwise
+ */
+ void setAddedByUses(boolean addedByUses);
+
+ /**
+ *
+ * Returns QName associated with this unknown node.
+ *
+ * @return QName associated with this unknown node.
+ */
+ QName getNodeType();
+
+ /**
+ * Returns string representation of argument associated with this unknown node.
+ *
+ * @return string representation of argument associated with this unknown node.
+ */
+ String getNodeParameter();
+
+ /**
+ * Sets string representation of argument associated with this unknown node.
+ * @param nodeParameter string representation of argument associated with this unknown node.
+ */
+ void setNodeParameter(String nodeParameter);
+
+ /**
+ * Returns extension definition, which declares this unknown node
+ * @return extension definition, which declares this unknown node
+ */
+ ExtensionDefinition getExtensionDefinition();
+
+ /**
+ * Sets extension definition, which declares this unknown node
+ * @param extensionDefinition extension definition, which declares this unknown node
+ */
+ void setExtensionDefinition(ExtensionDefinition extensionDefinition);
+
+ /**
+ * Returns builder for extension, which declares this unknown node.
+ *
+ * @return builder for extension, which declares this unknown node.
+ */
+ ExtensionBuilder getExtensionBuilder();
+
+ /**
+ * Sets extension builder, which declares this unknown node
+ * @param extensionBuilder extension definition, which declares this unknown node
+ */
+ void setExtensionBuilder(ExtensionBuilder extension);
+
+ @Override
+ UnknownSchemaNode build();
+
+ /**
+ * Sets node type associated with this unknown schema node
+ *
+ * @param qName node type associated with this unknown schema node
+ */
+ void setNodeType(QName qName);
+
+}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
/**
* Builder for 'uses' statement.
*
* @return list of RefineHolder objects
*/
- List<RefineHolder> getRefines();
+ List<RefineBuilder> getRefines();
/**
* Get refined nodes.
* @param refine
* new RefineHolder object
*/
- void addRefine(RefineHolder refine);
+ void addRefine(RefineBuilder refine);
/**
* Add refine node.
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
import com.google.common.collect.ImmutableList;
public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line);
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
public AnyXmlBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
final AnyXmlSchemaNode base) {
super(moduleName, line, qname);
this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraintsDef = constraints.build();
+ instance.constraintsDef = constraints.toInstance();
// UNKNOWN NODES
for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableSet;
-
public final class AugmentationSchemaBuilderImpl extends AbstractDataNodeContainerBuilder implements
AugmentationSchemaBuilder {
private final int order;
super(moduleName, line, null);
this.order = order;
this.augmentTargetStr = augmentTargetStr;
- targetPath = ParserUtils.parseXPathString(augmentTargetStr);
+ targetPath = BuilderUtils.parseXPathString(augmentTargetStr);
}
@Override
}
if (parent instanceof UsesNodeBuilder) {
- final ModuleBuilder mb = ParserUtils.getParentModule(this);
+ final ModuleBuilder mb = BuilderUtils.getParentModule(this);
final QNameModule qm = QNameModule.create(mb.getNamespace(), mb.getRevision());
List<QName> newPath = new ArrayList<>();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.io.ByteArrayOutputStream;
import java.io.File;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.util.NamedByteArrayInputStream;
+import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.Collections2;
import com.google.common.io.ByteSource;
-public final class ParserUtils {
+public final class BuilderUtils {
- private static final Logger LOG = LoggerFactory.getLogger(ParserUtils.class);
+ private static final Logger LOG = LoggerFactory.getLogger(BuilderUtils.class);
private static final Splitter SLASH_SPLITTER = Splitter.on('/');
private static final Splitter COLON_SPLITTER = Splitter.on(':');
private static final String INPUT = "input";
private static final String OUTPUT = "output";
- private ParserUtils() {
+ private BuilderUtils() {
}
public static Collection<ByteSource> streamsToByteSources(final Collection<InputStream> streams) throws IOException {
}
TreeMap<Date, Module> modulesByRevision = new TreeMap<>();
- ModuleImport dependentModuleImport = ParserUtils.getModuleImport(currentModule, prefix);
+ ModuleImport dependentModuleImport = BuilderUtils.getModuleImport(currentModule, prefix);
if (dependentModuleImport == null) {
throw new YangParseException(currentModule.getName(), line, "No import found with prefix '" + prefix + "'.");
}
return currentNode;
}
- private static Optional<SchemaNodeBuilder> findDataChild(SchemaNodeBuilder parent, QName child) {
+ private static Optional<SchemaNodeBuilder> findDataChild(final SchemaNodeBuilder parent, final QName child) {
if (parent instanceof DataNodeContainerBuilder) {
return castOptional(SchemaNodeBuilder.class,
findDataChildInDataNodeContainer((DataNodeContainerBuilder) parent, child));
* Original value
* @return
*/
- private static <T> Optional<T> castOptional(Class<T> cls, Optional<?> optional) {
+ private static <T> Optional<T> castOptional(final Class<T> cls, final Optional<?> optional) {
if (optional.isPresent()) {
Object value = optional.get();
if (cls.isInstance(value)) {
* @return Optional of input/output if defined and QName is input/output.
* Otherwise {@link Optional#absent()}.
*/
- private static Optional<ContainerSchemaNodeBuilder> findContainerInRpc(RpcDefinitionBuilder parent, QName child) {
+ private static Optional<ContainerSchemaNodeBuilder> findContainerInRpc(final RpcDefinitionBuilder parent, final QName child) {
if (INPUT.equals(child.getLocalName())) {
return Optional.of(parent.getInput());
} else if (OUTPUT.equals(child.getLocalName())) {
* @return Optional of child if found.
*/
- private static Optional<ChoiceCaseBuilder> findCaseInChoice(ChoiceBuilder parent, QName child) {
+ private static Optional<ChoiceCaseBuilder> findCaseInChoice(final ChoiceBuilder parent, final QName child) {
for (ChoiceCaseBuilder caze : parent.getCases()) {
if (caze.getQName().equals(child)) {
return Optional.of(caze);
* QName of child
* @return Optional of child if found.
*/
- private static Optional<DataSchemaNodeBuilder> findDataChildInDataNodeContainer(DataNodeContainerBuilder parent,
- QName child) {
+ private static Optional<DataSchemaNodeBuilder> findDataChildInDataNodeContainer(final DataNodeContainerBuilder parent,
+ final QName child) {
for (DataSchemaNodeBuilder childNode : parent.getChildNodeBuilders()) {
if (childNode.getQName().equals(child)) {
return Optional.of(childNode);
* ModuleBuilder to start lookup in
* @return Node Builder if found, {@link Optional#absent()} otherwise.
*/
- private static Optional<SchemaNodeBuilder> getDataNamespaceChild(ModuleBuilder module, QName child) {
+ private static Optional<SchemaNodeBuilder> getDataNamespaceChild(final ModuleBuilder module, final QName child) {
/*
* First we do lookup in data tree, if node is found we return it.
*/
return Optional.absent();
}
- private static Optional<SchemaNodeBuilder> getDataChildByQName(DataNodeContainerBuilder builder, QName child) {
+ private static Optional<SchemaNodeBuilder> getDataChildByQName(final DataNodeContainerBuilder builder, final QName child) {
for (DataSchemaNodeBuilder childNode : builder.getChildNodeBuilders()) {
if (childNode.getQName().equals(child)) {
return Optional.<SchemaNodeBuilder> of(childNode);
return result;
}
- public static List<UnknownSchemaNodeBuilder> wrapUnknownNodes(final String moduleName, final int line,
+ public static List<UnknownSchemaNodeBuilderImpl> wrapUnknownNodes(final String moduleName, final int line,
final List<UnknownSchemaNode> nodes, final SchemaPath parentPath, final URI ns, final Date rev,
final String pref) {
- List<UnknownSchemaNodeBuilder> result = new ArrayList<>();
+ List<UnknownSchemaNodeBuilderImpl> result = new ArrayList<>();
for (UnknownSchemaNode node : nodes) {
QName qname = new QName(ns, rev, pref, node.getQName().getLocalName());
List<QName> path = new ArrayList<>(parentPath.getPath());
path.add(qname);
SchemaPath schemaPath = SchemaPath.create(path, parentPath.isAbsolute());
- result.add(new UnknownSchemaNodeBuilder(moduleName, line, qname, schemaPath, node));
+ result.add(new UnknownSchemaNodeBuilderImpl(moduleName, line, qname, schemaPath, node));
}
return result;
}
private final String toString;
private final ByteArrayOutputStream output = new ByteArrayOutputStream();
- private ByteSourceImpl(InputStream input) throws IOException {
+ private ByteSourceImpl(final InputStream input) throws IOException {
toString = input.toString();
IOUtils.copy(input, output);
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.collect.ImmutableList;
public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line);
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
public ChoiceBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
final ChoiceNode base) {
super(moduleName, line, qname);
this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- Set<DataSchemaNodeBuilder> wrapped = ParserUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
+ Set<DataSchemaNodeBuilder> wrapped = BuilderUtils.wrapChildNodes(moduleName, line, new HashSet<DataSchemaNode>(
base.getCases()), path, ns, rev, pref);
for (DataSchemaNodeBuilder wrap : wrapped) {
if (wrap instanceof ChoiceCaseBuilder) {
}
}
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
}
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraints = constraints.build();
+ instance.constraints = constraints.toInstance();
instance.defaultCase = defaultCase;
// CASES
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line);
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
public ChoiceCaseBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
final ChoiceCaseNode base) {
super(moduleName, line, qname);
- this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
augmentations.addAll(base.getAvailableAugmentations());
instance.augmenting = augmenting;
instance.addedByUses = addedByUses;
- instance.constraints = constraints.build();
+ instance.constraints = constraints.toInstance();
// CHILD NODES
for (DataSchemaNodeBuilder node : addedChildNodes) {
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import com.google.common.collect.ImmutableSet;
-public final class ConstraintsBuilder {
+public final class ConstraintsBuilderImpl implements ConstraintsBuilder {
private static final ConstraintDefinitionImpl EMPTY_CONSTRAINT = new ConstraintDefinitionImpl();
private static final ConstraintDefinitionImpl EMPTY_MANDATORY_CONSTRAINT;
private Integer min;
private Integer max;
- public ConstraintsBuilder(final String moduleName, final int line) {
+ public ConstraintsBuilderImpl(final String moduleName, final int line) {
this.moduleName = moduleName;
this.line = line;
mustDefinitions = new HashSet<MustDefinition>();
}
- ConstraintsBuilder(final ConstraintsBuilder b) {
+ ConstraintsBuilderImpl(final ConstraintsBuilder b) {
this.moduleName = b.getModuleName();
this.line = b.getLine();
mustDefinitions = new HashSet<MustDefinition>(b.getMustDefinitions());
max = b.getMaxElements();
}
- ConstraintsBuilder(final String moduleName, final int line, final ConstraintDefinition base) {
+ ConstraintsBuilderImpl(final String moduleName, final int line, final ConstraintDefinition base) {
this.moduleName = moduleName;
this.line = line;
whenStmt = base.getWhenCondition();
max = base.getMaxElements();
}
- public ConstraintDefinition build() {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#build()
+ */
+ @Override
+ public ConstraintDefinition toInstance() {
if (instance != null) {
return instance;
}
return instance;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getModuleName()
+ */
+ @Override
public String getModuleName() {
return moduleName;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getLine()
+ */
+ @Override
public int getLine() {
return line;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMinElements()
+ */
+ @Override
public Integer getMinElements() {
return min;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMinElements(java.lang.Integer)
+ */
+ @Override
public void setMinElements(final Integer minElements) {
this.min = minElements;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMaxElements()
+ */
+ @Override
public Integer getMaxElements() {
return max;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMaxElements(java.lang.Integer)
+ */
+ @Override
public void setMaxElements(final Integer maxElements) {
this.max = maxElements;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getMustDefinitions()
+ */
+ @Override
public Set<MustDefinition> getMustDefinitions() {
return mustDefinitions;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#addMustDefinition(org.opendaylight.yangtools.yang.model.api.MustDefinition)
+ */
+ @Override
public void addMustDefinition(final MustDefinition must) {
mustDefinitions.add(must);
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#getWhenCondition()
+ */
+ @Override
public String getWhenCondition() {
return whenCondition;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#addWhenCondition(java.lang.String)
+ */
+ @Override
public void addWhenCondition(final String whenCondition) {
this.whenCondition = whenCondition;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#isMandatory()
+ */
+ @Override
public boolean isMandatory() {
return mandatory;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IConstraintsBuilder#setMandatory(boolean)
+ */
+ @Override
public void setMandatory(final boolean mandatory) {
this.mandatory = mandatory;
}
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.path = path;
- this.constraints = new ConstraintsBuilder(moduleName, line);
+ this.path = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ this.constraints = new ConstraintsBuilderImpl(moduleName, line);
}
// constructor for uses
public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname,
final SchemaPath path, final ContainerSchemaNode base) {
super(moduleName, line, qname);
- this.path = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ this.path = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
augmentations.addAll(base.getAvailableAugmentations());
instance.augmenting = augmenting;
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraints = constraints.build();
+ instance.constraints = constraints.toInstance();
instance.presence = presence;
// CHILD NODES
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AugmentationSchemaBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.TypeDefinitionBuilderImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UsesNodeBuilderImpl;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class CopyUtils {
return copy;
}
- public static UnknownSchemaNodeBuilder copy(final UnknownSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
+ public static UnknownSchemaNodeBuilderImpl copy(final UnknownSchemaNodeBuilder old, final Builder newParent, final boolean updateQName) {
DataBean data = getdata(old, newParent, updateQName);
QName newQName = data.qname;
SchemaPath newSchemaPath = data.schemaPath;
- UnknownSchemaNodeBuilder c = new UnknownSchemaNodeBuilder(newParent.getModuleName(), newParent.getLine(),
+ UnknownSchemaNodeBuilderImpl c = new UnknownSchemaNodeBuilderImpl(newParent.getModuleName(), newParent.getLine(),
newQName, newSchemaPath);
c.setNodeType(old.getNodeType());
}
} else if (newParent instanceof AugmentationSchemaBuilder) {
AugmentationSchemaBuilder augment = (AugmentationSchemaBuilder) newParent;
- ModuleBuilder parent = ParserUtils.getParentModule(newParent);
+ ModuleBuilder parent = BuilderUtils.getParentModule(newParent);
if (updateQName) {
newQName = new QName(parent.getNamespace(), parent.getRevision(), parent.getPrefix(), old.getQName()
.getLocalName());
import org.opendaylight.yangtools.yang.model.api.Deviation.Deviate;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.collect.ImmutableList;
"Deviation argument string must be an absolute schema node identifier.");
}
this.targetPathStr = targetPathStr;
- this.targetPath = ParserUtils.parseXPathString(targetPathStr);
+ this.targetPath = BuilderUtils.parseXPathString(targetPathStr);
}
@Override
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
-public final class ExtensionBuilder extends AbstractSchemaNodeBuilder {
+public final class ExtensionBuilderImpl extends AbstractSchemaNodeBuilder implements ExtensionBuilder {
private ExtensionDefinitionImpl instance;
private String argument;
private boolean yin;
- ExtensionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
+ ExtensionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
@Override
return instance;
}
- public void setYinElement(boolean yin) {
+ @Override
+ public void setYinElement(final boolean yin) {
this.yin = yin;
}
- public void setArgument(String argument) {
+ @Override
+ public void setArgument(final String argument) {
this.argument = argument;
}
private ImmutableList<UnknownSchemaNode> unknownNodes;
private boolean yin;
- private ExtensionDefinitionImpl(QName qname, SchemaPath path) {
+ private ExtensionDefinitionImpl(final QName qname, final SchemaPath path) {
this.qname = qname;
this.schemaPath = path;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
public final class FeatureBuilder extends AbstractSchemaNodeBuilder {
FeatureBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
@Override
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.CopyUtils;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
public GroupingBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path,
final GroupingDefinition base) {
- super(moduleName, line, base.getQName());
- schemaPath = path;
+ this(moduleName, line, base.getQName(),path);
description = base.getDescription();
reference = base.getReference();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
usesNodes.addAll(base.getUses());
final Set<DataSchemaNodeBuilder> nodes = new HashSet<>();
for (DataSchemaNodeBuilder node : addedChildNodes) {
DataSchemaNodeBuilder copy = CopyUtils.copy(node, newParent, true);
- ParserUtils.setNodeAddedByUses(copy);
+ BuilderUtils.setNodeAddedByUses(copy);
nodes.add(copy);
}
return nodes;
GroupingBuilder copy = CopyUtils.copy(node, newParent, true);
copy.setAddedByUses(true);
for (DataSchemaNodeBuilder childNode : copy.getChildNodeBuilders()) {
- ParserUtils.setNodeAddedByUses(childNode);
+ BuilderUtils.setNodeAddedByUses(childNode);
}
nodes.add(copy);
}
public Set<UnknownSchemaNodeBuilder> instantiateUnknownNodes(final Builder newParent) {
final Set<UnknownSchemaNodeBuilder> nodes = new HashSet<>();
for (UnknownSchemaNodeBuilder node : addedUnknownNodes) {
- UnknownSchemaNodeBuilder copy = CopyUtils.copy(node, newParent, true);
+ UnknownSchemaNodeBuilderImpl copy = CopyUtils.copy(node, newParent, true);
copy.setAddedByUses(true);
nodes.add(copy);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.util.Comparator;
import java.util.Date;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
public final class GroupingUtils {
if (groupingPrefix.equals(module.getPrefix())) {
dependentModule = module;
} else {
- dependentModule = ParserUtils.findModuleFromBuilders(modules, module, groupingPrefix, line);
+ dependentModule = BuilderUtils.findModuleFromBuilders(modules, module, groupingPrefix, line);
}
if (dependentModule == null) {
groupingName = groupingString;
}
- Module dependentModule = ParserUtils.findModuleFromContext(context, module, groupingPrefix, line);
+ Module dependentModule = BuilderUtils.findModuleFromContext(context, module, groupingPrefix, line);
return findGroupingDefinition(dependentModule.getGroupings(), groupingName);
}
* name of grouping
* @return grouping with given name if present in collection, null otherwise
*/
- public static GroupingBuilder findGroupingBuilder(Set<GroupingBuilder> groupings, String name) {
+ public static GroupingBuilder findGroupingBuilder(final Set<GroupingBuilder> groupings, final String name) {
for (GroupingBuilder grouping : groupings) {
if (grouping.getQName().getLocalName().equals(name)) {
return grouping;
* name of grouping
* @return grouping with given name if present in collection, null otherwise
*/
- public static GroupingDefinition findGroupingDefinition(Set<GroupingDefinition> groupings, String name) {
+ public static GroupingDefinition findGroupingDefinition(final Set<GroupingDefinition> groupings, final String name) {
for (GroupingDefinition grouping : groupings) {
if (grouping.getQName().getLocalName().equals(name)) {
return grouping;
* @param usesNode
* uses node containing refine statements
*/
- public static void performRefine(UsesNodeBuilder usesNode) {
- for (RefineHolder refine : usesNode.getRefines()) {
- String refineTargetPath = refine.getName();
+ public static void performRefine(final UsesNodeBuilder usesNode) {
+ for (RefineBuilder refine : usesNode.getRefines()) {
+ String refineTargetPath = refine.getTargetPathString();
String[] splitted = refineTargetPath.split("/");
Builder currentNode = usesNode.getParent();
DataSchemaNodeBuilder nodeToRefine = (DataSchemaNodeBuilder) currentNode;
if (nodeToRefine == null) {
throw new YangParseException(refine.getModuleName(), refine.getLine(), "Refine target node '"
- + refine.getName() + "' not found");
+ + refine.getTargetPathString() + "' not found");
}
RefineUtils.performRefine(nodeToRefine, refine);
usesNode.addRefineNode(nodeToRefine);
public static class UsesComparator implements Comparator<UsesNodeBuilder> {
@Override
- public int compare(UsesNodeBuilder o1, UsesNodeBuilder o2) {
+ public int compare(final UsesNodeBuilder o1, final UsesNodeBuilder o2) {
return getElementPosition(o2) - getElementPosition(o1);
}
}
- private static int getElementPosition(UsesNodeBuilder usesNode) {
+ private static int getElementPosition(final UsesNodeBuilder usesNode) {
int i = 0;
Builder parent = usesNode.getParent();
while (!(parent instanceof ModuleBuilder)) {
*/
package org.opendaylight.yangtools.yang.parser.builder.impl;
-import com.google.common.collect.ImmutableList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
public final class IdentitySchemaNodeBuilder extends AbstractSchemaNodeBuilder {
private IdentitySchemaNodeImpl instance;
IdentitySchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
- IdentitySchemaNodeBuilder(final String moduleName, IdentitySchemaNode base) {
+ IdentitySchemaNodeBuilder(final String moduleName, final IdentitySchemaNode base) {
super(moduleName, 0, base.getQName());
schemaPath = base.getPath();
derivedIdentities.addAll(base.getDerivedIdentities());
this.baseIdentityBuilder = baseType;
}
- public void addDerivedIdentity(IdentitySchemaNode derivedIdentity) {
+ public void addDerivedIdentity(final IdentitySchemaNode derivedIdentity) {
if (derivedIdentity != null) {
derivedIdentities.add(derivedIdentity);
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import com.google.common.base.Preconditions;
+
/**
* Builder for YANG identityref type.
*/
final SchemaPath schemaPath) {
super(moduleName, line, BaseTypes.constructQName(NAME));
this.baseString = baseString;
- this.schemaPath = schemaPath;
+ this.schemaPath = Preconditions.checkNotNull(schemaPath, "Schema Path must not be null");
+
}
@Override
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line);
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
public LeafListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
final LeafListSchemaNode base) {
super(moduleName, line, qname);
- schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
instance.augmenting = augmenting;
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraintsDef = constraints.build();
+ instance.constraintsDef = constraints.toInstance();
instance.userOrdered = userOrdered;
if (type == null) {
}
@Override
- public void setPath(SchemaPath path) {
+ public void setPath(final SchemaPath path) {
this.schemaPath = path;
}
}
@Override
- public void setStatus(Status status) {
+ public void setStatus(final Status status) {
this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
}
@Override
- public void setAugmenting(boolean augmenting) {
+ public void setAugmenting(final boolean augmenting) {
this.augmenting = augmenting;
}
}
@Override
- public void setConfiguration(boolean configuration) {
+ public void setConfiguration(final boolean configuration) {
this.configuration = configuration;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
public LeafSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath schemaPath) {
super(moduleName, line, qname);
- this.schemaPath = schemaPath;
- constraints = new ConstraintsBuilder(moduleName, line);
+ this.schemaPath = Preconditions.checkNotNull(schemaPath, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
- public LeafSchemaNodeBuilder(String moduleName, int line, QName qname, SchemaPath path, LeafSchemaNode base) {
+ public LeafSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final LeafSchemaNode base) {
super(moduleName, line, qname);
- this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
description = base.getDescription();
reference = base.getReference();
instance.augmenting = augmenting;
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraintsDef = constraints.build();
+ instance.constraintsDef = constraints.toInstance();
instance.defaultStr = defaultStr;
instance.unitsStr = unitsStr;
}
@Override
- public void setPath(SchemaPath path) {
+ public void setPath(final SchemaPath path) {
this.schemaPath = path;
}
}
@Override
- public void setStatus(Status status) {
+ public void setStatus(final Status status) {
this.status = Preconditions.checkNotNull(status, "status cannot be null");
}
return defaultStr;
}
- public void setDefaultStr(String defaultStr) {
+ public void setDefaultStr(final String defaultStr) {
this.defaultStr = defaultStr;
}
return unitsStr;
}
- public void setUnits(String unitsStr) {
+ public void setUnits(final String unitsStr) {
this.unitsStr = unitsStr;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line);
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line);
}
public ListSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
final ListSchemaNode base) {
super(moduleName, line, qname);
- schemaPath = path;
- constraints = new ConstraintsBuilder(moduleName, line, base.getConstraints());
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
+ constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
keyDefinition = ImmutableList.copyOf(base.getKeyDefinition());
userOrdered = base.isUserOrdered();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
augmentations.addAll(base.getAvailableAugmentations());
instance.augmenting = augmenting;
instance.addedByUses = addedByUses;
instance.configuration = configuration;
- instance.constraints = constraints.build();
+ instance.constraints = constraints.toInstance();
instance.userOrdered = userOrdered;
// CHILD NODES
/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.model.util.ModuleImportImpl;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.ModuleImportImpl;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
/**
private ModuleBuilder parent;
@Override
- public ModuleBuilder getParent() {
+ public ModuleBuilder getParent() {
return parent;
}
private final List<ExtensionDefinition> extensions = new ArrayList<>();
private final List<ExtensionBuilder> addedExtensions = new ArrayList<>();
- private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<>();
- private final List<ListSchemaNodeBuilder> allLists = new ArrayList<ListSchemaNodeBuilder>();
+ private final List<ListSchemaNodeBuilder> allLists = new ArrayList<>();
private String source;
raiseYangParserException("extension", "node", extName, line, addedExtension.getLine());
}
}
- final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname, path);
+ final ExtensionBuilder builder = new ExtensionBuilderImpl(name, line, qname, path);
builder.setParent(parent);
addedExtensions.add(builder);
return builder;
return usesBuilder;
}
- public void addRefine(final RefineHolder refine) {
+ public void addRefine(final RefineHolderImpl refine) {
final Builder parent = getActualNode();
if (!(parent instanceof UsesNodeBuilder)) {
throw new YangParseException(name, refine.getLine(), "refine can be defined only in uses statement");
allUnknownNodes.add(builder);
}
- public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname, final SchemaPath path) {
+ public UnknownSchemaNodeBuilderImpl addUnknownSchemaNode(final int line, final QName qname, final SchemaPath path) {
final Builder parent = getActualNode();
- final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname, path);
+ final UnknownSchemaNodeBuilderImpl builder = new UnknownSchemaNodeBuilderImpl(name, line, qname, path);
builder.setParent(parent);
allUnknownNodes.add(builder);
((SchemaNodeBuilder) parent).addUnknownNodeBuilder(builder);
} else if (parent instanceof DataNodeContainerBuilder) {
((DataNodeContainerBuilder) parent).addUnknownNodeBuilder(builder);
- } else if (parent instanceof RefineHolder) {
- ((RefineHolder) parent).addUnknownNodeBuilder(builder);
+ } else if (parent instanceof RefineHolderImpl) {
+ ((RefineHolderImpl) parent).addUnknownNodeBuilder(builder);
} else {
throw new YangParseException(name, line, "Unresolved parent of unknown node '" + qname.getLocalName()
+ "'");
return getChildNode(childNodes, name);
}
- void setSource(final String source){
+ void setSource(final String source) {
this.source = source;
}
return true;
}
-
}
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.base.Preconditions;
NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final NotificationDefinition base) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
description = base.getDescription();
reference = base.getReference();
URI ns = qname.getNamespace();
Date rev = qname.getRevision();
String pref = qname.getPrefix();
- addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
- addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
- addedTypedefs.addAll(ParserUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
- addedUnknownNodes.addAll(ParserUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
+ addedChildNodes.addAll(BuilderUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
+ addedGroupings.addAll(BuilderUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
+ addedTypedefs.addAll(BuilderUtils.wrapTypedefs(moduleName, line, base, path, ns, rev, pref));
+ addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path, ns,
rev, pref));
augmentations.addAll(base.getAvailableAugmentations());
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractBuilder;
-public final class RefineHolder extends AbstractBuilder {
- private final String name;
+public final class RefineHolderImpl extends AbstractBuilder implements RefineBuilder {
+ private final String targetPathString;
private String defaultStr;
private String description;
private String reference;
private Integer minElements;
private Integer maxElements;
- public RefineHolder(final String moduleName, final int line, final String name) {
+ public RefineHolderImpl(final String moduleName, final int line, final String name) {
super(moduleName, line);
- this.name = name;
+ this.targetPathString = name;
}
+ @Override
public String getDefaultStr() {
return defaultStr;
}
this.defaultStr = defaultStr;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#getDescription()
+ */
+ @Override
public String getDescription() {
return description;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setDescription(java.lang.String)
+ */
+ @Override
public void setDescription(final String description) {
this.description = description;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#getReference()
+ */
+ @Override
public String getReference() {
return reference;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setReference(java.lang.String)
+ */
+ @Override
public void setReference(final String reference) {
this.reference = reference;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#isConfiguration()
+ */
+ @Override
public Boolean isConfiguration() {
return config;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setConfiguration(java.lang.Boolean)
+ */
+ @Override
public void setConfiguration(final Boolean config) {
this.config = config;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#isMandatory()
+ */
+ @Override
public Boolean isMandatory() {
return mandatory;
}
- public void setMandatory(Boolean mandatory) {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setMandatory(java.lang.Boolean)
+ */
+ @Override
+ public void setMandatory(final Boolean mandatory) {
this.mandatory = mandatory;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#isPresence()
+ */
+ @Override
public Boolean isPresence() {
return presence;
}
- public void setPresence(Boolean presence) {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setPresence(java.lang.Boolean)
+ */
+ @Override
+ public void setPresence(final Boolean presence) {
this.presence = presence;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#getMust()
+ */
+ @Override
public MustDefinition getMust() {
return must;
}
- public void setMust(MustDefinition must) {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setMust(org.opendaylight.yangtools.yang.model.api.MustDefinition)
+ */
+ @Override
+ public void setMust(final MustDefinition must) {
this.must = must;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#getMinElements()
+ */
+ @Override
public Integer getMinElements() {
return minElements;
}
- public void setMinElements(Integer minElements) {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setMinElements(java.lang.Integer)
+ */
+ @Override
+ public void setMinElements(final Integer minElements) {
this.minElements = minElements;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#getMaxElements()
+ */
+ @Override
public Integer getMaxElements() {
return maxElements;
}
- public void setMaxElements(Integer maxElements) {
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IRefineBuilder#setMaxElements(java.lang.Integer)
+ */
+ @Override
+ public void setMaxElements(final Integer maxElements) {
this.maxElements = maxElements;
}
- public String getName() {
- return name;
+ @Override
+ public String toString() {
+ return "refine " + targetPathString;
}
@Override
- public Object build() {
+ public Status getStatus() {
+ // TODO Auto-generated method stub
return null;
}
+ @Override
+ public void setStatus(final Status status) {
+ // TODO Auto-generated method stub
+
+ }
+
@Override
public int hashCode() {
final int prime = 31;
result = prime * result + ((maxElements == null) ? 0 : maxElements.hashCode());
result = prime * result + ((minElements == null) ? 0 : minElements.hashCode());
result = prime * result + ((must == null) ? 0 : must.hashCode());
- result = prime * result + ((name == null) ? 0 : name.hashCode());
+ result = prime * result + ((targetPathString == null) ? 0 : targetPathString.hashCode());
result = prime * result + ((getParent() == null) ? 0 : getParent().hashCode());
result = prime * result + ((presence == null) ? 0 : presence.hashCode());
result = prime * result + ((reference == null) ? 0 : reference.hashCode());
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (getClass() != obj.getClass()) {
return false;
}
- RefineHolder other = (RefineHolder) obj;
+ RefineHolderImpl other = (RefineHolderImpl) obj;
if (addedUnknownNodes == null) {
if (other.addedUnknownNodes != null) {
return false;
} else if (!must.equals(other.must)) {
return false;
}
- if (name == null) {
- if (other.name != null) {
+ if (targetPathString == null) {
+ if (other.targetPathString != null) {
return false;
}
- } else if (!name.equals(other.name)) {
+ } else if (!targetPathString.equals(other.targetPathString)) {
return false;
}
if (getParent() == null) {
return true;
}
+
+
@Override
- public String toString() {
- return "refine " + name;
+ public Object build() {
+ // FIXME: Currently RefineBuilder.build() is not used
+ // build should returned refined element, so
+ // whole refine process is encapsulated in this refinement
+ // statement.
+ return null;
+ }
+
+ @Override
+ public String getTargetPathString() {
+ return targetPathString;
}
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
import java.lang.reflect.Method;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.MustDefinition;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.AnyXmlBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
/**
* Utility class with helper methods to perform operations tied to refine
private RefineUtils() {
}
- public static void refineLeaf(LeafSchemaNodeBuilder leaf, RefineHolder refine) {
+ public static void refineLeaf(final LeafSchemaNodeBuilder leaf, final RefineBuilder refine) {
String defaultStr = refine.getDefaultStr();
Boolean mandatory = refine.isMandatory();
MustDefinition must = refine.getMust();
}
}
- public static void refineContainer(ContainerSchemaNodeBuilder container, RefineHolder refine) {
+ public static void refineContainer(final ContainerSchemaNodeBuilder container, final RefineBuilder refine) {
Boolean presence = refine.isPresence();
MustDefinition must = refine.getMust();
List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
}
}
- public static void refineList(ListSchemaNodeBuilder list, RefineHolder refine) {
+ public static void refineList(final ListSchemaNodeBuilder list, final RefineBuilder refine) {
MustDefinition must = refine.getMust();
Integer min = refine.getMinElements();
Integer max = refine.getMaxElements();
}
}
- public static void refineLeafList(LeafListSchemaNodeBuilder leafList, RefineHolder refine) {
+ public static void refineLeafList(final LeafListSchemaNodeBuilder leafList, final RefineBuilder refine) {
MustDefinition must = refine.getMust();
Integer min = refine.getMinElements();
Integer max = refine.getMaxElements();
}
}
- public static void refineChoice(ChoiceBuilder choice, RefineHolder refine) {
+ public static void refineChoice(final ChoiceBuilder choice, final RefineBuilder refine) {
String defaultStr = refine.getDefaultStr();
Boolean mandatory = refine.isMandatory();
List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
}
}
- public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine) {
+ public static void refineAnyxml(final AnyXmlBuilder anyXml, final RefineBuilder refine) {
Boolean mandatory = refine.isMandatory();
MustDefinition must = refine.getMust();
List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
* @param refine
* refine object containing information about refine process
*/
- private static void checkRefine(SchemaNodeBuilder node, RefineHolder refine) {
+ private static void checkRefine(final SchemaNodeBuilder node, final RefineBuilder refine) {
String moduleName = refine.getModuleName();
int line = refine.getLine();
String name = node.getQName().getLocalName();
}
}
- private static void checkRefineDefault(SchemaNodeBuilder node, String defaultStr, String moduleName, int line) {
+ private static void checkRefineDefault(final SchemaNodeBuilder node, final String defaultStr, final String moduleName, final int line) {
if (defaultStr != null) {
throw new YangParseException(moduleName, line, "Can not refine 'default' for '"
+ node.getQName().getLocalName() + "'.");
}
}
- private static void checkRefineMandatory(SchemaNodeBuilder node, Boolean mandatory, String moduleName, int line) {
+ private static void checkRefineMandatory(final SchemaNodeBuilder node, final Boolean mandatory, final String moduleName, final int line) {
if (mandatory != null) {
throw new YangParseException(moduleName, line, "Can not refine 'mandatory' for '"
+ node.getQName().getLocalName() + "'.");
}
}
- private static void checkRefinePresence(SchemaNodeBuilder node, Boolean presence, String moduleName, int line) {
+ private static void checkRefinePresence(final SchemaNodeBuilder node, final Boolean presence, final String moduleName, final int line) {
if (presence != null) {
throw new YangParseException(moduleName, line, "Can not refine 'presence' for '"
+ node.getQName().getLocalName() + "'.");
}
}
- private static void checkRefineMust(SchemaNodeBuilder node, MustDefinition must, String moduleName, int line) {
+ private static void checkRefineMust(final SchemaNodeBuilder node, final MustDefinition must, final String moduleName, final int line) {
if (must != null) {
throw new YangParseException(moduleName, line, "Can not refine 'must' for '"
+ node.getQName().getLocalName() + "'.");
}
}
- private static void checkRefineMinMax(String refineTargetName, Integer min, Integer max, String moduleName, int line) {
+ private static void checkRefineMinMax(final String refineTargetName, final Integer min, final Integer max, final String moduleName, final int line) {
if (min != null || max != null) {
throw new YangParseException(moduleName, line, "Can not refine 'min-elements' or 'max-elements' for '"
+ refineTargetName + "'.");
* @param refine
* refine object containing information about refine process
*/
- private static void refineDefault(final Builder node, final RefineHolder refine) {
+ private static void refineDefault(final Builder node, final RefineBuilder refine) {
final String moduleName = refine.getModuleName();
final int line = refine.getLine();
Class<? extends Builder> cls = node.getClass();
* @param refine
* refine object containing information about refine process
*/
- static void performRefine(SchemaNodeBuilder nodeToRefine, RefineHolder refine) {
+ static void performRefine(final SchemaNodeBuilder nodeToRefine, final RefineBuilder refine) {
checkRefine(nodeToRefine, refine);
refineDefault(nodeToRefine, refine);
if (nodeToRefine instanceof LeafSchemaNodeBuilder) {
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
+import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
RpcDefinitionBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
@Override
import java.util.List;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.*;
-import org.opendaylight.yangtools.yang.model.api.type.*;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.util.ExtendedType;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
+import com.google.common.base.Preconditions;
+
public final class TypeDefinitionBuilderImpl extends AbstractTypeAwareBuilder implements TypeDefinitionBuilder {
private SchemaPath schemaPath;
private List<RangeConstraint> ranges = Collections.emptyList();
public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
}
public TypeDefinitionBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final ExtendedType base) {
super(moduleName, line, base.getQName());
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
this.type = base.getBaseType();
this.description = base.getDescription();
}
@Override
- public void setQName(QName qname) {
+ public void setQName(final QName qname) {
this.qname = qname;
}
}
@Override
- public void setPath(SchemaPath path) {
+ public void setPath(final SchemaPath path) {
this.schemaPath = path;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.impl;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromBuilders;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromContext;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromBuilders;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromContext;
import java.util.*;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.*;
import org.opendaylight.yangtools.yang.parser.builder.impl.*;
+import org.opendaylight.yangtools.yang.parser.util.TypeConstraints;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
/**
* Utility class which contains helper methods for dealing with type operations.
} else {
QName qname = type.getQName();
if (type instanceof UnknownType) {
- ModuleBuilder dependentModuleBuilder = ParserUtils.findModuleFromBuilders(modules, builder,
+ ModuleBuilder dependentModuleBuilder = BuilderUtils.findModuleFromBuilders(modules, builder,
qname.getPrefix(), nodeToResolve.getLine());
if (dependentModuleBuilder == null) {
if (context == null) {
throw new YangParseException(builder.getName(), nodeToResolve.getLine(),
"Failed to resolved type constraints.");
}
- Module dm = ParserUtils.findModuleFromContext(context, builder, qname.getPrefix(),
+ Module dm = BuilderUtils.findModuleFromContext(context, builder, qname.getPrefix(),
nodeToResolve.getLine());
TypeDefinition<?> t = findTypeByName(dm.getTypeDefinitions(), qname.getLocalName());
return mergeConstraints(t, constraints);
TypeDefinition<?> base = ((ExtendedType) type).getBaseType();
if (base instanceof UnknownType) {
- ModuleBuilder dependentModule = ParserUtils.findModuleFromBuilders(modules, builder, base
+ ModuleBuilder dependentModule = BuilderUtils.findModuleFromBuilders(modules, builder, base
.getQName().getPrefix(), nodeToResolve.getLine());
TypeDefinitionBuilder tdb = findTypeDefinitionBuilder(nodeToResolve, dependentModule, base
.getQName().getLocalName(), builder.getName(), nodeToResolve.getLine());
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.UnionType;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractTypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
/**
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
-public final class UnknownSchemaNodeBuilder extends AbstractSchemaNodeBuilder {
+import com.google.common.base.Preconditions;
+
+public final class UnknownSchemaNodeBuilderImpl extends AbstractSchemaNodeBuilder implements UnknownSchemaNodeBuilder {
private boolean isBuilt;
private final UnknownSchemaNodeImpl instance;
private QName nodeType;
private ExtensionDefinition extensionDefinition;
private ExtensionBuilder extensionBuilder;
- public UnknownSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
+ public UnknownSchemaNodeBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path) {
super(moduleName, line, qname);
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
instance = new UnknownSchemaNodeImpl(qname, path);
}
- public UnknownSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, final UnknownSchemaNode base) {
+ public UnknownSchemaNodeBuilderImpl(final String moduleName, final int line, final QName qname, final SchemaPath path, final UnknownSchemaNode base) {
super(moduleName, line, base.getQName());
- this.schemaPath = path;
+ this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
instance = new UnknownSchemaNodeImpl(qname, path);
instance.nodeType = base.getNodeType();
instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getPath()
+ */
@Override
public SchemaPath getPath() {
return instance.path;
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
if (getClass() != obj.getClass()) {
return false;
}
- UnknownSchemaNodeBuilder other = (UnknownSchemaNodeBuilder) obj;
+ UnknownSchemaNodeBuilderImpl other = (UnknownSchemaNodeBuilderImpl) obj;
if (qname == null) {
if (other.qname != null) {
return false;
return true;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#build()
+ */
@Override
public UnknownSchemaNode build() {
if (!isBuilt) {
return instance;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getDescription()
+ */
@Override
public String getDescription() {
return instance.description;
instance.description = description;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getReference()
+ */
@Override
public String getReference() {
return instance.reference;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setReference(java.lang.String)
+ */
@Override
public void setReference(final String reference) {
instance.reference = reference;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getStatus()
+ */
@Override
public Status getStatus() {
return instance.status;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setStatus(org.opendaylight.yangtools.yang.model.api.Status)
+ */
@Override
- public void setStatus(Status status) {
+ public void setStatus(final Status status) {
if (status != null) {
instance.status = status;
}
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#isAddedByUses()
+ */
+ @Override
public boolean isAddedByUses() {
return instance.addedByUses;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setAddedByUses(boolean)
+ */
+ @Override
public void setAddedByUses(final boolean addedByUses) {
instance.addedByUses = addedByUses;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getNodeType()
+ */
+ @Override
public QName getNodeType() {
return nodeType;
}
+ @Override
public void setNodeType(final QName nodeType) {
this.nodeType = nodeType;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getNodeParameter()
+ */
+ @Override
public String getNodeParameter() {
return nodeParameter;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setNodeParameter(java.lang.String)
+ */
+ @Override
public void setNodeParameter(final String nodeParameter) {
this.nodeParameter = nodeParameter;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getExtensionDefinition()
+ */
+ @Override
public ExtensionDefinition getExtensionDefinition() {
return extensionDefinition;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setExtensionDefinition(org.opendaylight.yangtools.yang.model.api.ExtensionDefinition)
+ */
+ @Override
public void setExtensionDefinition(final ExtensionDefinition extensionDefinition) {
this.extensionDefinition = extensionDefinition;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#getExtensionBuilder()
+ */
+ @Override
public ExtensionBuilder getExtensionBuilder() {
return extensionBuilder;
}
+ /* (non-Javadoc)
+ * @see org.opendaylight.yangtools.yang.parser.builder.impl.IUnkownSchemaNodeBuilder#setExtensionBuilder(org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder)
+ */
+ @Override
public void setExtensionBuilder(final ExtensionBuilder extension) {
this.extensionBuilder = extension;
}
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
+import org.opendaylight.yangtools.yang.parser.builder.util.AbstractBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import com.google.common.collect.ImmutableList;
private boolean resolved;
private final Set<AugmentationSchemaBuilder> augmentationBuilders = new HashSet<>();
private final List<SchemaNodeBuilder> refineBuilders = new ArrayList<>();
- private final List<RefineHolder> refines = new ArrayList<>();
+ private final List<RefineBuilder> refines = new ArrayList<>();
public UsesNodeBuilderImpl(final String moduleName, final int line, final String groupingName) {
super(moduleName, line);
}
@Override
- public List<RefineHolder> getRefines() {
+ public List<RefineBuilder> getRefines() {
return refines;
}
@Override
- public void addRefine(final RefineHolder refine) {
+ public void addRefine(final RefineBuilder refine) {
refines.add(refine);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.builder.api;
+package org.opendaylight.yangtools.yang.parser.builder.util;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import com.google.common.base.Preconditions;
}
@Override
- public void addUnknownNodeBuilder(UnknownSchemaNodeBuilder unknownNode) {
+ public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder unknownNode) {
addedUnknownNodes.add(unknownNode);
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.builder.api;
+package org.opendaylight.yangtools.yang.parser.builder.util;
import java.util.Collections;
import java.util.HashSet;
import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
/**
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.builder.api;
+package org.opendaylight.yangtools.yang.parser.builder.util;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
+import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import com.google.common.base.Preconditions;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.builder.api;
+package org.opendaylight.yangtools.yang.parser.builder.util;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
/**
* Basic implementation for TypeAwareBuilder builders.
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.builder.util;
import java.util.Comparator;
+
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
/**
* Comparator based on augment target path length.
*/
+ @Deprecated
public static final AugmentComparator AUGMENT_COMP = new AugmentComparator();
private Comparators() {
private static final class SchemaNodeComparator implements Comparator<SchemaNode> {
@Override
- public int compare(SchemaNode o1, SchemaNode o2) {
+ public int compare(final SchemaNode o1, final SchemaNode o2) {
return o1.getQName().compareTo(o2.getQName());
}
}
private static final class AugmentComparator implements Comparator<AugmentationSchemaBuilder> {
@Override
- public int compare(AugmentationSchemaBuilder o1, AugmentationSchemaBuilder o2) {
+ public int compare(final AugmentationSchemaBuilder o1, final AugmentationSchemaBuilder o2) {
return o1.getTargetPath().getPath().size() - o2.getTargetPath().getPath().size();
}
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/eplv10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import java.text.ParseException;
import java.util.Date;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.impl;
import java.util.ArrayList;
import java.util.Collection;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
+import org.opendaylight.yangtools.yang.parser.util.NodeWrappedType;
+import org.opendaylight.yangtools.yang.parser.util.TopologicalSort;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
import com.google.common.collect.Maps;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/eplv10.html
*/
-package org.opendaylight.yangtools.yang.parser.util;
+package org.opendaylight.yangtools.yang.parser.impl;
import static com.google.common.base.Preconditions.checkState;
import org.opendaylight.yangtools.yang.model.util.BaseConstraints;
import org.opendaylight.yangtools.yang.model.util.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.BinaryType;
+import org.opendaylight.yangtools.yang.model.util.BitImpl;
import org.opendaylight.yangtools.yang.model.util.BitsType;
import org.opendaylight.yangtools.yang.model.util.Decimal64;
import org.opendaylight.yangtools.yang.model.util.EnumerationType;
import org.opendaylight.yangtools.yang.model.util.Int64;
import org.opendaylight.yangtools.yang.model.util.Int8;
import org.opendaylight.yangtools.yang.model.util.Leafref;
+import org.opendaylight.yangtools.yang.model.util.MustDefinitionImpl;
import org.opendaylight.yangtools.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.yangtools.yang.model.util.StringType;
import org.opendaylight.yangtools.yang.model.util.Uint16;
import org.opendaylight.yangtools.yang.model.util.UnknownType;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ConstraintsBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.RefineHolderImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
+import org.opendaylight.yangtools.yang.parser.util.TypeConstraints;
+import org.opendaylight.yangtools.yang.parser.util.UnknownBoundaryNumber;
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
* name of current module
* @return RefineHolder object representing this refine statement
*/
- public static RefineHolder parseRefine(final Refine_stmtContext refineCtx, final String moduleName) {
+ public static RefineHolderImpl parseRefine(final Refine_stmtContext refineCtx, final String moduleName) {
final String refineTarget = stringFromNode(refineCtx);
- final RefineHolder refine = new RefineHolder(moduleName, refineCtx.getStart().getLine(), refineTarget);
+ final RefineHolderImpl refine = new RefineHolderImpl(moduleName, refineCtx.getStart().getLine(), refineTarget);
for (int i = 0; i < refineCtx.getChildCount(); i++) {
ParseTree refinePom = refineCtx.getChild(i);
if (refinePom instanceof Refine_pomContext) {
return refine;
}
- private static void parseRefineDefault(final RefineHolder refine, final ParseTree refineStmt) {
+ private static void parseRefineDefault(final RefineHolderImpl refine, final ParseTree refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Description_stmtContext) {
}
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_leaf_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineHolderImpl refine, final Refine_leaf_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Default_stmtContext) {
return refine;
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_container_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineBuilder refine, final Refine_container_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Must_stmtContext) {
return refine;
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_list_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineHolderImpl refine, final Refine_list_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Must_stmtContext) {
return refine;
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_leaf_list_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineHolderImpl refine, final Refine_leaf_list_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Must_stmtContext) {
return refine;
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_choice_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineHolderImpl refine, final Refine_choice_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Default_stmtContext) {
return refine;
}
- private static RefineHolder parseRefine(final RefineHolder refine, final Refine_anyxml_stmtsContext refineStmt) {
+ private static RefineBuilder parseRefine(final RefineBuilder refine, final Refine_anyxml_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
ParseTree refineArg = refineStmt.getChild(i);
if (refineArg instanceof Must_stmtContext) {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/eplv10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import java.util.Arrays;
import java.util.Collection;
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Module_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_stmtContext;
-import org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
/**
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import java.net.URI;
import java.net.URISyntaxException;
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import java.util.Collection;
package org.opendaylight.yangtools.yang.parser.impl;
import static com.google.common.base.Preconditions.checkNotNull;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.fillAugmentTarget;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findBaseIdentity;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromBuilders;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findModuleFromContext;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findSchemaNode;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.findSchemaNodeInModule;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.processAugmentation;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.setNodeAddedByUses;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.wrapChildNode;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.wrapChildNodes;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.wrapGroupings;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.wrapTypedefs;
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.wrapUnknownNodes;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveType;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnion;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeUnionWithContext;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.resolveTypeWithContext;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.fillAugmentTarget;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findBaseIdentity;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromBuilders;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findModuleFromContext;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findSchemaNode;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.findSchemaNodeInModule;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.processAugmentation;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.setNodeAddedByUses;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.wrapChildNode;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.wrapChildNodes;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.wrapGroupings;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.wrapTypedefs;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils.wrapUnknownNodes;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.TypeUtils.resolveType;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.TypeUtils.resolveTypeUnion;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.TypeUtils.resolveTypeUnionWithContext;
+import static org.opendaylight.yangtools.yang.parser.builder.impl.TypeUtils.resolveTypeWithContext;
import java.io.File;
import java.io.IOException;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.GroupingUtils;
import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder.ModuleImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.GroupingSort;
-import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilderImpl;
+import org.opendaylight.yangtools.yang.parser.builder.util.Comparators;
import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
import org.opendaylight.yangtools.yang.parser.util.NamedByteArrayInputStream;
import org.opendaylight.yangtools.yang.parser.util.NamedFileInputStream;
import org.opendaylight.yangtools.yang.parser.util.NamedInputStream;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import org.opendaylight.yangtools.yang.validator.YangModelBasicValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
final String[] fileList = checkNotNull(directory.list(), directory + " not found or is not a directory");
Map<ByteSource, File> sourceToFile = new LinkedHashMap<>();
- ByteSource mainFileSource = ParserUtils.fileToByteSource(yangFile);
+ ByteSource mainFileSource = BuilderUtils.fileToByteSource(yangFile);
sourceToFile.put(mainFileSource, yangFile);
for (String fileName : fileList) {
}
File dependency = new File(directory, fileName);
if (dependency.isFile()) {
- sourceToFile.put(ParserUtils.fileToByteSource(dependency), dependency);
+ sourceToFile.put(BuilderUtils.fileToByteSource(dependency), dependency);
}
}
return resolveSchemaContext(Collections.<Module> emptySet());
}
- Collection<ByteSource> sources = ParserUtils.filesToByteSources(yangFiles);
+ Collection<ByteSource> sources = BuilderUtils.filesToByteSources(yangFiles);
SchemaContext result = parseSources(sources, context);
return result;
}
@Deprecated
public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {
try {
- Collection<ByteSource> sources = ParserUtils.streamsToByteSources(yangModelStreams);
+ Collection<ByteSource> sources = BuilderUtils.streamsToByteSources(yangModelStreams);
return parseSources(sources).getModules();
} catch (IOException | YangSyntaxErrorException e) {
throw new YangParseException("Failed to parse yang data", e);
@Deprecated
public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams, final SchemaContext context) {
try {
- Collection<ByteSource> sources = ParserUtils.streamsToByteSources(yangModelStreams);
+ Collection<ByteSource> sources = BuilderUtils.streamsToByteSources(yangModelStreams);
return parseSources(sources, context).getModules();
} catch (IOException | YangSyntaxErrorException e) {
throw new YangParseException("Failed to parse yang data", e);
Map<ByteSource, ModuleBuilder> sourceToBuilder = resolveSources(sources);
// sort and check for duplicates
List<ModuleBuilder> sorted = ModuleDependencySort.sort(sourceToBuilder.values());
- ParserUtils.setSourceToBuilder(sourceToBuilder);
+ BuilderUtils.setSourceToBuilder(sourceToBuilder);
Map<String, TreeMap<Date, ModuleBuilder>> modules = orderModules(sorted);
Map<ModuleBuilder, Module> builderToModule = build(modules);
Map<ModuleBuilder, ByteSource> builderToSource = HashBiMap.create(sourceToBuilder).inverse();
sourceToBuilder.put(source, moduleBuilder);
}
- ParserUtils.setSourceToBuilder(sourceToBuilder);
+ BuilderUtils.setSourceToBuilder(sourceToBuilder);
return sourceToBuilder;
}
*/
private void setCorrectAugmentTargetPath(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final AugmentationSchemaBuilder augment, final SchemaContext context) {
- ModuleBuilder module = ParserUtils.getParentModule(augment);
+ ModuleBuilder module = BuilderUtils.getParentModule(augment);
SchemaPath oldSchemaPath = augment.getTargetPath();
List<QName> oldPath = oldSchemaPath.getPath();
List<QName> newPath = new ArrayList<>();
String prefix;
QName baseQName = usesParent.getQName();
if (baseQName == null) {
- ModuleBuilder m = ParserUtils.getParentModule(usesParent);
+ ModuleBuilder m = BuilderUtils.getParentModule(usesParent);
ns = m.getNamespace();
revision = m.getRevision();
prefix = m.getPrefix();
Date rev = module.getRevision();
String localPrefix = qn.getPrefix();
if (localPrefix != null && !("".equals(localPrefix))) {
- ModuleBuilder currentModule = ParserUtils.findModuleFromBuilders(modules, module, localPrefix,
+ ModuleBuilder currentModule = BuilderUtils.findModuleFromBuilders(modules, module, localPrefix,
augment.getLine());
if (currentModule == null) {
- Module m = ParserUtils.findModuleFromContext(context, module, localPrefix, augment.getLine());
+ Module m = BuilderUtils.findModuleFromContext(context, module, localPrefix, augment.getLine());
if (m == null) {
throw new YangParseException(module.getName(), augment.getLine(), "Module with prefix "
+ localPrefix + " not found.");
private void checkAugmentMandatoryNodes(final Collection<AugmentationSchemaBuilder> augments) {
for (AugmentationSchemaBuilder augment : augments) {
String augmentPrefix = augment.getTargetPath().getPathFromRoot().iterator().next().getPrefix();
- ModuleBuilder module = ParserUtils.getParentModule(augment);
+ ModuleBuilder module = BuilderUtils.getParentModule(augment);
String modulePrefix = module.getPrefix();
if (augmentPrefix == null || augmentPrefix.isEmpty() || augmentPrefix.equals(modulePrefix)) {
String name = splittedBase[1];
ModuleBuilder dependentModule = findTargetModule(prefix, module, modules, context, line);
if (dependentModule != null) {
- result = ParserUtils.findIdentity(dependentModule.getAddedIdentities(), name);
+ result = BuilderUtils.findIdentity(dependentModule.getAddedIdentities(), name);
}
} else {
- result = ParserUtils.findIdentity(module.getAddedIdentities(), baseIdentityName);
+ result = BuilderUtils.findIdentity(module.getAddedIdentities(), baseIdentityName);
}
identity.setBaseIdentity(result);
}
}
}
for (UsesNodeBuilder usesNode : allUses) {
- ModuleBuilder module = ParserUtils.getParentModule(usesNode);
+ ModuleBuilder module = BuilderUtils.getParentModule(usesNode);
final GroupingBuilder targetGroupingBuilder = GroupingUtils.getTargetGroupingFromModules(usesNode, modules,
module);
if (targetGroupingBuilder == null) {
final SchemaContext context) {
if (!usesNode.isResolved()) {
DataNodeContainerBuilder parent = usesNode.getParent();
- ModuleBuilder module = ParserUtils.getParentModule(parent);
+ ModuleBuilder module = BuilderUtils.getParentModule(parent);
GroupingBuilder target = GroupingUtils.getTargetGroupingFromModules(usesNode, modules, module);
if (target == null) {
resolveUsesWithContext(usesNode);
private void resolveUsesWithContext(final UsesNodeBuilder usesNode) {
final int line = usesNode.getLine();
DataNodeContainerBuilder parent = usesNode.getParent();
- ModuleBuilder module = ParserUtils.getParentModule(parent);
+ ModuleBuilder module = BuilderUtils.getParentModule(parent);
SchemaPath parentPath;
URI ns = null;
Date rev = null;
setNodeAddedByUses(gb);
}
- List<UnknownSchemaNodeBuilder> unknownNodes = wrapUnknownNodes(module.getModuleName(), line,
+ List<UnknownSchemaNodeBuilderImpl> unknownNodes = wrapUnknownNodes(module.getModuleName(), line,
gd.getUnknownSchemaNodes(), parentPath, ns, rev, pref);
parent.getUnknownNodes().addAll(unknownNodes);
for (UnknownSchemaNodeBuilder un : unknownNodes) {
*/
package org.opendaylight.yangtools.yang.parser.impl;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.checkMissingBody;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.createActualSchemaPath;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.createListKey;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.getConfig;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.getIdentityrefBase;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseConstraints;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseDefault;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseRefine;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseSchemaNodeArgs;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseStatus;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseTypeWithBody;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseUnits;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseUnknownTypeWithBody;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseUserOrdered;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.parseYinValue;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.stringFromNode;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.checkMissingBody;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createActualSchemaPath;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.createListKey;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getConfig;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getIdentityrefBase;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseConstraints;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseDefault;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseRefine;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseSchemaNodeArgs;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseStatus;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseTypeWithBody;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnits;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUnknownTypeWithBody;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseUserOrdered;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.parseYinValue;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.stringFromNode;
-import com.google.common.base.Strings;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Stack;
+
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Argument_stmtContext;
import org.opendaylight.yangtools.yang.model.util.YangTypesConverter;
import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
+import org.opendaylight.yangtools.yang.parser.builder.api.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.FeatureBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.RefineHolderImpl;
import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder;
import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilderImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Strings;
+
public final class YangParserListenerImpl extends YangParserBaseListener {
private static final Logger LOGGER = LoggerFactory.getLogger(YangParserListenerImpl.class);
private static final String AUGMENT_STR = "augment";
private final Stack<Stack<QName>> actualPath = new Stack<>();
private int augmentOrder;
- private void addNodeToPath(QName name) {
+ private void addNodeToPath(final QName name) {
actualPath.peek().push(name);
}
return actualPath.peek().pop();
}
- public YangParserListenerImpl(String sourcePath) {
+ public YangParserListenerImpl(final String sourcePath) {
this.sourcePath = sourcePath;
}
@Override
- public void enterModule_stmt(YangParser.Module_stmtContext ctx) {
+ public void enterModule_stmt(final YangParser.Module_stmtContext ctx) {
moduleName = stringFromNode(ctx);
LOGGER.trace("entering module " + moduleName);
enterLog("module", moduleName, 0);
}
@Override
- public void exitModule_stmt(YangParser.Module_stmtContext ctx) {
+ public void exitModule_stmt(final YangParser.Module_stmtContext ctx) {
exitLog("module", "");
actualPath.pop();
}
- @Override public void enterSubmodule_stmt(YangParser.Submodule_stmtContext ctx) {
+ @Override public void enterSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
moduleName = stringFromNode(ctx);
LOGGER.trace("entering submodule " + moduleName);
enterLog("submodule", moduleName, 0);
moduleBuilder.setReference(reference);
}
- @Override public void exitSubmodule_stmt(YangParser.Submodule_stmtContext ctx) {
+ @Override public void exitSubmodule_stmt(final YangParser.Submodule_stmtContext ctx) {
exitLog("submodule", "");
actualPath.pop();
}
- @Override public void enterBelongs_to_stmt(YangParser.Belongs_to_stmtContext ctx) {
+ @Override public void enterBelongs_to_stmt(final YangParser.Belongs_to_stmtContext ctx) {
moduleBuilder.setBelongsTo(stringFromNode(ctx));
}
@Override
- public void enterModule_header_stmts(Module_header_stmtsContext ctx) {
+ public void enterModule_header_stmts(final Module_header_stmtsContext ctx) {
enterLog("module_header", "", ctx.getStart().getLine());
String yangVersion = null;
for (int i = 0; i < ctx.getChildCount(); ++i) {
}
@Override
- public void exitModule_header_stmts(Module_header_stmtsContext ctx) {
+ public void exitModule_header_stmts(final Module_header_stmtsContext ctx) {
exitLog("module_header", "");
}
@Override
- public void enterMeta_stmts(YangParser.Meta_stmtsContext ctx) {
+ public void enterMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
enterLog("meta_stmt", "", ctx.getStart().getLine());
for (int i = 0; i < ctx.getChildCount(); i++) {
ParseTree child = ctx.getChild(i);
}
@Override
- public void exitMeta_stmts(YangParser.Meta_stmtsContext ctx) {
+ public void exitMeta_stmts(final YangParser.Meta_stmtsContext ctx) {
exitLog("meta_stmt", "");
}
@Override
- public void enterRevision_stmts(Revision_stmtsContext ctx) {
+ public void enterRevision_stmts(final Revision_stmtsContext ctx) {
enterLog("revisions", "", ctx.getStart().getLine());
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree treeNode = ctx.getChild(i);
}
@Override
- public void exitRevision_stmts(Revision_stmtsContext ctx) {
+ public void exitRevision_stmts(final Revision_stmtsContext ctx) {
exitLog("revisions", "");
}
}
@Override
- public void enterImport_stmt(Import_stmtContext ctx) {
+ public void enterImport_stmt(final Import_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String importName = stringFromNode(ctx);
enterLog("import", importName, line);
}
@Override
- public void exitImport_stmt(Import_stmtContext ctx) {
+ public void exitImport_stmt(final Import_stmtContext ctx) {
exitLog("import", "");
}
@Override
- public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
+ public void enterAugment_stmt(final YangParser.Augment_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String augmentPath = stringFromNode(ctx);
enterLog(AUGMENT_STR, augmentPath, line);
}
@Override
- public void exitAugment_stmt(YangParser.Augment_stmtContext ctx) {
+ public void exitAugment_stmt(final YangParser.Augment_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog(AUGMENT_STR, "");
actualPath.pop();
}
@Override
- public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
+ public void enterExtension_stmt(final YangParser.Extension_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String extName = stringFromNode(ctx);
enterLog("extension", extName, line);
}
@Override
- public void exitExtension_stmt(YangParser.Extension_stmtContext ctx) {
+ public void exitExtension_stmt(final YangParser.Extension_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("extension", removeNodeFromPath());
}
@Override
- public void enterTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
+ public void enterTypedef_stmt(final YangParser.Typedef_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String typedefName = stringFromNode(ctx);
enterLog("typedef", typedefName, line);
}
@Override
- public void exitTypedef_stmt(YangParser.Typedef_stmtContext ctx) {
+ public void exitTypedef_stmt(final YangParser.Typedef_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("typedef", removeNodeFromPath());
}
@Override
- public void enterType_stmt(YangParser.Type_stmtContext ctx) {
+ public void enterType_stmt(final YangParser.Type_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String typeName = stringFromNode(ctx);
enterLog("type", typeName, line);
}
- private QName parseQName(String typeName) {
+ private QName parseQName(final String typeName) {
QName typeQName;
if (typeName.contains(":")) {
String[] splittedName = typeName.split(":");
}
@Override
- public void exitType_stmt(YangParser.Type_stmtContext ctx) {
+ public void exitType_stmt(final YangParser.Type_stmtContext ctx) {
final String typeName = stringFromNode(ctx);
if ("union".equals(typeName)) {
moduleBuilder.exitNode();
}
@Override
- public void enterGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
+ public void enterGrouping_stmt(final YangParser.Grouping_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String groupName = stringFromNode(ctx);
enterLog("grouping", groupName, line);
}
@Override
- public void exitGrouping_stmt(YangParser.Grouping_stmtContext ctx) {
+ public void exitGrouping_stmt(final YangParser.Grouping_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("grouping", removeNodeFromPath());
}
@Override
- public void enterContainer_stmt(Container_stmtContext ctx) {
+ public void enterContainer_stmt(final Container_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String containerName = stringFromNode(ctx);
enterLog("container", containerName, line);
}
@Override
- public void exitContainer_stmt(Container_stmtContext ctx) {
+ public void exitContainer_stmt(final Container_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("container", removeNodeFromPath());
}
@Override
- public void enterLeaf_stmt(Leaf_stmtContext ctx) {
+ public void enterLeaf_stmt(final Leaf_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String leafName = stringFromNode(ctx);
enterLog("leaf", leafName, line);
}
@Override
- public void exitLeaf_stmt(YangParser.Leaf_stmtContext ctx) {
+ public void exitLeaf_stmt(final YangParser.Leaf_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("leaf", removeNodeFromPath());
}
@Override
- public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
+ public void enterUses_stmt(final YangParser.Uses_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String groupingPathStr = stringFromNode(ctx);
enterLog("uses", groupingPathStr, line);
}
@Override
- public void exitUses_stmt(YangParser.Uses_stmtContext ctx) {
+ public void exitUses_stmt(final YangParser.Uses_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("uses", "");
}
@Override
- public void enterUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
+ public void enterUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
actualPath.push(new Stack<QName>());
final int line = ctx.getStart().getLine();
final String augmentPath = stringFromNode(ctx);
}
@Override
- public void exitUses_augment_stmt(YangParser.Uses_augment_stmtContext ctx) {
+ public void exitUses_augment_stmt(final YangParser.Uses_augment_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog(AUGMENT_STR, "");
actualPath.pop();
}
@Override
- public void enterRefine_stmt(YangParser.Refine_stmtContext ctx) {
+ public void enterRefine_stmt(final YangParser.Refine_stmtContext ctx) {
final String refineString = stringFromNode(ctx);
enterLog("refine", refineString, ctx.getStart().getLine());
- RefineHolder refine = parseRefine(ctx, moduleName);
+ RefineHolderImpl refine = parseRefine(ctx, moduleName);
moduleBuilder.addRefine(refine);
moduleBuilder.enterNode(refine);
}
@Override
- public void exitRefine_stmt(YangParser.Refine_stmtContext ctx) {
+ public void exitRefine_stmt(final YangParser.Refine_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("refine", "");
}
@Override
- public void enterLeaf_list_stmt(Leaf_list_stmtContext ctx) {
+ public void enterLeaf_list_stmt(final Leaf_list_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String leafListName = stringFromNode(ctx);
enterLog("leaf-list", leafListName, line);
}
@Override
- public void exitLeaf_list_stmt(YangParser.Leaf_list_stmtContext ctx) {
+ public void exitLeaf_list_stmt(final YangParser.Leaf_list_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("leaf-list", removeNodeFromPath());
}
@Override
- public void enterList_stmt(List_stmtContext ctx) {
+ public void enterList_stmt(final List_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String listName = stringFromNode(ctx);
enterLog("list", listName, line);
}
@Override
- public void exitList_stmt(List_stmtContext ctx) {
+ public void exitList_stmt(final List_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("list", removeNodeFromPath());
}
@Override
- public void enterAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
+ public void enterAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String anyXmlName = stringFromNode(ctx);
enterLog("anyxml", anyXmlName, line);
}
@Override
- public void exitAnyxml_stmt(YangParser.Anyxml_stmtContext ctx) {
+ public void exitAnyxml_stmt(final YangParser.Anyxml_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("anyxml", removeNodeFromPath());
}
@Override
- public void enterChoice_stmt(YangParser.Choice_stmtContext ctx) {
+ public void enterChoice_stmt(final YangParser.Choice_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String choiceName = stringFromNode(ctx);
enterLog("choice", choiceName, line);
}
@Override
- public void exitChoice_stmt(YangParser.Choice_stmtContext ctx) {
+ public void exitChoice_stmt(final YangParser.Choice_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("choice", removeNodeFromPath());
}
@Override
- public void enterCase_stmt(YangParser.Case_stmtContext ctx) {
+ public void enterCase_stmt(final YangParser.Case_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String caseName = stringFromNode(ctx);
enterLog("case", caseName, line);
}
@Override
- public void exitCase_stmt(YangParser.Case_stmtContext ctx) {
+ public void exitCase_stmt(final YangParser.Case_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("case", removeNodeFromPath());
}
@Override
- public void enterNotification_stmt(YangParser.Notification_stmtContext ctx) {
+ public void enterNotification_stmt(final YangParser.Notification_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String notificationName = stringFromNode(ctx);
enterLog("notification", notificationName, line);
}
@Override
- public void exitNotification_stmt(YangParser.Notification_stmtContext ctx) {
+ public void exitNotification_stmt(final YangParser.Notification_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("notification", removeNodeFromPath());
}
// Unknown nodes
@Override
- public void enterIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
+ public void enterIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
handleUnknownNode(ctx.getStart().getLine(), ctx);
}
@Override
- public void exitIdentifier_stmt(YangParser.Identifier_stmtContext ctx) {
+ public void exitIdentifier_stmt(final YangParser.Identifier_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("unknown-node", removeNodeFromPath());
}
- @Override public void enterUnknown_statement(YangParser.Unknown_statementContext ctx) {
+ @Override public void enterUnknown_statement(final YangParser.Unknown_statementContext ctx) {
handleUnknownNode(ctx.getStart().getLine(), ctx);
}
- @Override public void exitUnknown_statement(YangParser.Unknown_statementContext ctx) {
+ @Override public void exitUnknown_statement(final YangParser.Unknown_statementContext ctx) {
moduleBuilder.exitNode();
exitLog("unknown-node", removeNodeFromPath());
}
- @Override public void enterUnknown_statement2(YangParser.Unknown_statement2Context ctx) {
+ @Override public void enterUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
handleUnknownNode(ctx.getStart().getLine(), ctx);
}
- @Override public void exitUnknown_statement2(YangParser.Unknown_statement2Context ctx) {
+ @Override public void exitUnknown_statement2(final YangParser.Unknown_statement2Context ctx) {
moduleBuilder.exitNode();
exitLog("unknown-node", removeNodeFromPath());
}
- @Override public void enterUnknown_statement3(YangParser.Unknown_statement3Context ctx) {
+ @Override public void enterUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
handleUnknownNode(ctx.getStart().getLine(), ctx);
}
- @Override public void exitUnknown_statement3(YangParser.Unknown_statement3Context ctx) {
+ @Override public void exitUnknown_statement3(final YangParser.Unknown_statement3Context ctx) {
moduleBuilder.exitNode();
exitLog("unknown-node", removeNodeFromPath());
}
@Override
- public void enterRpc_stmt(YangParser.Rpc_stmtContext ctx) {
+ public void enterRpc_stmt(final YangParser.Rpc_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String rpcName = stringFromNode(ctx);
enterLog("rpc", rpcName, line);
}
@Override
- public void exitRpc_stmt(YangParser.Rpc_stmtContext ctx) {
+ public void exitRpc_stmt(final YangParser.Rpc_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("rpc", removeNodeFromPath());
}
@Override
- public void enterInput_stmt(YangParser.Input_stmtContext ctx) {
+ public void enterInput_stmt(final YangParser.Input_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String input = "input";
enterLog(input, input, line);
}
@Override
- public void exitInput_stmt(YangParser.Input_stmtContext ctx) {
+ public void exitInput_stmt(final YangParser.Input_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("input", removeNodeFromPath());
}
@Override
- public void enterOutput_stmt(YangParser.Output_stmtContext ctx) {
+ public void enterOutput_stmt(final YangParser.Output_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String output = "output";
enterLog(output, output, line);
}
@Override
- public void exitOutput_stmt(YangParser.Output_stmtContext ctx) {
+ public void exitOutput_stmt(final YangParser.Output_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("output", removeNodeFromPath());
}
@Override
- public void enterFeature_stmt(YangParser.Feature_stmtContext ctx) {
+ public void enterFeature_stmt(final YangParser.Feature_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String featureName = stringFromNode(ctx);
enterLog("feature", featureName, line);
}
@Override
- public void exitFeature_stmt(YangParser.Feature_stmtContext ctx) {
+ public void exitFeature_stmt(final YangParser.Feature_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("feature", removeNodeFromPath());
}
@Override
- public void enterDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
+ public void enterDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String targetPath = stringFromNode(ctx);
enterLog("deviation", targetPath, line);
}
@Override
- public void exitDeviation_stmt(YangParser.Deviation_stmtContext ctx) {
+ public void exitDeviation_stmt(final YangParser.Deviation_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("deviation", "");
}
@Override
- public void enterIdentity_stmt(YangParser.Identity_stmtContext ctx) {
+ public void enterIdentity_stmt(final YangParser.Identity_stmtContext ctx) {
final int line = ctx.getStart().getLine();
final String identityName = stringFromNode(ctx);
enterLog("identity", identityName, line);
}
@Override
- public void exitIdentity_stmt(YangParser.Identity_stmtContext ctx) {
+ public void exitIdentity_stmt(final YangParser.Identity_stmtContext ctx) {
moduleBuilder.exitNode();
exitLog("identity", removeNodeFromPath());
}
return moduleBuilder;
}
- private void enterLog(String p1, String p2, int line) {
+ private void enterLog(final String p1, final String p2, final int line) {
LOGGER.trace("entering {} {} ({})", p1, p2, line);
}
- private void exitLog(String p1, String p2) {
+ private void exitLog(final String p1, final String p2) {
LOGGER.trace("exiting {} {}", p1, p2);
}
- private void exitLog(String p1, QName p2) {
+ private void exitLog(final String p1, final QName p2) {
LOGGER.trace("exiting {} {}", p1, p2.getLocalName());
}
- private void setLog(String p1, String p2) {
+ private void setLog(final String p1, final String p2) {
LOGGER.trace("setting {} {}", p1, p2);
}
addNodeToPath(qname);
SchemaPath path = createActualSchemaPath(actualPath.peek());
- UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
+ UnknownSchemaNodeBuilderImpl builder = moduleBuilder.addUnknownSchemaNode(line, qname, path);
builder.setNodeType(nodeType);
builder.setNodeParameter(nodeParameter);
*/
package org.opendaylight.yangtools.yang.parser.impl.util;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.getArgumentString;
-import static org.opendaylight.yangtools.yang.parser.util.ParserListenerUtils.getFirstContext;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getArgumentString;
+import static org.opendaylight.yangtools.yang.parser.impl.ParserListenerUtils.getFirstContext;
import java.io.InputStream;
import java.util.Date;
/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
package org.opendaylight.yangtools.yang.parser.util;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Function;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import org.opendaylight.yangtools.yang.model.api.ModuleImport;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node;
import org.opendaylight.yangtools.yang.parser.util.TopologicalSort.NodeImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+
/**
* Creates a module dependency graph from provided {@link ModuleBuilder}s and
* provides a {@link #sort(ModuleBuilder...)} method. It is topological sort and
/**
* Extracts {@link ModuleBuilder} from a {@link ModuleNodeImpl}.
*/
- private static final Function<Node, ModuleBuilder> NODE_TO_MODULEBUILDER = new Function<Node, ModuleBuilder>() {
+ private static final Function<TopologicalSort.Node, ModuleBuilder> NODE_TO_MODULEBUILDER = new Function<TopologicalSort.Node, ModuleBuilder>() {
@Override
- public ModuleBuilder apply(final Node input) {
+ public ModuleBuilder apply(final TopologicalSort.Node input) {
// Cast to ModuleBuilder from Node and return
return (ModuleBuilder) ((ModuleNodeImpl) input).getReference();
}
* in returned order.
*/
public static List<ModuleBuilder> sort(final ModuleBuilder... builders) {
- List<Node> sorted = sortInternal(Arrays.asList(builders));
- return Lists.transform(sorted, NODE_TO_MODULEBUILDER);
+ return sort(Arrays.asList(builders));
}
public static List<ModuleBuilder> sort(final Collection<ModuleBuilder> builders) {
- ModuleBuilder[] array = new ModuleBuilder[builders.size()];
- builders.toArray(array);
- return sort(array);
+ List<TopologicalSort.Node> sorted = sortInternal(builders);
+ return Lists.transform(sorted, NODE_TO_MODULEBUILDER);
}
public static List<ModuleBuilder> sortWithContext(final SchemaContext context, final ModuleBuilder... builders) {
Collections.addAll(modules, builders);
modules.addAll(context.getModules());
- List<Node> sorted = sortInternal(modules);
+ List<TopologicalSort.Node> sorted = sortInternal(modules);
// Cast to ModuleBuilder from Node if possible and return
- return Lists.transform(sorted, new Function<Node, ModuleBuilder>() {
+ return Lists.transform(sorted, new Function<TopologicalSort.Node, ModuleBuilder>() {
@Override
- public ModuleBuilder apply(final Node input) {
+ public ModuleBuilder apply(final TopologicalSort.Node input) {
if (((ModuleNodeImpl) input).getReference() instanceof ModuleBuilder) {
return (ModuleBuilder) ((ModuleNodeImpl) input).getReference();
} else {
* returned order.
*/
public static List<Module> sort(final Module... modules) {
- List<Node> sorted = sortInternal(Arrays.asList(modules));
+ List<TopologicalSort.Node> sorted = sortInternal(Arrays.asList(modules));
// Cast to Module from Node and return
- return Lists.transform(sorted, new Function<Node, Module>() {
+ return Lists.transform(sorted, new Function<TopologicalSort.Node, Module>() {
@Override
- public Module apply(final Node input) {
+ public Module apply(final TopologicalSort.Node input) {
return (Module) ((ModuleNodeImpl) input).getReference();
}
});
}
- private static List<Node> sortInternal(final List<?> modules) {
+ private static List<TopologicalSort.Node> sortInternal(final Iterable<?> modules) {
Map<String, Map<Date, ModuleNodeImpl>> moduleGraph = createModuleGraph(modules);
- Set<Node> nodes = Sets.newHashSet();
+ Set<TopologicalSort.Node> nodes = Sets.newHashSet();
for (Map<Date, ModuleNodeImpl> map : moduleGraph.values()) {
for (ModuleNodeImpl node : map.values()) {
nodes.add(node);
}
@VisibleForTesting
- static Map<String, Map<Date, ModuleNodeImpl>> createModuleGraph(final List<?> builders) {
+ static Map<String, Map<Date, ModuleNodeImpl>> createModuleGraph(final Iterable<?> builders) {
Map<String, Map<Date, ModuleNodeImpl>> moduleGraph = Maps.newHashMap();
processModules(moduleGraph, builders);
/**
* Extract module:revision from module builders
*/
- private static void processDependencies(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph, final List<?> builders) {
+ private static void processDependencies(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
+ final Iterable<?> builders) {
Map<URI, Object> allNS = new HashMap<>();
// Create edges in graph
fromName = ((Module) mb).getName();
fromRevision = ((Module) mb).getRevision();
imports = ((Module) mb).getImports();
- ns = ((Module)mb).getNamespace();
+ ns = ((Module) mb).getNamespace();
} else if (mb instanceof ModuleBuilder) {
fromName = ((ModuleBuilder) mb).getName();
fromRevision = ((ModuleBuilder) mb).getRevision();
imports = ((ModuleBuilder) mb).getModuleImports();
- ns = ((ModuleBuilder)mb).getNamespace();
+ ns = ((ModuleBuilder) mb).getNamespace();
}
// check for existence of module with same namespace
* Extract dependencies from module builders or modules to fill dependency
* graph
*/
- private static void processModules(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph, final List<?> builders) {
+ private static void processModules(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph,
+ final Iterable<?> builders) {
// Process nodes
for (Object mb : builders) {
/**
* Create new instance of class <code>NodeWrappedType</code>.
- *
+ *
* @param wrappedType
* object with payload data
*/
- NodeWrappedType(Object wrappedType) {
+ public NodeWrappedType(Object wrappedType) {
this.wrappedType = wrappedType;
}
/**
* Gets payload from class
- *
+ *
* @return object with <code>wrappedType</code>
*/
- Object getWrappedType() {
+ public Object getWrappedType() {
return wrappedType;
}
/**
* Marker object representing special 'min' or 'max' values in YANG.
*/
-final class UnknownBoundaryNumber extends Number {
+public final class UnknownBoundaryNumber extends Number {
private static final long serialVersionUID = 1464861684686434869L;
private final String value;
+ @Deprecated
+ public
UnknownBoundaryNumber(final String value) {
this.value = value;
}
import static org.junit.Assert.assertEquals;
-import com.google.common.io.ByteSource;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.Set;
+
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
import org.opendaylight.yangtools.yang.model.parser.api.YangSyntaxErrorException;
+import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils;
import org.opendaylight.yangtools.yang.parser.util.NamedByteArrayInputStream;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+
+import com.google.common.io.ByteSource;
final class TestUtils {
}
public static Set<Module> loadModules(final List<InputStream> input) throws IOException, YangSyntaxErrorException {
- Collection<ByteSource> sources = ParserUtils.streamsToByteSources(input);
+ Collection<ByteSource> sources = BuilderUtils.streamsToByteSources(input);
final YangContextParser parser = new YangParserImpl();
SchemaContext ctx = parser.parseSources(sources);
return ctx.getModules();
public static Set<Module> loadModulesWithContext(final Collection<InputStream> input, final SchemaContext context)
throws IOException, YangSyntaxErrorException {
- Collection<ByteSource> sources = ParserUtils.streamsToByteSources(input);
+ Collection<ByteSource> sources = BuilderUtils.streamsToByteSources(input);
final YangContextParser parser = new YangParserImpl();
SchemaContext ctx = parser.parseSources(sources, context);
final Set<Module> modules = ctx.getModules();
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Ordered_by_argContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Type_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Unique_stmtContext;
+import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationListTest {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_stmtsContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
+import org.opendaylight.yangtools.yang.parser.impl.BasicValidations;
+import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationModuleTest {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import static org.junit.Assert.assertThat;
import static org.junit.matchers.JUnitMatchers.containsString;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Belongs_to_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_header_stmtsContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Submodule_stmtContext;
+import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
public class YangModelValidationSubModuleTest {
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-package org.opendaylight.yangtools.yang.validator;
+package org.opendaylight.yangtools.yang.parser.impl;
import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Revision_date_stmtContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.Status_argContext;
import org.opendaylight.yangtools.antlrv4.code.gen.YangParser.StringContext;
+import org.opendaylight.yangtools.yang.parser.impl.BasicValidations;
+import org.opendaylight.yangtools.yang.parser.impl.ValidationUtil;
+import org.opendaylight.yangtools.yang.parser.impl.YangModelBasicValidationListener;
import org.opendaylight.yangtools.yang.parser.util.YangValidationException;
import com.google.common.collect.Sets;
import java.util.List;
import java.util.Map;
import java.util.Set;
+
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.util.StringType;
import org.opendaylight.yangtools.yang.model.util.Uint32;
import org.opendaylight.yangtools.yang.model.util.UnionType;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
+import org.opendaylight.yangtools.yang.parser.builder.impl.BuilderUtils;
public class YangParserTest {
public static final String FS = File.separator;
for (File f : testFiles) {
streams.add(new FileInputStream(f));
}
- newModules = parser.parseSources(ParserUtils.filesToByteSources(testFiles)).getModules();
+ newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles)).getModules();
assertSetEquals(newModules, modules);
ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
assertSetEquals(newModules, ctx.getModules());
for (File f : testFiles) {
streams.add(new FileInputStream(f));
}
- newModules = parser.parseSources(ParserUtils.filesToByteSources(testFiles), null).getModules();
+ newModules = parser.parseSources(BuilderUtils.filesToByteSources(testFiles), null).getModules();
assertSetEquals(newModules, modules);
ctx = new SchemaContextImpl(newModules, Collections.<ModuleIdentifier, String>emptyMap());
assertSetEquals(newModules, ctx.getModules());
public class ModuleDependencySortTest {
private final DateFormat SIMPLE_DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
- private ModuleBuilder a = mockModuleBuilder("a", null);
- private ModuleBuilder b = mockModuleBuilder("b", null);
- private ModuleBuilder c = mockModuleBuilder("c", null);
- private ModuleBuilder d = mockModuleBuilder("d", null);
+ private final ModuleBuilder a = mockModuleBuilder("a", null);
+ private final ModuleBuilder b = mockModuleBuilder("b", null);
+ private final ModuleBuilder c = mockModuleBuilder("c", null);
+ private final ModuleBuilder d = mockModuleBuilder("d", null);
@Test
public void testValid() throws Exception {
}
}
- private void assertDependencyGraph(Map<String, Map<Date, ModuleNodeImpl>> moduleGraph) {
+ private void assertDependencyGraph(final Map<String, Map<Date, ModuleNodeImpl>> moduleGraph) {
for (Entry<String, Map<Date, ModuleNodeImpl>> node : moduleGraph.entrySet()) {
String name = node.getKey();
}
}
- private void assertEdgeCount(Set<Edge> inEdges, int i, Set<Edge> outEdges, int j) {
+ private void assertEdgeCount(final Set<Edge> inEdges, final int i, final Set<Edge> outEdges, final int j) {
assertThat(inEdges.size(), is(i));
assertThat(outEdges.size(), is(j));
}
- private void mockDependency(ModuleBuilder a, ModuleBuilder b) {
+ private void mockDependency(final ModuleBuilder a, final ModuleBuilder b) {
ModuleImport imprt = mock(ModuleImport.class);
doReturn(b.getName()).when(imprt).getModuleName();
doReturn(b.getRevision()).when(imprt).getRevision();
a.getModuleImports().add(imprt);
}
- private void mockDependency(Module a, Module b) {
+ private void mockDependency(final Module a, final Module b) {
ModuleImport imprt = mock(ModuleImport.class);
doReturn(b.getName()).when(imprt).getModuleName();
doReturn(b.getRevision()).when(imprt).getRevision();
a.getImports().add(imprt);
}
- private ModuleBuilder mockModuleBuilder(String name, Date rev) {
+ private ModuleBuilder mockModuleBuilder(final String name, final Date rev) {
ModuleBuilder a = mock(ModuleBuilder.class);
doReturn(name).when(a).getName();
Set<ModuleImport> set = Sets.newHashSet();
return a;
}
- private Module mockModule(String name, Date rev) {
+ private Module mockModule(final String name, final Date rev) {
Module a = mock(Module.class);
doReturn(name).when(a).getName();
Set<ModuleImport> set = Sets.newHashSet();
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.util;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-
-import org.junit.Test;
-
-public class MustDefinitionImplTest {
-
- @Test
- public void test() {
- MustDefinitionImpl mdiA;
- MustDefinitionImpl mdiB;
- mdiA = new MustDefinitionImpl("mustStrA", "descriptionA", "referenceA", "errorAppTagA", "errorMessageA");
-
- assertEquals("mdiA should equals to itsefl", mdiA, mdiA);
- assertFalse("mdiA shouldn't equal to null", mdiA.equals(null));
- assertFalse("mdiA shouldn't equal to object of other type", mdiA.equals(new String("str")));
-
- // test of equals method
-
- // //confirmation of equality
- mdiA = new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage");
- assertEquals("mdiA should equal to mdiB", mdiA, mdiB);
-
- // // mustStr
- mdiA = new MustDefinitionImpl(null, "description", "reference", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- mdiA = new MustDefinitionImpl("mustStrA", "description", "reference", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStrB", "description", "reference", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- // //description
- mdiA = new MustDefinitionImpl("mustStr", null, "reference", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- mdiA = new MustDefinitionImpl("mustStr", "descriptionA", "reference", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "descriptionB", "reference", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- // //reference
- mdiA = new MustDefinitionImpl("mustStr", "description", null, "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- mdiA = new MustDefinitionImpl("mustStr", "description", "referenceA", "errorAppTag", "errorMessage");
- mdiB = new MustDefinitionImpl("mustStr", "description", "referenceB", "errorAppTag", "errorMessage");
- assertFalse("mdiA shouldn't equal to mdiB", mdiA.equals(mdiB));
-
- }
-
-}
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
+
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.model.util.MustDefinitionImpl;
+import org.opendaylight.yangtools.yang.parser.builder.api.RefineBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.RefineHolderImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilderImpl;
public class RefineHolderTest {
- private RefineHolder rh;
- private RefineHolder rh1;
+ private RefineHolderImpl rh;
+ private RefineHolderImpl rh1;
@Before
public void init() {
- rh = new RefineHolder("module", 2104, "name");
- rh1 = new RefineHolder("module", 2104, "name");
+ rh = new RefineHolderImpl("module", 2104, "name");
+ rh1 = new RefineHolderImpl("module", 2104, "name");
}
assertEquals("rh1 should equals to rh", rh, rh1);
- RefineHolder rh2 = new RefineHolder("module", 2104, null);
+ RefineBuilder rh2 = new RefineHolderImpl("module", 2104, null);
assertFalse("rh shouldn't equal to rh2", rh2.equals(rh1));
- rh2 = new RefineHolder("module", 2104, "name2");
+ rh2 = new RefineHolderImpl("module", 2104, "name2");
assertFalse("rh shouldn't equal to rh2", rh.equals(rh2));
assertEquals("Wrong hash code", 1557537141, rh.hashCode());
qnamesB.add(qnameB);
SchemaPath schemaPathB = SchemaPath.create(qnamesB, true);
- UnknownSchemaNodeBuilder usnb = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
- UnknownSchemaNodeBuilder usnb1 = new UnknownSchemaNodeBuilder("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
+ UnknownSchemaNodeBuilderImpl usnb = new UnknownSchemaNodeBuilderImpl("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
+ UnknownSchemaNodeBuilderImpl usnb1 = new UnknownSchemaNodeBuilderImpl("usnb", 151, new QName(simpleUri, "tst"), schemaPathB);
assertEquals("rh should equal to rh1", rh, rh1);
rh1.addUnknownNodeBuilder(usnb);
SchemaPath path = org.mockito.Mockito.mock(SchemaPath.class);
- UnknownSchemaNodeBuilder usnbA = new UnknownSchemaNodeBuilder("usnbA", 151, new QName(simpleUriA, "tst"), path);
- UnknownSchemaNodeBuilder usnbB = new UnknownSchemaNodeBuilder("usnbB", 151, new QName(simpleUriB, "tst"), path);
- UnknownSchemaNodeBuilder usnbAParent = new UnknownSchemaNodeBuilder("usnbAParent", 151, new QName(simpleUriA,
+ UnknownSchemaNodeBuilderImpl usnbA = new UnknownSchemaNodeBuilderImpl("usnbA", 151, new QName(simpleUriA, "tst"), path);
+ UnknownSchemaNodeBuilderImpl usnbB = new UnknownSchemaNodeBuilderImpl("usnbB", 151, new QName(simpleUriB, "tst"), path);
+ UnknownSchemaNodeBuilderImpl usnbAParent = new UnknownSchemaNodeBuilderImpl("usnbAParent", 151, new QName(simpleUriA,
"tst"), path);
usnbA.setParent(usnbAParent);
Code Review / yangtools.git / commitdiff