return genType;
}
- private void containerToGenType(final Module module, final String basePackageName, final GeneratedTypeBuilder parent,
- final GeneratedTypeBuilder childOf, final ContainerSchemaNode node) {
+ private void containerToGenType(final Module module, final String basePackageName,
+ final GeneratedTypeBuilder parent, final GeneratedTypeBuilder childOf, final ContainerSchemaNode node) {
final GeneratedTypeBuilder genType = processDataSchemaNode(module, basePackageName, childOf, node);
if (genType != null) {
constructGetter(parent, node.getQName().getLocalName(), node.getDescription(), genType);
* information about base of identity
*
*/
- private void identityToGenType(final Module module, final String basePackageName, final IdentitySchemaNode identity,
- final SchemaContext context) {
+ private void identityToGenType(final Module module, final String basePackageName,
+ final IdentitySchemaNode identity, final SchemaContext context) {
if (identity == null) {
return;
}
final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());
final String genTypeName = BindingMapping.getClassName(identity.getQName());
- final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTypeName);
+ final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTypeName);
final IdentitySchemaNode baseIdentity = identity.getBaseIdentity();
if (baseIdentity == null) {
final GeneratedTOBuilderImpl gto = new GeneratedTOBuilderImpl(BaseIdentity.class.getPackage().getName(),
newType.setExtendsType(gto.toInstance());
} else {
final Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);
- final String returnTypePkgName = BindingMapping.getRootPackageName(baseIdentityParentModule.getQNameModule());
+ final String returnTypePkgName = BindingMapping.getRootPackageName(baseIdentityParentModule
+ .getQNameModule());
final String returnTypeName = BindingMapping.getClassName(baseIdentity.getQName());
final GeneratedTransferObject gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName)
.toInstance();
}
newType.setAbstract(true);
newType.addComment(identity.getDescription());
+ newType.setDescription(identity.getDescription());
+ newType.setReference(identity.getReference());
+ newType.setModuleName(module.getName());
+ newType.setSchemaPath(identity.getPath().getPathFromRoot());
+
final QName qname = identity.getQName();
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, qname);
genCtx.get(module).addIdentityType(identity.getQName(), newType);
}
- private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName, final QName name) {
+ private static Constant qnameConstant(final GeneratedTypeBuilderBase<?> toBuilder, final String constantName,
+ final QName name) {
StringBuilder sb = new StringBuilder("org.opendaylight.yangtools.yang.common.QName");
sb.append(".create(");
sb.append('"');
&& (enumTypeDef.getQName().getLocalName() != null)) {
final String enumerationName = BindingMapping.getClassName(enumName);
final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
+ enumBuilder.setDescription(enumTypeDef.getDescription());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
return enumBuilder;
}
checkArgument(module != null, "Module reference cannot be NULL.");
final String packageName = BindingMapping.getRootPackageName(module.getQNameModule());
final String moduleName = BindingMapping.getClassName(module.getName()) + postfix;
- return new GeneratedTypeBuilderImpl(packageName, moduleName);
+
+ final GeneratedTypeBuilderImpl moduleBuilder = new GeneratedTypeBuilderImpl(packageName, moduleName);
+ moduleBuilder.setDescription(module.getDescription());
+ moduleBuilder.setReference(module.getReference());
+ moduleBuilder.setModuleName(moduleName);
+
+ return moduleBuilder;
}
/**
* @throws IllegalStateException
* if augment target path is null
*/
- private void augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema, final Module module) {
+ private void augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema,
+ final Module module) {
checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
checkState(augSchema.getTargetPath() != null,
}
}
- private void usesAugmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema, final Module module,
- final UsesNode usesNode, final DataNodeContainer usesNodeParent) {
+ private void usesAugmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema,
+ final Module module, final UsesNode usesNode, final DataNodeContainer usesNodeParent) {
checkArgument(augmentPackageName != null, "Package Name cannot be NULL.");
checkArgument(augSchema != null, "Augmentation Schema cannot be NULL.");
checkState(augSchema.getTargetPath() != null,
* added to it.
*/
private GeneratedTypeBuilder augSchemaNodeToMethods(final Module module, final String basePackageName,
- final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf, final Set<DataSchemaNode> schemaNodes) {
+ final GeneratedTypeBuilder typeBuilder, final GeneratedTypeBuilder childOf,
+ final Set<DataSchemaNode> schemaNodes) {
if ((schemaNodes != null) && (typeBuilder != null)) {
for (DataSchemaNode schemaNode : schemaNodes) {
if (!schemaNode.isAugmenting()) {
* <li>if <code>choiceNode</code> is null</li>
* </ul>
*/
- private void choiceToGeneratedType(final Module module, final String basePackageName, final GeneratedTypeBuilder parent,
- final ChoiceNode choiceNode) {
+ private void choiceToGeneratedType(final Module module, final String basePackageName,
+ final GeneratedTypeBuilder parent, final ChoiceNode choiceNode) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(choiceNode != null, "Choice Schema Node cannot be NULL.");
* <li>if <code>caseNodes</code> equals null</li>
* </ul>
*/
- private void generateTypesFromChoiceCases(final Module module, final String basePackageName, final Type refChoiceType,
- final ChoiceNode choiceNode) {
+ private void generateTypesFromChoiceCases(final Module module, final String basePackageName,
+ final Type refChoiceType, final ChoiceNode choiceNode) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(refChoiceType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(choiceNode != null, "ChoiceNode cannot be NULL.");
* <li>if <code>augmentedNodes</code> is null</li>
* </ul>
*/
- private void generateTypesFromAugmentedChoiceCases(final Module module, final String basePackageName, final Type targetType,
- final ChoiceNode targetNode, final Set<DataSchemaNode> augmentedNodes) {
+ private void generateTypesFromAugmentedChoiceCases(final Module module, final String basePackageName,
+ final Type targetType, final ChoiceNode targetNode, final Set<DataSchemaNode> augmentedNodes) {
checkArgument(basePackageName != null, "Base Package Name cannot be NULL.");
checkArgument(targetType != null, "Referenced Choice Type cannot be NULL.");
checkArgument(augmentedNodes != null, "Set of Choice Case Nodes cannot be NULL.");
}
((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);
} else if (typeDef instanceof UnionType) {
- genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf);
+ genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
}
} else if (typeDef instanceof BitsTypeDefinition) {
- genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf);
+ genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leaf, parentModule);
if (genTOBuilder != null) {
returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
}
return returnType;
}
- private void processContextRefExtension(final LeafSchemaNode leaf, final MethodSignatureBuilder getter, final Module module) {
+ private void processContextRefExtension(final LeafSchemaNode leaf, final MethodSignatureBuilder getter,
+ final Module module) {
for (UnknownSchemaNode node : leaf.getUnknownSchemaNodes()) {
final QName nodeType = node.getNodeType();
if ("context-reference".equals(nodeType.getLocalName())) {
* <li>true - other cases</li>
* </ul>
*/
- private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf, final Type returnType,
- final boolean isReadOnly) {
+ private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,
+ final Type returnType, final boolean isReadOnly) {
if (returnType == null) {
return false;
}
returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());
((TypeProviderImpl) typeProvider).putReferencedType(node.getPath(), returnType);
} else if (typeDef instanceof UnionType) {
- final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node);
+ final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
if (genTOBuilder != null) {
returnType = createReturnTypeForUnion(genTOBuilder, typeDef, typeBuilder, parentModule);
}
} else if (typeDef instanceof BitsTypeDefinition) {
- final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node);
+ final GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, node, parentModule);
returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());
} else {
final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
final GeneratedTypeBuilder typeBuilder, final Module parentModule) {
final GeneratedTOBuilderImpl returnType = new GeneratedTOBuilderImpl(genTOBuilder.getPackageName(),
genTOBuilder.getName());
+
+ returnType.setDescription(typeDef.getDescription());
+ returnType.setReference(typeDef.getReference());
+ returnType.setSchemaPath(typeDef.getPath().getPathFromRoot());
+ returnType.setModuleName(parentModule.getName());
+
genTOBuilder.setTypedef(true);
genTOBuilder.setIsUnion(true);
((TypeProviderImpl) typeProvider).addUnitsToGenTO(genTOBuilder, typeDef.getUnits());
* parent type (can be null)
* @return generated type builder <code>schemaNode</code>
*/
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode, final Type parent) {
+ private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
+ final Type parent) {
final GeneratedTypeBuilder it = addRawInterfaceDefinition(packageName, schemaNode, "");
if (parent == null) {
it.addImplementsType(DATA_OBJECT);
* </ul>
*
*/
- private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode, final String prefix) {
+ private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,
+ final String prefix) {
checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
checkArgument(packageName != null, "Package Name for Generated Type cannot be NULL.");
checkArgument(schemaNode.getQName() != null, "QName for Data Schema Node cannot be NULL.");
final GeneratedTypeBuilderImpl newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);
qnameConstant(newType, BindingMapping.QNAME_STATIC_FIELD_NAME, schemaNode.getQName());
newType.addComment(schemaNode.getDescription());
+ newType.setDescription(schemaNode.getDescription());
+ newType.setReference(schemaNode.getReference());
+ newType.setSchemaPath(schemaNode.getPath().getPathFromRoot());
+
+ final Module module = findParentModule(schemaContext, schemaNode);
+ newType.setModuleName(module.getName());
+
if (!genTypeBuilders.containsKey(packageName)) {
final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();
builders.put(genTypeName, newType);
* @return method signature builder which represents the getter method of
* <code>interfaceBuilder</code>
*/
- private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder, final String schemaNodeName,
- final String comment, final Type returnType) {
+ private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,
+ final String schemaNodeName, final String comment, final Type returnType) {
final MethodSignatureBuilder getMethod = interfaceBuilder
.addMethod(getterMethodName(schemaNodeName, returnType));
getMethod.setComment(comment);
* </ul>
*/
private void addSchemaNodeToListBuilders(final String basePackageName, final DataSchemaNode schemaNode,
- final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys, final Module module) {
+ final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys,
+ final Module module) {
checkArgument(schemaNode != null, "Data Schema Node cannot be NULL.");
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
}
}
- private void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder) {
+ private void typeBuildersToGenTypes(final Module module, final GeneratedTypeBuilder typeBuilder,
+ final GeneratedTOBuilder genTOBuilder) {
checkArgument(typeBuilder != null, "Generated Type Builder cannot be NULL.");
if (genTOBuilder != null) {
* @param leaf
* @return generated TO builder for <code>typeDef</code>
*/
- private GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef, final GeneratedTypeBuilder typeBuilder,
- final DataSchemaNode leaf) {
+ private GeneratedTOBuilder addTOToTypeBuilder(final TypeDefinition<?> typeDef,
+ final GeneratedTypeBuilder typeBuilder, final DataSchemaNode leaf, final Module parentModule) {
final String classNameFromLeaf = BindingMapping.getClassName(leaf.getQName());
final List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>();
final String packageName = typeBuilder.getFullyQualifiedName();
} else if (typeDef instanceof BitsTypeDefinition) {
genTOBuilders.add((((TypeProviderImpl) typeProvider)).provideGeneratedTOBuilderForBitsTypeDefinition(
- packageName, typeDef, classNameFromLeaf));
+ packageName, typeDef, classNameFromLeaf, parentModule.getName()));
}
if (genTOBuilders != null && !genTOBuilders.isEmpty()) {
for (GeneratedTOBuilder genTOBuilder : genTOBuilders) {
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.util.SchemaNodeUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public Class<?> getClassForPath(final List<QName> names) {
- final DataSchemaNode node = getSchemaNode(names);
+ DataSchemaNode node = getSchemaNode(names);
+ Preconditions.checkArgument(node != null, "Path %s points to invalid schema location",names);
+ SchemaNode originalDefinition = SchemaNodeUtils.getRootOriginalIfPossible(node);
+ if(originalDefinition instanceof DataSchemaNode) {
+ node =(DataSchemaNode) originalDefinition;
+ }
final SchemaPath path = node.getPath();
final Type t = pathToType.get(path);
@SuppressWarnings("rawtypes")
final WeakReference<Class> weakRef = typeToClass.get(type);
- Preconditions.checkState(weakRef != null, "Could not find loaded class for path: %s and type: %s", path,
- type.getFullyQualifiedName());
- return weakRef.get();
+ if(weakRef != null) {
+ return weakRef.get();
+ }
+ try {
+ return classLoadingStrategy.loadClass(type);
+ } catch (ClassNotFoundException e) {
+ throw new IllegalStateException(String.format("Could not find loaded class for path: %s and type: %s", path,type.getFullyQualifiedName()));
+ }
}
@Override
WeakReference<Class> weakRef = new WeakReference<>(cls);
typeToClass.put(typeRef, weakRef);
if (Augmentation.class.isAssignableFrom(cls)) {
-
+ // Intentionally NOOP
} else if (DataObject.class.isAssignableFrom(cls)) {
getCodecForDataObject((Class<? extends DataObject>) cls);
}
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.AnnotationTypeBuilder;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.yangtools.yang.binding.BindingMapping;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
private final String name;
private final List<Enumeration.Pair> values;
private final List<AnnotationTypeBuilder> annotationBuilders = new ArrayList<>();
+ private String description;
+ private String reference;
+ private String moduleName;
+ private Iterable<QName> schemaPath;
public EnumerationBuilderImpl(final String packageName, final String name) {
super(packageName, name);
values = new ArrayList<>();
}
+ public void setReference(final String reference) {
+ this.reference = reference;
+ }
+
+ public void setModuleName(final String moduleName) {
+ this.moduleName = moduleName;
+ }
+
+ public void setSchemaPath(final Iterable<QName> schemaPath) {
+ this.schemaPath = schemaPath;
+ }
+
+ @Override
+ public void setDescription(String description) {
+ this.description = description;
+
+ }
+
@Override
public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
if (packageName != null && name != null) {
}
@Override
- public void addValue(final String name, final Integer value) {
- values.add(new EnumPairImpl(name, value));
+ public void addValue(final String name, final Integer value, final String description) {
+ values.add(new EnumPairImpl(name, value, description));
}
@Override
public Enumeration toInstance(final Type definingType) {
- return new EnumerationImpl(definingType, annotationBuilders, packageName, name, values);
+ return new EnumerationImpl(definingType, annotationBuilders, packageName, name, values,
+ description, reference, moduleName, schemaPath);
+ }
+
+ @Override
+ public void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
+ final List<EnumPair> enums = enumTypeDef.getValues();
+ if (enums != null) {
+ int listIndex = 0;
+ for (final EnumPair enumPair : enums) {
+ if (enumPair != null) {
+ final String enumPairName = BindingMapping.getClassName(enumPair.getName());
+ Integer enumPairValue = enumPair.getValue();
+
+ if (enumPairValue == null) {
+ enumPairValue = listIndex;
+ }
+ else {
+ listIndex = enumPairValue;
+ }
+
+ this.addValue(enumPairName, enumPairValue, enumPair.getDescription());
+ listIndex++;
+ }
+ }
+ }
}
/*
return builder.toString();
}
- @Override
- public void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef) {
- final List<EnumPair> enums = enumTypeDef.getValues();
- if (enums != null) {
- int listIndex = 0;
- for (final EnumPair enumPair : enums) {
- if (enumPair != null) {
- final String enumPairName = BindingMapping.getClassName(enumPair.getName());
- Integer enumPairValue = enumPair.getValue();
-
- if (enumPairValue == null) {
- enumPairValue = listIndex;
- }
- this.addValue(enumPairName, enumPairValue);
- listIndex++;
- }
- }
- }
-
- }
-
private static final class EnumPairImpl implements Enumeration.Pair {
private final String name;
private final Integer value;
+ private final String description;
- public EnumPairImpl(String name, Integer value) {
+ public EnumPairImpl(String name, Integer value, String description) {
super();
this.name = name;
this.value = value;
+ this.description = description;
}
@Override
builder.append("]");
return builder.toString();
}
+
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
+ @Override
+ public String getReference() {
+ return null;
+ }
+
+ @Override
+ public Status getStatus() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
}
private static final class EnumerationImpl implements Enumeration {
private final Type definingType;
private final String packageName;
private final String name;
+ private final String description;
+ private final String reference;
+ private final String moduleName;
+ private final Iterable<QName> schemaPath;
private final List<Pair> values;
private List<AnnotationType> annotations = new ArrayList<>();
public EnumerationImpl(final Type definingType, final List<AnnotationTypeBuilder> annotationBuilders,
- final String packageName, final String name, final List<Pair> values) {
+ final String packageName, final String name, final List<Pair> values, final String description,
+ final String reference, final String moduleName, final Iterable<QName> schemaPath) {
super();
this.definingType = definingType;
for (final AnnotationTypeBuilder builder : annotationBuilders) {
this.packageName = packageName;
this.name = name;
this.values = Collections.unmodifiableList(values);
+ this.description = description;
+ this.reference = reference;
+ this.moduleName = moduleName;
+ this.schemaPath = schemaPath;
}
@Override
public List<GeneratedProperty> getProperties() {
return Collections.emptyList();
}
+
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
+ @Override
+ public String getReference() {
+ return reference;
+ }
+
+ @Override
+ public Iterable<QName> getSchemaPath() {
+ return schemaPath;
+ }
+
+ @Override
+ public String getModuleName() {
+ return moduleName;
+ }
}
}
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;
+import org.opendaylight.yangtools.yang.common.QName;
public final class GeneratedTOBuilderImpl extends AbstractGeneratedTypeBuilder<GeneratedTOBuilder> implements
GeneratedTOBuilder {
private boolean isUnionTypeBuilder = false;
private Restrictions restrictions;
private GeneratedPropertyBuilder SUID;
+ private String reference;
+ private String description;
+ private String moduleName;
+ private Iterable<QName> schemaPath;
public GeneratedTOBuilderImpl(final String packageName, final String name) {
super(packageName, name);
@Override
public GeneratedTransferObject toInstance() {
- // FIXME: can we compact the arrays now? It needs to be thread-safe, though
+ // FIXME: can we compact the arrays now? It needs to be thread-safe,
+ // though
return new GeneratedTransferObjectImpl(this);
}
this.isUnionTypeBuilder = isUnionTypeBuilder;
}
+ @Override
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ @Override
+ public void setModuleName(String moduleName) {
+ this.moduleName = moduleName;
+ }
+
+ @Override
+ public void setSchemaPath(Iterable<QName> schemaPath) {
+ this.schemaPath = schemaPath;
+ }
+
+ @Override
+ public void setReference(String reference) {
+ this.reference = reference;
+ }
+
private static final class GeneratedTransferObjectImpl extends AbstractGeneratedType implements
GeneratedTransferObject {
private final boolean isUnionTypeBuilder;
private final Restrictions restrictions;
private final GeneratedProperty SUID;
+ private final String reference;
+ private final String description;
+ private final String moduleName;
+ private final Iterable<QName> schemaPath;
public GeneratedTransferObjectImpl(final GeneratedTOBuilderImpl builder) {
super(builder);
this.isUnionType = builder.isUnionType;
this.isUnionTypeBuilder = builder.isUnionTypeBuilder;
this.restrictions = builder.restrictions;
+ this.reference = builder.reference;
+ this.description = builder.description;
+ this.moduleName = builder.moduleName;
+ this.schemaPath = builder.schemaPath;
+
if (builder.SUID == null) {
this.SUID = null;
} else {
@Override
public String toString() {
- if(isTypedef) {
+ if (isTypedef) {
return serializeTypedef(this);
}
StringBuilder builder = new StringBuilder();
}
}
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
+ @Override
+ public String getReference() {
+ return reference;
+ }
+
+ @Override
+ public Iterable<QName> getSchemaPath() {
+ return schemaPath;
+ }
+
+ @Override
+ public String getModuleName() {
+ return moduleName;
+ }
}
}
*/
package org.opendaylight.yangtools.binding.generator.util.generated.type.builder;
-
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.yangtools.yang.common.QName;
+
+public final class GeneratedTypeBuilderImpl extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements
+ GeneratedTypeBuilder {
-public final class GeneratedTypeBuilderImpl extends AbstractGeneratedTypeBuilder<GeneratedTypeBuilder> implements GeneratedTypeBuilder {
+ private String description;
+ private String reference;
+ private String moduleName;
+ private Iterable<QName> schemaPath;
- public GeneratedTypeBuilderImpl(String packageName, String name) {
+ public GeneratedTypeBuilderImpl(final String packageName, final String name) {
super(packageName, name);
setAbstract(true);
}
return new GeneratedTypeImpl(this);
}
+ @Override
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ @Override
+ public void setModuleName(String moduleName) {
+ this.moduleName = moduleName;
+ }
+
+ @Override
+ public void setSchemaPath(Iterable<QName> schemaPath) {
+ this.schemaPath = schemaPath;
+ }
+
+ @Override
+ public void setReference(String reference) {
+ this.reference = reference;
+ }
+
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("]");
return builder.toString();
}
-
+
@Override
protected GeneratedTypeBuilderImpl thisInstance() {
return this;
private static final class GeneratedTypeImpl extends AbstractGeneratedType {
+ private final String description;
+ private final String reference;
+ private final String moduleName;
+ private final Iterable<QName> schemaPath;
+
public GeneratedTypeImpl(GeneratedTypeBuilderImpl builder) {
super(builder);
+
+ this.description = builder.description;
+ this.reference = builder.reference;
+ this.moduleName = builder.moduleName;
+ this.schemaPath = builder.schemaPath;
+ }
+
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
+ @Override
+ public String getReference() {
+ return reference;
+ }
+
+ @Override
+ public Iterable<QName> getSchemaPath() {
+ return schemaPath;
+ }
+
+ @Override
+ public String getModuleName() {
+ return moduleName;
}
}
}
*/
package org.opendaylight.yangtools.sal.java.api.generator
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
-import java.util.Map
-import org.opendaylight.yangtools.sal.binding.model.api.Type
-import org.opendaylight.yangtools.binding.generator.util.Types
-import com.google.common.base.Splitter
-import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature
+import com.google.common.collect.ImmutableList
import com.google.common.collect.Range
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.util.Arrays
+import java.util.Collection
+import java.util.HashMap
import java.util.List
+import java.util.Map
+import java.util.StringTokenizer
+import org.opendaylight.yangtools.binding.generator.util.Types
import org.opendaylight.yangtools.sal.binding.model.api.ConcreteType
-import org.opendaylight.yangtools.sal.binding.model.api.Restrictions
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedProperty
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject
-import java.util.Collection
-import java.util.Arrays
-import java.util.HashMap
-import com.google.common.collect.ImmutableList
-import java.math.BigInteger
-import java.math.BigDecimal
+import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
+import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature
+import org.opendaylight.yangtools.sal.binding.model.api.Restrictions
+import org.opendaylight.yangtools.sal.binding.model.api.Type
+import org.opendaylight.yangtools.yang.common.QName
abstract class BaseTemplate {
protected val GeneratedType type;
protected val Map<String, String> importMap;
- static val paragraphSplitter = Splitter.on("\n\n").omitEmptyStrings();
+
+ private static final String NEW_LINE = '\n'
new(GeneratedType _type) {
if (_type == null) {
'''
«packageDefinition»
«imports»
-
+
«_body»
'''.toString
}
«ENDIF»
«ENDFOR»
«ENDIF»
-
+
'''
protected abstract def CharSequence body();
* @return string with comment in JAVA format
*/
def protected CharSequence asJavadoc(String comment) {
- if(comment == null) return '';
+ if(comment == null) return ''
var txt = comment
if (txt.contains("*/")) {
txt = txt.replace("*/", "*/")
}
- val paragraphs = paragraphSplitter.split(txt)
+ txt = comment.trim
+ txt = formatToParagraph(txt)
return '''
- /**
- «FOR p : paragraphs SEPARATOR "<p>"»
- «p»
- «ENDFOR»
- **/
+ «wrapToDocumentation(txt)»
'''
}
+ def String wrapToDocumentation(String text) {
+ val StringTokenizer tokenizer = new StringTokenizer(text, "\n", false)
+ val StringBuilder sb = new StringBuilder()
+
+ if(text.empty)
+ return ""
+
+ sb.append("/**")
+ sb.append(NEW_LINE)
+
+ while(tokenizer.hasMoreTokens) {
+ sb.append(" * ")
+ sb.append(tokenizer.nextToken)
+ sb.append(NEW_LINE)
+ }
+ sb.append(" */")
+
+ return sb.toString
+ }
+
+ def protected String formatDataForJavaDoc(GeneratedType type) {
+ val typeDescription = type.description
+ val typeReference = type.reference
+ val typeModuleName = type.moduleName
+ val typeSchemaPath = type.schemaPath
+
+ return '''
+ «IF !type.isDocumentationParametersNullOrEmtpy»
+ «IF typeDescription != null && !typeDescription.empty»
+ «formatToParagraph(typeDescription)»
+ «ENDIF»
+ «IF typeReference != null && !typeReference.empty»
+ Reference:
+ «formatReference(typeReference)»
+ «ENDIF»
+ «IF typeModuleName != null && !typeModuleName.empty»
+ Module name:
+ «typeModuleName»
+ «ENDIF»
+ «IF typeSchemaPath != null && !typeSchemaPath.empty»
+ Schema path:
+ «formatPath(typeSchemaPath)»
+ «ENDIF»
+ «ENDIF»
+ '''.toString
+ }
+
+ def formatPath(Iterable<QName> schemaPath) {
+ var currentElement = schemaPath.head
+ val StringBuilder sb = new StringBuilder()
+ sb.append('[')
+ sb.append(currentElement)
+
+ for(pathElement : schemaPath) {
+ if(!currentElement.namespace.equals(pathElement.namespace)) {
+ currentElement = pathElement
+ sb.append('/')
+ sb.append(pathElement)
+ }
+ else {
+ sb.append('/')
+ sb.append(pathElement.localName)
+ }
+ }
+ sb.append(']')
+ return sb.toString
+ }
+
+ def formatReference(String reference) {
+ if(reference == null || reference.isEmpty)
+ return reference
+
+ val StringTokenizer tokenizer = new StringTokenizer(reference, " ", true)
+ val StringBuilder sb = new StringBuilder();
+
+ while(tokenizer.hasMoreTokens) {
+ var String oneElement = tokenizer.nextToken
+ if (oneElement.contains("http://")) {
+ oneElement = asLink(oneElement)
+ }
+ sb.append(oneElement)
+ }
+ return sb.toString
+ }
+
+ def asLink(String text) {
+ val StringBuilder sb = new StringBuilder()
+ var tempText = text
+ var char lastChar = ' '
+ var boolean badEnding = false
+
+ if(text.endsWith(".") || text.endsWith(":") || text.endsWith(",")) {
+ tempText = text.substring(0, text.length - 1)
+ lastChar = text.charAt(text.length - 1)
+ badEnding = true
+ }
+ sb.append("<a href = \"")
+ sb.append(tempText)
+ sb.append("\">")
+ sb.append(tempText)
+ sb.append("</a>")
+
+ if(badEnding)
+ sb.append(lastChar)
+
+ return sb.toString
+ }
+
+ protected def formatToParagraph(String text) {
+ if(text == null || text.isEmpty)
+ return text
+
+ var formattedText = text
+ val StringBuilder sb = new StringBuilder();
+ var StringBuilder lineBuilder = new StringBuilder();
+ var boolean isFirstElementOnNewLineEmptyChar = false;
+
+ formattedText = formattedText.replace("*/", "*/")
+ formattedText = formattedText.replace(NEW_LINE, "")
+ formattedText = formattedText.replace("\t", "")
+ formattedText = formattedText.replaceAll(" +", " ");
+
+ val StringTokenizer tokenizer = new StringTokenizer(formattedText, " ", true);
+
+ while(tokenizer.hasMoreElements) {
+ val nextElement = tokenizer.nextElement.toString
+
+ if(lineBuilder.length + nextElement.length > 80) {
+ if (lineBuilder.charAt(lineBuilder.length - 1) == ' ') {
+ lineBuilder.setLength(0)
+ lineBuilder.append(lineBuilder.substring(0, lineBuilder.length - 1))
+ }
+ if (lineBuilder.charAt(0) == ' ') {
+ lineBuilder.setLength(0)
+ lineBuilder.append(lineBuilder.substring(1))
+ }
+
+ sb.append(lineBuilder);
+ lineBuilder.setLength(0)
+ sb.append(NEW_LINE)
+
+ if(nextElement.toString == ' ')
+ isFirstElementOnNewLineEmptyChar = !isFirstElementOnNewLineEmptyChar;
+ }
+
+ if(isFirstElementOnNewLineEmptyChar) {
+ isFirstElementOnNewLineEmptyChar = !isFirstElementOnNewLineEmptyChar
+ }
+
+ else {
+ lineBuilder.append(nextElement)
+ }
+ }
+ sb.append(lineBuilder)
+ sb.append(NEW_LINE)
+
+ return sb.toString
+ }
+
+ def isDocumentationParametersNullOrEmtpy(GeneratedType type) {
+ var boolean isNullOrEmpty = true
+ val String typeDescription = type.description
+ val String typeReference = type.reference
+ val String typeModuleName = type.moduleName
+ val Iterable<QName> typeSchemaPath = type.schemaPath
+
+ if(typeDescription != null && !typeDescription.empty) {
+ isNullOrEmpty = false
+ return isNullOrEmpty
+ }
+ if(typeReference != null && !typeReference.empty) {
+ isNullOrEmpty = false
+ return isNullOrEmpty
+ }
+ if(typeModuleName != null && !typeModuleName.empty) {
+ isNullOrEmpty = false
+ return isNullOrEmpty
+ }
+ if(typeSchemaPath != null && !typeSchemaPath.empty) {
+ isNullOrEmpty = false
+ return isNullOrEmpty
+ }
+ return isNullOrEmpty
+ }
+
def generateRestrictions(Type type, String paramName, Type returnType) '''
«val restrictions = type.getRestrictions»
«IF restrictions !== null»
return if (lastDotIndex == -1) "" else fullyQualifiedName.substring(0, lastDotIndex)
}
- /**
- * Returns the name of tye type from <code>fullyQualifiedName</code>
- *
- * @param fullyQualifiedName string with fully qualified type name (package + type)
- * @return string with the name of the type
- */
+ /**
+ * Returns the name of tye type from <code>fullyQualifiedName</code>
+ *
+ * @param fullyQualifiedName string with fully qualified type name (package + type)
+ * @return string with the name of the type
+ */
def private String getName(String fullyQualifiedName) {
val lastDotIndex = fullyQualifiedName.lastIndexOf(Constants.DOT)
return if (lastDotIndex == -1) fullyQualifiedName else fullyQualifiedName.substring(lastDotIndex + 1)
* @param method method signature from which is the method name and return type obtained
* @return generated property instance for the getter <code>method</code>
* @throws IllegalArgumentException<ul>
- * <li>if the <code>method</code> equals <code>null</code></li>
- * <li>if the name of the <code>method</code> equals <code>null</code></li>
- * <li>if the name of the <code>method</code> is empty</li>
- * <li>if the return type of the <code>method</code> equals <code>null</code></li>
+ * <li>if the <code>method</code> equals <code>null</code></li>
+ * <li>if the name of the <code>method</code> equals <code>null</code></li>
+ * <li>if the name of the <code>method</code> is empty</li>
+ * <li>if the return type of the <code>method</code> equals <code>null</code></li>
* </ul>
*/
def private GeneratedProperty propertyFromGetter(MethodSignature method) {
* @return string with JAVA source code
*/
override body() '''
-
+ «wrapToDocumentation(formatDataForJavaDoc(type))»
public class «type.name»«BUILDER» {
«generateFields(false)»
def private generateMethodFieldsFromComment(GeneratedType type) '''
/**
- Set fields from given grouping argument. Valid argument is instance of one of following types:
+ *Set fields from given grouping argument. Valid argument is instance of one of following types:
* <ul>
«FOR impl : type.getAllIfcs»
* <li>«impl.fullyQualifiedName»</li>
* @return string with class source code in JAVA format
*/
def protected generateBody(boolean isInnerClass) '''
- «type.comment.asJavadoc»
+ «wrapToDocumentation(formatDataForJavaDoc(type))»
«generateClassDeclaration(isInnerClass)» {
«suidDeclaration»
«innerClassesDeclarations»
return body
}
+ def writeEnumItem(String name, int value, String description) '''
+ «asJavadoc(formatToParagraph(description))»
+ «name»(«value»)
+ '''
+
/**
* Template method which generates enumeration body (declaration + enumeration items).
*
* @return string with the enumeration body
*/
override body() '''
+ «wrapToDocumentation(formatDataForJavaDoc(enums))»
public enum «enums.name» {
- «FOR v : enums.values SEPARATOR ",\n"»
- «" "»«v.name»(«v.value»)«
- ENDFOR»;
-
+ «writeEnumeration(enums)»
+
+
int value;
static java.util.Map<java.lang.Integer, «enums.name»> valueMap;
}
}
'''
+
+ def writeEnumeration(Enumeration enumeration)
+ '''
+ «FOR v : enumeration.values SEPARATOR ",\n" AFTER ";"»
+ «writeEnumItem(v.name, v.value, v.description)»«
+ ENDFOR»
+ '''
}
enclosedGeneratedTypes = genType.enclosedTypes
}
-
-
/**
* Template method which generate the whole body of the interface.
*
* @return string with code for interface body in JAVA format
*/
override body() '''
- «type.comment.asJavadoc»
+ «wrapToDocumentation(formatDataForJavaDoc(type))»
public interface «type.name»
«superInterfaces»
{
}
def override body() '''
- «type.comment.asJavadoc»
+ «wrapToDocumentation(formatDataForJavaDoc(type))»
public class «type.name» {
«generateMethods»
yang-version 1;
namespace "urn:opendaylight.bar";
prefix "bar";
+
+ description "bar - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
revision "2013-10-08" {
}
container network-topology {
+ description "network-topology - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
+
list topology {
+ description "topology - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
+
key "topology-id";
leaf topology-id {
+ description "topology-id - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
type int32;
}
uses link;
grouping link {
list link {
+ description "Link - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
key "link-id";
uses link-attributes;
}
grouping link-attributes {
leaf link-id {
+ description "Link-attributes - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
type int8;
}
}
+
+ leaf inclusion-rulez {
+ description "Specified rulez description.";
+ reference "RFC 6020 http://technet.com";
+
+ type string;
+ }
+ leaf inclusion-rule {
+ description "Specify how inheritance will work for this label";
+ default include;
+
+ type enumeration {
+ enum include {
+ description
+ "This label will be included normally in the
+ matching. This seems to be a little bit longer comment. I hear you very weel my darling.
+ Network topology is the arrangement of the various elements (links, nodes, etc.) of any other builder nodes types.";
+ }
+ enum exclude {
+ description
+ "This label will be excluded from the
+ matching. This allows removing labels that
+ would have otherwise been included because of
+ inheritence rules.";
+ }
+ }
+ }
}
prefix "br";
revision-date 2013-10-08;
}
+
+ description "Baz - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
revision "2013-10-08" {
}
grouping link-attributes {
container ospf-link-attributes {
+ description "Ospf-link-attributes - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
leaf multi-topology-id {
+ description "Multi-topology-id - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
+
type uint8 {
range "0..127";
}
prefix "br";
revision-date 2013-10-08;
}
+
+ description "Foo - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
revision "2013-10-08" {
}
grouping igp-link-attributes {
container igp-link-attributes {
+ description "Igp-link-attributes - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
+
leaf name {
+ description "Name - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
type string;
}
leaf-list flag {
+ description "Flag - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
type string;
}
leaf metric {
+ description "Metric - Network topology is the arrangement of the various elements (links, nodes, etc.) of a computer network.[1][2] Essentially, it is the topological[3] structure of a network, and may be depicted physically or logically. Physical topology is the placement of the various components of a network, including device location and cable installation, while logical topology illustrates how data flows within a network, regardless of its physical design. Distances between nodes, physical interconnections, transmission rates, or signal types may differ between two networks, yet their topologies may be identical.";
+ reference "RFC 6020 - http://tools.ietf.org/html/rfc6020";
type uint32 {
range "0..16777215" {
}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.sal.binding.model.api;
+
+import org.opendaylight.yangtools.yang.common.QName;
+
+/**
+ * Implementing this interface allows an object to hold information which are
+ * essential for generating java doc from type definition.
+ */
+public interface DocumentedType {
+
+ /**
+ * Returns a string that contains a human-readable textual description of
+ * type definition.
+ *
+ * @return a human-readable textual description of type definition.
+ */
+ String getDescription();
+
+ /**
+ * Returns a string that is used to specify a textual cross-reference to an
+ * external document, either another module that defines related management
+ * information, or a document that provides additional information relevant
+ * to this definition.
+ *
+ * @return a textual cross-reference to an external document.
+ */
+ String getReference();
+
+ /**
+ * Returns a list of QNames which represent schema path in schema tree from
+ * actual concrete type to the root.
+ *
+ * @return a schema path in schema tree from actual concrete schema node
+ * identifier to the root.
+ */
+ Iterable<QName> getSchemaPath();
+
+ /**
+ * Returns the name of the module, in which generated type was specified.
+ *
+ * @return the name of the module, in which generated type was specified.
+ */
+ String getModuleName();
+}
import java.util.List;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
+
/**
* Interface provide methods for reading data of enumeration class.
*/
public interface Enumeration extends GeneratedType {
/**
- *
+ *
* Returns list of annotation definitions associated with enumeration type.
- *
+ *
* @return list of annotation definitions associated with enumeration type.
- *
+ *
*/
+ @Override
List<AnnotationType> getAnnotations();
+ @Override
Type getParentType();
/**
* Returns list of the couples - name and value.
- *
+ *
* @return list of the enumeration pairs.
*/
List<Pair> getValues();
/**
* Formats enumeration according to rules of the programming language.
- *
+ *
* @return string with source code in some programming language
*/
String toFormattedString();
* Interface is used for reading enumeration item. It means item's name and
* its value.
*/
- interface Pair {
+ interface Pair extends DocumentedNode {
/**
* Returns the name of the enumeration item.
- *
+ *
* @return the name of the enumeration item.
*/
String getName();
/**
* Returns value of the enumeration item.
- *
+ *
* @return the value of the enumeration item.
*/
Integer getValue();
* <li><code>method definitions</code> with specified input parameters (with
* types) and return values</li>
* </ul>
- *
+ *
* By the definition of the interface constant, enum, enclosed types and method
* definitions MUST be public, so there is no need to specify the scope of
* visibility.
*/
-public interface GeneratedType extends Type {
+public interface GeneratedType extends Type, DocumentedType {
/**
* Returns the parent type if Generated Type is defined as enclosing type,
* otherwise returns <code>null</code>
- *
+ *
* @return the parent type if Generated Type is defined as enclosing type,
* otherwise returns <code>null</code>
*/
/**
* Returns comment string associated with Generated Type.
- *
+ *
* @return comment string associated with Generated Type.
*/
String getComment();
/**
* Returns List of annotation definitions associated with generated type.
- *
+ *
* @return List of annotation definitions associated with generated type.
*/
List<AnnotationType> getAnnotations();
/**
* Returns <code>true</code> if The Generated Type is defined as abstract.
- *
+ *
* @return <code>true</code> if The Generated Type is defined as abstract.
*/
boolean isAbstract();
/**
* Returns List of Types that Generated Type will implement.
- *
+ *
* @return List of Types that Generated Type will implement.
*/
List<Type> getImplements();
/**
* Returns List of enclosing Generated Types.
- *
+ *
* @return List of enclosing Generated Types.
*/
List<GeneratedType> getEnclosedTypes();
/**
* Returns List of all Enumerator definitions associated with Generated
* Type.
- *
+ *
* @return List of all Enumerator definitions associated with Generated
* Type.
*/
/**
* Returns List of Constant definitions associated with Generated Type.
- *
+ *
* @return List of Constant definitions associated with Generated Type.
*/
List<Constant> getConstantDefinitions();
/**
* Returns List of Method Definitions associated with Generated Type.
- *
+ *
* List does not contains getters and setters for properties.
- *
+ *
* @return List of Method Definitions associated with Generated Type.
*/
List<MethodSignature> getMethodDefinitions();
/**
* Returns List of Properties that are declared for Generated Transfer
* Object.
- *
+ *
* @return List of Properties that are declared for Generated Transfer
* Object.
*/
/**
* Enum Builder is interface that contains methods to build and instantiate
* Enumeration definition.
- *
+ *
* @see Enumeration
*/
public interface EnumBuilder extends Type {
* Neither the package name or annotation name can contain <code>null</code>
* references. In case that any of parameters contains <code>null</code> the
* method SHOULD thrown {@link IllegalArgumentException}
- *
+ *
* @param packageName
* Package Name of Annotation Type
* @param name
AnnotationTypeBuilder addAnnotation(final String packageName, final String name);
/**
- *
+ *
* @param name
* @param value
*/
- void addValue(final String name, final Integer value);
+ void addValue(final String name, final Integer value, final String description);
/**
- *
+ *
* @param definingType
* @return
*/
/**
* Updates this builder with data from <code>enumTypeDef</code>.
* Specifically this data represents list of value-name pairs.
- *
+ *
* @param enumTypeDef
* enum type definition as source of enum data for
* <code>enumBuilder</code>
*/
void updateEnumPairsFromEnumTypeDef(final EnumTypeDefinition enumTypeDef);
+ /**
+ * @param description
+ */
+ void setDescription(final String description);
+
}
package org.opendaylight.yangtools.sal.binding.model.api.type.builder;
import java.util.List;
+
import org.opendaylight.yangtools.sal.binding.model.api.Constant;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
+import org.opendaylight.yangtools.yang.common.QName;
public interface GeneratedTypeBuilderBase<T extends GeneratedTypeBuilderBase<T>> extends Type {
*/
boolean containsProperty(final String name);
+ /**
+ * Set a string that contains a human-readable textual description of type
+ * definition.
+ *
+ * @param description
+ * a string that contains a human-readable textual description of
+ * type definition.
+ */
+ public void setDescription(String description);
+
+ /**
+ * Set the name of the module, in which generated type was specified.
+ *
+ * @param moduleName
+ * the name of the module
+ */
+ public void setModuleName(String moduleName);
+
+ /**
+ * Set a list of QNames which represent schema path in schema tree from
+ * actual concrete type to the root.
+ *
+ * @param schemaPath
+ * a list of QNames which represent schema path in schema tree
+ */
+ public void setSchemaPath(Iterable<QName> schemaPath);
+
+ /**
+ * Set a string that is used to specify a textual cross-reference to an
+ * external document, either another module that defines related management
+ * information, or a document that provides additional information relevant
+ * to this definition.
+ *
+ * @param reference
+ * a textual cross-reference to an external document.
+ */
+ public void setReference(String reference);
+
}
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findParentModule;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Sets;
-import com.google.common.io.BaseEncoding;
import java.io.Serializable;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+
import org.apache.commons.lang3.StringEscapeUtils;
import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil;
import org.opendaylight.yangtools.binding.generator.util.TypeConstants;
import org.opendaylight.yangtools.yang.model.util.Uint8;
import org.opendaylight.yangtools.yang.model.util.UnionType;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Sets;
+import com.google.common.io.BaseEncoding;
+
public final class TypeProviderImpl implements TypeProvider {
private static final Pattern NUMBERS_PATTERN = Pattern.compile("[0-9]+\\z");
Preconditions.checkArgument(typeDefinition.getQName() != null,
"Type Definition cannot have non specified QName (QName cannot be NULL!)");
String typedefName = typeDefinition.getQName().getLocalName();
- Preconditions.checkArgument(typedefName != null,
- "Type Definitions Local Name cannot be NULL!");
+ Preconditions.checkArgument(typedefName != null, "Type Definitions Local Name cannot be NULL!");
if (typeDefinition instanceof ExtendedType) {
returnType = javaTypeForExtendedType(typeDefinition);
Module module = findParentModule(schemaContext, parentNode);
final String basePackageName = moduleNamespaceToPackageName(module);
- final EnumBuilder enumBuilder = new EnumerationBuilderImpl(basePackageName, enumerationName);
+ final EnumerationBuilderImpl enumBuilder = new EnumerationBuilderImpl(basePackageName, enumerationName);
+ enumBuilder.setDescription(enumTypeDef.getDescription());
+ enumBuilder.setReference(enumTypeDef.getReference());
+ enumBuilder.setModuleName(module.getName());
+ enumBuilder.setSchemaPath(enumTypeDef.getPath().getPathFromRoot());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
return enumBuilder.toInstance(null);
}
final String enumerationName = BindingMapping.getClassName(enumName);
final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);
+ enumBuilder.setDescription(enumTypeDef.getDescription());
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
return enumBuilder.toInstance(enumBuilder);
}
for (Module modul : modules) {
modulesArray[i++] = modul;
}
- final List<Module> modulesSortedByDependency = org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort.sort(modulesArray);
+ final List<Module> modulesSortedByDependency = org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort
+ .sort(modulesArray);
for (final Module module : modulesSortedByDependency) {
Map<Date, Map<String, Type>> dateTypeMap = genTypeDefsContextMap.get(module.getName());
Type returnType = null;
if (innerTypeDefinition instanceof ExtendedType) {
ExtendedType innerExtendedType = (ExtendedType) innerTypeDefinition;
- returnType = provideGeneratedTOFromExtendedType(typedef, innerExtendedType, basePackageName);
+ returnType = provideGeneratedTOFromExtendedType(typedef, innerExtendedType, basePackageName,
+ module.getName());
} else if (innerTypeDefinition instanceof UnionTypeDefinition) {
final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForUnionTypeDef(basePackageName,
(UnionTypeDefinition) innerTypeDefinition, typedefName, typedef);
} else if (innerTypeDefinition instanceof BitsTypeDefinition) {
final BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) innerTypeDefinition;
final GeneratedTOBuilder genTOBuilder = provideGeneratedTOBuilderForBitsTypeDefinition(
- basePackageName, bitsTypeDefinition, typedefName);
+ basePackageName, bitsTypeDefinition, typedefName, module.getName());
genTOBuilder.setTypedef(true);
addUnitsToGenTO(genTOBuilder, typedef.getUnits());
makeSerializable((GeneratedTOBuilderImpl) genTOBuilder);
} else {
final Type javaType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER.javaTypeForSchemaDefinitionType(
innerTypeDefinition, typedef);
- returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType);
+ returnType = wrapJavaTypeIntoTO(basePackageName, typedef, javaType, module.getName());
}
if (returnType != null) {
final Map<Date, Map<String, Type>> modulesByDate = genTypeDefsContextMap.get(moduleName);
* @return generated transfer object which represent<code>javaType</code>
*/
private GeneratedTransferObject wrapJavaTypeIntoTO(final String basePackageName, final TypeDefinition<?> typedef,
- final Type javaType) {
+ final Type javaType, final String moduleName) {
Preconditions.checkNotNull(javaType, "javaType cannot be null");
final String propertyName = "value";
- final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef);
+ final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(basePackageName, typedef, moduleName);
genTOBuilder.setRestrictions(BindingGeneratorUtil.getRestrictions(typedef));
final GeneratedPropertyBuilder genPropBuilder = genTOBuilder.addProperty(propertyName);
genPropBuilder.setReturnType(javaType);
final List<GeneratedTOBuilder> generatedTOBuilders = new ArrayList<>();
final List<TypeDefinition<?>> unionTypes = typedef.getTypes();
+ final Module module = findParentModule(schemaContext, parentNode);
- final GeneratedTOBuilder unionGenTOBuilder;
+ final GeneratedTOBuilderImpl unionGenTOBuilder;
if (typeDefName != null && !typeDefName.isEmpty()) {
final String typeName = BindingMapping.getClassName(typeDefName);
unionGenTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName);
+ unionGenTOBuilder.setDescription(typedef.getDescription());
+ unionGenTOBuilder.setReference(typedef.getReference());
+ unionGenTOBuilder.setSchemaPath(typedef.getPath().getPathFromRoot());
+ unionGenTOBuilder.setModuleName(module.getName());
} else {
- unionGenTOBuilder = typedefToTransferObject(basePackageName, typedef);
+ unionGenTOBuilder = typedefToTransferObject(basePackageName, typedef, module.getName());
}
generatedTOBuilders.add(unionGenTOBuilder);
* list of strings with the regular expressions
*/
private void resolveExtendedSubtypeAsUnion(final GeneratedTOBuilder parentUnionGenTOBuilder,
- final ExtendedType unionSubtype, final List<String> regularExpressions,
- final SchemaNode parentNode) {
+ final ExtendedType unionSubtype, final List<String> regularExpressions, final SchemaNode parentNode) {
final String unionTypeName = unionSubtype.getQName().getLocalName();
final Type genTO = findGenTO(unionTypeName, unionSubtype);
if (genTO != null) {
* generated TO builder which is converted to generated TO and
* stored
*/
- private void storeGenTO(final TypeDefinition<?> newTypeDef, final GeneratedTOBuilder genTOBuilder, final SchemaNode parentNode) {
+ private void storeGenTO(final TypeDefinition<?> newTypeDef, final GeneratedTOBuilder genTOBuilder,
+ final SchemaNode parentNode) {
if (!(newTypeDef instanceof UnionType)) {
final Module parentModule = findParentModule(schemaContext, parentNode);
* @return generated TO builder which contains data from
* <code>typedef</code> and <code>basePackageName</code>
*/
- private GeneratedTOBuilder typedefToTransferObject(final String basePackageName, final TypeDefinition<?> typedef) {
+ private GeneratedTOBuilderImpl typedefToTransferObject(final String basePackageName,
+ final TypeDefinition<?> typedef, final String moduleName) {
final String packageName = packageNameForGeneratedType(basePackageName, typedef.getPath());
final String typeDefTOName = typedef.getQName().getLocalName();
if ((packageName != null) && (typedef != null) && (typeDefTOName != null)) {
final String genTOName = BindingMapping.getClassName(typeDefTOName);
- final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(packageName, genTOName);
- newType.addComment(typedef.getDescription());
+ final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTOName);
+
+ newType.setDescription(typedef.getDescription());
+ newType.setReference(typedef.getReference());
+ newType.setSchemaPath(typedef.getPath().getPathFromRoot());
+ newType.setModuleName(moduleName);
+
return newType;
}
return null;
* </ul>
*/
public GeneratedTOBuilder provideGeneratedTOBuilderForBitsTypeDefinition(final String basePackageName,
- final TypeDefinition<?> typeDef, final String typeDefName) {
+ final TypeDefinition<?> typeDef, final String typeDefName, final String moduleName) {
Preconditions.checkArgument(typeDef != null, "typeDef cannot be NULL!");
Preconditions.checkArgument(basePackageName != null, "Base Package Name cannot be NULL!");
BitsTypeDefinition bitsTypeDefinition = (BitsTypeDefinition) typeDef;
final String typeName = BindingMapping.getClassName(typeDefName);
- final GeneratedTOBuilder genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName);
+ final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, typeName);
+
+ genTOBuilder.setDescription(typeDef.getDescription());
+ genTOBuilder.setReference(typeDef.getReference());
+ genTOBuilder.setSchemaPath(typeDef.getPath().getPathFromRoot());
+ genTOBuilder.setModuleName(moduleName);
final List<Bit> bitList = bitsTypeDefinition.getBits();
GeneratedPropertyBuilder genPropertyBuilder;
* </ul>
*/
private GeneratedTransferObject provideGeneratedTOFromExtendedType(final TypeDefinition<?> typedef,
- final ExtendedType innerExtendedType, final String basePackageName) {
+ final ExtendedType innerExtendedType, final String basePackageName, final String moduleName) {
Preconditions.checkArgument(innerExtendedType != null, "Extended type cannot be NULL!");
Preconditions.checkArgument(basePackageName != null, "String with base package name cannot be NULL!");
final String classTypedefName = BindingMapping.getClassName(typedefName);
final String innerTypeDef = innerExtendedType.getQName().getLocalName();
final GeneratedTOBuilderImpl genTOBuilder = new GeneratedTOBuilderImpl(basePackageName, classTypedefName);
+
+ genTOBuilder.setDescription(typedef.getDescription());
+ genTOBuilder.setReference(typedef.getReference());
+ genTOBuilder.setSchemaPath(typedef.getPath().getPathFromRoot());
+ genTOBuilder.setModuleName(moduleName);
genTOBuilder.setTypedef(true);
Restrictions r = BindingGeneratorUtil.getRestrictions(typedef);
genTOBuilder.setRestrictions(r);
return sb.toString();
}
- private String bitsToDef(final BitsTypeDefinition type, final String className, final String defaultValue, final boolean isExt) {
+ private String bitsToDef(final BitsTypeDefinition type, final String className, final String defaultValue,
+ final boolean isExt) {
List<Bit> bits = new ArrayList<>(type.getBits());
Collections.sort(bits, new Comparator<Bit>() {
@Override
return localName;
}
- /**
- * QName Constructor.
- *
- * @param namespace
- * the namespace assigned to the YANG module
- * @param revision
- * the revision of the YANG module
- * @param localName
- * YANG schema identifier
- *
- * @deprecated Use {@link #create(URI, Date, String)} instead.
- */
- @Deprecated
- public QName(final URI namespace, final Date revision, final String localName) {
- this(QNameModule.create(namespace, revision), null, localName);
- }
-
- /**
- * Construct new QName which reuses namespace, revision and prefix from
- * base.
- *
- * @param base
- * @param localName
- * @deprecated Use {@link #create(QName, String)} instead.
- */
- @Deprecated
- public QName(final QName base, final String localName) {
- this(base.getModule(), base.getPrefix(), localName);
- }
-
- /**
- * @deprecated Use {@link #create(String)} instead. This implementation is
- * broken.
- */
- @Deprecated
- public QName(final String input) throws ParseException {
- final String nsAndRev = input.substring(input.indexOf("(") + 1, input.indexOf(")"));
- final Date revision;
- final URI namespace;
- if (nsAndRev.contains("?")) {
- String[] splitted = nsAndRev.split("\\?");
- namespace = URI.create(splitted[0]);
- revision = getRevisionFormat().parse(splitted[1]);
- } else {
- namespace = URI.create(nsAndRev);
- revision = null;
- }
-
- this.localName = checkLocalName(input.substring(input.indexOf(")") + 1));
- this.prefix = null;
- this.module = QNameModule.create(namespace, revision);
- }
-
public static QName create(final String input) {
Matcher matcher = QNAME_PATTERN_FULL.matcher(input);
if (matcher.matches()) {
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Function;
-import com.google.common.base.Objects;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableList;
-
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.dom.DOMResult;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.AttributesContainer;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
-public class XmlDocumentUtils {
+import com.google.common.base.Function;
+import com.google.common.base.Objects;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+public class XmlDocumentUtils {
private static class ElementWithSchemaContext {
Element element;
SchemaContext schemaContext;
}
}
+ public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"), null, "operation");
+ private static final Logger logger = LoggerFactory.getLogger(XmlDocumentUtils.class);
+ private static final XMLOutputFactory FACTORY = XMLOutputFactory.newFactory();
private static final XmlCodecProvider DEFAULT_XML_VALUE_CODEC_PROVIDER = new XmlCodecProvider() {
-
@Override
public TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> codecFor(final TypeDefinition<?> baseType) {
return TypeDefinitionAwareCodec.from(baseType);
}
};
- private static final Logger logger = LoggerFactory.getLogger(XmlDocumentUtils.class);
-
/**
* Converts Data DOM structure to XML Document for specified XML Codec Provider and corresponding
* Data Node Container schema. The CompositeNode data parameter enters as root of Data DOM tree and will
Preconditions.checkNotNull(data);
Preconditions.checkNotNull(schema);
- Document doc = getDocument();
+ if (!(schema instanceof ContainerSchemaNode || schema instanceof ListSchemaNode)) {
+ throw new UnsupportedDataTypeException("Schema can be ContainerSchemaNode or ListSchemaNode. Other types are not supported yet.");
+ }
- if (schema instanceof ContainerSchemaNode || schema instanceof ListSchemaNode) {
- doc.appendChild(createXmlRootElement(doc, data, (SchemaNode) schema, codecProvider));
- return doc;
- } else {
- throw new UnsupportedDataTypeException(
- "Schema can be ContainerSchemaNode or ListSchemaNode. Other types are not supported yet.");
+ final DOMResult result = new DOMResult();
+ result.setNode(getDocument());
+ try {
+ final XMLStreamWriter writer = FACTORY.createXMLStreamWriter(result);
+ XmlStreamUtils.create(codecProvider).writeDocument(writer, data, (SchemaNode)schema);
+ writer.close();
+ return (Document)result.getNode();
+ } catch (XMLStreamException e) {
+ logger.error("Failed to serialize data {}", data, e);
+ return null;
}
}
* @return new instance of XML Document
* @throws UnsupportedDataTypeException
*/
- public static Document toDocument(final CompositeNode data, final XmlCodecProvider codecProvider)
- throws UnsupportedDataTypeException {
- Preconditions.checkNotNull(data);
-
- DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
- dbf.setNamespaceAware(true);
- Document doc = null;
+ public static Document toDocument(final CompositeNode data, final XmlCodecProvider codecProvider) {
+ final DOMResult result = new DOMResult();
try {
- DocumentBuilder bob = dbf.newDocumentBuilder();
- doc = bob.newDocument();
- } catch (ParserConfigurationException e) {
+ final XMLStreamWriter writer = FACTORY.createXMLStreamWriter(result);
+ XmlStreamUtils.create(codecProvider).writeDocument(writer, data);
+ writer.close();
+ return (Document)result.getNode();
+ } catch (XMLStreamException e) {
+ logger.error("Failed to serialize data {}", data, e);
return null;
}
-
- doc.appendChild(createXmlRootElement(doc, data, null, codecProvider));
- return doc;
- }
-
- private static Element createXmlRootElement(final Document doc, final Node<?> data, final SchemaNode schema,
- final XmlCodecProvider codecProvider) throws UnsupportedDataTypeException {
- Element itemEl = createElementFor(doc, data);
- if (data instanceof SimpleNode<?>) {
- if (schema instanceof LeafListSchemaNode) {
- writeValueByType(itemEl, (SimpleNode<?>) data, ((LeafListSchemaNode) schema).getType(),
- (DataSchemaNode) schema, codecProvider);
- } else if (schema instanceof LeafSchemaNode) {
- writeValueByType(itemEl, (SimpleNode<?>) data, ((LeafSchemaNode) schema).getType(),
- (DataSchemaNode) schema, codecProvider);
- } else {
- Object value = data.getValue();
- if (value != null) {
- itemEl.setTextContent(String.valueOf(value));
- }
- }
- } else { // CompositeNode
- for (Node<?> child : ((CompositeNode) data).getValue()) {
- DataSchemaNode childSchema = null;
- if (schema instanceof DataNodeContainer) {
- childSchema = findFirstSchema(child.getNodeType(), ((DataNodeContainer) schema).getChildNodes()).orNull();
- if (logger.isDebugEnabled()) {
- if (childSchema == null) {
- logger.debug("Probably the data node \""
- + ((child == null) ? "" : child.getNodeType().getLocalName())
- + "\" is not conform to schema");
- }
- }
- }
- itemEl.appendChild(createXmlRootElement(doc, child, childSchema, codecProvider));
- }
- }
- return itemEl;
}
private static final Element createElementFor(final Document doc, final QName qname, final Object obj) {
return ImmutableCompositeNode.create(qName, values, modifyAction.orNull());
}
- public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(URI.create("urn:ietf:params:xml:ns:netconf:base:1.0"), null, "operation");
-
public static Optional<ModifyAction> getModifyOperationFromAttributes(final Element xmlElement) {
Attr attributeNodeNS = xmlElement.getAttributeNodeNS(OPERATION_ATTRIBUTE_QNAME.getNamespace().toString(), OPERATION_ATTRIBUTE_QNAME.getLocalName());
if(attributeNodeNS == null) {
--- /dev/null
+package org.opendaylight.yangtools.yang.data.impl.schema.tree;
+
+import com.google.common.base.Optional;
+import junit.framework.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Map;
+
+import static org.junit.Assert.*;
+import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.*;
+
+
+public class TreeNodeUtilsTest {
+ private static final Logger LOG = LoggerFactory.getLogger(TreeNodeUtilsTest.class);
+
+ private static final Short ONE_ID = 1;
+ private static final Short TWO_ID = 2;
+ private static final String TWO_ONE_NAME = "one";
+ private static final String TWO_TWO_NAME = "two";
+
+ private static final InstanceIdentifier OUTER_LIST_1_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID) //
+ .build();
+
+ private static final InstanceIdentifier OUTER_LIST_2_PATH = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
+ .build();
+
+ private static final InstanceIdentifier TWO_TWO_PATH = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ .node(TestModel.INNER_LIST_QNAME) //
+ .nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, TWO_TWO_NAME) //
+ .build();
+
+ private static final MapEntryNode BAR_NODE = mapEntryBuilder(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, TWO_ID) //
+ .withChild(mapNodeBuilder(TestModel.INNER_LIST_QNAME) //
+ .withChild(mapEntry(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, TWO_ONE_NAME)) //
+ .withChild(mapEntry(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, TWO_TWO_NAME)) //
+ .build()) //
+ .build();
+
+ private SchemaContext schemaContext;
+ private RootModificationApplyOperation rootOper;
+
+ @Before
+ public void prepare() {
+ schemaContext = TestModel.createTestContext();
+ assertNotNull("Schema context must not be null.", schemaContext);
+ rootOper = RootModificationApplyOperation.from(SchemaAwareApplyOperation.from(schemaContext));
+ }
+
+ public NormalizedNode<?, ?> createDocumentOne() {
+ return ImmutableContainerNodeBuilder
+ .create()
+ .withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
+ .withChild(createTestContainer()).build();
+
+ }
+
+ private ContainerNode createTestContainer() {
+ return ImmutableContainerNodeBuilder
+ .create()
+ .withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
+ .withChild(
+ mapNodeBuilder(TestModel.OUTER_LIST_QNAME)
+ .withChild(mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, ONE_ID))
+ .withChild(BAR_NODE).build()).build();
+ }
+
+ private static <T> T assertPresentAndType(final Optional<?> potential, final Class<T> type) {
+ assertNotNull(potential);
+ assertTrue(potential.isPresent());
+ assertTrue(type.isInstance(potential.get()));
+ return type.cast(potential.get());
+ }
+
+ @Test
+ public void findNodeTestNodeFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ Optional<TreeNode> node = TreeNodeUtils.findNode(rootNode, OUTER_LIST_1_PATH);
+ assertPresentAndType(node, TreeNode.class);
+ }
+
+ @Test
+ public void findNodeTestNodeNotFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final InstanceIdentifier outerList1InvalidPath = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
+ .build();
+ Optional<TreeNode> node = TreeNodeUtils.findNode(rootNode, outerList1InvalidPath);
+ Assert.assertFalse(node.isPresent());
+ }
+
+ @Test
+ public void findNodeCheckedTestNodeFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ TreeNode foundNode = null;
+ try {
+ foundNode = TreeNodeUtils.findNodeChecked(rootNode, OUTER_LIST_1_PATH);
+ } catch (IllegalArgumentException e) {
+ fail("Illegal argument exception was thrown and should not have been" + e.getMessage());
+ }
+ Assert.assertNotNull(foundNode);
+ }
+
+ @Test
+ public void findNodeCheckedTestNodeNotFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final InstanceIdentifier outerList1InvalidPath = InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)
+ .nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, 3) //
+ .build();
+ try {
+ TreeNodeUtils.findNodeChecked(rootNode, outerList1InvalidPath);
+ fail("Illegal argument exception should have been thrown");
+ } catch (IllegalArgumentException e) {
+ LOG.debug("Illegal argument exception was thrown as expected: '{}' - '{}'", e.getClass(), e.getMessage());
+ }
+ }
+
+ @Test
+ public void findClosestOrFirstMatchTestNodeExists() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ Optional<TreeNode> expectedNode = TreeNodeUtils.findNode(rootNode, TWO_TWO_PATH);
+ assertPresentAndType(expectedNode, TreeNode.class);
+ Map.Entry<InstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, TWO_TWO_PATH);
+ Assert.assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
+ }
+
+ @Test
+ public void findClosestOrFirstMatchTestNodeDoesNotExist() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ final InstanceIdentifier outerListInnerListPath = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ .node(TestModel.INNER_LIST_QNAME)
+ .build();
+ final InstanceIdentifier twoTwoInvalidPath = InstanceIdentifier.builder(OUTER_LIST_2_PATH)
+ .node(TestModel.INNER_LIST_QNAME) //
+ .nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, "three") //
+ .build();
+ Optional<TreeNode> expectedNode = TreeNodeUtils.findNode(rootNode, outerListInnerListPath);
+ assertPresentAndType(expectedNode, TreeNode.class);
+ Map.Entry<InstanceIdentifier, TreeNode> actualNode = TreeNodeUtils.findClosest(rootNode, twoTwoInvalidPath);
+ Assert.assertEquals("Expected node and actual node are not the same", expectedNode.get(), actualNode.getValue());
+ }
+
+ @Test
+ public void getChildTestChildFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ Optional<TreeNode> node = TreeNodeUtils.getChild(Optional.fromNullable(rootNode),
+ TestModel.TEST_PATH.getLastPathArgument());
+ assertPresentAndType(node, TreeNode.class);
+ }
+
+ @Test
+ public void getChildTestChildNotFound() {
+ InMemoryDataTreeSnapshot inMemoryDataTreeSnapshot = new InMemoryDataTreeSnapshot(schemaContext,
+ TreeNodeFactory.createTreeNode(createDocumentOne(), Version.initial()), rootOper);
+ TreeNode rootNode = inMemoryDataTreeSnapshot.getRootNode();
+ Optional<TreeNode> node = TreeNodeUtils.getChild(Optional.fromNullable(rootNode),
+ TestModel.OUTER_LIST_PATH.getLastPathArgument());
+ Assert.assertFalse(node.isPresent());
+ }
+}
}
final List<QName> pathList = new ArrayList<QName>();
for (final String path : actualPath) {
- final QName qname = new QName(namespace, revision, path);
+ final QName qname = QName.create(namespace, revision, path);
if (qname != null) {
pathList.add(qname);
}
*/
package org.opendaylight.yangtools.yang.model.util;
+import com.google.common.base.Preconditions;
import java.util.Collections;
import java.util.List;
-
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.RevisionAwareXPath;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
-import com.google.common.base.Preconditions;
-
/**
* The <code>default</code> implementation of Instance Leafref Type Definition
* interface.
*/
public final class Leafref implements LeafrefTypeDefinition {
private static final QName NAME = BaseTypes.constructQName("leafref");
- private static final SchemaPath PATH = BaseTypes.schemaPath(NAME);
+ private static final SchemaPath PATH = SchemaPath.create(true, NAME);
private static final String DESCRIPTION = "The leafref type is used to reference a particular leaf instance in the data tree.";
private static final String REF = "https://tools.ietf.org/html/rfc6020#section-9.9";
import java.util.Set;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
public class TwoRevisionsTest {
@Test
public void testTwoRevisions() throws Exception {
- YangModelParser parser = new YangParserImpl();
-
Set<Module> modules = TestUtils.loadModules(getClass().getResource("/ietf").toURI());
assertEquals(2, TestUtils.findModules(modules, "network-topology").size());
-
- SchemaContext schemaContext = parser.resolveSchemaContext(modules);
- assertEquals(2, TestUtils.findModules(schemaContext.getModules(), "network-topology").size());
-
}
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import com.google.common.base.Optional;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
@Test
public void testMustEqualsBranch() {
assertEquals("rh should equal to rh1", rh, rh1);
- rh1.setMust(new MustDefinitionImpl("mustStr1", "description1", "reference1", "errorAppTag1", "errorMessage1"));
+ rh1.setMust(MustDefinitionImpl.create("mustStr1", Optional.of("description1"), Optional.of("reference1"),
+ Optional.of("errorAppTag1"), Optional.of("errorMessage1")));
assertFalse("rh shouldn't equal to rh1", rh.equals(rh1));
- rh.setMust(new MustDefinitionImpl("mustStr1", "description1", "reference1", "errorAppTag1", "errorMessage1"));
+ rh.setMust(MustDefinitionImpl.create("mustStr1", Optional.of("description1"), Optional.of("reference1"),
+ Optional.of("errorAppTag1"), Optional.of("errorMessage1")));
assertEquals("rh should equal to rh1", rh, rh1);
- rh.setMust(new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage"));
+ rh.setMust(MustDefinitionImpl.create("mustStr", Optional.of("description"), Optional.of("reference"),
+ Optional.of("errorAppTag"), Optional.of("errorMessage")));
assertFalse("rh shouldn't equal to rh1", rh.equals(rh1));
- rh1.setMust(new MustDefinitionImpl("mustStr", "description", "reference", "errorAppTag", "errorMessage"));
+ rh1.setMust(MustDefinitionImpl.create("mustStr", Optional.of("description"), Optional.of("reference"),
+ Optional.of("errorAppTag"), Optional.of("errorMessage")));
}
@Test
Code Review / yangtools.git / commitdiff