/**
* Basic implementation for TypeAwareBuilder builders.
*/
-public class AbstractTypeAwareBuilder implements TypeAwareBuilder {
+public abstract class AbstractTypeAwareBuilder implements TypeAwareBuilder {
protected TypeDefinition<?> type;
protected TypeDefinitionBuilder typedef;
public interface Builder {
Object build();
+ int getLine();
}
* Builders of all nodes, which can have 'type' statement must implement this interface.
* [typedef, type, leaf, leaf-list, deviate]
*/
-public interface TypeAwareBuilder {
+public interface TypeAwareBuilder extends Builder {
TypeDefinition<?> getType();
import org.opendaylight.controller.yang.model.parser.builder.api.DataSchemaNodeBuilder;
public class AnyXmlBuilder implements DataSchemaNodeBuilder {
+ private final int line;
private final QName qname;
private SchemaPath path;
private final AnyXmlSchemaNodeImpl instance;
- private final ConstraintsBuilder constraints = new ConstraintsBuilder();
+ private final ConstraintsBuilder constraints;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private String description;
private Status status = Status.CURRENT;
private boolean configuration;
- public AnyXmlBuilder(final QName qname) {
+ public AnyXmlBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new AnyXmlSchemaNodeImpl(qname);
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
import org.opendaylight.controller.yang.model.util.RevisionAwareXPathImpl;
public class AugmentationSchemaBuilderImpl implements AugmentationSchemaBuilder {
-
private final AugmentationSchemaImpl instance;
+ private final int line;
private final String augmentTargetStr;
private final SchemaPath augmentTarget;
private String whenCondition;
private final Set<GroupingBuilder> groupings = new HashSet<GroupingBuilder>();
private final Set<UsesNodeBuilder> usesNodes = new HashSet<UsesNodeBuilder>();
- AugmentationSchemaBuilderImpl(final String augmentTargetStr) {
+ AugmentationSchemaBuilderImpl(final String augmentTargetStr, final int line) {
this.augmentTargetStr = augmentTargetStr;
+ this.line = line;
final SchemaPath targetPath = YangModelBuilderUtil
.parseAugmentPath(augmentTargetStr);
augmentTarget = targetPath;
instance = new AugmentationSchemaImpl(targetPath);
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public void addChildNode(DataSchemaNodeBuilder childNode) {
childNodes.add(childNode);
public class ChoiceBuilder implements DataSchemaNodeBuilder, ChildNodeBuilder,
AugmentationTargetBuilder {
private final ChoiceNodeImpl instance;
+ private final int line;
// SchemaNode args
private final QName qname;
private SchemaPath schemaPath;
private final Set<ChoiceCaseBuilder> cases = new HashSet<ChoiceCaseBuilder>();
private String defaultCase;
- public ChoiceBuilder(QName qname) {
+ public ChoiceBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new ChoiceNodeImpl(qname);
- constraints = new ConstraintsBuilder();
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public Set<ChoiceCaseBuilder> getCases() {
return cases;
}
public void addChildNode(DataSchemaNodeBuilder childNode) {
if (!(childNode instanceof ChoiceCaseBuilder)) {
ChoiceCaseBuilder caseBuilder = new ChoiceCaseBuilder(
- childNode.getQName());
+ childNode.getQName(), childNode.getLine());
caseBuilder.addChildNode(childNode);
cases.add(caseBuilder);
} else {
public final class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements
DataSchemaNodeBuilder {
private final ChoiceCaseNodeImpl instance;
+ private final int line;
private SchemaPath schemaPath;
private String description;
private String reference;
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
private final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- ChoiceCaseBuilder(QName qname) {
+ ChoiceCaseBuilder(final QName qname, final int line) {
super(qname);
+ this.line = line;
instance = new ChoiceCaseNodeImpl(qname);
- constraints = new ConstraintsBuilder();
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public SchemaPath getPath() {
return schemaPath;
}
import org.opendaylight.controller.yang.model.util.RevisionAwareXPathImpl;
public class ConstraintsBuilder implements Builder {
-
private final ConstraintDefinitionImpl instance;
+ private final int line;
private final Set<MustDefinition> mustDefinitions;
private String whenCondition;
private boolean mandatory;
private Integer min;
private Integer max;
- ConstraintsBuilder() {
+ ConstraintsBuilder(final int line) {
+ this.line = line;
instance = new ConstraintDefinitionImpl();
mustDefinitions = new HashSet<MustDefinition>();
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public Integer getMinElements() {
return min;
}
public class ContainerSchemaNodeBuilder extends AbstractChildNodeBuilder
implements TypeDefinitionAwareBuilder, AugmentationTargetBuilder,
DataSchemaNodeBuilder {
-
private final ContainerSchemaNodeImpl instance;
+ private final int line;
private final ConstraintsBuilder constraints;
private SchemaPath schemaPath;
private String description;
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- public ContainerSchemaNodeBuilder(QName qname) {
+ public ContainerSchemaNodeBuilder(final QName qname, final int line) {
super(qname);
+ this.line = line;
instance = new ContainerSchemaNodeImpl(qname);
- constraints = new ConstraintsBuilder();
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public Set<TypeDefinitionBuilder> getTypedefs() {
return addedTypedefs;
}
import org.opendaylight.controller.yang.model.parser.util.YangModelBuilderUtil;
public class DeviationBuilder implements Builder {
-
private final DeviationImpl instance;
+ private final int line;
- DeviationBuilder(final String targetPathStr) {
+ DeviationBuilder(final String targetPathStr, final int line) {
+ this.line = line;
final SchemaPath targetPath = YangModelBuilderUtil
.parseAugmentPath(targetPathStr);
instance = new DeviationImpl(targetPath);
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public void setDeviate(final String deviate) {
if ("not-supported".equals(deviate)) {
instance.setDeviate(Deviate.NOT_SUPPORTED);
@Override
public String toString() {
- StringBuilder sb = new StringBuilder(DeviationImpl.class.getSimpleName());
+ StringBuilder sb = new StringBuilder(
+ DeviationImpl.class.getSimpleName());
sb.append("[");
- sb.append("targetPath="+ targetPath);
- sb.append(", deviate="+ deviate);
- sb.append(", reference="+ reference);
+ sb.append("targetPath=" + targetPath);
+ sb.append(", deviate=" + deviate);
+ sb.append(", reference=" + reference);
sb.append("]");
return sb.toString();
}
import org.opendaylight.controller.yang.model.parser.builder.api.SchemaNodeBuilder;
public class ExtensionBuilder implements SchemaNodeBuilder {
-
private final ExtensionDefinitionImpl instance;
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private final List<UnknownSchemaNodeBuilder> addedExtensions = new ArrayList<UnknownSchemaNodeBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- ExtensionBuilder(final QName qname) {
+ ExtensionBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new ExtensionDefinitionImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public void addExtension(UnknownSchemaNodeBuilder extension) {
addedExtensions.add(extension);
}
import org.opendaylight.controller.yang.model.parser.builder.api.SchemaNodeBuilder;
public class FeatureBuilder implements SchemaNodeBuilder {
-
private final FeatureDefinitionImpl instance;
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- FeatureBuilder(final QName qname) {
+ FeatureBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new FeatureDefinitionImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
import org.opendaylight.controller.yang.model.parser.builder.api.UsesNodeBuilder;
public class GroupingBuilderImpl implements GroupingBuilder {
-
private final GroupingDefinitionImpl instance;
+ private final int line;
private SchemaPath schemaPath;
private final Set<DataSchemaNodeBuilder> childNodes = new HashSet<DataSchemaNodeBuilder>();
private final Set<GroupingBuilder> groupings = new HashSet<GroupingBuilder>();
private final Set<UsesNodeBuilder> usesNodes = new HashSet<UsesNodeBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- GroupingBuilderImpl(final QName qname) {
+ GroupingBuilderImpl(final QName qname, final int line) {
this.instance = new GroupingDefinitionImpl(qname);
+ this.line = line;
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
/**
* Always returns null.
*/
public final class IdentitySchemaNodeBuilder implements SchemaNodeBuilder {
private final IdentitySchemaNodeImpl instance;
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private IdentitySchemaNodeBuilder baseIdentity;
private String baseIdentityName;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- IdentitySchemaNodeBuilder(final QName qname) {
+ IdentitySchemaNodeBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new IdentitySchemaNodeImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
*/
public class IdentityrefTypeBuilder extends AbstractTypeAwareBuilder implements
TypeDefinitionBuilder, Builder {
+ private final int line;
private final String baseString;
private final SchemaPath schemaPath;
private QName baseQName;
- public IdentityrefTypeBuilder(final String baseString, SchemaPath schemaPath) {
+ public IdentityrefTypeBuilder(final String baseString, final SchemaPath schemaPath, final int line) {
+ this.line = line;
this.baseString = baseString;
this.schemaPath = schemaPath;
}
this.baseQName = baseQName;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public TypeDefinition<?> getType() {
return null;
public class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder
implements SchemaNodeBuilder, DataSchemaNodeBuilder {
private final LeafListSchemaNodeImpl instance;
+ private final int line;
+ // SchemaNode args
private final QName qname;
- private final ConstraintsBuilder constraints = new ConstraintsBuilder();
private SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
private boolean configuration;
+ private final ConstraintsBuilder constraints;
+ // LeafListSchemaNode args
private boolean userOrdered;
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
-
- public LeafListSchemaNodeBuilder(final QName qname) {
+ public LeafListSchemaNodeBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new LeafListSchemaNodeImpl(qname);
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
@Override
public void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
public class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements
DataSchemaNodeBuilder, SchemaNodeBuilder {
+ private final LeafSchemaNodeImpl instance;
+ private final int line;
+ // SchemaNode args
private final QName qname;
private SchemaPath path;
- private final LeafSchemaNodeImpl instance;
- private final ConstraintsBuilder constraints = new ConstraintsBuilder();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
-
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
private boolean configuration;
+ private final ConstraintsBuilder constraints;
+ // leaf args
private String defaultStr;
private String unitsStr;
- public LeafSchemaNodeBuilder(final QName qname) {
+ public LeafSchemaNodeBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new LeafSchemaNodeImpl(qname);
+ constraints = new ConstraintsBuilder(line);
}
@Override
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
DataSchemaNodeBuilder, SchemaNodeBuilder, AugmentationTargetBuilder,
TypeDefinitionAwareBuilder {
private final ListSchemaNodeImpl instance;
- private List<QName> keyDefinition;
- private final ConstraintsBuilder constraints;
+ private final int line;
+ // SchemaNode args
private SchemaPath schemaPath;
private String description;
private String reference;
private Status status = Status.CURRENT;
+ private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // DataSchemaNode args
private boolean augmenting;
private boolean configuration;
- private boolean userOrdered;
-
+ private final ConstraintsBuilder constraints;
+ // DataNodeContainer args
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
+ // AugmentationTarget args
private final Set<AugmentationSchemaBuilder> addedAugmentations = new HashSet<AugmentationSchemaBuilder>();
- private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
+ // ListSchemaNode args
+ private List<QName> keyDefinition;
+ private boolean userOrdered;
- public ListSchemaNodeBuilder(final QName qname) {
+ public ListSchemaNodeBuilder(final QName qname, final int line) {
super(qname);
+ this.line = line;
instance = new ListSchemaNodeImpl(qname);
- constraints = new ConstraintsBuilder();
+ constraints = new ConstraintsBuilder(line);
}
@Override
// AUGMENTATIONS
final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for(AugmentationSchemaBuilder builder : addedAugmentations) {
+ for (AugmentationSchemaBuilder builder : addedAugmentations) {
augmentations.add(builder.build());
}
instance.setAvailableAugmentations(augmentations);
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public Set<TypeDefinitionBuilder> getTypedefs() {
return addedTypedefs;
}
@Override
public void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
return instance;
}
+ @Override
+ public int getLine() {
+ return 0;
+ }
+
public Builder getNode(final List<String> path) {
return moduleNodes.get(path);
}
return imports;
}
- public ExtensionBuilder addExtension(final QName qname) {
- final ExtensionBuilder builder = new ExtensionBuilder(qname);
+ public ExtensionBuilder addExtension(final QName qname, final int line) {
+ final ExtensionBuilder builder = new ExtensionBuilder(qname, line);
addedExtensions.add(builder);
return builder;
}
public ContainerSchemaNodeBuilder addContainerNode(
- final QName containerName, final List<String> parentPath) {
+ final QName containerName, final List<String> parentPath,
+ final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
final ContainerSchemaNodeBuilder containerBuilder = new ContainerSchemaNodeBuilder(
- containerName);
+ containerName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
}
public ListSchemaNodeBuilder addListNode(final QName listName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
final ListSchemaNodeBuilder listBuilder = new ListSchemaNodeBuilder(
- listName);
+ listName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
}
public LeafSchemaNodeBuilder addLeafNode(final QName leafName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
final LeafSchemaNodeBuilder leafBuilder = new LeafSchemaNodeBuilder(
- leafName);
+ leafName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
}
public LeafListSchemaNodeBuilder addLeafListNode(final QName leafListName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToNode = new ArrayList<String>(parentPath);
final LeafListSchemaNodeBuilder leafListBuilder = new LeafListSchemaNodeBuilder(
- leafListName);
+ leafListName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToNode);
if (parent != null) {
}
public GroupingBuilder addGrouping(final QName qname,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToGroup = new ArrayList<String>(parentPath);
- final GroupingBuilder builder = new GroupingBuilderImpl(qname);
+ final GroupingBuilder builder = new GroupingBuilderImpl(qname, line);
final ChildNodeBuilder parentNodeBuilder = (ChildNodeBuilder) moduleNodes
.get(pathToGroup);
if (parentNodeBuilder != null) {
}
public AugmentationSchemaBuilder addAugment(final String name,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToAugment = new ArrayList<String>(parentPath);
final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(
- name);
+ name, line);
// augment can only be in 'module' or 'uses' statement
final UsesNodeBuilder parent = addedUsesNodes.get(pathToAugment);
}
public UsesNodeBuilder addUsesNode(final String groupingPathStr,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToUses = new ArrayList<String>(parentPath);
final UsesNodeBuilder usesBuilder = new UsesNodeBuilderImpl(
- groupingPathStr);
+ groupingPathStr, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToUses);
if (parent != null) {
}
public RpcDefinitionBuilder addRpc(final QName qname,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToRpc = new ArrayList<String>(parentPath);
- final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(qname);
+ final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(qname,
+ line);
pathToRpc.add(qname.getLocalName());
addedRpcs.put(pathToRpc, rpcBuilder);
final QName inputQName = new QName(qname.getNamespace(),
qname.getRevision(), qname.getPrefix(), "input");
final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(
- inputQName);
+ inputQName, line);
final List<String> pathToInput = new ArrayList<String>(pathToRpc);
pathToInput.add("input");
moduleNodes.put(pathToInput, inputBuilder);
final QName outputQName = new QName(qname.getNamespace(),
qname.getRevision(), qname.getPrefix(), "output");
final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(
- outputQName);
+ outputQName, line);
final List<String> pathToOutput = new ArrayList<String>(pathToRpc);
pathToOutput.add("output");
moduleNodes.put(pathToOutput, outputBuilder);
}
public NotificationBuilder addNotification(final QName notificationName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
final List<String> pathToNotification = new ArrayList<String>(
parentPath);
- NotificationBuilder builder = new NotificationBuilder(notificationName);
+ NotificationBuilder builder = new NotificationBuilder(notificationName,
+ line);
pathToNotification.add(notificationName.getLocalName());
moduleNodes.put(pathToNotification, builder);
}
public FeatureBuilder addFeature(final QName featureName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
List<String> pathToFeature = new ArrayList<String>(parentPath);
pathToFeature.add(featureName.getLocalName());
- FeatureBuilder builder = new FeatureBuilder(featureName);
+ FeatureBuilder builder = new FeatureBuilder(featureName, line);
addedFeatures.put(pathToFeature, builder);
return builder;
}
public ChoiceBuilder addChoice(final QName choiceName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
List<String> pathToChoice = new ArrayList<String>(parentPath);
- ChoiceBuilder builder = new ChoiceBuilder(choiceName);
+ ChoiceBuilder builder = new ChoiceBuilder(choiceName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToChoice);
}
public ChoiceCaseBuilder addCase(final QName caseName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
List<String> pathToCase = new ArrayList<String>(parentPath);
- ChoiceCaseBuilder builder = new ChoiceCaseBuilder(caseName);
+ ChoiceCaseBuilder builder = new ChoiceCaseBuilder(caseName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToCase);
}
public AnyXmlBuilder addAnyXml(final QName anyXmlName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
List<String> pathToAnyXml = new ArrayList<String>(parentPath);
- AnyXmlBuilder builder = new AnyXmlBuilder(anyXmlName);
+ AnyXmlBuilder builder = new AnyXmlBuilder(anyXmlName, line);
final ChildNodeBuilder parent = (ChildNodeBuilder) moduleNodes
.get(pathToAnyXml);
}
public TypedefBuilder addTypedef(final QName typeDefName,
- final List<String> parentPath) {
+ final List<String> parentPath, final int line) {
List<String> pathToType = new ArrayList<String>(parentPath);
- TypedefBuilder builder = new TypedefBuilder(typeDefName);
+ TypedefBuilder builder = new TypedefBuilder(typeDefName, line);
TypeDefinitionAwareBuilder parent = (TypeDefinitionAwareBuilder) moduleNodes
.get(pathToType);
if (parent != null) {
}
public void addUnionType(final List<String> actualPath,
- final URI namespace, final Date revision) {
+ final URI namespace, final Date revision, final int line) {
List<String> pathToUnion = new ArrayList<String>(actualPath);
TypeAwareBuilder parent = (TypeAwareBuilder) moduleNodes
.get(pathToUnion);
UnionTypeBuilder union = new UnionTypeBuilder(pathToUnion, namespace,
- revision);
+ revision, line);
parent.setType(union);
List<String> path = new ArrayList<String>(pathToUnion);
moduleNodes.put(path, union);
}
- public void addIdentityrefType(String baseString, List<String> parentPath,
- SchemaPath schemaPath) {
+ public void addIdentityrefType(final String baseString,
+ final List<String> parentPath, final SchemaPath schemaPath,
+ final int line) {
List<String> pathToIdentityref = new ArrayList<String>(parentPath);
TypeAwareBuilder parent = (TypeAwareBuilder) moduleNodes
.get(pathToIdentityref);
IdentityrefTypeBuilder identityref = new IdentityrefTypeBuilder(
- baseString, schemaPath);
+ baseString, schemaPath, line);
parent.setType(identityref);
dirtyNodes.put(pathToIdentityref, parent);
}
- public DeviationBuilder addDeviation(String targetPath,
- List<String> parentPath) {
+ public DeviationBuilder addDeviation(final String targetPath,
+ final List<String> parentPath, final int line) {
final List<String> pathToDeviation = new ArrayList<String>(parentPath);
pathToDeviation.add(targetPath);
- DeviationBuilder builder = new DeviationBuilder(targetPath);
+ DeviationBuilder builder = new DeviationBuilder(targetPath, line);
addedDeviations.put(targetPath, builder);
moduleNodes.put(pathToDeviation, builder);
return builder;
}
- public IdentitySchemaNodeBuilder addIdentity(QName qname,
- List<String> parentPath) {
- List<String> pathToIdentity = new ArrayList<String>(parentPath);
- IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(qname);
+ public IdentitySchemaNodeBuilder addIdentity(final QName qname,
+ final List<String> parentPath, final int line) {
+ final List<String> pathToIdentity = new ArrayList<String>(parentPath);
+ final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(
+ qname, line);
pathToIdentity.add(qname.getLocalName());
moduleNodes.put(pathToIdentity, builder);
addedIdentities.add(builder);
}
}
- public UnknownSchemaNodeBuilder addUnknownSchemaNode(QName qname,
- List<String> parentPath) {
+ public UnknownSchemaNodeBuilder addUnknownSchemaNode(final QName qname,
+ final List<String> parentPath, final int line) {
final List<String> pathToUnknown = new ArrayList<String>(parentPath);
final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(
- qname);
+ qname, line);
final Builder parent = moduleNodes.get(pathToUnknown);
if (parent instanceof RefineHolder) {
((RefineHolder) parent).addUnknownSchemaNode(builder);
public class NotificationBuilder extends AbstractChildNodeBuilder implements
TypeDefinitionAwareBuilder, SchemaNodeBuilder {
-
private final NotificationDefinitionImpl instance;
+ private final int line;
private SchemaPath schemaPath;
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- NotificationBuilder(QName qname) {
+ NotificationBuilder(final QName qname, final int line) {
super(qname);
+ this.line = line;
instance = new NotificationDefinitionImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public void addTypedef(final TypeDefinitionBuilder type) {
addedTypedefs.add(type);
public class RpcDefinitionBuilder implements SchemaNodeBuilder,
TypeDefinitionAwareBuilder {
private final RpcDefinitionImpl instance;
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private ContainerSchemaNodeBuilder inputBuilder;
private final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- RpcDefinitionBuilder(final QName qname) {
+ RpcDefinitionBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
this.instance = new RpcDefinitionImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
this.inputBuilder = inputBuilder;
}
public class TypedefBuilder extends AbstractTypeAwareBuilder implements
TypeDefinitionBuilder {
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private String units;
private Object defaultValue;
- public TypedefBuilder(final QName qname) {
+ public TypedefBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
}
@Override
return result;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
*/
public class UnionTypeBuilder extends AbstractTypeAwareBuilder implements
TypeDefinitionBuilder, Builder {
+ private final int line;
private final List<TypeDefinition<?>> types;
private final List<TypeDefinitionBuilder> typedefs;
private final UnionType instance;
private final Date revision;
public UnionTypeBuilder(final List<String> actualPath, final URI namespace,
- final Date revision) {
+ final Date revision, final int line) {
+ this.line = line;
types = new ArrayList<TypeDefinition<?>>();
typedefs = new ArrayList<TypeDefinitionBuilder>();
instance = new UnionType(actualPath, namespace, revision, types);
this.revision = revision;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
public List<TypeDefinition<?>> getTypes() {
return types;
}
public class UnknownSchemaNodeBuilder implements SchemaNodeBuilder {
private final UnknownSchemaNodeImpl instance;
+ private final int line;
private final QName qname;
private SchemaPath schemaPath;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
private QName nodeType;
private String nodeParameter;
- UnknownSchemaNodeBuilder(final QName qname) {
+ UnknownSchemaNodeBuilder(final QName qname, final int line) {
this.qname = qname;
+ this.line = line;
instance = new UnknownSchemaNodeImpl(qname);
}
return instance;
}
+ @Override
+ public int getLine() {
+ return line;
+ }
+
@Override
public QName getQName() {
return qname;
\r
final class UsesNodeBuilderImpl implements UsesNodeBuilder, Builder {\r
private final UsesNodeImpl instance;\r
+ private final int line;\r
private final SchemaPath groupingPath;\r
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
private List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();\r
private List<RefineHolder> refines = new ArrayList<RefineHolder>();\r
\r
- UsesNodeBuilderImpl(final String groupingPathStr) {\r
+ UsesNodeBuilderImpl(final String groupingPathStr, final int line) {\r
this.groupingPath = parseUsesPath(groupingPathStr);\r
+ this.line = line;\r
instance = new UsesNodeImpl(groupingPath);\r
}\r
\r
\r
// REFINES\r
final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();\r
- for(SchemaNodeBuilder refineBuilder : refineBuilders) {\r
+ for (SchemaNodeBuilder refineBuilder : refineBuilders) {\r
SchemaNode refineNode = refineBuilder.build();\r
refineNodes.put(refineNode.getPath(), refineNode);\r
}\r
return instance;\r
}\r
\r
+ @Override\r
+ public int getLine() {\r
+ return line;\r
+ }\r
+\r
@Override\r
public SchemaPath getGroupingPath() {\r
return groupingPath;\r
return augmentations;\r
}\r
\r
- private void setAugmentations(final Set<AugmentationSchema> augmentations) {\r
+ private void setAugmentations(\r
+ final Set<AugmentationSchema> augmentations) {\r
if (augmentations != null) {\r
this.augmentations = augmentations;\r
}\r
}\r
\r
private void setRefines(Map<SchemaPath, SchemaNode> refines) {\r
- if(refines != null) {\r
+ if (refines != null) {\r
this.refines = refines;\r
}\r
}\r
// search for module which contains referenced typedef
final ModuleBuilder dependentModule = findDependentModule(modules,
- builder, unknownTypeQName.getPrefix());
+ builder, unknownTypeQName.getPrefix(), nodeToResolve.getLine());
final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
- dependentModule, unknownTypeQName.getLocalName());
+ dependentModule, unknownTypeQName.getLocalName(),
+ builder.getName(), nodeToResolve.getLine());
final TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder(
lookedUpBuilder, nodeToResolve instanceof TypeDefinitionBuilder);
final QName unknownTypeQName = unknownType.getQName();
// search for module which contains referenced typedef
final ModuleBuilder dependentModule = findDependentModule(modules,
- module, unknownTypeQName.getPrefix());
+ module, unknownTypeQName.getPrefix(), nodeToResolve.getLine());
final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
- dependentModule, unknownTypeQName.getLocalName());
+ dependentModule, unknownTypeQName.getLocalName(),
+ module.getName(), nodeToResolve.getLine());
final TypeDefinitionBuilder lookedUpBuilderCopy = copyTypedefBuilder(
lookedUpBuilder, nodeToResolve instanceof TypeDefinitionBuilder);
final UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
final UnionTypeBuilder newUnion = new UnionTypeBuilder(
oldUnion.getActualPath(), oldUnion.getNamespace(),
- oldUnion.getRevision());
+ oldUnion.getRevision(), old.getLine());
for (TypeDefinition<?> td : oldUnion.getTypes()) {
newUnion.setType(td);
}
final QName newName = new QName(oldName.getNamespace(),
oldName.getRevision(), oldName.getPrefix(),
oldName.getLocalName());
- final TypeDefinitionBuilder tdb = new TypedefBuilder(newName);
+ final TypeDefinitionBuilder tdb = new TypedefBuilder(newName,
+ old.getLine());
tdb.setRanges(old.getRanges());
tdb.setLengths(old.getLengths());
final QName unknownTypeQName = unknownType.getQName();
final String unknownTypePrefix = unknownTypeQName.getPrefix();
final ModuleBuilder dependentModule = findDependentModule(modules,
- builder, unknownTypePrefix);
+ builder, unknownTypePrefix, copy.getLine());
final TypeDefinitionBuilder utBuilder = getTypedefBuilder(copy,
modules, dependentModule);
copy.setType(utBuilder);
private TypeDefinitionBuilder findTypedefBuilder(
final QName unknownTypeQName,
final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder builder) {
+ final ModuleBuilder builder, int line) {
// search for module which contains referenced typedef
final ModuleBuilder dependentModule = findDependentModule(modules,
- builder, unknownTypeQName.getPrefix());
+ builder, unknownTypeQName.getPrefix(), line);
final TypeDefinitionBuilder lookedUpBuilder = findTypedefBuilderByName(
- dependentModule, unknownTypeQName.getLocalName());
+ dependentModule, unknownTypeQName.getLocalName(),
+ builder.getName(), line);
return copyTypedefBuilder(lookedUpBuilder, true);
}
fractionDigits = ext.getFractionDigits();
constraints.setFractionDigits(fractionDigits);
return findConstraints(
- findTypedefBuilder(ext.getQName(), modules, builder),
- constraints, modules, builder);
+ findTypedefBuilder(ext.getQName(), modules, builder,
+ nodeToResolve.getLine()), constraints, modules,
+ builder);
} else if (referencedType instanceof UnknownType) {
final UnknownType unknown = (UnknownType) referencedType;
ranges = unknown.getRangeStatements();
unknownTypePrefix = builder.getPrefix();
}
final ModuleBuilder dependentModule = findDependentModule(modules,
- builder, unknown.getQName().getPrefix());
+ builder, unknown.getQName().getPrefix(),
+ nodeToResolve.getLine());
final TypeDefinitionBuilder utBuilder = findTypedefBuilder(
- unknown.getQName(), modules, builder);
+ unknown.getQName(), modules, builder,
+ nodeToResolve.getLine());
return findConstraints(utBuilder, constraints, modules,
dependentModule);
} else {
* @return typedef with name equals to given name
*/
private TypeDefinitionBuilder findTypedefBuilderByName(
- final ModuleBuilder dependentModule, final String name) {
+ final ModuleBuilder dependentModule, final String name,
+ final String currentModuleName, final int line) {
TypeDefinitionBuilder result = null;
final Set<TypeDefinitionBuilder> typedefs = dependentModule
.getModuleTypedefs();
}
}
if (result == null) {
- throw new YangParseException("Target module '"
- + dependentModule.getName()
- + "' does not contain typedef '" + name + "'.");
+ throw new YangParseException(currentModuleName, line,
+ "Target module '" + dependentModule.getName()
+ + "' does not contain typedef '" + name + "'.");
}
return result;
}
DataSchemaNodeBuilder currentParent = null;
final ModuleBuilder dependentModule = findDependentModule(
- modules, module, prefix);
+ modules, module, prefix, augmentBuilder.getLine());
for (DataSchemaNodeBuilder child : dependentModule
.getChildNodes()) {
final QName childQName = child.getQName();
baseIdentityLocalName = baseIdentityName;
}
final ModuleBuilder dependentModule = findDependentModule(
- modules, module, baseIdentityPrefix);
+ modules, module, baseIdentityPrefix, identity.getLine());
final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule
.getAddedIdentities();
final ModuleBuilder module) {
Builder result = null;
final Builder lookedUpBuilder = findRefineTargetBuilder(groupingPath,
- refine.getName(), modules, module);
+ refine, modules, module);
if (lookedUpBuilder instanceof LeafSchemaNodeBuilder) {
result = ParserUtils
.copyLeafBuilder((LeafSchemaNodeBuilder) lookedUpBuilder);
result = ParserUtils
.copyAnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
} else {
- throw new YangParseException("Target '" + refine.getName()
- + "' can not be refined");
+ throw new YangParseException(module.getName(), refine.getLine(),
+ "Target '" + refine.getName() + "' can not be refined");
}
return result;
}
* otherwise
*/
private Builder findRefineTargetBuilder(final String groupingPath,
- final String refineNodeName,
+ final RefineHolder refine,
final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module) {
final SchemaPath path = ParserUtils.parseUsesPath(groupingPath);
}
final ModuleBuilder dependentModule = findDependentModule(modules,
- module, prefix);
+ module, prefix, refine.getLine());
builderPath.add(0, "grouping");
builderPath.add(0, dependentModule.getName());
final GroupingBuilder builder = (GroupingBuilder) dependentModule
.getNode(builderPath);
- return builder.getChildNode(refineNodeName);
+ return builder.getChildNode(refine.getName());
}
private QName findFullQName(
if (baseString.contains(":")) {
String[] splittedBase = baseString.split(":");
if (splittedBase.length > 2) {
- throw new YangParseException(
+ throw new YangParseException(module.getName(), idref.getLine(),
"Failed to parse identityref base: " + baseString);
}
String prefix = splittedBase[0];
String name = splittedBase[1];
ModuleBuilder dependentModule = findDependentModule(modules,
- module, prefix);
+ module, prefix, idref.getLine());
result = new QName(dependentModule.getNamespace(),
dependentModule.getRevision(), prefix, name);
} else {
|| nodeType.getRevision() == null) {
try {
ModuleBuilder dependentModule = findDependentModule(
- modules, module, nodeType.getPrefix());
+ modules, module, nodeType.getPrefix(),
+ usnb.getLine());
QName newNodeType = new QName(
dependentModule.getNamespace(),
dependentModule.getRevision(),
nodeType.getPrefix(), nodeType.getLocalName());
usnb.setNodeType(newNodeType);
} catch (YangParseException e) {
- logger.debug("Failed to find unknown node type: "
- + nodeType);
+ logger.debug(module.getName(), usnb.getLine(),
+ "Failed to find unknown node type: " + nodeType);
}
}
}
*/
private ModuleBuilder findDependentModule(
final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final String prefix) {
+ final ModuleBuilder module, final String prefix, final int line) {
ModuleBuilder dependentModule = null;
Date dependentModuleRevision = null;
final ModuleImport dependentModuleImport = ParserUtils
.getModuleImport(module, prefix);
if (dependentModuleImport == null) {
- throw new YangParseException("No import found with prefix '"
- + prefix + "' in module " + module.getName() + "'.");
+ throw new YangParseException(module.getName(), line,
+ "No import found with prefix '" + prefix + "'.");
}
final String dependentModuleName = dependentModuleImport
.getModuleName();
final TreeMap<Date, ModuleBuilder> moduleBuildersByRevision = modules
.get(dependentModuleName);
if (moduleBuildersByRevision == null) {
- throw new YangParseException(
+ throw new YangParseException(module.getName(), line,
"Failed to find dependent module '"
- + dependentModuleName + "' needed by module '"
- + module.getName() + "'.");
+ + dependentModuleName + "'.");
}
if (dependentModuleRevision == null) {
dependentModule = moduleBuildersByRevision.lastEntry()
}
if (dependentModule == null) {
- throw new YangParseException(
+ throw new YangParseException(module.getName(), line,
"Failed to find dependent module with prefix '" + prefix
+ "' and revision '" + dependentModuleRevision
+ "'.");
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public final class YangModelParserListenerImpl extends YangParserBaseListener {\r
-\r
+public final class YangModelParserListenerImpl extends YangParserBaseListener {
+
private static final Logger logger = LoggerFactory
.getLogger(YangModelParserListenerImpl.class);
private String yangModelPrefix;
private Date revision = new Date(0L);
- public final static DateFormat simpleDateFormat = new SimpleDateFormat(\r
+ public final static DateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd");
private final Stack<String> actualPath = new Stack<String>();
public void enterAugment_stmt(YangParser.Augment_stmtContext ctx) {
final String augmentPath = stringFromNode(ctx);
AugmentationSchemaBuilder builder = moduleBuilder.addAugment(
- augmentPath, actualPath);
+ augmentPath, actualPath, ctx.getStart().getLine());
updatePath(augmentPath);
for (int i = 0; i < ctx.getChildCount(); i++) {
public void enterExtension_stmt(YangParser.Extension_stmtContext ctx) {
final String extName = stringFromNode(ctx);
QName qname = new QName(namespace, revision, yangModelPrefix, extName);
- ExtensionBuilder builder = moduleBuilder.addExtension(qname);
+ ExtensionBuilder builder = moduleBuilder.addExtension(qname, ctx
+ .getStart().getLine());
parseSchemaNodeArgs(ctx, builder);
String argument = null;
QName typedefQName = new QName(namespace, revision, yangModelPrefix,
typedefName);
TypedefBuilder builder = moduleBuilder.addTypedef(typedefQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(typedefName);
builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
@Override
public void enterType_stmt(YangParser.Type_stmtContext ctx) {
final String typeName = stringFromNode(ctx);
- QName typeQName = parseQName(typeName);
+ final int line = ctx.getStart().getLine();
+ final QName typeQName = parseQName(typeName);
TypeDefinition<?> type = null;
Type_body_stmtsContext typeBody = null;
// if this is base yang type...
if (YangTypesConverter.isBaseYangType(typeName)) {
if (typeBody == null) {
+ // check for types which must have body
+ checkMissingBody(typeName, moduleName, line);
// if there are no constraints, just grab default base yang type
- type = YangTypesConverter.javaTypeForBaseYangType(actualPath, namespace, revision, typeName);
+ type = YangTypesConverter.javaTypeForBaseYangType(actualPath,
+ namespace, revision, typeName);
moduleBuilder.setType(type, actualPath);
} else {
if ("union".equals(typeName)) {
- moduleBuilder.addUnionType(actualPath, namespace, revision);
- } else if("identityref".equals(typeName)) {
- SchemaPath path = createActualSchemaPath(actualPath, namespace, revision, yangModelPrefix);
- moduleBuilder.addIdentityrefType(getIdentityrefBase(typeBody), actualPath, path);
+ moduleBuilder.addUnionType(actualPath, namespace, revision,
+ line);
+ } else if ("identityref".equals(typeName)) {
+ SchemaPath path = createActualSchemaPath(actualPath,
+ namespace, revision, yangModelPrefix);
+ moduleBuilder.addIdentityrefType(
+ getIdentityrefBase(typeBody), actualPath, path,
+ line);
} else {
List<String> typePath = new ArrayList<String>(actualPath);
typePath.remove(0);
QName groupQName = new QName(namespace, revision, yangModelPrefix,
groupName);
GroupingBuilder groupBuilder = moduleBuilder.addGrouping(groupQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath("grouping");
updatePath(groupName);
parseSchemaNodeArgs(ctx, groupBuilder);
QName containerQName = new QName(namespace, revision, yangModelPrefix,
containerName);
ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
- .addContainerNode(containerQName, actualPath);
+ .addContainerNode(containerQName, actualPath, ctx.getStart()
+ .getLine());
updatePath(containerName);
containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName leafQName = new QName(namespace, revision, yangModelPrefix,
leafName);
LeafSchemaNodeBuilder leafBuilder = moduleBuilder.addLeafNode(
- leafQName, actualPath);
+ leafQName, actualPath, ctx.getStart().getLine());
updatePath(leafName);
leafBuilder.setPath(createActualSchemaPath(actualPath, namespace,
@Override
public void enterUses_stmt(YangParser.Uses_stmtContext ctx) {
final String groupingPathStr = stringFromNode(ctx);
- moduleBuilder.addUsesNode(groupingPathStr,
- actualPath);
+ moduleBuilder.addUsesNode(groupingPathStr, actualPath, ctx.getStart()
+ .getLine());
updatePath(groupingPathStr);
}
QName leafListQName = new QName(namespace, revision, yangModelPrefix,
leafListName);
LeafListSchemaNodeBuilder leafListBuilder = moduleBuilder
- .addLeafListNode(leafListQName, actualPath);
+ .addLeafListNode(leafListQName, actualPath, ctx.getStart()
+ .getLine());
updatePath(leafListName);
parseSchemaNodeArgs(ctx, leafListBuilder);
QName containerQName = new QName(namespace, revision, yangModelPrefix,
containerName);
ListSchemaNodeBuilder listBuilder = moduleBuilder.addListNode(
- containerQName, actualPath);
+ containerQName, actualPath, ctx.getStart().getLine());
updatePath(containerName);
listBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName anyXmlQName = new QName(namespace, revision, yangModelPrefix,
anyXmlName);
AnyXmlBuilder anyXmlBuilder = moduleBuilder.addAnyXml(anyXmlQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(anyXmlName);
anyXmlBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName choiceQName = new QName(namespace, revision, yangModelPrefix,
choiceName);
ChoiceBuilder choiceBuilder = moduleBuilder.addChoice(choiceQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(choiceName);
choiceBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName choiceQName = new QName(namespace, revision, yangModelPrefix,
caseName);
ChoiceCaseBuilder caseBuilder = moduleBuilder.addCase(choiceQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(caseName);
caseBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName notificationQName = new QName(namespace, revision,
yangModelPrefix, notificationName);
NotificationBuilder notificationBuilder = moduleBuilder
- .addNotification(notificationQName, actualPath);
+ .addNotification(notificationQName, actualPath, ctx.getStart()
+ .getLine());
updatePath(notificationName);
notificationBuilder.setPath(createActualSchemaPath(actualPath,
final String nodeTypeStr = ctx.getChild(0).getText();
final String[] splittedElement = nodeTypeStr.split(":");
if (splittedElement.length == 1) {
- nodeType = new QName(null, null, yangModelPrefix, splittedElement[0]);
+ nodeType = new QName(null, null, yangModelPrefix,
+ splittedElement[0]);
} else {
nodeType = new QName(null, null, splittedElement[0],
splittedElement[1]);
splittedName[0]);
}
} else {
- qname = new QName(namespace, revision, yangModelPrefix, nodeParameter);
+ qname = new QName(namespace, revision, yangModelPrefix,
+ nodeParameter);
}
UnknownSchemaNodeBuilder builder = moduleBuilder.addUnknownSchemaNode(
- qname, actualPath);
+ qname, actualPath, ctx.getStart().getLine());
builder.setNodeType(nodeType);
builder.setNodeParameter(nodeParameter);
updatePath(nodeParameter);
QName rpcQName = new QName(namespace, revision, yangModelPrefix,
rpcName);
RpcDefinitionBuilder rpcBuilder = moduleBuilder.addRpc(rpcQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(rpcName);
rpcBuilder.setPath(createActualSchemaPath(actualPath, namespace,
QName featureQName = new QName(namespace, revision, yangModelPrefix,
featureName);
FeatureBuilder featureBuilder = moduleBuilder.addFeature(featureQName,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(featureName);
featureBuilder.setPath(createActualSchemaPath(actualPath, namespace,
String reference = null;
String deviate = null;
DeviationBuilder builder = moduleBuilder.addDeviation(targetPath,
- actualPath);
+ actualPath, ctx.getStart().getLine());
updatePath(targetPath);
for (int i = 0; i < ctx.getChildCount(); i++) {
final String identityName = stringFromNode(ctx);
final QName identityQName = new QName(namespace, revision,
yangModelPrefix, identityName);
- IdentitySchemaNodeBuilder builder = moduleBuilder
- .addIdentity(identityQName, actualPath);
+ IdentitySchemaNodeBuilder builder = moduleBuilder.addIdentity(
+ identityQName, actualPath, ctx.getStart().getLine());
updatePath(identityName);
builder.setPath(createActualSchemaPath(actualPath, namespace, revision,
public static LeafSchemaNodeBuilder copyLeafBuilder(
final LeafSchemaNodeBuilder old) {
final LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(
- old.getQName());
+ old.getQName(), old.getLine());
final TypeDefinition<?> type = old.getType();
if (type == null) {
public static ContainerSchemaNodeBuilder copyContainerBuilder(
final ContainerSchemaNodeBuilder old) {
final ContainerSchemaNodeBuilder copy = new ContainerSchemaNodeBuilder(
- old.getQName());
+ old.getQName(), old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
public static ListSchemaNodeBuilder copyListBuilder(
final ListSchemaNodeBuilder old) {
final ListSchemaNodeBuilder copy = new ListSchemaNodeBuilder(
- old.getQName());
+ old.getQName(), old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
public static LeafListSchemaNodeBuilder copyLeafListBuilder(
final LeafListSchemaNodeBuilder old) {
final LeafListSchemaNodeBuilder copy = new LeafListSchemaNodeBuilder(
- old.getQName());
+ old.getQName(), old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
final TypeDefinition<?> type = old.getType();
}
public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) {
- final ChoiceBuilder copy = new ChoiceBuilder(old.getQName());
+ final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(), old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (ChoiceCaseBuilder caseBuilder : old.getCases()) {
}
public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) {
- final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName());
+ final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(), old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
public final class RefineHolder implements Builder {
private final String name;
+ private final int line;
private String defaultStr;
private String description;
private String reference;
private Integer maxElements;
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- public RefineHolder(final String name) {
+ public RefineHolder(final String name, final int line) {
this.name = name;
+ this.line = line;
+ }
+
+ @Override
+ public int getLine() {
+ return line;
}
public String getDefaultStr() {
*/
private static List<RangeConstraint> parseRangeConstraints(
final Range_stmtContext ctx) {
+ final int line = ctx.getStart().getLine();
List<RangeConstraint> rangeConstraints = new ArrayList<RangeConstraint>();
String description = null;
String reference = null;
Number min;
Number max;
if (splittedRangeDef.length == 1) {
- min = max = parseNumberConstraintValue(splittedRangeDef[0]);
+ min = max = parseNumberConstraintValue(splittedRangeDef[0],
+ line);
} else {
- min = parseNumberConstraintValue(splittedRangeDef[0]);
- max = parseNumberConstraintValue(splittedRangeDef[1]);
+ min = parseNumberConstraintValue(splittedRangeDef[0], line);
+ max = parseNumberConstraintValue(splittedRangeDef[1], line);
}
RangeConstraint range = BaseConstraints.rangeConstraint(min, max,
description, reference);
*/
private static List<LengthConstraint> parseLengthConstraints(
final Length_stmtContext ctx) {
+ final int line = ctx.getStart().getLine();
List<LengthConstraint> lengthConstraints = new ArrayList<LengthConstraint>();
String description = null;
String reference = null;
Number min;
Number max;
if (splittedRangeDef.length == 1) {
- min = max = parseNumberConstraintValue(splittedRangeDef[0]);
+ min = max = parseNumberConstraintValue(splittedRangeDef[0],
+ line);
} else {
- min = parseNumberConstraintValue(splittedRangeDef[0]);
- max = parseNumberConstraintValue(splittedRangeDef[1]);
+ min = parseNumberConstraintValue(splittedRangeDef[0], line);
+ max = parseNumberConstraintValue(splittedRangeDef[1], line);
}
LengthConstraint range = BaseConstraints.lengthConstraint(min, max,
description, reference);
* @return wrapper object of primitive java type or UnknownBoundaryNumber if
* type is one of special YANG values 'min' or 'max'
*/
- private static Number parseNumberConstraintValue(final String value) {
+ private static Number parseNumberConstraintValue(final String value,
+ final int line) {
Number result = null;
if ("min".equals(value) || "max".equals(value)) {
result = new UnknownBoundaryNumber(value);
try {
result = Long.valueOf(value);
} catch (NumberFormatException e) {
- throw new YangParseException("Unable to parse range value '"
- + value + "'.", e);
+ throw new YangParseException("Error on line " + line
+ + ": Unable to parse range value '" + value + "'.", e);
}
}
return result;
typeBody, actualPath, namespace, revision, prefix);
if ("decimal64".equals(typeName)) {
- type = new Decimal64(actualPath, namespace, revision, fractionDigits);
+ type = new Decimal64(actualPath, namespace, revision,
+ fractionDigits);
} else if (typeName.startsWith("int")) {
if (typeName.equals("int8")) {
- type = new Int8(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Int8(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("int16")) {
- type = new Int16(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Int16(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("int32")) {
- type = new Int32(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Int32(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("int64")) {
- type = new Int64(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Int64(actualPath, namespace, revision,
+ rangeStatements, null, null);
}
} else if (typeName.startsWith("uint")) {
if (typeName.equals("uint8")) {
- type = new Uint8(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Uint8(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("uint16")) {
- type = new Uint16(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Uint16(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("uint32")) {
- type = new Uint32(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Uint32(actualPath, namespace, revision,
+ rangeStatements, null, null);
} else if (typeName.equals("uint64")) {
- type = new Uint64(actualPath, namespace, revision, rangeStatements, null, null);
+ type = new Uint64(actualPath, namespace, revision,
+ rangeStatements, null, null);
}
} else if ("enumeration".equals(typeName)) {
type = new EnumerationType(actualPath, namespace, revision,
enumConstants);
} else if ("string".equals(typeName)) {
- type = new StringType(actualPath, namespace, revision, lengthStatements, patternStatements);
+ type = new StringType(actualPath, namespace, revision,
+ lengthStatements, patternStatements);
} else if ("bits".equals(typeName)) {
- type = new BitsType(actualPath, namespace, revision, getBits(typeBody, actualPath, namespace,
- revision, prefix));
+ type = new BitsType(actualPath, namespace, revision, getBits(
+ typeBody, actualPath, namespace, revision, prefix));
} else if ("leafref".equals(typeName)) {
final String path = parseLeafrefPath(typeBody);
final boolean absolute = path.startsWith("/");
type = new Leafref(actualPath, namespace, revision, xpath);
} else if ("binary".equals(typeName)) {
List<Byte> bytes = Collections.emptyList();
- type = new BinaryType(actualPath, namespace, revision, bytes, lengthStatements, null);
+ type = new BinaryType(actualPath, namespace, revision, bytes,
+ lengthStatements, null);
} else if ("instance-identifier".equals(typeName)) {
boolean requireInstance = isRequireInstance(typeBody);
- type = new InstanceIdentifier(actualPath, namespace, revision, null, requireInstance);
+ type = new InstanceIdentifier(actualPath, namespace, revision,
+ null, requireInstance);
}
return type;
}
public static String getIdentityrefBase(Type_body_stmtsContext ctx) {
String result = null;
- outer:
- for (int i = 0; i < ctx.getChildCount(); i++) {
+ outer: for (int i = 0; i < ctx.getChildCount(); i++) {
ParseTree child = ctx.getChild(i);
if (child instanceof Identityref_specificationContext) {
for (int j = 0; j < child.getChildCount(); j++) {
return yinValue;
}
-// public static List<RefineHolder> parseRefines(Uses_stmtContext ctx) {
-// List<RefineHolder> refines = new ArrayList<RefineHolder>();
-//
-// for (int i = 0; i < ctx.getChildCount(); i++) {
-// ParseTree child = ctx.getChild(i);
-// if (child instanceof Refine_stmtContext) {
-// final String refineTarget = stringFromNode(child);
-// final RefineHolder refine = new RefineHolder(refineTarget);
-// for (int j = 0; j < child.getChildCount(); j++) {
-// ParseTree refinePom = child.getChild(j);
-// if (refinePom instanceof Refine_pomContext) {
-// for (int k = 0; k < refinePom.getChildCount(); k++) {
-// ParseTree refineStmt = refinePom.getChild(k);
-// if (refineStmt instanceof Refine_leaf_stmtsContext) {
-// parseRefine(refine,
-// (Refine_leaf_stmtsContext) refineStmt);
-// } else if (refineStmt instanceof Refine_container_stmtsContext) {
-// parseRefine(
-// refine,
-// (Refine_container_stmtsContext) refineStmt);
-// } else if (refineStmt instanceof Refine_list_stmtsContext) {
-// parseRefine(refine,
-// (Refine_list_stmtsContext) refineStmt);
-// } else if (refineStmt instanceof Refine_leaf_list_stmtsContext) {
-// parseRefine(
-// refine,
-// (Refine_leaf_list_stmtsContext) refineStmt);
-// } else if (refineStmt instanceof Refine_choice_stmtsContext) {
-// parseRefine(refine,
-// (Refine_choice_stmtsContext) refineStmt);
-// } else if (refineStmt instanceof Refine_anyxml_stmtsContext) {
-// parseRefine(refine,
-// (Refine_anyxml_stmtsContext) refineStmt);
-// }
-// }
-// }
-// }
-// refines.add(refine);
-// }
-// }
-// return refines;
-// }
+ /**
+ * Check this base type.
+ *
+ * @param typeName
+ * base YANG type name
+ * @param moduleName
+ * name of current module
+ * @param line
+ * line in module
+ * @throws YangParseException
+ * if this is one of YANG type which MUST contain additional
+ * informations in its body
+ */
+ public static void checkMissingBody(final String typeName,
+ final String moduleName, final int line) throws YangParseException {
+ if ("decimal64".equals(typeName)) {
+ throw new YangParseException(moduleName, line,
+ "The 'fraction-digits' statement MUST be present if the type is 'decimal64'.");
+ } else if ("identityref".equals(typeName)) {
+ throw new YangParseException(moduleName, line,
+ "The 'base' statement MUST be present if the type is 'identityref'.");
+ } else if ("leafref".equals(typeName)) {
+ throw new YangParseException(moduleName, line,
+ "The 'path' statement MUST be present if the type is 'leafref'.");
+ } else if("bits".equals(typeName)) {
+ throw new YangParseException(moduleName, line,
+ "The 'bit' statement MUST be present if the type is 'bits'.");
+ } else if("enumeration".equals(typeName)) {
+ throw new YangParseException(moduleName, line,
+ "The 'enum' statement MUST be present if the type is 'enumeration'.");
+ }
+ }
public static RefineHolder parseRefine(Refine_stmtContext child) {
final String refineTarget = stringFromNode(child);
- final RefineHolder refine = new RefineHolder(refineTarget);
+ final RefineHolder refine = new RefineHolder(refineTarget, child
+ .getStart().getLine());
for (int j = 0; j < child.getChildCount(); j++) {
ParseTree refinePom = child.getChild(j);
if (refinePom instanceof Refine_pomContext) {
parseRefine(refine,
(Refine_leaf_stmtsContext) refineStmt);
} else if (refineStmt instanceof Refine_container_stmtsContext) {
- parseRefine(
- refine,
+ parseRefine(refine,
(Refine_container_stmtsContext) refineStmt);
} else if (refineStmt instanceof Refine_list_stmtsContext) {
parseRefine(refine,
(Refine_list_stmtsContext) refineStmt);
} else if (refineStmt instanceof Refine_leaf_list_stmtsContext) {
- parseRefine(
- refine,
+ parseRefine(refine,
(Refine_leaf_list_stmtsContext) refineStmt);
} else if (refineStmt instanceof Refine_choice_stmtsContext) {
parseRefine(refine,
super(errorMsg, exception);
}
+ public YangParseException(final int line, final String errorMsg) {
+ super("Error on line " + line + ": " + errorMsg);
+ }
+
+ public YangParseException(final int line, final String errorMsg,
+ final Exception exception) {
+ super("Error on line " + line + ": " + errorMsg, exception);
+ }
+
+ public YangParseException(final String moduleName, final int line,
+ final String errorMsg) {
+ super("Error in module '" + moduleName + "' on line " + line + ": "
+ + errorMsg);
+ }
+
+ public YangParseException(final String moduleName, final int line,
+ final String errorMsg, final Exception exception) {
+ super("Error in module '" + moduleName + "' on line " + line + ": "
+ + errorMsg, exception);
+ }
+
}
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Yang_version_stmtContext;
import org.opendaylight.controller.yang.model.parser.impl.YangModelParserListenerImpl;
message = parent.equals(name) ? message : ValidationUtil.f(
"(In (sub)module:%s) %s", parent, message);
+ if(statement instanceof ParserRuleContext) {
+ message = "Error on line "+ ((ParserRuleContext)statement).getStart().getLine() + ": "+ message;
+ }
+
ValidationUtil.ex(message);
}
}
*/
package org.opendaylight.controller.yang.model.validator;
-import static org.hamcrest.core.Is.*;
+import static org.hamcrest.core.Is.is;
import static org.junit.Assert.*;
-import static org.junit.matchers.JUnitMatchers.*;
+import static org.junit.matchers.JUnitMatchers.containsString;
import static org.mockito.Mockito.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
+import org.antlr.v4.runtime.Token;
import org.antlr.v4.runtime.tree.ParseTree;
import org.junit.Before;
import org.junit.Test;
int thrown = 0;
for (String id : ids) {
try {
+ Module_stmtContext module = mock(Module_stmtContext.class);
+ Token token = mock(Token.class);
+ when(module.getStart()).thenReturn(token);
BasicValidations.checkIdentifierInternal(
- mock(Module_stmtContext.class), id);
+ module, id);
} catch (YangValidationException e) {
thrown++;
}
"mod1");
addChild(mod1, augument);
+ Token token = mock(Token.class);
+ when(augument.getStart()).thenReturn(token);
+
try {
valid.enterAugment_stmt(augument);
} catch (YangValidationException e) {
type = new StringType(actualPath, namespace, revision);\r
} else if("binary".equals(typeName)) {\r
type = new BinaryType(actualPath, namespace, revision);\r
- } else if("bits".equals(typeName)) {\r
- type = new BitsType(actualPath, namespace, revision);\r
} else if("boolean".equals(typeName)) {\r
type = new BooleanType(actualPath, namespace, revision);\r
} else if("empty".equals(typeName)) {\r
Code Review / controller.git / commitdiff