@Override
public List<FlowEntry> getFlowEntriesForGroup(String policyName) {
- List<FlowEntry> list = null;
+ List<FlowEntry> list = new ArrayList<FlowEntry>();
if (this.groupFlows != null && this.groupFlows.containsKey(policyName)) {
- list = new ArrayList<FlowEntry>();
for (FlowEntryInstall entries : groupFlows.get(policyName)) {
list.add(entries.getOriginal());
}
- return new ArrayList<FlowEntry>();
}
return list;
}
*/
package org.opendaylight.controller.sal.binding.yang.types;
-import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
-import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
-import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.resolveModuleFromSchemaPath;
+import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.*;
import java.util.ArrayList;
import java.util.HashMap;
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.type.provider.TypeProvider#
* javaTypeForYangType(java.lang.String)
*/
returnType = resolveEnumFromTypeDefinition(enumTypeDef,
typedefName);
} else {
- final Module module = resolveModuleFromSchemaPath(schemaContext, typeDefinition
- .getPath());
+
+ final Module module = resolveModuleFromTypePath(schemaContext, typeDefinition);
if (module != null) {
final Map<String, GeneratedTransferObject> genTOs = genTypeDefsContextMap
if (strXPath.matches(".*//[.* | .*//].*")) {
returnType = Types.typeForClass(Object.class);
} else {
- final Module module = resolveModuleFromSchemaPath(schemaContext, leafrefType.getPath());
+ final Module module = resolveModuleFromTypePath(schemaContext, leafrefType);
if (module != null) {
final DataSchemaNode dataNode;
if (xpath.isAbsolute()) {
- dataNode = findDataSchemaNode(schemaContext,
+ dataNode = findDataSchemaNode(schemaContext,
module, xpath);
} else {
dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module,
final String enumerationName = BindingGeneratorUtil
.parseToClassName(enumName);
- Module module = resolveModuleFromSchemaPath(schemaContext, enumTypeDef.getPath());
+ Module module = resolveModuleFromTypePath(schemaContext, enumTypeDef);
+
final String basePackageName = BindingGeneratorUtil
.moduleNamespaceToPackageName(module);
final String packageName = BindingGeneratorUtil
final List<MethodSignature> networkLink2Methods = gtNetworkLink2.getMethodDefinitions();
assertNotNull("networkLink2Methods is null", networkLink2Methods);
-// FIXME: in some cases getIfcMethod is null which causes test fail. fix ASAP
-// MethodSignature getIfcMethod = null;
-// for (MethodSignature method : networkLink2Methods) {
-// if (method.getName().equals("getInterface")) {
-// getIfcMethod = method;
-// break;
-// }
-// }
-
-// assertNotNull("getIfcMethod is null", getIfcMethod);
-// assertNotNull("getIfcMethod.getReturnType() is null", getIfcMethod.getReturnType());
-// assertFalse("getIfcMethod.getReturnType() should not be Void", getIfcMethod.getReturnType().equals("java.lang.Void"));
-// assertTrue("getIfcMethod.getReturnType().getName() must be String", getIfcMethod.getReturnType().getName().equals("String"));
+
+// FIXME: in some cases getIfcMethod is null which causes test fail. fix ASAP
+// MethodSignature getIfcMethod = null;
+// for (MethodSignature method : networkLink2Methods) {
+// if (method.getName().equals("getInterface")) {
+// getIfcMethod = method;
+// break;
+// }
+// }
+//
+// assertNotNull("getIfcMethod is null", getIfcMethod);
+// assertNotNull("getIfcMethod.getReturnType() is null",
+// getIfcMethod.getReturnType());
+// assertFalse("getIfcMethod.getReturnType() should not be Void",
+// getIfcMethod.getReturnType().equals("java.lang.Void"));
+// assertTrue("getIfcMethod.getReturnType().getName() must be String",
+// getIfcMethod.getReturnType().getName().equals("String"));
}
@Test
*/
package org.opendaylight.controller.sal.binding.generator.impl;
-import org.junit.Test;
-import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
-import org.opendaylight.controller.sal.binding.model.api.*;
-import org.opendaylight.controller.yang.model.api.Module;
-import org.opendaylight.controller.yang.model.api.SchemaContext;
-import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
-import org.opendaylight.controller.yang.parser.impl.YangParserImpl;
+import static org.junit.Assert.*;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
-import static org.junit.Assert.*;
+import org.junit.Test;
+import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
+import org.opendaylight.controller.sal.binding.model.api.Enumeration;
+import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty;
+import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
+import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
+import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
+import org.opendaylight.controller.sal.binding.model.api.Type;
+import org.opendaylight.controller.yang.model.api.Module;
+import org.opendaylight.controller.yang.model.api.SchemaContext;
+import org.opendaylight.controller.yang.model.parser.api.YangModelParser;
+import org.opendaylight.controller.yang.parser.impl.YangParserImpl;
public class GeneratedTypesTest {
assertEquals(50, genTypes.size());
assertTrue(genTypes != null);
- int resolvedLeafrefCount = 0;
+ GeneratedTransferObject gtIfcKey = null;
+ GeneratedType gtIfc = null;
+ GeneratedType gtNetworkLink = null;
+ GeneratedType gtSource = null;
+ GeneratedType gtDest = null;
+ GeneratedType gtTunnel = null;
+ GeneratedTransferObject gtTunnelKey = null;
for (final Type type : genTypes) {
- if (type.getName().equals("InterfaceKey")
- && type instanceof GeneratedTransferObject) {
- final GeneratedTransferObject genTO = (GeneratedTransferObject) type;
- final List<GeneratedProperty> properties = genTO
- .getProperties();
-
- assertTrue(properties != null);
- for (final GeneratedProperty property : properties) {
- if (property.getName().equals("InterfaceId")) {
- assertTrue(property.getReturnType() != null);
- assertFalse(property.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(property.getReturnType().getName()
- .equals("String"));
- resolvedLeafrefCount++;
- }
- }
-
- } else if (type.getName().equals("Interface")
- && type instanceof GeneratedType) {
- final GeneratedType genType = (GeneratedType) type;
- final List<MethodSignature> methods = genType
- .getMethodDefinitions();
-
- assertTrue(methods != null);
- for (final MethodSignature method : methods) {
- if (method.getName().equals("getInterfaceKey")) {
- assertTrue(method.getReturnType() != null);
- assertFalse(method.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(method.getReturnType().getName()
- .equals("InterfaceKey"));
- resolvedLeafrefCount++;
- } else if (method.getName().equals("getHigherLayerIf")) {
- assertTrue(method.getReturnType() != null);
- assertFalse(method.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(method.getReturnType().getName()
- .equals("List"));
- resolvedLeafrefCount++;
- }
- }
- } else if (type.getName().equals("NetworkLink")
- && type instanceof GeneratedType) {
- final GeneratedType genType = (GeneratedType) type;
- final List<MethodSignature> methods = genType
- .getMethodDefinitions();
- assertTrue(methods != null);
- for (MethodSignature method : methods) {
- if (method.getName().equals("getInterface")) {
- assertTrue(method.getReturnType() != null);
- assertFalse(method.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(method.getReturnType().getName()
- .equals("String"));
- resolvedLeafrefCount++;
- }
- }
- } else if ((type.getName().equals("SourceNode") || type.getName()
- .equals("DestinationNode"))
- && type instanceof GeneratedType) {
- final GeneratedType genType = (GeneratedType) type;
- final List<MethodSignature> methods = genType
- .getMethodDefinitions();
- assertTrue(methods != null);
- for (MethodSignature method : methods) {
- if (method.getName().equals("getId")) {
- assertTrue(method.getReturnType() != null);
- assertFalse(method.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(method.getReturnType().getName()
- .equals("Uri"));
- resolvedLeafrefCount++;
- }
- }
- } else if (type.getName().equals("Tunnel")
- && type instanceof GeneratedType) {
- final GeneratedType genType = (GeneratedType) type;
- final List<MethodSignature> methods = genType
- .getMethodDefinitions();
- assertTrue(methods != null);
- for (MethodSignature method : methods) {
- if (method.getName().equals("getTunnelKey")) {
- assertTrue(method.getReturnType() != null);
- assertFalse(method.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(method.getReturnType().getName()
- .equals("TunnelKey"));
- resolvedLeafrefCount++;
- }
- }
- } else if (type.getName().equals("TunnelKey")
- && type instanceof GeneratedTransferObject) {
- final GeneratedTransferObject genTO = (GeneratedTransferObject) type;
- final List<GeneratedProperty> properties = genTO
- .getProperties();
+ String name = type.getName();
+ if ("InterfaceKey".equals(name)) {
+ gtIfcKey = (GeneratedTransferObject) type;
+ } else if ("Interface".equals(name)) {
+ gtIfc = (GeneratedType) type;
+ } else if ("NetworkLink".equals(name)) {
+ gtNetworkLink = (GeneratedType) type;
+ } else if ("SourceNode".equals(name)) {
+ gtSource = (GeneratedType) type;
+ } else if ("DestinationNode".equals(name)) {
+ gtDest = (GeneratedType) type;
+ } else if ("Tunnel".equals(name)) {
+ gtTunnel = (GeneratedType) type;
+ } else if ("TunnelKey".equals(name)) {
+ gtTunnelKey = (GeneratedTransferObject) type;
+ }
+ }
- assertTrue(properties != null);
- for (final GeneratedProperty property : properties) {
- if (property.getName().equals("TunnelId")) {
- assertTrue(property.getReturnType() != null);
- assertFalse(property.getReturnType().equals(
- "java.lang.Void"));
- assertTrue(property.getReturnType().getName()
- .equals("Uri"));
- resolvedLeafrefCount++;
- }
- }
+ assertNotNull(gtIfcKey);
+ assertNotNull(gtIfc);
+ assertNotNull(gtNetworkLink);
+ assertNotNull(gtSource);
+ assertNotNull(gtDest);
+ assertNotNull(gtTunnel);
+ assertNotNull(gtTunnelKey);
+
+ // InterfaceId
+ final List<GeneratedProperty> gtIfcKeyProps = gtIfcKey.getProperties();
+ assertNotNull(gtIfcKeyProps);
+ GeneratedProperty ifcIdProp = null;
+ for (final GeneratedProperty property : gtIfcKeyProps) {
+ if (property.getName().equals("InterfaceId")) {
+ ifcIdProp = property;
+ }
+ }
+ assertNotNull(ifcIdProp);
+ Type ifcIdPropType = ifcIdProp.getReturnType();
+ assertNotNull(ifcIdPropType);
+ assertFalse(ifcIdPropType.equals("java.lang.Void"));
+ assertTrue(ifcIdPropType.getName().equals("String"));
+
+ // Interface
+ final List<MethodSignature> gtIfcMethods = gtIfc.getMethodDefinitions();
+ assertNotNull(gtIfcMethods);
+ MethodSignature getIfcKey = null;
+ MethodSignature getHigherLayerIf = null;
+ for (final MethodSignature method : gtIfcMethods) {
+ if (method.getName().equals("getInterfaceKey")) {
+ getIfcKey = method;
+ } else if (method.getName().equals("getHigherLayerIf")) {
+ getHigherLayerIf = method;
+ }
+ }
+ assertNotNull(getIfcKey);
+ Type getIfcKeyType = getIfcKey.getReturnType();
+ assertNotNull(getIfcKeyType);
+ assertFalse(getIfcKeyType.equals("java.lang.Void"));
+ assertTrue(getIfcKeyType.getName().equals("InterfaceKey"));
+
+ assertNotNull(getHigherLayerIf);
+ Type getHigherLayerIfType = getHigherLayerIf.getReturnType();
+ assertNotNull(getHigherLayerIfType);
+ assertFalse(getHigherLayerIfType.equals("java.lang.Void"));
+ assertTrue(getHigherLayerIfType.getName().equals("List"));
+
+ // NetworkLink
+ final List<MethodSignature> gtNetworkLinkMethods = gtNetworkLink
+ .getMethodDefinitions();
+ assertNotNull(gtNetworkLinkMethods);
+ MethodSignature getIfc = null;
+ for (MethodSignature method : gtNetworkLinkMethods) {
+ if (method.getName().equals("getInterface")) {
+ getIfc = method;
+ }
+ }
+ assertNotNull(getIfc);
+ Type getIfcType = getIfc.getReturnType();
+ assertNotNull(getIfcType);
+ assertFalse(getIfcType.equals("java.lang.Void"));
+ assertTrue(getIfcType.getName().equals("String"));
+
+ // SourceNode
+ final List<MethodSignature> gtSourceMethods = gtSource
+ .getMethodDefinitions();
+ assertNotNull(gtSourceMethods);
+ MethodSignature getIdSource = null;
+ for (MethodSignature method : gtSourceMethods) {
+ if (method.getName().equals("getId")) {
+ getIdSource = method;
+ }
+ }
+ assertNotNull(getIdSource);
+ Type getIdType = getIdSource.getReturnType();
+ assertNotNull(getIdType);
+ assertFalse(getIdType.equals("java.lang.Void"));
+ assertTrue(getIdType.getName().equals("Uri"));
+
+ // DestinationNode
+ final List<MethodSignature> gtDestMethods = gtDest
+ .getMethodDefinitions();
+ assertNotNull(gtDestMethods);
+ MethodSignature getIdDest = null;
+ for (MethodSignature method : gtDestMethods) {
+ if (method.getName().equals("getId")) {
+ getIdDest = method;
+ }
+ }
+ assertNotNull(getIdDest);
+ Type getIdDestType = getIdDest.getReturnType();
+ assertNotNull(getIdDestType);
+ assertFalse(getIdDestType.equals("java.lang.Void"));
+ assertTrue(getIdDestType.getName().equals("Uri"));
+
+ // Tunnel
+ final List<MethodSignature> gtTunnelMethods = gtTunnel
+ .getMethodDefinitions();
+ assertNotNull(gtTunnelMethods);
+ MethodSignature getTunnelKey = null;
+ for (MethodSignature method : gtTunnelMethods) {
+ if (method.getName().equals("getTunnelKey")) {
+ getTunnelKey = method;
+ }
+ }
+ assertNotNull(getTunnelKey);
+ Type getTunnelKeyType = getTunnelKey.getReturnType();
+ assertNotNull(getTunnelKeyType);
+ assertFalse(getTunnelKeyType.equals("java.lang.Void"));
+ assertTrue(getTunnelKeyType.getName().equals("TunnelKey"));
+
+ // TunnelKey
+ final List<GeneratedProperty> gtTunnelKeyProps = gtTunnelKey
+ .getProperties();
+ assertNotNull(gtTunnelKeyProps);
+ GeneratedProperty tunnelId = null;
+ for (final GeneratedProperty property : gtTunnelKeyProps) {
+ if (property.getName().equals("TunnelId")) {
+ tunnelId = property;
}
}
- assertEquals(10, resolvedLeafrefCount);
+ assertNotNull(tunnelId);
+ Type tunnelIdType = tunnelId.getReturnType();
+ assertNotNull(tunnelIdType);
+ assertFalse(tunnelIdType.equals("java.lang.Void"));
+ assertTrue(tunnelIdType.getName().equals("Uri"));
}
@Test
int genTypesCount = 0;
int genTOsCount = 0;
for (final Type type : genTypes) {
- if (type instanceof GeneratedType &&
- !(type instanceof GeneratedTransferObject)) {
+ if (type instanceof GeneratedType
+ && !(type instanceof GeneratedTransferObject)) {
final GeneratedType genType = (GeneratedType) type;
if (genType.getName().equals("ListParentContainer")) {
assertEquals(2, genType.getMethodDefinitions().size());
int genTypesCount = 0;
int genTOsCount = 0;
for (final Type type : genTypes) {
- if (type instanceof GeneratedType &&
- !(type instanceof GeneratedTransferObject)) {
+ if (type instanceof GeneratedType
+ && !(type instanceof GeneratedTransferObject)) {
genTypesCount++;
} else if (type instanceof GeneratedTransferObject) {
final GeneratedTransferObject genTO = (GeneratedTransferObject) type;
int genTypesCount = 0;
int genTOsCount = 0;
for (final Type type : genTypes) {
- if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
+ if (type instanceof GeneratedType
+ && !(type instanceof GeneratedTransferObject)) {
genTypesCount++;
} else if (type instanceof GeneratedTransferObject) {
genTOsCount++;
import org.junit.After;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
assertTrue(filesList.contains("Type3.java"));
}
+ @Ignore
@Test
public void compilationTest() throws Exception {
final YangParserImpl parser = new YangParserImpl();
*/
package org.opendaylight.controller.yang.parser.builder.api;
+import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
/**
*/
public interface TypeAwareBuilder extends Builder {
+ QName getQName();
+
TypeDefinition<?> getType();
TypeDefinitionBuilder getTypedef();
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public class AnyXmlBuilder implements DataSchemaNodeBuilder {
+public final class AnyXmlBuilder implements DataSchemaNodeBuilder {
private boolean built;
private final int line;
private final QName qname;
import org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public class AugmentationSchemaBuilderImpl implements AugmentationSchemaBuilder {
+public final class AugmentationSchemaBuilderImpl implements AugmentationSchemaBuilder {
private boolean built;
private final AugmentationSchemaImpl instance;
private final int line;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public class ChoiceBuilder implements DataSchemaNodeBuilder, ChildNodeBuilder,
- AugmentationTargetBuilder {
+public final class ChoiceBuilder implements DataSchemaNodeBuilder,
+ ChildNodeBuilder, AugmentationTargetBuilder {
private boolean built;
private final ChoiceNodeImpl instance;
private final int line;
return new HashSet<DataSchemaNodeBuilder>(cases);
}
- private class ChoiceNodeImpl implements ChoiceNode {
+ private final class ChoiceNodeImpl implements ChoiceNode {
private final QName qname;
private SchemaPath path;
private String description;
return augmentations;
}
- private class ChoiceCaseNodeImpl implements ChoiceCaseNode {
+ private final class ChoiceCaseNodeImpl implements ChoiceCaseNode {
private final QName qname;
private SchemaPath path;
private String description;
}
}
+ /**
+ * Always returns an empty set, because case node can not contains type
+ * definitions.
+ */
@Override
public Set<TypeDefinition<?>> getTypeDefinitions() {
return Collections.emptySet();
import org.opendaylight.controller.yang.model.util.RevisionAwareXPathImpl;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
-public class ConstraintsBuilder implements Builder {
+public final class ConstraintsBuilder implements Builder {
private final ConstraintDefinitionImpl instance;
private final int line;
private final Set<MustDefinition> mustDefinitions;
this.mandatory = mandatory;
}
- private static class ConstraintDefinitionImpl implements
+ private final class ConstraintDefinitionImpl implements
ConstraintDefinition {
private RevisionAwareXPath whenCondition;
private Set<MustDefinition> mustConstraints;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public class ContainerSchemaNodeBuilder extends AbstractChildNodeBuilder
+public final class ContainerSchemaNodeBuilder extends AbstractChildNodeBuilder
implements TypeDefinitionAwareBuilder, AugmentationTargetBuilder,
DataSchemaNodeBuilder {
- private boolean built;
+ private boolean isBuilt;
private final ContainerSchemaNodeImpl instance;
private final int line;
private final ConstraintsBuilder constraints;
@Override
public ContainerSchemaNode build() {
- if(!built) {
+ if (!isBuilt) {
instance.setPath(schemaPath);
instance.setDescription(description);
instance.setReference(reference);
// AUGMENTATIONS
final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for(AugmentationSchemaBuilder builder : addedAugmentations) {
+ for (AugmentationSchemaBuilder builder : addedAugmentations) {
augmentations.add(builder.build());
}
instance.setAvailableAugmentations(augmentations);
instance.setConstraints(constraints.build());
instance.setAvailableAugmentations(augmentations);
- built = true;
+ isBuilt = true;
}
return instance;
}
@Override
public void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
addedUnknownNodes.add(unknownNode);
}
- private class ContainerSchemaNodeImpl implements ContainerSchemaNode {
+ private final class ContainerSchemaNodeImpl implements ContainerSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
}
private void setStatus(Status status) {
- if(status != null) {
+ if (status != null) {
this.status = status;
}
}
import org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public class DeviationBuilder implements Builder {
+public final class DeviationBuilder implements Builder {
private final DeviationImpl instance;
private final int line;
instance.setReference(reference);
}
- private class DeviationImpl implements Deviation {
+ private final class DeviationImpl implements Deviation {
private final SchemaPath targetPath;
private Deviate deviate;
private String reference;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
-public class ExtensionBuilder implements SchemaNodeBuilder {
+public final class ExtensionBuilder implements SchemaNodeBuilder {
+ private boolean isBuilt;
private final ExtensionDefinitionImpl instance;
private final int line;
private final QName qname;
@Override
public ExtensionDefinition build() {
- instance.setPath(schemaPath);
+ if(!isBuilt) {
+ instance.setPath(schemaPath);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> extensions = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder e : addedExtensions) {
- extensions.add(e.build());
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> extensions = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder e : addedExtensions) {
+ extensions.add(e.build());
+ }
+ instance.setUnknownSchemaNodes(extensions);
+
+ isBuilt = true;
}
- instance.setUnknownSchemaNodes(extensions);
return instance;
}
addedUnknownNodes.add(unknownNode);
}
- private class ExtensionDefinitionImpl implements ExtensionDefinition {
+ private final class ExtensionDefinitionImpl implements ExtensionDefinition {
private final QName qname;
private String argument;
private SchemaPath schemaPath;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
-public class FeatureBuilder implements SchemaNodeBuilder {
+public final class FeatureBuilder implements SchemaNodeBuilder {
+ private boolean isBuilt;
private final FeatureDefinitionImpl instance;
private final int line;
private final QName qname;
@Override
public FeatureDefinitionImpl build() {
- instance.setPath(schemaPath);
+ if(!isBuilt) {
+ instance.setPath(schemaPath);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
+ isBuilt = true;
+ }
return instance;
}
addedUnknownNodes.add(unknownNode);
}
- private class FeatureDefinitionImpl implements FeatureDefinition {
+ private final class FeatureDefinitionImpl implements FeatureDefinition {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public class GroupingBuilderImpl implements GroupingBuilder {
- private boolean built;
+public final class GroupingBuilderImpl implements GroupingBuilder {
+ private boolean isBuilt;
private final GroupingDefinitionImpl instance;
private final int line;
private final QName qname;
@Override
public GroupingDefinition build() {
- if (!built) {
+ if (!isBuilt) {
instance.setPath(schemaPath);
instance.setDescription(description);
instance.setReference(reference);
}
instance.setUnknownSchemaNodes(unknownNodes);
- built = true;
+ isBuilt = true;
}
return instance;
addedUnknownNodes.add(unknownNode);
}
- private static class GroupingDefinitionImpl implements GroupingDefinition {
+ private final class GroupingDefinitionImpl implements GroupingDefinition {
private final QName qname;
private SchemaPath path;
private String description;
* When build is called, types in builder form will be built and add to resolved
* types.
*/
-public class IdentityrefTypeBuilder extends AbstractTypeAwareBuilder implements
- TypeDefinitionBuilder {
+public final class IdentityrefTypeBuilder extends AbstractTypeAwareBuilder
+ implements TypeDefinitionBuilder {
private static final String NAME = "identityref";
private final int line;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
-public class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder
+public final class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder
implements SchemaNodeBuilder, DataSchemaNodeBuilder {
- private boolean built;
+ private boolean isBuilt;
private final LeafListSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public LeafListSchemaNode build() {
- if (!built) {
+ if (!isBuilt) {
instance.setConstraints(constraints.build());
instance.setPath(schemaPath);
instance.setDescription(description);
}
instance.setUnknownSchemaNodes(unknownNodes);
- built = true;
+ isBuilt = true;
}
return instance;
}
addedUnknownNodes.add(unknownNode);
}
- private class LeafListSchemaNodeImpl implements LeafListSchemaNode {
+ private final class LeafListSchemaNodeImpl implements LeafListSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
-public class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements
- DataSchemaNodeBuilder, SchemaNodeBuilder {
- private boolean built;
+public final class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder
+ implements DataSchemaNodeBuilder, SchemaNodeBuilder {
+ private boolean isBuilt;
private final LeafSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public LeafSchemaNode build() {
- if(!built) {
+ if (!isBuilt) {
instance.setPath(path);
instance.setConstraints(constraints.build());
instance.setDescription(description);
}
instance.setUnknownSchemaNodes(unknownNodes);
- built = true;
+ isBuilt = true;
}
return instance;
}
this.augmenting = augmenting;
}
-
-
public boolean isConfiguration() {
return configuration;
}
this.unitsStr = unitsStr;
}
- private class LeafSchemaNodeImpl implements LeafSchemaNode {
+ private final class LeafSchemaNodeImpl implements LeafSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public class ListSchemaNodeBuilder extends AbstractChildNodeBuilder implements
- DataSchemaNodeBuilder, AugmentationTargetBuilder,
+public final class ListSchemaNodeBuilder extends AbstractChildNodeBuilder
+ implements DataSchemaNodeBuilder, AugmentationTargetBuilder,
TypeDefinitionAwareBuilder {
- private boolean built;
+ private boolean isBuilt;
private final ListSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public ListSchemaNode build() {
- if(!built) {
+ if (!isBuilt) {
instance.setKeyDefinition(keyDefinition);
instance.setPath(schemaPath);
instance.setDescription(description);
instance.setConstraints(constraints.build());
instance.setAvailableAugmentations(augmentations);
- built = true;
+ isBuilt = true;
}
return instance;
}
addedUnknownNodes.add(unknownNode);
}
- private class ListSchemaNodeImpl implements ListSchemaNode {
+ private final class ListSchemaNodeImpl implements ListSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
parent.setType(type);
}
- public void addUnionType(final List<String> actualPath,
+ public UnionTypeBuilder addUnionType(final List<String> actualPath,
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, line);
+ UnionTypeBuilder union = new UnionTypeBuilder(line);
parent.setType(union);
List<String> path = new ArrayList<String>(pathToUnion);
path.add("union");
moduleNodes.put(path, union);
+ return union;
}
public void addIdentityrefType(final String baseString,
return builder;
}
- private class ModuleImpl implements Module {
+ private final class ModuleImpl implements Module {
private URI namespace;
private final String name;
private Date revision;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
-public class NotificationBuilder extends AbstractChildNodeBuilder implements
- TypeDefinitionAwareBuilder, SchemaNodeBuilder {
- private boolean built;
+public final class NotificationBuilder extends AbstractChildNodeBuilder
+ implements TypeDefinitionAwareBuilder, SchemaNodeBuilder {
+ private boolean isBuilt;
private final NotificationDefinitionImpl instance;
private final int line;
private SchemaPath schemaPath;
@Override
public SchemaNode build() {
- if(!built) {
+ if (!isBuilt) {
instance.setPath(schemaPath);
// CHILD NODES
}
instance.setUnknownSchemaNodes(unknownNodes);
- built = true;
+ isBuilt = true;
}
return instance;
addedUnknownNodes.add(unknownNode);
}
- private class NotificationDefinitionImpl implements NotificationDefinition {
+ private final class NotificationDefinitionImpl implements NotificationDefinition {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
-public class RpcDefinitionBuilder implements SchemaNodeBuilder,
+public final class RpcDefinitionBuilder implements SchemaNodeBuilder,
TypeDefinitionAwareBuilder {
- private boolean built;
+ private boolean isBuilt;
private final RpcDefinitionImpl instance;
private final int line;
private final QName qname;
@Override
public RpcDefinition build() {
- if(!built) {
+ if (!isBuilt) {
final ContainerSchemaNode input = inputBuilder.build();
final ContainerSchemaNode output = outputBuilder.build();
instance.setInput(input);
}
instance.setUnknownSchemaNodes(unknownNodes);
- built = true;
+ isBuilt = true;
}
return instance;
}
return true;
}
- private class RpcDefinitionImpl implements RpcDefinition {
+ private final class RpcDefinitionImpl implements RpcDefinition {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.util.YangParseException;
-public class TypedefBuilder extends AbstractTypeAwareBuilder implements
+public final class TypedefBuilder extends AbstractTypeAwareBuilder implements
TypeDefinitionBuilder {
private final int line;
private final QName qname;
*/
package org.opendaylight.controller.yang.parser.builder.impl;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
* When build is called, types in builder form will be built and add to resolved
* types.
*/
-public class UnionTypeBuilder extends AbstractTypeAwareBuilder implements
+public final class UnionTypeBuilder extends AbstractTypeAwareBuilder implements
TypeDefinitionBuilder {
private final static String NAME = "union";
private final int line;
private final List<TypeDefinition<?>> types;
private final List<TypeDefinitionBuilder> typedefs;
- private final UnionType instance;
- private boolean built;
+ private UnionType instance;
+ private boolean isBuilt;
- private final List<String> actualPath;
- private final URI namespace;
- private final Date revision;
+ private SchemaPath path;
- public UnionTypeBuilder(final List<String> actualPath, final URI namespace,
- final Date revision, final int line) {
+ public UnionTypeBuilder(final int line) {
this.line = line;
types = new ArrayList<TypeDefinition<?>>();
typedefs = new ArrayList<TypeDefinitionBuilder>();
- instance = new UnionType(actualPath, namespace, revision, types);
-
- this.actualPath = actualPath;
- this.namespace = namespace;
- this.revision = revision;
}
@Override
@Override
public UnionType build() {
- if (built) {
- return instance;
- } else {
+ if (!isBuilt) {
+ instance = new UnionType(path, types);
for (TypeDefinitionBuilder tdb : typedefs) {
types.add(tdb.build());
}
- built = true;
- return instance;
+ isBuilt = true;
}
+ return instance;
}
@Override
public void setPath(final SchemaPath schemaPath) {
- throw new YangParseException(line, "Can not set path to " + NAME);
+ this.path = schemaPath;
}
@Override
throw new YangParseException(line, "Can not set units to " + NAME);
}
- public List<String> getActualPath() {
- return actualPath;
- }
-
- public URI getNamespace() {
- return namespace;
- }
-
- public Date getRevision() {
- return revision;
- }
-
@Override
public String toString() {
final StringBuilder result = new StringBuilder(
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
-public class UnknownSchemaNodeBuilder implements SchemaNodeBuilder {
+public final class UnknownSchemaNodeBuilder implements SchemaNodeBuilder {
+ private boolean isBuilt;
private final UnknownSchemaNodeImpl instance;
private final int line;
private final QName qname;
@Override
public UnknownSchemaNode build() {
- instance.setPath(schemaPath);
- instance.setNodeType(nodeType);
- instance.setNodeParameter(nodeParameter);
+ if(!isBuilt) {
+ instance.setPath(schemaPath);
+ instance.setNodeType(nodeType);
+ instance.setNodeParameter(nodeParameter);
+
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
+ isBuilt = true;
}
- instance.setUnknownSchemaNodes(unknownNodes);
+
return instance;
}
this.nodeParameter = nodeParameter;
}
- private static class UnknownSchemaNodeImpl implements UnknownSchemaNode {
+ private final class UnknownSchemaNodeImpl implements UnknownSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.util.RefineHolder;\r
\r
public final class UsesNodeBuilderImpl implements UsesNodeBuilder {\r
- private boolean built;\r
+ private boolean isBuilt;\r
private final UsesNodeImpl instance;\r
private final int line;\r
private final String groupingPathStr;\r
\r
@Override\r
public UsesNode build() {\r
- if (!built) {\r
+ if (!isBuilt) {\r
instance.setAugmenting(augmenting);\r
\r
// AUGMENTATIONS\r
}\r
instance.setRefines(refineNodes);\r
\r
- built = true;\r
+ isBuilt = true;\r
}\r
return instance;\r
}\r
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class YangParserImpl implements YangModelParser {
+public final class YangParserImpl implements YangModelParser {
private static final Logger logger = LoggerFactory
.getLogger(YangParserImpl.class);
final TypeDefinitionBuilder old, final boolean seekByTypedefBuilder) {
if (old instanceof UnionTypeBuilder) {
final UnionTypeBuilder oldUnion = (UnionTypeBuilder) old;
- final UnionTypeBuilder newUnion = new UnionTypeBuilder(
- oldUnion.getActualPath(), oldUnion.getNamespace(),
- oldUnion.getRevision(), old.getLine());
+ final UnionTypeBuilder newUnion = new UnionTypeBuilder(old.getLine());
for (TypeDefinition<?> td : oldUnion.getTypes()) {
newUnion.setType(td);
}
for (TypeDefinitionBuilder tdb : oldUnion.getTypedefs()) {
newUnion.setType(copyTypedefBuilder(tdb, true));
}
+ newUnion.setPath(old.getPath());
return newUnion;
}
import org.opendaylight.controller.yang.parser.builder.impl.NotificationBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.RpcDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.TypedefBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.UnionTypeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.util.RefineHolder;
import org.slf4j.Logger;
moduleBuilder.setType(type, actualPath);
} else {
if ("union".equals(typeName)) {
- moduleBuilder.addUnionType(actualPath, namespace, revision,
+ List<String> typePath = new ArrayList<String>(actualPath);
+ typePath.add(typeName);
+
+ SchemaPath p = createActualSchemaPath(typePath, namespace, revision, yangModelPrefix);
+ UnionTypeBuilder unionBuilder = moduleBuilder.addUnionType(actualPath, namespace, revision,
line);
+ unionBuilder.setPath(p);
} else if ("identityref".equals(typeName)) {
SchemaPath path = createActualSchemaPath(actualPath,
namespace, revision, yangModelPrefix);
line);
} else {
List<String> typePath = new ArrayList<String>(actualPath);
- typePath.remove(0);
+ typePath.add(typeName);
+
type = parseTypeBody(typeName, typeBody, typePath,
namespace, revision, yangModelPrefix);
moduleBuilder.setType(type, actualPath);
package org.opendaylight.controller.yang.parser.util;
import java.lang.reflect.Method;
+import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.yang.model.api.MustDefinition;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BinaryTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.BooleanTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.DecimalTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EmptyTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
+import org.opendaylight.controller.yang.model.api.type.IdentityrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.InstanceIdentifierTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.LengthConstraint;
+import org.opendaylight.controller.yang.model.api.type.PatternConstraint;
+import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
+import org.opendaylight.controller.yang.model.api.type.StringTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition;
+import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
+import org.opendaylight.controller.yang.model.util.BinaryType;
+import org.opendaylight.controller.yang.model.util.BitsType;
+import org.opendaylight.controller.yang.model.util.BooleanType;
+import org.opendaylight.controller.yang.model.util.Decimal64;
+import org.opendaylight.controller.yang.model.util.EmptyType;
+import org.opendaylight.controller.yang.model.util.EnumerationType;
+import org.opendaylight.controller.yang.model.util.IdentityrefType;
+import org.opendaylight.controller.yang.model.util.InstanceIdentifier;
+import org.opendaylight.controller.yang.model.util.Int16;
+import org.opendaylight.controller.yang.model.util.Int32;
+import org.opendaylight.controller.yang.model.util.Int64;
+import org.opendaylight.controller.yang.model.util.Int8;
+import org.opendaylight.controller.yang.model.util.Leafref;
+import org.opendaylight.controller.yang.model.util.StringType;
+import org.opendaylight.controller.yang.model.util.UnionType;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.builder.api.ChildNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.TypeAwareBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
final ChildNodeBuilder target) {
for (DataSchemaNodeBuilder builder : augment.getChildNodes()) {
builder.setAugmenting(true);
- correctPath(augment, target.getPath());
+ correctAugmentChildPath(augment, target.getPath());
target.addChildNode(builder);
}
}
- private static void correctPath(final ChildNodeBuilder node,
+ private static void correctAugmentChildPath(final ChildNodeBuilder node,
final SchemaPath parentSchemaPath) {
for (DataSchemaNodeBuilder builder : node.getChildNodes()) {
// add correct path
- SchemaPath targetNodeSchemaPath = parentSchemaPath;
List<QName> targetNodePath = new ArrayList<QName>(
- targetNodeSchemaPath.getPath());
+ parentSchemaPath.getPath());
targetNodePath.add(builder.getQName());
builder.setPath(new SchemaPath(targetNodePath, true));
if (builder instanceof ChildNodeBuilder) {
ChildNodeBuilder cnb = (ChildNodeBuilder) builder;
- correctPath(cnb, builder.getPath());
+ correctAugmentChildPath(cnb, builder.getPath());
}
+
+ // if child can contains type, correct path for this type too
+ if(builder instanceof TypeAwareBuilder) {
+ TypeAwareBuilder nodeBuilder = (TypeAwareBuilder)builder;
+ QName nodeBuilderQName = nodeBuilder.getQName();
+ TypeDefinition<?> nodeBuilderType = nodeBuilder.getType();
+ if(nodeBuilderType != null) {
+ TypeDefinition<?> newType = createCorrectTypeDefinition(parentSchemaPath, nodeBuilderQName, nodeBuilderType);
+ nodeBuilder.setType(newType);
+ } else {
+ TypeDefinitionBuilder nodeBuilderTypedef = nodeBuilder.getTypedef();
+ SchemaPath newSchemaPath = createNewSchemaPath(nodeBuilderTypedef.getPath(), nodeBuilderQName, nodeBuilderTypedef.getQName());
+ nodeBuilderTypedef.setPath(newSchemaPath);
+ }
+ }
+ }
+ }
+
+ private static TypeDefinition<?> createCorrectTypeDefinition(SchemaPath parentSchemaPath, QName nodeQName, TypeDefinition<?> nodeType) {
+ TypeDefinition<?> result = null;
+ SchemaPath newSchemaPath = null;
+ if(nodeType != null) {
+ if(nodeType instanceof BinaryTypeDefinition) {
+ BinaryTypeDefinition binType = (BinaryTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, binType.getQName());
+ List<Byte> bytes = (List<Byte>)binType.getDefaultValue();
+ result = new BinaryType(newSchemaPath, bytes, binType.getLengthConstraints(), binType.getUnits());
+ } else if(nodeType instanceof BitsTypeDefinition) {
+ BitsTypeDefinition bitsType = (BitsTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, nodeType.getQName());
+ result = new BitsType(newSchemaPath, bitsType.getBits(), bitsType.getUnits());
+ } else if(nodeType instanceof BooleanTypeDefinition) {
+ BooleanTypeDefinition booleanType = (BooleanTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, booleanType.getQName());
+ result = new BooleanType(newSchemaPath, (Boolean)booleanType.getDefaultValue(), booleanType.getUnits());
+ } else if(nodeType instanceof DecimalTypeDefinition) {
+ DecimalTypeDefinition decimalType = (DecimalTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, decimalType.getQName());
+ BigDecimal defaultValue = (BigDecimal)decimalType.getDefaultValue();
+ result = new Decimal64(newSchemaPath, decimalType.getUnits(), defaultValue, decimalType.getRangeStatements(), decimalType.getFractionDigits());
+ } else if(nodeType instanceof EmptyTypeDefinition) {
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, nodeType.getQName());
+ result = new EmptyType(newSchemaPath);
+ } else if(nodeType instanceof EnumTypeDefinition) {
+ EnumTypeDefinition enumType = (EnumTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, enumType.getQName());
+ result = new EnumerationType(newSchemaPath, (EnumPair)enumType.getDefaultValue(), enumType.getValues(), enumType.getUnits());
+ } else if(nodeType instanceof IdentityrefTypeDefinition) {
+ IdentityrefTypeDefinition idrefType = (IdentityrefTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, idrefType.getQName());
+ result = new IdentityrefType(idrefType.getIdentity(), newSchemaPath);
+ } else if(nodeType instanceof InstanceIdentifierTypeDefinition) {
+ InstanceIdentifierTypeDefinition instIdType = (InstanceIdentifierTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, instIdType.getQName());
+ return new InstanceIdentifier(newSchemaPath, instIdType.getPathStatement(), instIdType.requireInstance());
+ } else if(nodeType instanceof StringTypeDefinition) {
+ result = copyStringType(parentSchemaPath, nodeQName, (StringTypeDefinition)nodeType);
+ } else if(nodeType instanceof IntegerTypeDefinition) {
+ result = copyIntType(parentSchemaPath, nodeQName, (IntegerTypeDefinition)nodeType);
+ } else if(nodeType instanceof UnsignedIntegerTypeDefinition) {
+ result = copyUIntType(parentSchemaPath, nodeQName, (UnsignedIntegerTypeDefinition)nodeType);
+ } else if(nodeType instanceof LeafrefTypeDefinition) {
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, nodeType.getQName());
+ result = new Leafref(newSchemaPath, ((LeafrefTypeDefinition)nodeType).getPathStatement());
+ } else if(nodeType instanceof UnionTypeDefinition) {
+ UnionTypeDefinition unionType = (UnionTypeDefinition)nodeType;
+ newSchemaPath = createNewSchemaPath(parentSchemaPath, nodeQName, unionType.getQName());
+ return new UnionType(newSchemaPath, unionType.getTypes());
+ }
+ }
+ return result;
+ }
+
+ private static TypeDefinition<?> copyStringType(SchemaPath schemaPath, QName nodeQName, StringTypeDefinition nodeType) {
+ List<QName> path = schemaPath.getPath();
+ List<QName> newPath = new ArrayList<QName>(path);
+ newPath.add(nodeQName);
+ newPath.add(nodeType.getQName());
+ SchemaPath newSchemaPath = new SchemaPath(newPath, schemaPath.isAbsolute());
+
+ String newDefault = nodeType.getDefaultValue().toString();
+ String newUnits = nodeType.getUnits();
+ List<LengthConstraint> lengths = nodeType.getLengthStatements();
+ List<PatternConstraint> patterns = nodeType.getPatterns();
+
+ return new StringType(newSchemaPath, newDefault, lengths, patterns, newUnits);
+ }
+
+ private static TypeDefinition<?> copyIntType(SchemaPath schemaPath, QName nodeQName, IntegerTypeDefinition type) {
+ QName typeQName = type.getQName();
+ SchemaPath newSchemaPath = createNewSchemaPath(schemaPath, nodeQName, typeQName);
+
+ String localName = typeQName.getLocalName();
+ List<RangeConstraint> ranges = type.getRangeStatements();
+ String units = type.getUnits();
+
+ if("int8".equals(localName)) {
+ Byte defaultValue = (Byte)type.getDefaultValue();
+ return new Int8(newSchemaPath, ranges, units, defaultValue);
+ } else if("int16".equals(localName)) {
+ Short defaultValue = (Short)type.getDefaultValue();
+ return new Int16(newSchemaPath, ranges, units, defaultValue);
+ } else if("int32".equals(localName)) {
+ Integer defaultValue = (Integer)type.getDefaultValue();
+ return new Int32(newSchemaPath, ranges, units, defaultValue);
+ } else if("int64".equals(localName)) {
+ Long defaultValue = (Long)type.getDefaultValue();
+ return new Int64(newSchemaPath, ranges, units, defaultValue);
+ } else {
+ return null;
}
}
+ private static TypeDefinition<?> copyUIntType(SchemaPath schemaPath, QName nodeQName, UnsignedIntegerTypeDefinition type) {
+ QName typeQName = type.getQName();
+ SchemaPath newSchemaPath = createNewSchemaPath(schemaPath, nodeQName, typeQName);
+
+ String localName = typeQName.getLocalName();
+ List<RangeConstraint> ranges = type.getRangeStatements();
+ String units = type.getUnits();
+
+ if("uint8".equals(localName)) {
+ Byte defaultValue = (Byte)type.getDefaultValue();
+ return new Int8(newSchemaPath, ranges, units, defaultValue);
+ } else if("uint16".equals(localName)) {
+ Short defaultValue = (Short)type.getDefaultValue();
+ return new Int16(newSchemaPath, ranges, units, defaultValue);
+ } else if("uint32".equals(localName)) {
+ Integer defaultValue = (Integer)type.getDefaultValue();
+ return new Int32(newSchemaPath, ranges, units, defaultValue);
+ } else if("uint64".equals(localName)) {
+ Long defaultValue = (Long)type.getDefaultValue();
+ return new Int64(newSchemaPath, ranges, units, defaultValue);
+ } else {
+ return null;
+ }
+ }
+
+ private static SchemaPath createNewSchemaPath(SchemaPath schemaPath, QName currentQName, QName qname) {
+ List<QName> newPath = new ArrayList<QName>(schemaPath.getPath());
+ newPath.add(currentQName);
+ newPath.add(qname);
+ return new SchemaPath(newPath, schemaPath.isAbsolute());
+ }
+
public static void refineLeaf(LeafSchemaNodeBuilder leaf,
RefineHolder refine, int line) {
String defaultStr = refine.getDefaultStr();
List<EnumTypeDefinition.EnumPair> enumConstants = getEnumConstants(
typeBody, actualPath, namespace, revision, prefix);
+ SchemaPath schemaPath = createActualSchemaPath(actualPath, namespace,
+ revision, prefix);
+
if ("decimal64".equals(typeName)) {
- type = new Decimal64(actualPath, namespace, revision,
- fractionDigits);
+ type = new Decimal64(schemaPath, fractionDigits);
} else if (typeName.startsWith("int")) {
if ("int8".equals(typeName)) {
- type = new Int8(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Int8(schemaPath, rangeStatements, null, null);
} else if ("int16".equals(typeName)) {
- type = new Int16(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Int16(schemaPath, rangeStatements, null, null);
} else if ("int32".equals(typeName)) {
- type = new Int32(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Int32(schemaPath, rangeStatements, null, null);
} else if ("int64".equals(typeName)) {
- type = new Int64(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Int64(schemaPath, rangeStatements, null, null);
}
} else if (typeName.startsWith("uint")) {
if ("uint8".equals(typeName)) {
- type = new Uint8(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Uint8(schemaPath, rangeStatements, null, null);
} else if ("uint16".equals(typeName)) {
- type = new Uint16(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Uint16(schemaPath, rangeStatements, null, null);
} else if ("uint32".equals(typeName)) {
- type = new Uint32(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Uint32(schemaPath, rangeStatements, null, null);
} else if ("uint64".equals(typeName)) {
- type = new Uint64(actualPath, namespace, revision,
- rangeStatements, null, null);
+ type = new Uint64(schemaPath, rangeStatements, null, null);
}
} else if ("enumeration".equals(typeName)) {
- type = new EnumerationType(actualPath, namespace, revision,
- enumConstants);
+ type = new EnumerationType(schemaPath, enumConstants);
} else if ("string".equals(typeName)) {
- type = new StringType(actualPath, namespace, revision,
- lengthStatements, patternStatements);
+ type = new StringType(schemaPath, lengthStatements,
+ patternStatements);
} else if ("bits".equals(typeName)) {
- type = new BitsType(actualPath, namespace, revision, getBits(
- typeBody, actualPath, namespace, revision, prefix));
+ type = new BitsType(schemaPath, getBits(typeBody, actualPath,
+ namespace, revision, prefix));
} else if ("leafref".equals(typeName)) {
final String path = parseLeafrefPath(typeBody);
final boolean absolute = path.startsWith("/");
RevisionAwareXPath xpath = new RevisionAwareXPathImpl(path,
absolute);
- type = new Leafref(actualPath, namespace, revision, xpath);
+ type = new Leafref(schemaPath, xpath);
} else if ("binary".equals(typeName)) {
List<Byte> bytes = Collections.emptyList();
- type = new BinaryType(actualPath, namespace, revision, bytes,
- lengthStatements, null);
+ type = new BinaryType(schemaPath, bytes, lengthStatements, null);
} else if ("instance-identifier".equals(typeName)) {
boolean requireInstance = isRequireInstance(typeBody);
- type = new InstanceIdentifier(actualPath, namespace, revision,
- null, requireInstance);
+ type = new InstanceIdentifier(schemaPath, null, requireInstance);
}
return type;
}
package org.opendaylight.controller.yang.parser.impl;
import java.io.File;
+import java.io.FileNotFoundException;
import java.net.URI;
import java.text.DateFormat;
import java.text.ParseException;
private TestUtils() {
}
- public static Set<Module> loadModules(String resourceDirectory) {
+ public static Set<Module> loadModules(String resourceDirectory) throws FileNotFoundException {
YangModelParser parser = new YangParserImpl();
final File testDir = new File(resourceDirectory);
final String[] fileList = testDir.list();
final List<File> testFiles = new ArrayList<File>();
+ if(fileList == null) {
+ throw new FileNotFoundException(resourceDirectory);
+ }
for (int i = 0; i < fileList.length; i++) {
String fileName = fileList[i];
testFiles.add(new File(testDir, fileName));
import static org.junit.Assert.*;
+import java.io.FileNotFoundException;
import java.net.URI;
import java.util.List;
import java.util.Set;
private Set<Module> testedModules;
@Before
- public void init() {
+ public void init() throws FileNotFoundException {
testedModules = TestUtils.loadModules("src/test/resources/types");
}
import static org.junit.Assert.*;
+import java.io.FileNotFoundException;
import java.net.URI;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
import org.opendaylight.controller.yang.model.api.FeatureDefinition;
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
+import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
import org.opendaylight.controller.yang.model.api.ListSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
import org.opendaylight.controller.yang.model.util.ExtendedType;
import org.opendaylight.controller.yang.model.util.Int16;
import org.opendaylight.controller.yang.model.util.Int32;
+import org.opendaylight.controller.yang.model.util.Leafref;
import org.opendaylight.controller.yang.model.util.StringType;
import org.opendaylight.controller.yang.model.util.Uint32;
import org.opendaylight.controller.yang.model.util.UnionType;
private Set<Module> modules;
@Before
- public void init() {
+ public void init() throws FileNotFoundException {
modules = TestUtils.loadModules("src/test/resources/model");
assertEquals(3, modules.size());
}
assertNull(constraints.getWhenCondition());
assertEquals(0, constraints.getMustConstraints().size());
assertFalse(constraints.isMandatory());
- assertEquals(1, (int)constraints.getMinElements());
- assertEquals(11, (int)constraints.getMaxElements());
+ assertEquals(1, (int) constraints.getMinElements());
+ assertEquals(11, (int) constraints.getMaxElements());
// test AugmentationTarget args
Set<AugmentationSchema> availableAugmentations = ifEntry
.getAvailableAugmentations();
SchemaNode value = entry.getValue();
if (value instanceof LeafSchemaNode) {
refineLeaf = (LeafSchemaNode) value;
- } else if(value instanceof ContainerSchemaNode) {
+ } else if (value instanceof ContainerSchemaNode) {
refineContainer = (ContainerSchemaNode) value;
- } else if(value instanceof ListSchemaNode) {
- refineList = (ListSchemaNode)value;
- } else if(value instanceof GroupingDefinition) {
- refineGrouping = (GroupingDefinition)value;
- } else if(value instanceof TypeDefinition<?>) {
- typedef = (TypeDefinition<?>)value;
+ } else if (value instanceof ListSchemaNode) {
+ refineList = (ListSchemaNode) value;
+ } else if (value instanceof GroupingDefinition) {
+ refineGrouping = (GroupingDefinition) value;
+ } else if (value instanceof TypeDefinition<?>) {
+ typedef = (TypeDefinition<?>) value;
}
}
// list addresses
assertNotNull(refineList);
- assertEquals("description of addresses defined by refine", refineList.getDescription());
- assertEquals("addresses reference added by refine", refineList.getReference());
+ assertEquals("description of addresses defined by refine",
+ refineList.getDescription());
+ assertEquals("addresses reference added by refine",
+ refineList.getReference());
assertFalse(refineList.isConfiguration());
- assertEquals(2, (int)refineList.getConstraints().getMinElements());
- assertEquals(12, (int)refineList.getConstraints().getMaxElements());
+ assertEquals(2, (int) refineList.getConstraints().getMinElements());
+ assertEquals(12, (int) refineList.getConstraints().getMaxElements());
// grouping target-inner
assertNotNull(refineGrouping);
- Set<DataSchemaNode> refineGroupingChildren = refineGrouping.getChildNodes();
+ Set<DataSchemaNode> refineGroupingChildren = refineGrouping
+ .getChildNodes();
assertEquals(1, refineGroupingChildren.size());
- LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode)refineGroupingChildren.iterator().next();
- assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName());
- assertEquals("new target-inner grouping description", refineGrouping.getDescription());
+ LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode) refineGroupingChildren
+ .iterator().next();
+ assertEquals("inner-grouping-id", refineGroupingLeaf.getQName()
+ .getLocalName());
+ assertEquals("new target-inner grouping description",
+ refineGrouping.getDescription());
// typedef group-type
assertNotNull(typedef);
assertEquals(5, children.size());
}
+ @Test
+ public void testAugmentNodesTypesSchemaPath() throws Exception {
+ final DateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
+ Module testModule = TestUtils.findModule(modules, "types1");
+ Set<AugmentationSchema> augments = testModule.getAugmentations();
+ assertEquals(1, augments.size());
+ AugmentationSchema augment = augments.iterator().next();
+
+ LeafSchemaNode ifcId = (LeafSchemaNode) augment
+ .getDataChildByName("interface-id");
+ Leafref ifcIdType = (Leafref) ifcId.getType();
+ SchemaPath ifcIdTypeSchemaPath = ifcIdType.getPath();
+ List<QName> ifcIdTypePath = ifcIdTypeSchemaPath.getPath();
+ QName q0 = new QName(new URI("urn:simple.types.data.demo"),
+ simpleDateFormat.parse("2013-02-27"), "data", "interfaces");
+ QName q1 = new QName(new URI("urn:simple.types.data.demo"),
+ simpleDateFormat.parse("2013-02-27"), "data", "ifEntry");
+ QName q2 = new QName(new URI("urn:simple.container.demo.test"),
+ simpleDateFormat.parse("2013-02-27"), "data", "augment-holder");
+ QName q3 = new QName(new URI("urn:simple.container.demo"),
+ simpleDateFormat.parse("2013-02-27"), "data", "interface-id");
+ assertEquals(q0, ifcIdTypePath.get(0));
+ assertEquals(q1, ifcIdTypePath.get(1));
+ assertEquals(q2, ifcIdTypePath.get(2));
+ assertEquals(q3, ifcIdTypePath.get(3));
+
+ LeafListSchemaNode higherLayer = (LeafListSchemaNode) augment
+ .getDataChildByName("higher-layer-if");
+ Leafref higherLayerType = (Leafref) higherLayer.getType();
+ SchemaPath higherLayerTypeSchemaPath = higherLayerType.getPath();
+ List<QName> higherLayerTypePath = higherLayerTypeSchemaPath.getPath();
+ assertEquals(q0, higherLayerTypePath.get(0));
+ assertEquals(q1, higherLayerTypePath.get(1));
+ assertEquals(q2, higherLayerTypePath.get(2));
+ q3 = new QName(new URI("urn:simple.container.demo"),
+ simpleDateFormat.parse("2013-02-27"), "data", "higher-layer-if");
+ assertEquals(q3, higherLayerTypePath.get(3));
+ }
+
}
}
leaf leaf-with-length {
- type data:my-string-type {
- length "7..max";
- }
+ type data:my-string-type {
+ length "7..max";
+ }
}
leaf test-int-leaf {
}
leaf union-leaf {
- type data:my-union-ext;
+ type data:my-union-ext;
}
deviation /data:system/data:user {
}
leaf nested-union-leaf {
- type data:nested-union1;
+ type data:nested-union1;
}
leaf custom-union-leaf {
leaf ds0ChannelNumber {
type string;
}
+ leaf interface-id {
+ type leafref {
+ path "/if:interfaces/if:interface/if:name";
+ }
+ }
+ leaf-list higher-layer-if {
+ type leafref {
+ path "/if:interfaces/if:interface/if:higher-layer-if";
+ }
+ }
}
}
}
typedef my-union {
- type union {
- type int16 {
- range "1..100";
- }
- type int32;
- }
+ type union {
+ type int16 {
+ range "1..100";
+ }
+ type int32;
+ }
}
typedef my-union-ext {
- type my-union;
+ type my-union;
}
typedef nested-union1 {
- type nested-union2;
+ type nested-union2;
}
typedef nested-union2 {
- type union {
- type my-union-ext;
- type string;
- }
+ type union {
+ type my-union-ext;
+ type string;
+ }
}
leaf if-name {
container network {
mnt:mountpoint point {
- mnt:target-ref target;
+ mnt:target-ref target;
}
- description "network-description";
- reference "network-reference";
- status obsolete;
- config true;
- presence "some presence text";
+ description "network-description";
+ reference "network-reference";
+ status obsolete;
+ config true;
+ presence "some presence text";
}
feature local-storage {
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
* @param maxRange
* @param units
*/
- public AbstractSignedInteger(final List<String> actualPath,
- final URI namespace, final Date revision, final QName name,
+ public AbstractSignedInteger(final SchemaPath path, final QName name,
final String description, final Number minRange,
final Number maxRange, final String units) {
this.name = name;
this.description = description;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.units = units;
this.rangeStatements = new ArrayList<RangeConstraint>();
final String rangeDescription = "Integer values between " + minRange
* @param rangeStatements
* @param units
*/
- public AbstractSignedInteger(final List<String> actualPath,
- final URI namespace, final Date revision, final QName name,
+ public AbstractSignedInteger(final SchemaPath path, final QName name,
final String description,
final List<RangeConstraint> rangeStatements, final String units) {
this.name = name;
this.description = description;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.units = units;
this.rangeStatements = rangeStatements;
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
* @param maxRange
* @param units
*/
- public AbstractUnsignedInteger(final List<String> actualPath,
- final URI namespace, final Date revision, final QName name,
+ public AbstractUnsignedInteger(final SchemaPath path, final QName name,
final String description, final Number minRange,
final Number maxRange, final String units) {
this.name = name;
this.description = description;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.units = units;
this.rangeStatements = new ArrayList<RangeConstraint>();
final String rangeDescription = "Integer values between " + minRange
* @param rangeStatements
* @param units
*/
- public AbstractUnsignedInteger(final List<String> actualPath,
- final URI namespace, final Date revision, final QName name,
+ public AbstractUnsignedInteger(final SchemaPath path, final QName name,
final String description,
final List<RangeConstraint> rangeStatements, final String units) {
this.name = name;
this.description = description;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.units = units;
this.rangeStatements = rangeStatements;
}
/*
- * 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
- */
+ * 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.controller.yang.model.util;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see BinaryTypeDefinition
*/
-public class BinaryType implements BinaryTypeDefinition {
+public final class BinaryType implements BinaryTypeDefinition {
private final QName name = BaseTypes.constructQName("binary");
private final SchemaPath path;
super();
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
- constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
+ constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "",
+ ""));
this.lengthConstraints = Collections.unmodifiableList(constraints);
this.bytes = Collections.emptyList();
this.path = BaseTypes.schemaPath(name);
this.baseType = this;
}
- public BinaryType(final List<String> actualPath, final URI namespace,
- final Date revision) {
+ public BinaryType(final SchemaPath path) {
super();
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
- constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
+ constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "",
+ ""));
this.lengthConstraints = Collections.unmodifiableList(constraints);
this.bytes = Collections.emptyList();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BinaryType();
}
* @param lengthConstraints
* @param units
*/
- public BinaryType(final List<String> actualPath, final URI namespace,
- final Date revision, final List<Byte> bytes,
+ public BinaryType(final SchemaPath path, final List<Byte> bytes,
final List<LengthConstraint> lengthConstraints, final String units) {
super();
if ((lengthConstraints == null) || (lengthConstraints.isEmpty())) {
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
- constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
+ constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE,
+ "", ""));
this.lengthConstraints = Collections.unmodifiableList(constraints);
} else {
- this.lengthConstraints = Collections.unmodifiableList(lengthConstraints);
+ this.lengthConstraints = Collections
+ .unmodifiableList(lengthConstraints);
}
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.bytes = Collections.unmodifiableList(bytes);
this.units = units;
this.baseType = new BinaryType();
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
*/
@Override
public BinaryTypeDefinition getBaseType() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue
+ * ()
*/
@Override
public Object getDefaultValue() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
+ * @see
+ * org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
*/
@Override
public String getDescription() {
* (non-Javadoc)
*
* @see
- * org.opendaylight.controller.yang.model.base.type.api.BinaryTypeDefinition#getLengthConstraint
- * ()
+ * org.opendaylight.controller.yang.model.base.type.api.BinaryTypeDefinition
+ * #getLengthConstraint ()
*/
@Override
public List<LengthConstraint> getLengthConstraints() {
+ ((description == null) ? 0 : description.hashCode());
result = prime
* result
- + ((lengthConstraints == null) ? 0 : lengthConstraints.hashCode());
+ + ((lengthConstraints == null) ? 0 : lengthConstraints
+ .hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + ((path == null) ? 0 : path.hashCode());
result = prime * result
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see BitsTypeDefinition
*/
-public class BitsType implements BitsTypeDefinition {
+public final class BitsType implements BitsTypeDefinition {
private final QName name = BaseTypes.constructQName("bits");
private final SchemaPath path;
this.baseType = this;
}
- public BitsType(final List<String> actualPath, final URI namespace,
- final Date revision) {
+ public BitsType(final SchemaPath path) {
super();
this.bits = Collections.emptyList();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BitsType();
}
* @param bits
* The bits assigned for Bits Type
*/
- public BitsType(final List<String> actualPath, final URI namespace,
- final Date revision, final List<Bit> bits) {
+ public BitsType(final SchemaPath path, final List<Bit> bits) {
super();
this.bits = Collections.unmodifiableList(bits);
this.units = "";
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BitsType();
}
* @param units
* units for bits type
*/
- public BitsType(final List<String> actualPath, final URI namespace,
- final Date revision, List<Bit> bits, String units) {
+ public BitsType(final SchemaPath path, List<Bit> bits, String units) {
super();
this.bits = Collections.unmodifiableList(bits);
this.units = units;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BitsType();
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see BooleanTypeDefinition
*/
-public class BooleanType implements BooleanTypeDefinition {
+public final class BooleanType implements BooleanTypeDefinition {
private final QName name = BaseTypes.constructQName("boolean");
private final SchemaPath path;
this.baseType = this;
}
- public BooleanType(final List<String> actualPath, final URI namespace,
- final Date revision) {
+ public BooleanType(final SchemaPath path) {
super();
this.defaultValue = false;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BooleanType();
}
* @param defaultValue
* Default Value
*/
- public BooleanType(final List<String> actualPath, final URI namespace,
- final Date revision, final Boolean defaultValue) {
+ public BooleanType(final SchemaPath path, final Boolean defaultValue) {
super();
this.defaultValue = defaultValue;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BooleanType();
}
* @param units
* Units
*/
- public BooleanType(final List<String> actualPath, final URI namespace,
- final Date revision, final Boolean defaultValue, final String units) {
+ public BooleanType(final SchemaPath path, final Boolean defaultValue, final String units) {
super();
this.defaultValue = defaultValue;
this.units = units;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new BooleanType();
}
package org.opendaylight.controller.yang.model.util;
import java.math.BigDecimal;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see DecimalTypeDefinition
*/
-public class Decimal64 implements DecimalTypeDefinition {
+public final class Decimal64 implements DecimalTypeDefinition {
private final QName name = BaseTypes.constructQName("decimal64");
private final SchemaPath path;
this.baseType = this;
}
- public Decimal64(final List<String> actualPath, final URI namespace,
- final Date revision, final Integer fractionDigits) {
+ public Decimal64(final SchemaPath path, final Integer fractionDigits) {
super();
if (!((fractionDigits.intValue() > 1) && (fractionDigits.intValue() <= 18))) {
throw new IllegalArgumentException(
}
this.fractionDigits = fractionDigits;
rangeStatements = defaultRangeStatements();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new Decimal64(fractionDigits);
}
* integer between 1 and 18 inclusively
* @exception IllegalArgumentException
*/
- public Decimal64(final List<String> actualPath, final URI namespace,
- final Date revision, final List<RangeConstraint> rangeStatements,
+ public Decimal64(final SchemaPath path, final List<RangeConstraint> rangeStatements,
Integer fractionDigits) {
super();
if (!((fractionDigits.intValue() > 1) && (fractionDigits.intValue() <= 18))) {
.unmodifiableList(rangeStatements);
}
this.fractionDigits = fractionDigits;
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.baseType = new Decimal64(fractionDigits);
}
* @param fractionDigits
* integer between 1 and 18 inclusively
*/
- public Decimal64(final List<String> actualPath, final URI namespace,
- final Date revision, final String units,
+ public Decimal64(final SchemaPath path, final String units,
final BigDecimal defaultValue,
final List<RangeConstraint> rangeStatements,
final Integer fractionDigits) {
this.units = units;
this.defaultValue = defaultValue;
this.fractionDigits = fractionDigits;
- this.path = BaseTypes.schemaPath(name);
+ this.path = path;
this.baseType = new Decimal64(fractionDigits);
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.type.EmptyTypeDefinition;
-public class EmptyType implements EmptyTypeDefinition {
+public final class EmptyType implements EmptyTypeDefinition {
private final QName name = BaseTypes.constructQName("empty");
private final SchemaPath path;
this.baseType = this;
}
- public EmptyType(final List<String> actualPath,
- final URI namespace, final Date revision) {
- path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ public EmptyType(final SchemaPath path) {
+ this.path = path;
this.baseType = new EmptyType();
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
/**
* The <code>default</code> implementation of Enumertaion Type Definition interface.
- *
+ *
* @see EnumTypeDefinition
*/
-public class EnumerationType implements EnumTypeDefinition {
+public final class EnumerationType implements EnumTypeDefinition {
private final QName name = BaseTypes.constructQName("enumeration");
private final SchemaPath path;
private final List<EnumPair> enums;
private String units = "";
private final EnumTypeDefinition baseType;
-
+
private EnumerationType(final List<EnumPair> enums) {
this.path = BaseTypes.schemaPath(name);
this.enums = Collections.unmodifiableList(enums);
this.defaultEnum = null;
baseType = this;
}
-
- public EnumerationType(final List<String> actualPath, final URI namespace,
- final Date revision, final List<EnumPair> enums) {
+
+ public EnumerationType(final SchemaPath path, final List<EnumPair> enums) {
super();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.enums = Collections.unmodifiableList(enums);
this.defaultEnum = null;
baseType = new EnumerationType(enums);
}
- public EnumerationType(final List<String> actualPath, final URI namespace,
- final Date revision, final EnumTypeDefinition baseType, final EnumPair defaultEnum,
+ public EnumerationType(final SchemaPath path, final EnumPair defaultEnum,
final List<EnumPair> enums, final String units) {
super();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
- this.baseType = baseType;
+ this.path = path;
+ baseType = new EnumerationType(enums);
this.defaultEnum = defaultEnum;
this.enums = Collections.unmodifiableList(enums);
this.units = units;
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.TypeDefinition#getUnits()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.SchemaNode#getQName()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.SchemaNode#getPath()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.SchemaNode#getReference()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.api.SchemaNode#getStatus()
*/
@Override
/*
* (non-Javadoc)
- *
+ *
* @see org.opendaylight.controller.yang.model.base.type.api.EnumTypeDefinition#getValues()
*/
@Override
+++ /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.controller.yang.model.util;
-
-import java.util.Collections;
-import java.util.List;
-
-import org.opendaylight.controller.yang.common.QName;
-import org.opendaylight.controller.yang.model.api.SchemaPath;
-import org.opendaylight.controller.yang.model.api.Status;
-import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.controller.yang.model.api.type.IdentityTypeDefinition;
-
-/**
- * The <code>default</code> implementation of Identity Type Definition interface.
- *
- * @see IdentityTypeDefinition
- */
-public class IdentityType implements IdentityTypeDefinition {
-
- private final QName name = BaseTypes.constructQName("identity");
- private final SchemaPath path = BaseTypes.schemaPath(name);
- private final String description = "The 'identity' statement is used to define a new " +
- "globally unique, abstract, and untyped identity.";
- private final String reference = "https://tools.ietf.org/html/rfc6020#section-7.16";
-
- private String units = "";
- private final QName identityName;
-
- public IdentityType(QName identityName) {
- super();
- this.identityName = identityName;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
- */
- @Override
- public IdentityTypeDefinition getBaseType() {
- return this;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getUnits()
- */
- @Override
- public String getUnits() {
- return units;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue()
- */
- @Override
- public Object getDefaultValue() {
- return this;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getQName()
- */
- @Override
- public QName getQName() {
- // TODO Auto-generated method stub
- return null;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getPath()
- */
- @Override
- public SchemaPath getPath() {
- return path;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getDescription()
- */
- @Override
- public String getDescription() {
- return description;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getReference()
- */
- @Override
- public String getReference() {
- return reference;
- }
-
- /*
- * (non-Javadoc)
- *
- * @see org.opendaylight.controller.yang.model.api.SchemaNode#getStatus()
- */
- @Override
- public Status getStatus() {
- return Status.CURRENT;
- }
-
- @Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return Collections.emptyList();
- }
-
- /*
- * (non-Javadoc)
- *
- * @see
- * org.opendaylight.controller.yang.model.base.type.api.IdentityTypeDefinition#getIdentityName
- * ()
- */
- @Override
- public QName getIdentityName() {
- return identityName;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result
- + ((description == null) ? 0 : description.hashCode());
- result = prime * result
- + ((identityName == null) ? 0 : identityName.hashCode());
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- result = prime * result + ((path == null) ? 0 : path.hashCode());
- result = prime * result
- + ((reference == null) ? 0 : reference.hashCode());
- result = prime * result + ((units == null) ? 0 : units.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- IdentityType other = (IdentityType) obj;
- if (description == null) {
- if (other.description != null) {
- return false;
- }
- } else if (!description.equals(other.description)) {
- return false;
- }
- if (identityName == null) {
- if (other.identityName != null) {
- return false;
- }
- } else if (!identityName.equals(other.identityName)) {
- return false;
- }
- if (name == null) {
- if (other.name != null) {
- return false;
- }
- } else if (!name.equals(other.name)) {
- return false;
- }
- if (path == null) {
- if (other.path != null) {
- return false;
- }
- } else if (!path.equals(other.path)) {
- return false;
- }
- if (reference == null) {
- if (other.reference != null) {
- return false;
- }
- } else if (!reference.equals(other.reference)) {
- return false;
- }
- if (units == null) {
- if (other.units != null) {
- return false;
- }
- } else if (!units.equals(other.units)) {
- return false;
- }
- return true;
- }
-
- @Override
- public String toString() {
- StringBuilder builder = new StringBuilder();
- builder.append("IdentityType [name=");
- builder.append(name);
- builder.append(", path=");
- builder.append(path);
- builder.append(", description=");
- builder.append(description);
- builder.append(", reference=");
- builder.append(reference);
- builder.append(", units=");
- builder.append(units);
- builder.append(", identityName=");
- builder.append(identityName);
- builder.append("]");
- return builder.toString();
- }
-}
*/\r
package org.opendaylight.controller.yang.model.util;\r
\r
-import java.net.URI;\r
import java.util.Collections;\r
-import java.util.Date;\r
import java.util.List;\r
\r
import org.opendaylight.controller.yang.common.QName;\r
*\r
* @see IdentityrefTypeDefinition\r
*/\r
-public class IdentityrefType implements IdentityrefTypeDefinition {\r
+public final class IdentityrefType implements IdentityrefTypeDefinition {\r
\r
private final QName name = BaseTypes.constructQName("identityref");\r
private final SchemaPath path;\r
this.baseType = new IdentityrefType(identity);\r
}\r
\r
- public IdentityrefType(final List<String> actualPath,\r
- final URI namespace, final Date revision, final QName identity) {\r
- this.identity = identity;\r
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);\r
- this.baseType = new IdentityrefType(identity);\r
- }\r
-\r
@Override\r
public String getUnits() {\r
return units;\r
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see InstanceIdentifierTypeDefinition
*/
-public class InstanceIdentifier implements InstanceIdentifierTypeDefinition {
+public final class InstanceIdentifier implements InstanceIdentifierTypeDefinition {
private static final QName name = BaseTypes
.constructQName("instance-identifier");
this.baseType = this;
}
- public InstanceIdentifier(final List<String> actualPath, final URI namespace,
- final Date revision, RevisionAwareXPath xpath, boolean requireInstance) {
+ public InstanceIdentifier(final SchemaPath path, RevisionAwareXPath xpath, boolean requireInstance) {
super();
- path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.xpath = xpath;
this.requireInstance = requireInstance;
this.baseType = new InstanceIdentifier(xpath, requireInstance);
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
*
* @see AbstractSignedInteger
*/
-public class Int16 extends AbstractSignedInteger {
+public final class Int16 extends AbstractSignedInteger {
private static final QName name = BaseTypes.constructQName("int16");
private Short defaultValue = null;
- private static final String description =
- "int16 represents integer values between -32768 and 32767, inclusively.";
+ private static final String description = "int16 represents integer values between -32768 and 32767, inclusively.";
private final IntegerTypeDefinition baseType;
private Int16() {
this.baseType = this;
}
- public Int16(final List<String> actualPath, final URI namespace,
- final Date revision) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Int16(final SchemaPath path) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Int16();
}
- public Int16(final List<String> actualPath, final URI namespace,
- final Date revision, final List<RangeConstraint> rangeStatements,
- final String units, final Short defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ public Int16(final SchemaPath path,
+ final List<RangeConstraint> rangeStatements, final String units,
+ final Short defaultValue) {
+ super(path, name, description, rangeStatements, units);
this.defaultValue = defaultValue;
this.baseType = new Int16();
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
* @see AbstractSignedInteger
*
*/
-public class Int32 extends AbstractSignedInteger {
+public final class Int32 extends AbstractSignedInteger {
private static final QName name = BaseTypes.constructQName("int32");
private Integer defaultValue = null;
- private static final String description =
- "int32 represents integer values between -2147483648 and 2147483647, inclusively.";
+ private static final String description = "int32 represents integer values between -2147483648 and 2147483647, inclusively.";
private final IntegerTypeDefinition baseType;
private Int32() {
this.baseType = this;
}
- public Int32(final List<String> actualPath, final URI namespace,
- final Date revision) {
- super(actualPath, namespace, revision, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
+ public Int32(final SchemaPath path) {
+ super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
this.baseType = new Int32();
}
- public Int32(final List<String> actualPath, final URI namespace,
- final Date revision, final Integer defaultValue) {
- super(actualPath, namespace, revision, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
+ public Int32(final SchemaPath path, final Integer defaultValue) {
+ super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
this.baseType = new Int32();
this.defaultValue = defaultValue;
}
- public Int32(final List<String> actualPath, final URI namespace,
- final Date revision, final List<RangeConstraint> rangeStatements,
- final String units, final Integer defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ public Int32(final SchemaPath path,
+ final List<RangeConstraint> rangeStatements, final String units,
+ final Integer defaultValue) {
+ super(path, name, description, rangeStatements, units);
this.baseType = new Int32();
this.defaultValue = defaultValue;
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
* {@link Long}.
*
*/
-public class Int64 extends AbstractSignedInteger {
+public final class Int64 extends AbstractSignedInteger {
private static final QName name = BaseTypes.constructQName("int64");
private Long defaultValue = null;
this.baseType = this;
}
- public Int64(final List<String> actualPath, final URI namespace,
- final Date revision) {
- super(actualPath, namespace, revision, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
+ public Int64(final SchemaPath path) {
+ super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
this.baseType = new Int64();
}
- public Int64(final List<String> actualPath, final URI namespace,
- final Date revision, final Long defaultValue) {
- super(actualPath, namespace, revision, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
+ public Int64(final SchemaPath path, final Long defaultValue) {
+ super(path, name, description, Integer.MIN_VALUE, Integer.MAX_VALUE, "");
this.baseType = new Int64();
this.defaultValue = defaultValue;
}
- public Int64(final List<String> actualPath, final URI namespace,
- final Date revision, final List<RangeConstraint> rangeStatements,
+ public Int64(final SchemaPath path, final List<RangeConstraint> rangeStatements,
final String units, final Long defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ super(path, name, description, rangeStatements, units);
this.baseType = new Int64();
this.defaultValue = defaultValue;
}
/*
- * 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
- */
+ * 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.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.IntegerTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
/**
- * Implementation of Yang int8 built-in type.
- * <br>
- * int8 represents integer values between -128 and 127, inclusively. The Java counterpart of
- * Yang int8 built-in type is {@link Byte}.
+ * Implementation of Yang int8 built-in type. <br>
+ * int8 represents integer values between -128 and 127, inclusively. The Java
+ * counterpart of Yang int8 built-in type is {@link Byte}.
*
* @see AbstractSignedInteger
*/
-public class Int8 extends AbstractSignedInteger {
+public final class Int8 extends AbstractSignedInteger {
private static final QName name = BaseTypes.constructQName("int8");
private Byte defaultValue = null;
- private static final String description =
- "represents integer values between -128 and 127, inclusively.";
+ private static final String description = "represents integer values between -128 and 127, inclusively.";
private final IntegerTypeDefinition baseType;
private Int8() {
this.baseType = this;
}
- public Int8(final List<String> actualPath, final URI namespace,
- final Date revision) {
- super(actualPath, namespace, revision, name, description, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
+ public Int8(final SchemaPath path) {
+ super(path, name, description, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
this.baseType = new Int8();
}
- public Int8(final List<String> actualPath, final URI namespace,
- final Date revision, final Byte defaultValue) {
- super(actualPath, namespace, revision, name, description, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
+ public Int8(final SchemaPath path, final Byte defaultValue) {
+ super(path, name, description, Byte.MIN_VALUE, Byte.MAX_VALUE, "");
this.baseType = new Int8();
this.defaultValue = defaultValue;
}
- public Int8(final List<String> actualPath, final URI namespace,
- final Date revision, final List<RangeConstraint> rangeStatements,
- final String units, final Byte defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ public Int8(final SchemaPath path,
+ final List<RangeConstraint> rangeStatements, final String units,
+ final Byte defaultValue) {
+ super(path, name, description, rangeStatements, units);
this.baseType = new Int8();
this.defaultValue = defaultValue;
}
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getBaseType()
*/
@Override
public IntegerTypeDefinition getBaseType() {
/*
* (non-Javadoc)
*
- * @see org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue()
+ * @see
+ * org.opendaylight.controller.yang.model.api.TypeDefinition#getDefaultValue
+ * ()
*/
@Override
public Object getDefaultValue() {
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see LeafrefTypeDefinition
*/
-public class Leafref implements LeafrefTypeDefinition {
+public final class Leafref implements LeafrefTypeDefinition {
private static final QName name = BaseTypes.constructQName("leafref");
private static final String description = "The leafref type is used to reference a "
+ "particular leaf instance in the data tree.";
this.baseType = this;
}
- public Leafref(final List<String> actualPath, final URI namespace,
- final Date revision, final RevisionAwareXPath xpath) {
+ public Leafref(final SchemaPath path, final RevisionAwareXPath xpath) {
super();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.xpath = xpath;
baseType = new Leafref(xpath);
}
- public Leafref(final List<String> actualPath, final URI namespace,
- final Date revision, final LeafrefTypeDefinition baseType,
- final RevisionAwareXPath xpath) {
- super();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
- this.xpath = xpath;
- this.baseType = baseType;
- }
-
/*
* (non-Javadoc)
*
import org.opendaylight.controller.yang.model.api.SchemaContext;
import org.opendaylight.controller.yang.model.api.SchemaNode;
import org.opendaylight.controller.yang.model.api.SchemaPath;
+import org.opendaylight.controller.yang.model.api.TypeDefinition;
public final class SchemaContextUtil {
public static DataSchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) {
if (schemaPath != null) {
final Module module = resolveModuleFromSchemaPath(context, schemaPath);
- final Queue<QName> prefixedPath = new LinkedList<QName>(schemaPath.getPath());
+ final Queue<QName> prefixedPath = new LinkedList<QName>(schemaPath.getPath());
if ((module != null) && (prefixedPath != null)) {
return findSchemaNodeForGivenPath(context, module, prefixedPath);
final Queue<QName> qnamedPath = xpathToQNamePath(context, module,
strXPath);
if (qnamedPath != null) {
- final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context,
+ final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context,
module, qnamedPath);
return dataNode;
}
return null;
}
- public static DataSchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context,
+ public static DataSchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context,
final Module module, final SchemaNode actualSchemaNode,
final RevisionAwareXPath relativeXPath) {
if ((actualSchemaNode != null) && (relativeXPath != null)
final SchemaPath actualNodePath = actualSchemaNode.getPath();
if (actualNodePath != null) {
- final Queue<QName> qnamePath = resolveRelativeXPath(context, module,
+ final Queue<QName> qnamePath = resolveRelativeXPath(context, module,
relativeXPath, actualNodePath);
if (qnamePath != null) {
- final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context,
+ final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context,
module, qnamePath);
return dataNode;
}
public static Module resolveModuleFromSchemaPath(final SchemaContext context, final SchemaPath schemaPath) {
if ((schemaPath != null) && (schemaPath.getPath() != null)) {
- final QName qname = schemaPath.getPath().get(0);
+ List<QName> path = schemaPath.getPath();
+ final QName qname = path.get(path.size()-1);
if ((qname != null) && (qname.getNamespace() != null)) {
return context.findModuleByNamespace(qname.getNamespace());
return null;
}
+ public static Module resolveModuleFromTypePath(final SchemaContext context, final TypeDefinition<?> type) {
+ final SchemaPath schemaPath = type.getPath();
+ if ((schemaPath != null) && (schemaPath.getPath() != null)) {
+ if(type instanceof ExtendedType) {
+ List<QName> path = schemaPath.getPath();
+ final QName qname = path.get(path.size()-1);
+
+ if ((qname != null) && (qname.getNamespace() != null)) {
+ return context.findModuleByNamespace(qname.getNamespace());
+ }
+ } else {
+ LinkedList<QName> path = new LinkedList<QName>(schemaPath.getPath());
+ path.removeLast();
+ final QName qname = path.get(path.size()-1);
+
+ if ((qname != null) && (qname.getNamespace() != null)) {
+ return context.findModuleByNamespace(qname.getNamespace());
+ }
+ }
+
+ }
+ return null;
+ }
+
public static Module findParentModule(final SchemaContext context, final SchemaNode schemaNode) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
childNodeQName = qnamedPath.peek();
if (childNodeQName != null) {
final URI childNodeNamespace = childNodeQName.getNamespace();
-
+
schemaNode = nextNode.getDataChildByName(childNodeQName);
if (schemaNode != null) {
if (schemaNode instanceof ContainerSchemaNode) {
}
final List<QName> path = leafrefSchemaPath.getPath();
if (path != null) {
- int lenght = path.size() - colCount;
+ int lenght = path.size() - colCount - 1;
for (int i = 0; i < lenght; ++i) {
absolutePath.add(path.get(i));
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
*
* @see StringTypeDefinition
*/
-public class StringType implements StringTypeDefinition {
+public final class StringType implements StringTypeDefinition {
- private final QName name = BaseTypes.constructQName("string");;
+ private final QName name = BaseTypes.constructQName("string");
private final SchemaPath path;
private String defaultValue = "";
private final String description = "";
/**
* Default Constructor.
*/
- public StringType(final List<String> actualPath,
- final URI namespace, final Date revision) {
+ public StringType(final SchemaPath path) {
super();
- path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
lengthStatements = Collections.unmodifiableList(constraints);
* @param lengthStatements
* @param patterns
*/
- public StringType(final List<String> actualPath,
- final URI namespace, final Date revision, final List<LengthConstraint> lengthStatements,
+ public StringType(final SchemaPath path, final List<LengthConstraint> lengthStatements,
final List<PatternConstraint> patterns) {
super();
- path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
if(lengthStatements == null || lengthStatements.size() == 0) {
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
constraints.add(BaseConstraints.lengthConstraint(0, Long.MAX_VALUE, "", ""));
* @param patterns
* @param units
*/
- public StringType(final List<String> actualPath,
- final URI namespace, final Date revision, final String defaultValue,
+ public StringType(final SchemaPath path, final String defaultValue,
final List<LengthConstraint> lengthStatements,
final List<PatternConstraint> patterns, final String units) {
super();
- this.path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.defaultValue = defaultValue;
if(lengthStatements == null || lengthStatements.size() == 0) {
final List<LengthConstraint> constraints = new ArrayList<LengthConstraint>();
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
* counterpart of Yang uint32 built-in type is {@link Integer}.
*
*/
-public class Uint16 extends AbstractUnsignedInteger {
+public final class Uint16 extends AbstractUnsignedInteger {
private static final QName name = BaseTypes.constructQName("uint16");
private Integer defaultValue = null;
this.baseType = this;
}
- public Uint16(final List<String> actualPath,
- final URI namespace, final Date revision) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint16(final SchemaPath path) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint16();
}
- public Uint16(final List<String> actualPath,
- final URI namespace, final Date revision, final Integer defaultValue) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint16(final SchemaPath path, final Integer defaultValue) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint16();
this.defaultValue = defaultValue;
}
- public Uint16(final List<String> actualPath,
- final URI namespace, final Date revision, final List<RangeConstraint> rangeStatements,
+ public Uint16(final SchemaPath path, final List<RangeConstraint> rangeStatements,
final String units, final Integer defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ super(path, name, description, rangeStatements, units);
this.baseType = new Uint16();
this.defaultValue = defaultValue;
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
* Java counterpart of Yang uint32 built-in type is {@link Long}.
*
*/
-public class Uint32 extends AbstractUnsignedInteger {
+public final class Uint32 extends AbstractUnsignedInteger {
private static final QName name = BaseTypes.constructQName("uint32");
private Long defaultValue = null;
this.baseType = this;
}
- public Uint32(final List<String> actualPath,
- final URI namespace, final Date revision) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint32(final SchemaPath path) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint32();
}
- public Uint32(final List<String> actualPath,
- final URI namespace, final Date revision, final Long defaultValue) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint32(final SchemaPath path, final Long defaultValue) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint32();
this.defaultValue = defaultValue;
}
- public Uint32(final List<String> actualPath,
- final URI namespace, final Date revision, final List<RangeConstraint> rangeStatements,
+ public Uint32(final SchemaPath path, final List<RangeConstraint> rangeStatements,
final String units, final Long defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ super(path, name, description, rangeStatements, units);
this.baseType = new Uint32();
this.defaultValue = defaultValue;
}
package org.opendaylight.controller.yang.model.util;
import java.math.BigInteger;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
* {@link BigInteger}.
*
*/
-public class Uint64 extends AbstractUnsignedInteger {
+public final class Uint64 extends AbstractUnsignedInteger {
private static final QName name = BaseTypes.constructQName("uint64");
private BigInteger defaultValue = null;
- private static final String description =
- "uint64 represents integer values between 0 and 18446744073709551615, inclusively.";
+ private static final String description = "uint64 represents integer values between 0 and 18446744073709551615, inclusively.";
private final UnsignedIntegerTypeDefinition baseType;
private Uint64() {
this.baseType = this;
}
- public Uint64(final List<String> actualPath,
- final URI namespace, final Date revision) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint64(final SchemaPath path) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint64();
}
- public Uint64(final List<String> actualPath,
- final URI namespace, final Date revision, final BigInteger defaultValue) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint64(final SchemaPath path, final BigInteger defaultValue) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint64();
this.defaultValue = defaultValue;
}
- public Uint64(final List<String> actualPath,
- final URI namespace, final Date revision, final List<RangeConstraint> rangeStatements,
- final String units, final BigInteger defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ public Uint64(final SchemaPath path,
+ final List<RangeConstraint> rangeStatements, final String units,
+ final BigInteger defaultValue) {
+ super(path, name, description, rangeStatements, units);
this.baseType = new Uint64();
this.defaultValue = defaultValue;
}
*/
package org.opendaylight.controller.yang.model.util;
-import java.net.URI;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
+import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.type.RangeConstraint;
import org.opendaylight.controller.yang.model.api.type.UnsignedIntegerTypeDefinition;
*
* @see AbstractUnsignedInteger
*/
-public class Uint8 extends AbstractUnsignedInteger {
+public final class Uint8 extends AbstractUnsignedInteger {
private static final QName name = BaseTypes.constructQName("uint8");
private Short defaultValue = null;
this.baseType = this;
}
- public Uint8(final List<String> actualPath,
- final URI namespace, final Date revision) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint8(final SchemaPath path) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint8();
}
- public Uint8(final List<String> actualPath,
- final URI namespace, final Date revision, final Short defaultValue) {
- super(actualPath, namespace, revision, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
+ public Uint8(final SchemaPath path, final Short defaultValue) {
+ super(path, name, description, Short.MIN_VALUE, Short.MAX_VALUE, "");
this.baseType = new Uint8();
this.defaultValue = defaultValue;
}
- public Uint8(final List<String> actualPath,
- final URI namespace, final Date revision, final List<RangeConstraint> rangeStatements,
+ public Uint8(final SchemaPath path, final List<RangeConstraint> rangeStatements,
final String units, final Short defaultValue) {
- super(actualPath, namespace, revision, name, description, rangeStatements, units);
+ super(path, name, description, rangeStatements, units);
this.baseType = new Uint8();
this.defaultValue = defaultValue;
}
/*
- * 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
- */
+ * 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.controller.yang.model.util;
-import java.net.URI;
import java.util.Collections;
-import java.util.Date;
import java.util.List;
import org.opendaylight.controller.yang.common.QName;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition;
-public class UnionType implements UnionTypeDefinition {
+public final class UnionType implements UnionTypeDefinition {
private final QName name = BaseTypes.constructQName("union");
private final SchemaPath path;
private final List<TypeDefinition<?>> types;
private UnionType(List<TypeDefinition<?>> types) {
- if(types == null) {
- throw new NullPointerException("When the type is 'union', the 'type' statement MUST be present.");
+ if (types == null) {
+ throw new NullPointerException(
+ "When the type is 'union', the 'type' statement MUST be present.");
}
path = BaseTypes.schemaPath(name);
this.types = types;
this.baseType = this;
}
- public UnionType(final List<String> actualPath, final URI namespace,
- final Date revision, List<TypeDefinition<?>> types) {
- if(types == null) {
- throw new NullPointerException("When the type is 'union', the 'type' statement MUST be present.");
+ public UnionType(final SchemaPath path, List<TypeDefinition<?>> types) {
+ if (types == null) {
+ throw new NullPointerException(
+ "When the type is 'union', the 'type' statement MUST be present.");
}
- path = BaseTypes.schemaPath(actualPath, namespace, revision);
+ this.path = path;
this.types = types;
this.baseType = new UnionType(types);
}
builder.append("UnionType [name=");
builder.append(name);
builder.append(", types=[");
- for(TypeDefinition<?> td : types) {
- builder.append(", "+ td.getQName().getLocalName());
+ for (TypeDefinition<?> td : types) {
+ builder.append(", " + td.getQName().getLocalName());
}
builder.append("]");
builder.append("]");
package org.opendaylight.controller.yang.model.util;\r
\r
import java.net.URI;\r
+import java.util.ArrayList;\r
import java.util.Date;\r
import java.util.HashSet;\r
import java.util.List;\r
import java.util.Set;\r
\r
+import org.opendaylight.controller.yang.common.QName;\r
+import org.opendaylight.controller.yang.model.api.SchemaPath;\r
import org.opendaylight.controller.yang.model.api.TypeDefinition;\r
\r
-public class YangTypesConverter {\r
+public final class YangTypesConverter {\r
private static final Set<String> baseYangTypes = new HashSet<String>();\r
\r
static {\r
String typeName) {\r
TypeDefinition<?> type = null;\r
\r
+ SchemaPath path = createSchemaPath(actualPath, namespace, revision);\r
if (typeName.startsWith("int")) {\r
if (typeName.equals("int8")) {\r
- type = new Int8(actualPath, namespace, revision);\r
+ type = new Int8(path);\r
} else if (typeName.equals("int16")) {\r
- type = new Int16(actualPath, namespace, revision);\r
+ type = new Int16(path);\r
} else if (typeName.equals("int32")) {\r
- type = new Int32(actualPath, namespace, revision);\r
+ type = new Int32(path);\r
} else if (typeName.equals("int64")) {\r
- type = new Int64(actualPath, namespace, revision);\r
+ type = new Int64(path);\r
}\r
} else if (typeName.startsWith("uint")) {\r
if (typeName.equals("uint8")) {\r
- type = new Uint8(actualPath, namespace, revision);\r
+ type = new Uint8(path);\r
} else if (typeName.equals("uint16")) {\r
- type = new Uint16(actualPath, namespace, revision);\r
+ type = new Uint16(path);\r
} else if (typeName.equals("uint32")) {\r
- type = new Uint32(actualPath, namespace, revision);\r
+ type = new Uint32(path);\r
} else if (typeName.equals("uint64")) {\r
- type = new Uint64(actualPath, namespace, revision);\r
+ type = new Uint64(path);\r
}\r
} else if ("string".equals(typeName)) {\r
- type = new StringType(actualPath, namespace, revision);\r
+ type = new StringType(path);\r
} else if("binary".equals(typeName)) {\r
- type = new BinaryType(actualPath, namespace, revision);\r
+ type = new BinaryType(path);\r
} else if("boolean".equals(typeName)) {\r
- type = new BooleanType(actualPath, namespace, revision);\r
+ type = new BooleanType(path);\r
} else if("empty".equals(typeName)) {\r
- type = new EmptyType(actualPath, namespace, revision);\r
+ type = new EmptyType(path);\r
} else if("instance-identifier".equals(typeName)) {\r
- type = new InstanceIdentifier(actualPath, namespace, revision, null, true);\r
+ type = new InstanceIdentifier(path, null, true);\r
}\r
\r
return type;\r
}\r
\r
+ private static SchemaPath createSchemaPath(List<String> actualPath, URI namespace, Date revision) {\r
+ List<QName> path = new ArrayList<QName>();\r
+ for(String element : actualPath) {\r
+ path.add(new QName(namespace, revision, element));\r
+ }\r
+ return new SchemaPath(path, true);\r
+ }\r
+\r
}\r