import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
public class TypeProviderWrapper {
private final TypeProvider typeProvider;
}
public Type getType(LeafSchemaNode leaf) {
+ TypeDefinition<?> type = leaf.getType();
+ return getType(leaf, type);
+ }
+
+ public Type getType(SchemaNode leaf, TypeDefinition<?> type) {
Type javaType;
try {
javaType = typeProvider.javaTypeForSchemaDefinitionType(
- leaf.getType(), leaf);
+ type, leaf);
if (javaType == null)
throw new IllegalArgumentException("Unknown type received for "
+ leaf.toString());
return javaType;
}
+ public String getJMXParamForBaseType(TypeDefinition<?> baseType) {
+ return typeProvider.getConstructorPropertyName(baseType);
+ }
}
public abstract class AbstractAttribute implements AttributeIfc {
private final String attributeYangName, upperCaseCammelCase,
lowerCaseCammelCase;
- private final DataSchemaNode node;
+ protected final DataSchemaNode node;
private static String getLocalName(DataSchemaNode attrNode) {
return attrNode.getQName().getLocalName();
*/
package org.opendaylight.controller.config.yangjmxgenerator.attribute;
-import javax.management.ObjectName;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-
import org.opendaylight.controller.config.yangjmxgenerator.ServiceInterfaceEntry;
import org.opendaylight.yangtools.binding.generator.util.Types;
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import javax.management.ObjectName;
+import javax.management.openmbean.SimpleType;
+
public class DependencyAttribute extends AbstractAttribute implements
TypedAttribute {
}
@Override
- public OpenType<?> getOpenType() {
+ public SimpleType<?> getOpenType() {
return SimpleType.OBJECTNAME;
}
import org.opendaylight.yangtools.sal.binding.model.api.Type;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
import javax.management.openmbean.OpenDataException;
import javax.management.openmbean.OpenType;
import javax.management.openmbean.SimpleType;
private final Type type;
private final String nullableDescription, nullableDefault;
+ private final TypeProviderWrapper typeProviderWrapper;
+ private final TypeDefinition<?> typeDefinition;
public JavaAttribute(LeafSchemaNode leaf,
TypeProviderWrapper typeProviderWrapper) {
super(leaf);
this.type = typeProviderWrapper.getType(leaf);
+ this.typeDefinition = leaf.getType();
+ this.typeProviderWrapper = typeProviderWrapper;
this.nullableDefault = leaf.getDefault();
this.nullableDescription = leaf.getDescription();
}
TypeProviderWrapper typeProviderWrapper) {
super(leaf);
this.type = typeProviderWrapper.getType(leaf);
+ this.typeDefinition = leaf.getType();
+ this.typeProviderWrapper = typeProviderWrapper;
this.nullableDefault = null;
this.nullableDescription = leaf.getDescription();
}
+ /**
+ * Returns the most base type
+ */
+ private TypeDefinition<?> getBaseType(TypeProviderWrapper typeProviderWrapper, TypeDefinition<?> baseType) {
+ while(baseType.getBaseType()!=null) {
+ baseType = baseType.getBaseType();
+ }
+ return baseType;
+ }
+
@Override
public Type getType() {
return type;
@Override
public OpenType<?> getOpenType() {
- // If is array => arrayType
- if (isArray(getType())) {
- String innerTypeFullyQName = getInnerType(getType());
- SimpleType<?> innerSimpleType = SimpleTypeResolver
- .getSimpleType(innerTypeFullyQName);
- try {
- ArrayType<Object> arrayType = isPrimitive(innerTypeFullyQName) ? new ArrayType<>(
- innerSimpleType, true) : new ArrayType<>(1,
- innerSimpleType);
- return arrayType;
- } catch (OpenDataException e) {
- throw new RuntimeException("Unable to create "
- + ArrayType.class + " with inner element of type "
- + innerSimpleType, e);
- }
+ TypeDefinition<?> baseTypeDefinition = getBaseType(typeProviderWrapper, typeDefinition);
+ Type baseType = typeProviderWrapper.getType(baseTypeDefinition, baseTypeDefinition);
+
+ if (isArray()) {
+ return getArrayType();
+ } else if (isDerivedType(baseType)) {
+ return getCompositeType(baseType, baseTypeDefinition);
}
- // else simple type
+
+ return getSimpleType();
+ }
+
+ private OpenType<?> getSimpleType() {
SimpleType<?> simpleType = SimpleTypeResolver.getSimpleType(getType());
return simpleType;
}
+ private OpenType<?> getCompositeType(Type baseType, TypeDefinition<?> baseTypeDefinition) {
+
+ SimpleType<?> innerItemType = SimpleTypeResolver.getSimpleType(baseType);
+ String innerItemName = typeProviderWrapper.getJMXParamForBaseType(baseTypeDefinition);
+
+ String[] itemNames = new String[]{innerItemName};
+ String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
+
+ OpenType<?>[] itemTypes = new OpenType[]{innerItemType};
+ try {
+ return new CompositeType(getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes);
+ } catch (OpenDataException e) {
+ throw new RuntimeException("Unable to create " + CompositeType.class + " with inner element of type "
+ + itemTypes, e);
+ }
+
+ }
+
+ private OpenType<?> getArrayType() {
+ String innerTypeFullyQName = getInnerType(getType());
+ SimpleType<?> innerSimpleType = SimpleTypeResolver.getSimpleType(innerTypeFullyQName);
+ try {
+ ArrayType<Object> arrayType = isPrimitive(innerTypeFullyQName) ? new ArrayType<>(innerSimpleType, true)
+ : new ArrayType<>(1, innerSimpleType);
+ return arrayType;
+ } catch (OpenDataException e) {
+ throw new RuntimeException("Unable to create " + ArrayType.class + " with inner element of type "
+ + innerSimpleType, e);
+ }
+ }
+
// TODO verify
private boolean isPrimitive(String innerTypeFullyQName) {
if (innerTypeFullyQName.contains("."))
return true;
}
+ private boolean isArray() {
+ return type.getName().endsWith("[]");
+ }
+
+ private boolean isDerivedType(Type baseType) {
+ return baseType.equals(getType()) == false;
+ }
+
private static String getInnerType(Type type) {
String fullyQualifiedName = type.getFullyQualifiedName();
return fullyQualifiedName.substring(0, fullyQualifiedName.length() - 2);
}
- private static boolean isArray(Type type) {
- return type.getName().endsWith("[]");
- }
-
}
*/
package org.opendaylight.controller.config.yangjmxgenerator.attribute;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import org.opendaylight.yangtools.sal.binding.model.api.Type;
+
+import javax.management.openmbean.SimpleType;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import java.util.Map;
-import javax.management.openmbean.SimpleType;
-
-import org.opendaylight.yangtools.sal.binding.model.api.Type;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
-
public class SimpleTypeResolver {
public static SimpleType<?> getSimpleType(Type type) {
return expectedSimpleType;
}
+ public static boolean canResolve(Type type) {
+ return JAVA_TYPE_TO_SIMPLE_TYPE.containsKey(type.getFullyQualifiedName());
+ }
+
public static SimpleType<?> getSimpleType(String fullyQualifiedName) {
SimpleType<?> expectedSimpleType = JAVA_TYPE_TO_SIMPLE_TYPE
.get(fullyQualifiedName);
*/
package org.opendaylight.controller.config.yangjmxgenerator.attribute;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenDataException;
-import javax.management.openmbean.OpenType;
-
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry;
import org.opendaylight.controller.config.yangjmxgenerator.TypeProviderWrapper;
import org.opendaylight.yangtools.yang.model.api.AugmentationTarget;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
-import com.google.common.base.Function;
-import com.google.common.collect.Collections2;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenDataException;
+import javax.management.openmbean.OpenType;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
public class TOAttribute extends AbstractAttribute {
createInnerAttribute(dataSchemaNode,
typeProviderWrapper));
} catch (IllegalArgumentException e) {
- throw new IllegalStateException("Unable to create TO");
+ throw new IllegalStateException("Unable to create TO", e);
}
}
return new TOAttribute(containerSchemaNode, map, attributeNameMap,
}
@Override
- public OpenType<?> getOpenType() {
+ public CompositeType getOpenType() {
String description = getNullableDescription() == null ? getAttributeYangName()
: getNullableDescription();
final String[] itemNames = new String[yangNameToAttributeMap.keySet()
</dependency>
</dependencies>
-
-
<build>
<plugins>
<plugin>
<groupId>org.opendaylight.yangtools</groupId>
<artifactId>yang-maven-plugin</artifactId>
+ <version>${opendaylight.yang.version}</version>
+ <executions>
+ <execution>
+ <id>config</id>
+ <goals>
+ <goal>generate-sources</goal>
+ </goals>
+ <configuration>
+ <yangFilesRootDir>src/main/yang</yangFilesRootDir>
+ <codeGenerators>
+ <generator>
+ <codeGeneratorClass>
+ org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+ </codeGeneratorClass>
+ <outputBaseDir>${jmxGeneratorPath}</outputBaseDir>
+ <additionalConfiguration>
+ <namespaceToPackage1>
+ urn:opendaylight:params:xml:ns:yang:controller==org.opendaylight.controller.config.yang
+ </namespaceToPackage1>
+ </additionalConfiguration>
+ </generator>
+ </codeGenerators>
+ <inspectDependencies>true</inspectDependencies>
+ </configuration>
+ </execution>
+
+ <execution>
+ <id>types</id>
+ <goals>
+ <goal>generate-sources</goal>
+ </goals>
+ <configuration>
+ <yangFilesRootDir>src/main/yang/types</yangFilesRootDir>
+ <codeGenerators>
+ <generator>
+ <codeGeneratorClass>
+ org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl
+ </codeGeneratorClass>
+ <outputBaseDir>
+ target/generated-sources/sal
+ </outputBaseDir>
+ </generator>
+ </codeGenerators>
+ <inspectDependencies>true</inspectDependencies>
+ </configuration>
+ </execution>
+ </executions>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>yang-jmx-generator-plugin</artifactId>
+ <version>${config.version}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>maven-sal-api-gen-plugin</artifactId>
+ <version>${yangtools.binding.version}</version>
+ </dependency>
+ </dependencies>
</plugin>
</plugins>
</build>
import config { prefix config; revision-date 2013-04-05; }
import ietf-inet-types { prefix inet; revision-date 2010-09-24;}
import rpc-context { prefix rpcx; revision-date 2013-06-17; }
-
+ import test-types { prefix tt; revision-date 2013-11-27; }
description
"Testing IMPL";
type string;
}
+ leaf extended {
+ type tt:extend-once;
+ }
+
+ leaf extended-twice {
+ type tt:extend-twice;
+ }
+
+/* TODO Add support for enums
+
+ leaf extended-enum {
+ type tt:extend-enum;
+ }
+*/
container dto-c {
leaf simple-arg {
type uint32;
--- /dev/null
+module test-types {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:config:test:types";
+ prefix "tt";
+
+ description
+ "Types generated for testing";
+
+ revision "2013-11-27";
+
+ typedef extend-once {
+ type uint16;
+ }
+
+ typedef extend-twice {
+ type extend-once;
+ }
+
+ typedef extend-enum {
+ type enumeration {
+ enum "ONE";
+ enum "TWO";
+ }
+ }
+
+}
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+
public abstract class AttributeIfcSwitchStatement<T> {
+ protected AttributeIfc lastAttribute;
+
public T switchAttribute(AttributeIfc attributeIfc) {
+ this.lastAttribute = attributeIfc;
+
if (attributeIfc instanceof JavaAttribute) {
- return caseJavaAttribute((JavaAttribute) attributeIfc);
+ try {
+ return caseJavaAttribute(attributeIfc.getOpenType());
+ } catch (UnknownOpenTypeException e) {
+ throw getIllegalArgumentException(attributeIfc);
+ }
+
} else if (attributeIfc instanceof DependencyAttribute) {
- return caseDependencyAttribute((DependencyAttribute) attributeIfc);
+ return caseDependencyAttribute(((DependencyAttribute) attributeIfc).getOpenType());
} else if (attributeIfc instanceof ListAttribute) {
- return caseListAttribute((ListAttribute) attributeIfc);
+ return caseListAttribute(((ListAttribute) attributeIfc).getOpenType());
} else if (attributeIfc instanceof TOAttribute) {
- return caseTOAttribute((TOAttribute) attributeIfc);
+ return caseTOAttribute(((TOAttribute) attributeIfc).getOpenType());
+ }
+
+ throw getIllegalArgumentException(attributeIfc);
+ }
+
+ private IllegalArgumentException getIllegalArgumentException(AttributeIfc attributeIfc) {
+ return new IllegalArgumentException("Unknown attribute type " + attributeIfc.getClass() + ", " + attributeIfc
+ + " with open type:" + attributeIfc.getOpenType());
+ }
+
+ public final T caseJavaAttribute(OpenType<?> openType) {
+ if (openType instanceof SimpleType<?>) {
+ return caseJavaSimpleAttribute((SimpleType<?>) openType);
+ } else if (openType instanceof ArrayType<?>) {
+ return caseJavaArrayAttribute((ArrayType<?>) openType);
+ } else if (openType instanceof CompositeType) {
+ return caseJavaCompositeAttribute((CompositeType) openType);
}
- throw new IllegalArgumentException("Unknown attribute type " + attributeIfc.getClass() + ", " + attributeIfc);
+ throw new UnknownOpenTypeException("Unknown attribute open type " + openType);
}
- protected abstract T caseJavaAttribute(JavaAttribute attributeIfc);
+ protected abstract T caseJavaSimpleAttribute(SimpleType<?> openType);
+
+ protected abstract T caseJavaArrayAttribute(ArrayType<?> openType);
+
+ protected abstract T caseJavaCompositeAttribute(CompositeType openType);
- protected abstract T caseDependencyAttribute(DependencyAttribute attributeIfc);
+ protected abstract T caseDependencyAttribute(SimpleType<?> attributeIfc);
- protected abstract T caseTOAttribute(TOAttribute attributeIfc);
+ protected abstract T caseTOAttribute(CompositeType openType);
- protected abstract T caseListAttribute(ListAttribute attributeIfc);
+ protected abstract T caseListAttribute(ArrayType<?> openType);
+
+
+ private static class UnknownOpenTypeException extends RuntimeException {
+ public UnknownOpenTypeException(String message) {
+ super(message);
+ }
+ }
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
-import java.util.List;
-
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
-public abstract class AbstractAttributeReadingStrategy<A extends AttributeIfc> implements AttributeReadingStrategy {
+import java.util.List;
+
+public abstract class AbstractAttributeReadingStrategy implements AttributeReadingStrategy {
- private final A attributeIfc;
+ private final String nullableDefault;
- public AbstractAttributeReadingStrategy(A attributeIfc) {
- this.attributeIfc = attributeIfc;
+ public AbstractAttributeReadingStrategy(String nullableDefault) {
+ this.nullableDefault = nullableDefault;
}
- public A getAttributeIfc() {
- return attributeIfc;
+ public String getNullableDefault() {
+ return nullableDefault;
}
@Override
public AttributeConfigElement readElement(List<XmlElement> configNodes) {
if (configNodes.size() == 0)
- return AttributeConfigElement.createNullValue(attributeIfc);
+ return AttributeConfigElement.createNullValue(nullableDefault);
return readElementHook(configNodes);
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.collect.Lists;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import java.util.List;
-public class ArrayAttributeReadingStrategy extends AbstractAttributeReadingStrategy<AttributeIfc> {
+public class ArrayAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
private final AttributeReadingStrategy innerStrategy;
* @param attributeIfc
* @param innerStrategy
*/
- public ArrayAttributeReadingStrategy(AttributeIfc attributeIfc, AttributeReadingStrategy innerStrategy) {
- super(attributeIfc);
+ public ArrayAttributeReadingStrategy(String nullableDefault, AttributeReadingStrategy innerStrategy) {
+ super(nullableDefault);
this.innerStrategy = innerStrategy;
}
for (int i = 0; i < configNodes.size(); i++) {
innerList.add(innerStrategy.readElement(Lists.newArrayList(configNodes.get(i))).getValue());
}
- return AttributeConfigElement.create(getAttributeIfc(), innerList);
+ return AttributeConfigElement.create(getNullableDefault(), innerList);
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
-import javax.management.openmbean.OpenType;
-
+import com.google.common.base.Optional;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving.AttributeResolvingStrategy;
-import com.google.common.base.Optional;
+import javax.management.openmbean.OpenType;
/**
* Parsed xml element containing configuration for one attribute of an instance
}
public static AttributeConfigElement create(AttributeIfc attributeIfc, Object value) {
- return new AttributeConfigElement(attributeIfc.getNullableDefault(), value);
+ String nullableDefault = attributeIfc.getNullableDefault();
+ return create(nullableDefault, value);
+ }
+
+ public static AttributeConfigElement create(String nullableDefault, Object value) {
+ return new AttributeConfigElement(nullableDefault, value);
}
public static AttributeConfigElement createNullValue(AttributeIfc attributeIfc) {
return new AttributeConfigElement(attributeIfc.getNullableDefault(), null);
}
+ public static AttributeConfigElement createNullValue(String nullableDefault) {
+ return new AttributeConfigElement(nullableDefault, null);
+ }
+
+
public Object getValue() {
return value;
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
-public class CompositeAttributeReadingStrategy extends AbstractAttributeReadingStrategy<TOAttribute> {
+public class CompositeAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
private final Map<String, AttributeReadingStrategy> innerStrategies;
- public CompositeAttributeReadingStrategy(TOAttribute attributeIfc,
+ public CompositeAttributeReadingStrategy(String nullableDefault,
Map<String, AttributeReadingStrategy> innerStrategies) {
- super(attributeIfc);
+ super(nullableDefault);
this.innerStrategies = innerStrategies;
}
Map<String, Object> innerMap = Maps.newHashMap();
- Map<String, AttributeIfc> inner = getAttributeIfc().getYangPropertiesToTypesMap();
-
List<XmlElement> recognisedChildren = Lists.newArrayList();
- for (Entry<String, AttributeIfc> innerAttrEntry : inner.entrySet()) {
+ for (Entry<String, AttributeReadingStrategy> innerAttrEntry : innerStrategies.entrySet()) {
List<XmlElement> childItem = complexElement.getChildElementsWithSameNamespace(innerAttrEntry.getKey());
recognisedChildren.addAll(childItem);
- AttributeConfigElement resolvedInner = innerStrategies.get(innerAttrEntry.getKey()).readElement(childItem);
+ AttributeConfigElement resolvedInner = innerAttrEntry.getValue().readElement(childItem);
innerMap.put(innerAttrEntry.getKey(), resolvedInner.getValue());
}
complexElement.checkUnrecognisedElements(recognisedChildren);
- return AttributeConfigElement.create(getAttributeIfc(), innerMap);
+ return AttributeConfigElement.create(getNullableDefault(), innerMap);
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping.ObjectNameAttributeMappingStrategy;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
import org.opendaylight.controller.netconf.util.xml.XmlNetconfConstants;
import java.util.List;
import java.util.Map;
-public class ObjectNameAttributeReadingStrategy extends AbstractAttributeReadingStrategy<AttributeIfc> {
+public class ObjectNameAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
private static final Object PREFIX_SEPARATOR = ":";
- public ObjectNameAttributeReadingStrategy(DependencyAttribute attributeIfc) {
- super(attributeIfc);
+ public ObjectNameAttributeReadingStrategy(String nullableDefault) {
+ super(nullableDefault);
}
@Override
+ " but was " + configNodes.size());
Preconditions.checkNotNull(firstChild, "Element %s should be present", firstChild);
- return AttributeConfigElement.create(getAttributeIfc(), resolve(firstChild));
+ return AttributeConfigElement.create(getNullableDefault(), resolve(firstChild));
}
private ObjectNameAttributeMappingStrategy.MappedDependency resolve(XmlElement firstChild) {
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
+import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
import javax.management.openmbean.SimpleType;
import java.util.Map;
import java.util.Map.Entry;
}
@Override
- protected AttributeReadingStrategy caseJavaAttribute(JavaAttribute attributeIfc) {
- if (attributeIfc.getOpenType() instanceof SimpleType<?>)
- return new SimpleAttributeReadingStrategy(attributeIfc);
- else if (attributeIfc.getOpenType() instanceof ArrayType<?>) {
- SimpleAttributeReadingStrategy innerStrategy = new SimpleAttributeReadingStrategy(
- ((ArrayType<?>) attributeIfc.getOpenType()).getElementOpenType());
- return new ArrayAttributeReadingStrategy(attributeIfc, innerStrategy);
- }
- throw new IllegalStateException(JavaAttribute.class + " can only provide open type " + SimpleType.class
- + " or " + ArrayType.class);
+ public AttributeReadingStrategy caseJavaSimpleAttribute(SimpleType<?> openType) {
+ return new SimpleAttributeReadingStrategy(lastAttribute.getNullableDefault());
+ }
+
+ @Override
+ public AttributeReadingStrategy caseJavaArrayAttribute(ArrayType<?> openType) {
+ SimpleAttributeReadingStrategy innerStrategy = new SimpleAttributeReadingStrategy(lastAttribute.getNullableDefault());
+ return new ArrayAttributeReadingStrategy(lastAttribute.getNullableDefault(), innerStrategy);
}
@Override
- protected AttributeReadingStrategy caseDependencyAttribute(DependencyAttribute attributeIfc) {
- return new ObjectNameAttributeReadingStrategy(attributeIfc);
+ public AttributeReadingStrategy caseJavaCompositeAttribute(CompositeType openType) {
+ Preconditions.checkState(openType.keySet().size() == 1, "Unexpected number of elements for open type %s, should be 1", openType);
+ String mappingKey = openType.keySet().iterator().next();
+ return new SimpleCompositeAttributeReadingStrategy(lastAttribute.getNullableDefault(), mappingKey);
}
@Override
- protected AttributeReadingStrategy caseTOAttribute(TOAttribute attributeIfc) {
- Map<String, AttributeIfc> inner = attributeIfc.getYangPropertiesToTypesMap();
+ protected AttributeReadingStrategy caseDependencyAttribute(SimpleType<?> openType) {
+ return new ObjectNameAttributeReadingStrategy(lastAttribute.getNullableDefault());
+ }
+
+ @Override
+ protected AttributeReadingStrategy caseTOAttribute(CompositeType openType) {
+ Preconditions.checkState(lastAttribute instanceof TOAttribute);
+ Map<String, AttributeIfc> inner = ((TOAttribute)lastAttribute).getYangPropertiesToTypesMap();
+
Map<String, AttributeReadingStrategy> innerStrategies = Maps.newHashMap();
for (Entry<String, AttributeIfc> innerAttrEntry : inner.entrySet()) {
innerStrategies.put(innerAttrEntry.getKey(), innerStrat);
}
- return new CompositeAttributeReadingStrategy(attributeIfc, innerStrategies);
+ return new CompositeAttributeReadingStrategy(lastAttribute.getNullableDefault(), innerStrategies);
}
@Override
- protected AttributeReadingStrategy caseListAttribute(ListAttribute attributeIfc) {
- AttributeIfc innerAttr = attributeIfc.getInnerAttribute();
- AttributeReadingStrategy innerStrategy = prepareReadingStrategy(key, innerAttr);
- return new ArrayAttributeReadingStrategy(attributeIfc, innerStrategy);
+ protected AttributeReadingStrategy caseListAttribute(ArrayType<?> openType) {
+ Preconditions.checkState(lastAttribute instanceof ListAttribute);
+ AttributeReadingStrategy innerStrategy = prepareReadingStrategy(key, ((ListAttribute) lastAttribute).getInnerAttribute());
+ return new ArrayAttributeReadingStrategy(lastAttribute.getNullableDefault(), innerStrategy);
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.fromxml;
import com.google.common.base.Preconditions;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.netconf.util.xml.XmlElement;
-import javax.management.openmbean.OpenType;
import java.util.List;
-public class SimpleAttributeReadingStrategy extends AbstractAttributeReadingStrategy<AttributeIfc> {
+public class SimpleAttributeReadingStrategy extends AbstractAttributeReadingStrategy {
- public SimpleAttributeReadingStrategy(AttributeIfc attributeIfc) {
- super(attributeIfc);
- }
-
- /**
- * @param elementOpenType
- */
- public SimpleAttributeReadingStrategy(OpenType<?> elementOpenType) {
- super(new AttributeIfcWrapper(elementOpenType));
+ public SimpleAttributeReadingStrategy(String nullableDefault) {
+ super(nullableDefault);
}
@Override
String textContent = xmlElement.getTextContent();
Preconditions.checkNotNull(textContent, "This element should contain text %s", xmlElement);
- return AttributeConfigElement.create(getAttributeIfc(), textContent);
+ return AttributeConfigElement.create(getNullableDefault(), postprocessParsedValue(textContent));
}
- /**
- * Wrapper for JavaAttribute inner element attributes (in case JavaAttribute
- * is array)
- */
- static class AttributeIfcWrapper implements AttributeIfc {
-
- private final OpenType<?> elementOpenType;
-
- public AttributeIfcWrapper(OpenType<?> elementOpenType) {
- this.elementOpenType = elementOpenType;
- }
-
- @Override
- public String getAttributeYangName() {
- return null;
- }
-
- @Override
- public String getNullableDescription() {
- return null;
- }
-
- @Override
- public String getNullableDefault() {
- return null;
- }
-
- @Override
- public String getUpperCaseCammelCase() {
- return null;
- }
-
- @Override
- public String getLowerCaseCammelCase() {
- return null;
- }
-
- @Override
- public OpenType<?> getOpenType() {
- return elementOpenType;
- }
-
+ protected Object postprocessParsedValue(String textContent) {
+ return textContent;
}
+
}
--- /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.netconf.confignetconfconnector.mapping.attributes.fromxml;
+
+import com.google.common.collect.Maps;
+
+import java.util.HashMap;
+
+public class SimpleCompositeAttributeReadingStrategy extends SimpleAttributeReadingStrategy {
+
+
+ private final String key;
+
+ public SimpleCompositeAttributeReadingStrategy(String nullableDefault, String key) {
+ super(nullableDefault);
+ this.key = key;
+ }
+
+ protected Object postprocessParsedValue(String textContent) {
+ HashMap<String,String> map = Maps.newHashMap();
+ map.put(key, textContent);
+ return map;
+ }
+
+}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.mapping;
+import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
}
public AttributeMappingStrategy<?, ? extends OpenType<?>> prepareStrategy(AttributeIfc attributeIfc) {
+
+ if(attributeIfc instanceof DependencyAttribute) {
+ serviceNameOfDepAttr = ((DependencyAttribute)attributeIfc).getDependency().getSie().getQName().getLocalName();
+ namespaceOfDepAttr = ((DependencyAttribute)attributeIfc).getDependency().getSie().getQName().getNamespace().toString();
+ }
+
return switchAttribute(attributeIfc);
}
}
@Override
- protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseJavaAttribute(JavaAttribute attributeIfc) {
-
- if (attributeIfc.getOpenType() instanceof SimpleType<?>)
- return new SimpleAttributeMappingStrategy((SimpleType<?>) attributeIfc.getOpenType());
- else if (attributeIfc.getOpenType() instanceof ArrayType<?>) {
- ArrayType<?> arrayType = (ArrayType<?>) attributeIfc.getOpenType();
- AttributeMappingStrategy<?, ? extends OpenType<?>> innerStrategy = new SimpleAttributeMappingStrategy(
- (SimpleType<?>) arrayType.getElementOpenType());
- return new ArrayAttributeMappingStrategy(arrayType, innerStrategy);
+ protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseJavaSimpleAttribute(SimpleType<?> openType) {
+ return new SimpleAttributeMappingStrategy(openType);
+ }
+
+ @Override
+ protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseJavaArrayAttribute(ArrayType<?> openType) {
+
+ AttributeMappingStrategy<?, ? extends OpenType<?>> innerStrategy = new SimpleAttributeMappingStrategy(
+ (SimpleType<?>) openType.getElementOpenType());
+ return new ArrayAttributeMappingStrategy(openType, innerStrategy);
+ }
+
+ @Override
+ protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseJavaCompositeAttribute(CompositeType openType) {
+ Map<String, AttributeMappingStrategy<?, ? extends OpenType<?>>> innerStrategies = Maps.newHashMap();
+
+ Map<String, String> attributeMapping = Maps.newHashMap();
+
+ for (String innerAttributeKey : openType.keySet()) {
+
+ innerStrategies.put(innerAttributeKey, caseJavaAttribute(openType.getType(innerAttributeKey)));
+ attributeMapping.put(innerAttributeKey, innerAttributeKey);
}
- throw new IllegalStateException(JavaAttribute.class + " can only provide open type " + SimpleType.class
- + " or " + ArrayType.class);
+
+ return new CompositeAttributeMappingStrategy(openType, innerStrategies, attributeMapping);
}
+ private String serviceNameOfDepAttr;
+ private String namespaceOfDepAttr;
+
@Override
protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseDependencyAttribute(
- DependencyAttribute attributeIfc) {
- String serviceName = attributeIfc.getDependency().getSie().getQName().getLocalName();
- String namespace = attributeIfc.getDependency().getSie().getQName().getNamespace().toString();
- return new ObjectNameAttributeMappingStrategy((SimpleType<?>) attributeIfc.getOpenType(), dependencyTracker,
- serviceName, namespace);
+ SimpleType<?> openType) {
+ return new ObjectNameAttributeMappingStrategy(openType, dependencyTracker,
+ serviceNameOfDepAttr, namespaceOfDepAttr);
}
@Override
- protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseTOAttribute(TOAttribute attributeIfc) {
+ protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseTOAttribute(CompositeType openType) {
Map<String, AttributeMappingStrategy<?, ? extends OpenType<?>>> innerStrategies = Maps.newHashMap();
- for (Entry<String, AttributeIfc> innerAttrEntry : attributeIfc.getJmxPropertiesToTypesMap().entrySet()) {
+ Preconditions.checkState(lastAttribute instanceof TOAttribute);
+ TOAttribute lastTO = (TOAttribute) lastAttribute;
+
+ for (Entry<String, AttributeIfc> innerAttrEntry : ((TOAttribute)lastAttribute).getJmxPropertiesToTypesMap().entrySet()) {
innerStrategies.put(innerAttrEntry.getKey(), prepareStrategy(innerAttrEntry.getValue()));
}
- return new CompositeAttributeMappingStrategy((CompositeType) attributeIfc.getOpenType(), innerStrategies,
- createJmxToYangMapping(attributeIfc));
+ return new CompositeAttributeMappingStrategy(openType, innerStrategies,
+ createJmxToYangMapping(lastTO));
}
@Override
- protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseListAttribute(ListAttribute attributeIfc) {
- return new ArrayAttributeMappingStrategy(attributeIfc.getOpenType(),
- prepareStrategy(attributeIfc.getInnerAttribute()));
+ protected AttributeMappingStrategy<?, ? extends OpenType<?>> caseListAttribute(ArrayType<?> openType) {
+ Preconditions.checkState(lastAttribute instanceof ListAttribute);
+ return new ArrayAttributeMappingStrategy(openType,
+ prepareStrategy(((ListAttribute) lastAttribute).getInnerAttribute()));
}
}
package org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.resolving;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import javax.management.openmbean.ArrayType;
-import javax.management.openmbean.CompositeType;
-import javax.management.openmbean.OpenType;
-import javax.management.openmbean.SimpleType;
-
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.config.Services;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.Maps;
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import java.util.Map;
+import java.util.Map.Entry;
public class ObjectResolver extends AttributeIfcSwitchStatement<AttributeResolvingStrategy<?, ? extends OpenType<?>>> {
private final Services serviceTracker;
- private OpenType<?> openType;
public ObjectResolver(Services serviceTracker) {
this.serviceTracker = serviceTracker;
for (Entry<String, AttributeIfc> attrEntry : configDefinition.entrySet()) {
strategies.put(attrEntry.getKey(),
- prepareStrategy(attrEntry.getValue(), attrEntry.getValue().getOpenType()));
+ prepareStrategy(attrEntry.getValue()));
}
return strategies;
}
- private AttributeResolvingStrategy<?, ? extends OpenType<?>> prepareStrategy(AttributeIfc attributeIfc,
- OpenType<?> openType) {
+ private AttributeResolvingStrategy<?, ? extends OpenType<?>> prepareStrategy(AttributeIfc attributeIfc) {
- this.openType = openType;
return switchAttribute(attributeIfc);
}
}
@Override
- protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseJavaAttribute(JavaAttribute attributeIfc) {
- if (attributeIfc.getOpenType() instanceof SimpleType<?>)
- return new SimpleAttributeResolvingStrategy((SimpleType<?>) openType);
- else if (attributeIfc.getOpenType() instanceof ArrayType<?>) {
- ArrayType<?> arrayType = (ArrayType<?>) openType;
- SimpleType<?> innerType = (SimpleType<?>) arrayType.getElementOpenType();
- AttributeResolvingStrategy<?, ? extends OpenType<?>> strat = new SimpleAttributeResolvingStrategy(innerType);
- return new ArrayAttributeResolvingStrategy(strat, arrayType);
+ protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseJavaSimpleAttribute(SimpleType<?> openType) {
+ return new SimpleAttributeResolvingStrategy(openType);
+ }
+
+ @Override
+ protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseJavaArrayAttribute(ArrayType<?> openType) {
+ SimpleType<?> innerType = (SimpleType<?>) openType.getElementOpenType();
+ AttributeResolvingStrategy<?, ? extends OpenType<?>> strat = new SimpleAttributeResolvingStrategy(innerType);
+ return new ArrayAttributeResolvingStrategy(strat, openType);
+ }
+
+ @Override
+ protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseJavaCompositeAttribute(CompositeType openType) {
+ Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerMap = Maps.newHashMap();
+
+ Map<String, String> yangToJmxMapping = Maps.newHashMap();
+ for (String innerAttributeKey : openType.keySet()) {
+ innerMap.put(innerAttributeKey, caseJavaAttribute(openType.getType(innerAttributeKey)));
+ yangToJmxMapping.put(innerAttributeKey, innerAttributeKey);
}
- throw new IllegalStateException(JavaAttribute.class + " can only provide open type " + SimpleType.class
- + " or " + ArrayType.class);
+ return new CompositeAttributeResolvingStrategy(innerMap, openType, yangToJmxMapping);
}
@Override
protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseDependencyAttribute(
- DependencyAttribute attributeIfc) {
+ SimpleType<?> openType) {
return new ObjectNameAttributeResolvingStrategy(serviceTracker);
}
@Override
- protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseTOAttribute(TOAttribute attributeIfc) {
- CompositeType compositeType = (CompositeType) openType;
+ protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseTOAttribute(CompositeType openType) {
+ Preconditions.checkState(lastAttribute instanceof TOAttribute);
+ TOAttribute toAttribute = (TOAttribute) lastAttribute;
+
Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerMap = Maps.newHashMap();
- for (String innerName : compositeType.keySet()) {
- Preconditions.checkState(attributeIfc instanceof TOAttribute, "Unexpected state, " + attributeIfc
- + " should be instance of " + TOAttribute.class.getName());
- AttributeIfc innerAttributeIfc = attributeIfc.getJmxPropertiesToTypesMap().get(innerName);
+
+ for (String innerName : openType.keySet()) {
+
+ AttributeIfc innerAttributeIfc = toAttribute.getJmxPropertiesToTypesMap().get(innerName);
innerMap.put(innerAttributeIfc.getAttributeYangName(),
- prepareStrategy(innerAttributeIfc, compositeType.getType(innerName)));
+ prepareStrategy(innerAttributeIfc));
}
- return new CompositeAttributeResolvingStrategy(innerMap, compositeType, createYangToJmxMapping(attributeIfc));
+ return new CompositeAttributeResolvingStrategy(innerMap, openType, createYangToJmxMapping(toAttribute));
}
@Override
- protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseListAttribute(ListAttribute attributeIfc) {
- ArrayType<?> arrayType = (ArrayType<?>) openType;
- OpenType<?> innerType = arrayType.getElementOpenType();
- AttributeIfc inner = attributeIfc.getInnerAttribute();
- return new ArrayAttributeResolvingStrategy(prepareStrategy(inner, innerType), arrayType);
+ protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseListAttribute(ArrayType<?> openType) {
+ Preconditions.checkState(lastAttribute instanceof ListAttribute);
+ AttributeIfc innerAttribute = ((ListAttribute) lastAttribute).getInnerAttribute();
+ return new ArrayAttributeResolvingStrategy(prepareStrategy(innerAttribute), openType);
}
}
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.AttributeIfc;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.DependencyAttribute;
-import org.opendaylight.controller.config.yangjmxgenerator.attribute.JavaAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.ListAttribute;
import org.opendaylight.controller.config.yangjmxgenerator.attribute.TOAttribute;
import org.opendaylight.controller.netconf.confignetconfconnector.mapping.attributes.AttributeIfcSwitchStatement;
import org.w3c.dom.Document;
import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeType;
import javax.management.openmbean.SimpleType;
import java.util.Map;
import java.util.Map.Entry;
}
@Override
- protected AttributeWritingStrategy caseJavaAttribute(JavaAttribute attributeIfc) {
+ protected AttributeWritingStrategy caseJavaSimpleAttribute(SimpleType<?> openType) {
+ return new SimpleAttributeWritingStrategy(document, key);
+ }
- if (attributeIfc.getOpenType() instanceof SimpleType<?>)
- return new SimpleAttributeWritingStrategy(document, key);
- else if (attributeIfc.getOpenType() instanceof ArrayType<?>) {
- AttributeWritingStrategy innerStrategy = new SimpleAttributeWritingStrategy(document, key);
- return new ArrayAttributeWritingStrategy(innerStrategy);
- }
- throw new IllegalStateException(JavaAttribute.class + " can only provide open type " + SimpleType.class
- + " or " + ArrayType.class);
+ @Override
+ protected AttributeWritingStrategy caseJavaArrayAttribute(ArrayType<?> openType) {
+ AttributeWritingStrategy innerStrategy = new SimpleAttributeWritingStrategy(document, key);
+ return new ArrayAttributeWritingStrategy(innerStrategy);
}
@Override
- protected AttributeWritingStrategy caseDependencyAttribute(DependencyAttribute attributeIfc) {
+ protected AttributeWritingStrategy caseJavaCompositeAttribute(CompositeType openType) {
+ return new SimpleCompositeAttributeWritingStrategy(document, key);
+ }
+
+ @Override
+ protected AttributeWritingStrategy caseDependencyAttribute(SimpleType<?> openType) {
return new ObjectNameAttributeWritingStrategy(document, key);
}
@Override
- protected AttributeWritingStrategy caseTOAttribute(TOAttribute attributeIfc) {
+ protected AttributeWritingStrategy caseTOAttribute(CompositeType openType) {
+ Preconditions.checkState(lastAttribute instanceof TOAttribute);
+
Map<String, AttributeWritingStrategy> innerStrats = Maps.newHashMap();
String currentKey = key;
- for (Entry<String, AttributeIfc> innerAttrEntry : attributeIfc.getYangPropertiesToTypesMap().entrySet()) {
+ for (Entry<String, AttributeIfc> innerAttrEntry : ((TOAttribute) lastAttribute).getYangPropertiesToTypesMap().entrySet()) {
AttributeWritingStrategy innerStrategy = prepareWritingStrategy(innerAttrEntry.getKey(),
innerAttrEntry.getValue(), document);
}
@Override
- protected AttributeWritingStrategy caseListAttribute(ListAttribute attributeIfc) {
- AttributeIfc inner = attributeIfc.getInnerAttribute();
- AttributeWritingStrategy innerStrategy = prepareWritingStrategy(key, inner, document);
+ protected AttributeWritingStrategy caseListAttribute(ArrayType<?> openType) {
+ Preconditions.checkState(lastAttribute instanceof ListAttribute);
+ AttributeIfc innerAttribute = ((ListAttribute) lastAttribute).getInnerAttribute();
+
+ AttributeWritingStrategy innerStrategy = prepareWritingStrategy(key, innerAttribute, document);
return new ArrayAttributeWritingStrategy(innerStrategy);
}
@Override
public void writeElement(Element parentElement, String namespace, Object value) {
+ value = preprocess(value);
Util.checkType(value, String.class);
Element innerNode = XmlUtil.createTextElement(document, key, (String) value);
XmlUtil.addNamespaceAttr(innerNode, namespace);
parentElement.appendChild(innerNode);
}
+ protected Object preprocess(Object value) {
+ return value;
+ }
+
+
}
--- /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.netconf.confignetconfconnector.mapping.attributes.toxml;
+
+import com.google.common.base.Preconditions;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.w3c.dom.Document;
+
+import java.util.Map;
+
+public class SimpleCompositeAttributeWritingStrategy extends SimpleAttributeWritingStrategy {
+
+ /**
+ * @param document
+ * @param key
+ */
+ public SimpleCompositeAttributeWritingStrategy(Document document, String key) {
+ super(document, key);
+ }
+
+ protected Object preprocess(Object value) {
+ Util.checkType(value, Map.class);
+ Preconditions.checkArgument(((Map)value).size() == 1, "Unexpected number of values in %s, expected 1", value);
+ return ((Map)value).values().iterator().next();
+ }
+
+}
} catch (IllegalStateException e) {
logger.warn("Error parsing xml", e);
final Map<String, String> errorInfo = new HashMap<>();
- errorInfo.put(ErrorTag.missing_attribute.name(), "Missing value for 'target' attribute");
+ errorInfo.put(ErrorTag.missing_attribute.name(), "Error parsing xml: " + e.getMessage());
throw new NetconfDocumentedException(e.getMessage(), ErrorType.rpc, ErrorTag.missing_attribute,
ErrorSeverity.error, errorInfo);
} catch (final IllegalArgumentException e) {
edit("netconfMessages/editConfig.xml");
checkBinaryLeafEdited(getConfigCandidate());
-
// default-operation:none, should not affect binary leaf
edit("netconfMessages/editConfig_none.xml");
checkBinaryLeafEdited(getConfigCandidate());
// check after edit
commit();
Element response = getConfigRunning();
-
+ System.err.println(XmlUtil.toString(response));
checkBinaryLeafEdited(response);
checkTypeConfigAttribute(response);
+ checkTypedefs(response);
edit("netconfMessages/editConfig_remove.xml");
buf.append(XmlElement.fromDomElement(e).getTextContent());
}
assertEquals("810", buf.toString());
+ }
+
+ private void checkTypedefs(final Element response) {
+ NodeList children = response.getElementsByTagName("extended");
+ assertEquals(1, children.getLength());
+ children = response.getElementsByTagName("extended-twice");
+ assertEquals(1, children.getLength());
}
private void checkTypeConfigAttribute(Element response) {
private List<InputStream> getYangs() throws FileNotFoundException {
List<String> paths = Arrays.asList("/META-INF/yang/config.yang", "/META-INF/yang/rpc-context.yang",
- "/META-INF/yang/config-test.yang", "/META-INF/yang/config-test-impl.yang",
+ "/META-INF/yang/config-test.yang", "/META-INF/yang/config-test-impl.yang", "/META-INF/yang/test-types.yang",
"/META-INF/yang/ietf-inet-types.yang");
final Collection<InputStream> yangDependencies = new ArrayList<>();
for (String path : paths) {
static Collection<InputStream> getBasicYangs() throws IOException {
List<String> paths = Arrays.asList("/META-INF/yang/config.yang", "/META-INF/yang/rpc-context.yang",
- "/META-INF/yang/config-test.yang", "/META-INF/yang/config-test-impl.yang",
+ "/META-INF/yang/config-test.yang", "/META-INF/yang/config-test-impl.yang", "/META-INF/yang/test-types.yang",
"/META-INF/yang/ietf-inet-types.yang");
final Collection<InputStream> yangDependencies = new ArrayList<>();
List<String> failedToFind = new ArrayList<>();
<name>test1</name>
+ <extended>
+ 1
+ </extended>
+
+ <extended-twice>
+ 1
+ </extended-twice>
+
<simple-long-2>44</simple-long-2>
<binaryLeaf>8</binaryLeaf>
<binaryLeaf>1</binaryLeaf>
Code Review / controller.git / commitdiff