org.opendaylight.controller.sal.utils,
org.opendaylight.controller.sal.packet,
org.opendaylight.controller.switchmanager,
+ org.opendaylight.controller.topologymanager,
org.opendaylight.controller.hosttracker,
org.opendaylight.controller.hosttracker.hostAware,
org.apache.felix.dm,
<groupId>org.opendaylight.controller</groupId>
<artifactId>switchmanager</artifactId>
<version>0.4.0-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>topologymanager</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
import org.opendaylight.controller.sal.packet.IListenDataPacket;
import org.opendaylight.controller.sal.packet.IDataPacketService;
import org.opendaylight.controller.switchmanager.ISwitchManager;
+import org.opendaylight.controller.topologymanager.ITopologyManager;
public class Activator extends ComponentActivatorAbstractBase {
protected static final Logger logger = LoggerFactory
"unsetSwitchManager").setRequired(true));
c.add(createContainerServiceDependency(containerName).setService(
+ ITopologyManager.class).setCallbacks("setTopologyManager",
+ "unsetTopologyMananger").setRequired(true));
+
+ c.add(createContainerServiceDependency(containerName).setService(
IDataPacketService.class).setCallbacks(
"setDataPacketService", "unsetDataPacketService")
.setRequired(true));
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
+import java.util.Timer;
+import java.util.TimerTask;
+import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.controller.sal.utils.NetUtils;
import org.opendaylight.controller.switchmanager.ISwitchManager;
import org.opendaylight.controller.switchmanager.Subnet;
+import org.opendaylight.controller.topologymanager.ITopologyManager;
public class ArpHandler implements IHostFinder, IListenDataPacket {
private static final Logger logger = LoggerFactory
.getLogger(ArpHandler.class);
private IfIptoHost hostTracker = null;
private ISwitchManager switchManager = null;
+ private ITopologyManager topologyManager;
private IDataPacketService dataPacketService = null;
private Set<IfHostListener> hostListener = Collections
.synchronizedSet(new HashSet<IfHostListener>());
+ private ConcurrentHashMap<InetAddress, Set<HostNodeConnector>> arpRequestors;
+ private ConcurrentHashMap<InetAddress, Short> countDownTimers;
+ private Timer periodicTimer;
void setHostListener(IfHostListener s) {
if (this.hostListener != null) {
}
}
+ public void setTopologyManager(ITopologyManager tm) {
+ this.topologyManager = tm;
+ }
+
+ public void unsetTopologyManager(ITopologyManager tm) {
+ if (this.topologyManager == tm) {
+ this.topologyManager = null;
+ }
+ }
+
protected void sendARPReply(NodeConnector p, byte[] sMAC, InetAddress sIP,
byte[] tMAC, InetAddress tIP) {
byte[] senderIP = sIP.getAddress();
return;
}
+ HostNodeConnector requestor = null;
if (isUnicastMAC(sourceMAC)) {
// TODO For not this is only OPENFLOW but we need to fix this
if (p.getType().equals(
NodeConnector.NodeConnectorIDType.OPENFLOW)) {
- HostNodeConnector host = null;
try {
- host = new HostNodeConnector(sourceMAC, sourceIP, p, subnet
+ requestor = new HostNodeConnector(sourceMAC, sourceIP, p, subnet
.getVlan());
} catch (ConstructionException e) {
return;
* Learn host from the received ARP REQ/REPLY, inform
* Host Tracker
*/
- logger.debug("Inform Host tracker of new host {}", host);
+ logger.debug("Inform Host tracker of new host {}", requestor.getNetworkAddress());
synchronized (this.hostListener) {
for (IfHostListener listener : this.hostListener) {
- listener.hostListener(host);
+ listener.hostListener(requestor);
}
}
}
}
/*
- * No further action is needed if this is a gratuitous ARP
+ * Gratuitous ARP. If there are hosts (in arpRequestors) waiting for the
+ * ARP reply for this sourceIP, it's time to generate the reply and it
+ * to these hosts
*/
if (sourceIP.equals(targetIP)) {
+ generateAndSendReply(sourceIP, sourceMAC);
return;
}
/*
- * No further action is needed if this is a ARP Reply
+ * ARP Reply. If there are hosts (in arpRequesttors) waiting for the ARP
+ * reply for this sourceIP, it's time to generate the reply and it to
+ * these hosts
*/
if (pkt.getOpCode() != ARP.REQUEST) {
+ generateAndSendReply(sourceIP, sourceMAC);
return;
}
+
/*
* ARP Request Handling:
* If targetIP is the IP of the subnet, reply with ARP REPLY
*/
HostNodeConnector host = hostTracker.hostQuery(targetIP);
if (host == null) {
+ // add the requestor to the list so that we can replay the reply
+ // when the host responds
+ if (requestor != null) {
+ Set<HostNodeConnector> requestorSet = arpRequestors
+ .get(targetIP);
+ if ((requestorSet == null) || requestorSet.isEmpty()) {
+ requestorSet = new HashSet<HostNodeConnector>();
+ countDownTimers.put(targetIP, (short) 2); // set max timeout
+ // to 2sec
+ }
+ requestorSet.add(requestor);
+ arpRequestors.put(targetIP, requestorSet);
+ }
sendBcastARPRequest(targetIP, subnet);
return;
}
nodeConnectors = subnet.getNodeConnectors();
}
for (NodeConnector p : nodeConnectors) {
+ if (topologyManager.isInternal(p)) {
+ continue;
+ }
ARP arp = new ARP();
byte[] senderIP = subnet.getNetworkAddress().getAddress();
byte[] targetIPB = targetIP.getAddress();
.setEtherType(EtherTypes.ARP.shortValue()).setPayload(arp);
// TODO For now send port-by-port, see how to optimize to
- // send to a bunch of port on the same node in a shoot
+ // send to multiple ports at once
RawPacket destPkt = this.dataPacketService.encodeDataPacket(ethernet);
destPkt.setOutgoingNodeConnector(p);
*
*/
void init() {
+ arpRequestors = new ConcurrentHashMap<InetAddress, Set<HostNodeConnector>>();
+ countDownTimers = new ConcurrentHashMap<InetAddress, Short>();
}
/**
*
*/
void start() {
+ startPeriodicTimer();
}
/**
*
*/
void stop() {
+ cancelPeriodicTimer();
}
void setSwitchManager(ISwitchManager s) {
}
return PacketResult.IGNORED;
}
+
+ private void startPeriodicTimer() {
+ this.periodicTimer = new Timer("ArpHandler Periodic Timer");
+ this.periodicTimer.scheduleAtFixedRate(new TimerTask() {
+ @Override
+ public void run() {
+ Set<InetAddress> targetIPs = countDownTimers.keySet();
+ Set<InetAddress> expiredTargets = new HashSet<InetAddress>();
+ for (InetAddress t : targetIPs) {
+ short tick = countDownTimers.get(t);
+ tick--;
+ if (tick <= 0) {
+ expiredTargets.add(t);
+ } else {
+ countDownTimers.replace(t, tick);
+ }
+ }
+ for (InetAddress t : expiredTargets) {
+ countDownTimers.remove(t);
+ // remove the requestor(s) who have been waited for the ARP
+ // reply from this target for more than 1sec
+ arpRequestors.remove(t);
+ logger.debug("{} didn't respond to ARP request", t);
+ }
+ }
+ }, 0, 1000);
+ }
+
+ private void cancelPeriodicTimer() {
+ if (this.periodicTimer != null) {
+ this.periodicTimer.cancel();
+ }
+ }
+
+ private void generateAndSendReply(InetAddress sourceIP, byte[] sourceMAC) {
+ Set<HostNodeConnector> hosts = arpRequestors.remove(sourceIP);
+ if ((hosts == null) || hosts.isEmpty()) {
+ return;
+ }
+ countDownTimers.remove(sourceIP);
+ for (HostNodeConnector host : hosts) {
+ logger.debug(
+ "Sending ARP Reply with src {}/{}, target {}/{}",
+ new Object[] { sourceMAC, sourceIP,
+ host.getDataLayerAddressBytes(),
+ host.getNetworkAddress() });
+ sendARPReply(host.getnodeConnector(), sourceMAC, sourceIP,
+ host.getDataLayerAddressBytes(), host.getNetworkAddress());
+ }
+ }
}
private static Map<String, Type> typeMap = new HashMap<String, Type>();
public static final Type BOOLEAN_TYPE = Types.typeForClass(Boolean.class);
+ public static final Type EMPTY_TYPE = Types.typeForClass(Boolean.class);
public static final Type INT8_TYPE = Types.typeForClass(Byte.class);
public static final Type INT16_TYPE = Types.typeForClass(Short.class);
public static final Type INT32_TYPE = Types.typeForClass(Integer.class);
static {
typeMap.put("boolean", BOOLEAN_TYPE);
+ typeMap.put("empty", EMPTY_TYPE);
typeMap.put("int8", INT8_TYPE);
typeMap.put("int16", INT16_TYPE);
typeMap.put("int32", INT32_TYPE);
*/
package org.opendaylight.controller.sal.java.api.generator;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.NL;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.RCB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.TAB;
+import static org.opendaylight.controller.sal.java.api.generator.Constants.*;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.controller.sal.binding.model.api.CodeGenerator;
import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty;
public class ClassCodeGenerator implements CodeGenerator {
+ private Map<String, LinkedHashMap<String, Integer>> imports;
+
@Override
public Writer generate(Type type) throws IOException {
final Writer writer = new StringWriter();
if (type instanceof GeneratedTransferObject) {
GeneratedTransferObject genTO = (GeneratedTransferObject) type;
+ imports = GeneratorUtil.createImports(genTO);
+
+ final String currentPkg = genTO.getPackageName();
final List<GeneratedProperty> fields = genTO.getProperties();
- writer.write(GeneratorUtil.createClassDeclarationWithPkgName(genTO,
- ""));
+ writer.write(GeneratorUtil.createPackageDeclaration(currentPkg));
+ writer.write(NL);
+
+ List<String> importLines = GeneratorUtil.createImportLines(imports);
+ for (String line : importLines) {
+ writer.write(line + NL);
+ }
+ writer.write(NL);
+
+ writer.write(GeneratorUtil.createClassDeclaration(genTO, "",
+ imports));
writer.write(NL);
writer.write(NL);
if (fields != null) {
for (GeneratedProperty field : fields) {
- writer.write(GeneratorUtil.createField(field, TAB) + NL);
+ writer.write(GeneratorUtil.createField(field, TAB, imports,
+ currentPkg) + NL);
}
writer.write(NL);
- writer.write(GeneratorUtil.createConstructor(genTO, TAB) + NL);
+ writer.write(GeneratorUtil.createConstructor(genTO, TAB,
+ imports) + NL);
writer.write(NL);
for (GeneratedProperty field : fields) {
- writer.write(GeneratorUtil.createGetter(field, TAB) + NL);
+ writer.write(GeneratorUtil.createGetter(field, TAB,
+ imports, currentPkg) + NL);
if (!field.isReadOnly()) {
- writer.write(GeneratorUtil.createSetter(field, TAB) + NL);
+ writer.write(GeneratorUtil.createSetter(field, TAB,
+ imports, currentPkg) + NL);
}
}
writer.write(NL);
-
+
if (!genTO.getHashCodeIdentifiers().isEmpty()) {
writer.write(GeneratorUtil.createHashCode(
genTO.getHashCodeIdentifiers(), TAB)
+ NL);
}
-
+
if (!genTO.getEqualsIdentifiers().isEmpty()) {
writer.write(GeneratorUtil.createEquals(genTO,
genTO.getEqualsIdentifiers(), TAB)
+ NL);
}
-
+
if (!genTO.getToStringIdentifiers().isEmpty()) {
writer.write(GeneratorUtil.createToString(genTO,
genTO.getToStringIdentifiers(), TAB)
+ NL);
}
-
+
writer.write(RCB);
}
}
*/
package org.opendaylight.controller.sal.java.api.generator;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.CLASS;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.COMMA;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.ENUM;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.FINAL;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.GAP;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.IFC;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.LB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.LCB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.NL;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.PKG;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.PRIVATE;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.PUBLIC;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.RB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.RCB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.SC;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.STATIC;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.TAB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.EXTENDS;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.IMPLEMENTS;
+import static org.opendaylight.controller.sal.java.api.generator.Constants.*;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.controller.sal.binding.model.api.AnnotationType;
import org.opendaylight.controller.sal.binding.model.api.Constant;
private GeneratorUtil() {
}
- public static String createIfcDeclarationWithPkgName(
- final GeneratedType genType, final String indent) {
- return createFileDeclarationWithPkgName(IFC, genType, indent);
+ public static String createIfcDeclaration(final GeneratedType genType,
+ final String indent,
+ final Map<String, LinkedHashMap<String, Integer>> availableImports) {
+ return createFileDeclaration(IFC, genType, indent, availableImports);
}
- public static String createClassDeclarationWithPkgName(
- final GeneratedTransferObject genTransferObject, final String indent) {
- return createFileDeclarationWithPkgName(CLASS, genTransferObject,
- indent);
+ public static String createClassDeclaration(
+ final GeneratedTransferObject genTransferObject,
+ final String indent,
+ final Map<String, LinkedHashMap<String, Integer>> availableImports) {
+ return createFileDeclaration(CLASS, genTransferObject, indent,
+ availableImports);
}
- private static String createFileDeclarationWithPkgName(final String type,
- final GeneratedType genType, final String indent) {
+ public static String createPackageDeclaration(final String packageName) {
+ return PKG + GAP + packageName + SC;
+ }
+
+ private static String createFileDeclaration(final String type,
+ final GeneratedType genType, final String indent,
+ final Map<String, LinkedHashMap<String, Integer>> availableImports) {
final StringBuilder builder = new StringBuilder();
- builder.append(PKG + GAP + genType.getPackageName() + SC);
- builder.append(NL);
- builder.append(NL);
+ final String currentPkg = genType.getPackageName();
+
createComment(builder, genType.getComment(), indent);
if (!genType.getAnnotations().isEmpty()) {
}
builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP);
- final List<Type> genImplements = genType.getImplements();
if (genType instanceof GeneratedTransferObject) {
GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
builder.append(genTO.getExtends() + GAP);
}
}
+
+ final List<Type> genImplements = genType.getImplements();
if (!genImplements.isEmpty()) {
if (genType instanceof GeneratedTransferObject) {
builder.append(IMPLEMENTS + GAP);
} else {
builder.append(EXTENDS + GAP);
}
- builder.append(getExplicitType(genImplements.get(0)));
+ builder.append(getExplicitType(genImplements.get(0),
+ availableImports, currentPkg));
+
for (int i = 1; i < genImplements.size(); ++i) {
builder.append(", ");
- builder.append(getExplicitType(genImplements.get(i)));
+ builder.append(getExplicitType(genImplements.get(i),
+ availableImports, currentPkg));
}
}
}
public static String createConstant(final Constant constant,
- final String indent) {
+ final String indent,
+ final Map<String, LinkedHashMap<String, Integer>> availableImports,
+ final String currentPkg) {
final StringBuilder builder = new StringBuilder();
builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP);
- builder.append(getExplicitType(constant.getType()) + GAP
- + constant.getName());
+ builder.append(getExplicitType(constant.getType(), availableImports,
+ currentPkg) + GAP + constant.getName());
builder.append(GAP + "=" + GAP);
builder.append(constant.getValue() + SC);
return builder.toString();
}
public static String createField(final GeneratedProperty property,
- final String indent) {
+ final String indent,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ final String currentPkg) {
final StringBuilder builder = new StringBuilder();
builder.append(indent);
if (!property.getAnnotations().isEmpty()) {
builder.append(NL);
}
builder.append(indent + PRIVATE + GAP);
- builder.append(getExplicitType(property.getReturnType()) + GAP
- + property.getName());
+ builder.append(getExplicitType(property.getReturnType(),
+ availableImports, currentPkg) + GAP + property.getName());
builder.append(SC);
return builder.toString();
}
/**
* Create method declaration in interface.
- *
+ *
* @param method
* @param indent
* @return
*/
public static String createMethodDeclaration(final MethodSignature method,
- final String indent) {
+ final String indent,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ final String currentPkg) {
+ final StringBuilder builder = new StringBuilder();
+
if (method == null) {
- throw new IllegalArgumentException("Method Signature parameter MUST be specified and cannot be NULL!");
+ throw new IllegalArgumentException(
+ "Method Signature parameter MUST be specified and cannot be NULL!");
}
final String comment = method.getComment();
final Type type = method.getReturnType();
if (type == null) {
- throw new IllegalStateException("Method Return type cannot be NULL!");
+ throw new IllegalStateException(
+ "Method Return type cannot be NULL!");
}
final List<Parameter> parameters = method.getParameters();
- final StringBuilder builder = new StringBuilder();
createComment(builder, comment, indent);
builder.append(NL);
builder.append(indent);
builder.append(NL);
}
- builder.append(indent + getExplicitType(type) + GAP + name);
+ builder.append(indent
+ + getExplicitType(type, availableImports, currentPkg) + GAP
+ + name);
builder.append(LB);
for (int i = 0; i < parameters.size(); i++) {
Parameter p = parameters.get(i);
if (i + 1 == parameters.size()) {
separator = "";
}
- builder.append(getExplicitType(p.getType()) + GAP + p.getName()
- + separator);
+ builder.append(getExplicitType(p.getType(), availableImports,
+ currentPkg) + GAP + p.getName() + separator);
}
builder.append(RB);
builder.append(SC);
}
public static String createConstructor(
- GeneratedTransferObject genTransferObject, final String indent) {
+ GeneratedTransferObject genTransferObject, final String indent,
+ Map<String, LinkedHashMap<String, Integer>> availableImports) {
final StringBuilder builder = new StringBuilder();
+ final String currentPkg = genTransferObject.getPackageName();
final List<GeneratedProperty> properties = genTransferObject
.getProperties();
final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
ctorParams.add(property);
}
}
-
+
builder.append(indent);
builder.append(PUBLIC);
builder.append(GAP);
builder.append(genTransferObject.getName());
builder.append(LB);
-
+
if (!ctorParams.isEmpty()) {
- builder.append(getExplicitType(ctorParams.get(0).getReturnType()));
+ builder.append(getExplicitType(ctorParams.get(0).getReturnType(),
+ availableImports, currentPkg));
builder.append(" ");
builder.append(ctorParams.get(0).getName());
for (int i = 1; i < ctorParams.size(); ++i) {
final GeneratedProperty param = ctorParams.get(i);
builder.append(", ");
- builder.append(getExplicitType(param.getReturnType()));
+ builder.append(getExplicitType(param.getReturnType(),
+ availableImports, currentPkg));
builder.append(GAP);
builder.append(param.getName());
}
}
public static String createGetter(final GeneratedProperty property,
- final String indent) {
+ final String indent,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ final String currentPkg) {
final StringBuilder builder = new StringBuilder();
final Type type = property.getReturnType();
final char first = Character.toUpperCase(varName.charAt(0));
final String methodName = "get" + first + varName.substring(1);
- builder.append(indent + PUBLIC + GAP + getExplicitType(type) + GAP
+ builder.append(indent + PUBLIC + GAP
+ + getExplicitType(type, availableImports, currentPkg) + GAP
+ methodName);
builder.append(LB + RB + LCB + NL);
builder.append(indent + RCB);
return builder.toString();
}
-
+
public static String createSetter(final GeneratedProperty property,
- final String indent) {
+ final String indent,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ String currentPkg) {
final StringBuilder builder = new StringBuilder();
final Type type = property.getReturnType();
final char first = Character.toUpperCase(varName.charAt(0));
final String methodName = "set" + first + varName.substring(1);
- builder.append(indent + PUBLIC + GAP + "void" + GAP
- + methodName);
- builder.append(LB + getExplicitType(type) + GAP + varName + RB + LCB + NL);
+ builder.append(indent + PUBLIC + GAP + "void" + GAP + methodName);
+ builder.append(LB + getExplicitType(type, availableImports, currentPkg)
+ + GAP + varName + RB + LCB + NL);
String currentIndent = indent + TAB;
- builder.append(currentIndent + "this." + varName + " = " + varName + SC + NL);
+ builder.append(currentIndent + "this." + varName + " = " + varName + SC
+ + NL);
builder.append(indent + RCB);
return builder.toString();
}
builder.append(indent + "public int hashCode() {" + NL);
builder.append(indent + TAB + "final int prime = 31;" + NL);
builder.append(indent + TAB + "int result = 1;" + NL);
-
+
for (GeneratedProperty property : properties) {
String fieldName = property.getName();
builder.append(indent + TAB + "result = prime * result + (("
final List<GeneratedProperty> properties, final String indent) {
StringBuilder builder = new StringBuilder();
final String indent1 = indent + TAB;
- final String indent2 = indent + TAB + TAB;
- final String indent3 = indent + TAB + TAB + TAB;
+ final String indent2 = indent1 + TAB;
+ final String indent3 = indent2 + TAB;
builder.append(indent + "public boolean equals(Object obj) {" + NL);
builder.append(indent1 + "if (this == obj) {" + NL);
builder.append(indent2 + "return false;" + NL);
builder.append(indent1 + "}" + NL);
- String typeStr = type.getPackageName() + "." + type.getName();
+ String typeStr = type.getName();
builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;"
+ NL);
return builder.toString();
}
- private static String getExplicitType(final Type type) {
+ private static String getExplicitType(final Type type,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ final String currentPkg) {
if (type == null) {
- throw new IllegalArgumentException("Type parameter MUST be specified and cannot be NULL!");
+ throw new IllegalArgumentException(
+ "Type parameter MUST be specified and cannot be NULL!");
}
String packageName = type.getPackageName();
- if (packageName.endsWith(".")) {
- packageName = packageName.substring(0, packageName.length() - 1);
- }
- final StringBuilder builder = new StringBuilder(packageName + "."
- + type.getName());
- if (type instanceof ParameterizedType) {
- final ParameterizedType pType = (ParameterizedType) type;
- Type[] pTypes = pType.getActualTypeArguments();
- builder.append("<");
- builder.append(getParameters(pTypes));
- builder.append(">");
- }
- if (builder.toString().equals("java.lang.Void")) {
- return "void";
+ LinkedHashMap<String, Integer> imports = availableImports.get(type
+ .getName());
+
+ if ((imports != null && packageName
+ .equals(findMaxValue(imports).get(0)))
+ || packageName.equals(currentPkg)) {
+ final StringBuilder builder = new StringBuilder(type.getName());
+ if (type instanceof ParameterizedType) {
+ ParameterizedType pType = (ParameterizedType) type;
+ Type[] pTypes = pType.getActualTypeArguments();
+ builder.append("<");
+ builder.append(getParameters(pTypes, availableImports,
+ currentPkg));
+ builder.append(">");
+ }
+ if (builder.toString().equals("Void")) {
+ return "void";
+ }
+ return builder.toString();
+ } else {
+ final StringBuilder builder = new StringBuilder();
+ if (packageName.startsWith("java.lang")) {
+ builder.append(type.getName());
+ } else {
+ builder.append(packageName + "." + type.getName());
+ }
+ if (type instanceof ParameterizedType) {
+ ParameterizedType pType = (ParameterizedType) type;
+ Type[] pTypes = pType.getActualTypeArguments();
+ builder.append("<");
+ builder.append(getParameters(pTypes, availableImports,
+ currentPkg));
+ builder.append(">");
+ }
+ if (builder.toString().equals("Void")) {
+ return "void";
+ }
+ return builder.toString();
}
- return builder.toString();
}
- private static String getParameters(final Type[] pTypes) {
+ private static String getParameters(final Type[] pTypes,
+ Map<String, LinkedHashMap<String, Integer>> availableImports,
+ String currentPkg) {
final StringBuilder builder = new StringBuilder();
for (int i = 0; i < pTypes.length; i++) {
Type t = pTypes[i];
if (i + 1 == pTypes.length) {
separator = "";
}
- builder.append(getExplicitType(t) + separator);
+ builder.append(getExplicitType(t, availableImports, currentPkg)
+ + separator);
}
return builder.toString();
}
+ private static List<String> findMaxValue(
+ LinkedHashMap<String, Integer> imports) {
+ final List<String> result = new ArrayList<String>();
+
+ int maxValue = 0;
+ int currentValue = 0;
+ for (Map.Entry<String, Integer> entry : imports.entrySet()) {
+ currentValue = entry.getValue();
+ if (currentValue > maxValue) {
+ result.clear();
+ result.add(entry.getKey());
+ } else if (currentValue == maxValue) {
+ result.add(entry.getKey());
+ }
+ }
+ return result;
+ }
+
private static void createComment(final StringBuilder builder,
final String comment, final String indent) {
if (comment != null && comment.length() > 0) {
}
}
+ public static Map<String, LinkedHashMap<String, Integer>> createImports(
+ GeneratedType genType) {
+ final Map<String, LinkedHashMap<String, Integer>> imports = new HashMap<String, LinkedHashMap<String, Integer>>();
+ final String genTypePkg = genType.getPackageName();
+
+ final List<Constant> constants = genType.getConstantDefinitions();
+ final List<MethodSignature> methods = genType.getMethodDefinitions();
+ List<Type> impl = genType.getImplements();
+
+ // IMPLEMENTATIONS
+ if (impl != null) {
+ for (Type t : impl) {
+ addTypeToImports(t, imports, genTypePkg);
+ }
+ }
+
+ // CONSTANTS
+ if (constants != null) {
+ for (Constant c : constants) {
+ Type ct = c.getType();
+ addTypeToImports(ct, imports, genTypePkg);
+ }
+ }
+
+ // METHODS
+ if (methods != null) {
+ for (MethodSignature m : methods) {
+ Type ct = m.getReturnType();
+ addTypeToImports(ct, imports, genTypePkg);
+ for (MethodSignature.Parameter p : m.getParameters()) {
+ addTypeToImports(p.getType(), imports, genTypePkg);
+ }
+ }
+ }
+
+ // PROPERTIES
+ if (genType instanceof GeneratedTransferObject) {
+ GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
+
+ List<GeneratedProperty> props = genTO.getProperties();
+ if (props != null) {
+ for (GeneratedProperty prop : props) {
+ Type pt = prop.getReturnType();
+ addTypeToImports(pt, imports, genTypePkg);
+ }
+ }
+ }
+
+ return imports;
+ }
+
+ private static void addTypeToImports(Type type,
+ Map<String, LinkedHashMap<String, Integer>> importedTypes,
+ String genTypePkg) {
+ String typeName = type.getName();
+ String typePkg = type.getPackageName();
+ if (typePkg.startsWith("java.lang") || typePkg.equals(genTypePkg)) {
+ return;
+ }
+ LinkedHashMap<String, Integer> packages = importedTypes.get(typeName);
+ if (packages == null) {
+ packages = new LinkedHashMap<String, Integer>();
+ packages.put(typePkg, 1);
+ importedTypes.put(typeName, packages);
+ } else {
+ Integer occurrence = packages.get(typePkg);
+ if (occurrence == null) {
+ packages.put(typePkg, 1);
+ } else {
+ occurrence++;
+ packages.put(typePkg, occurrence);
+ }
+ }
+
+ if (type instanceof ParameterizedType) {
+ ParameterizedType pt = (ParameterizedType) type;
+ Type[] params = pt.getActualTypeArguments();
+ for (Type param : params) {
+ addTypeToImports(param, importedTypes, genTypePkg);
+ }
+ }
+ }
+
+ public static List<String> createImportLines(
+ Map<String, LinkedHashMap<String, Integer>> imports) {
+ List<String> importLines = new ArrayList<String>();
+
+ for (Map.Entry<String, LinkedHashMap<String, Integer>> entry : imports
+ .entrySet()) {
+ String typeName = entry.getKey();
+ LinkedHashMap<String, Integer> typePkgMap = entry.getValue();
+ String typePkg = typePkgMap.keySet().iterator().next();
+ importLines.add("import " + typePkg + "." + typeName + SC);
+ }
+ return importLines;
+ }
+
}
*/
package org.opendaylight.controller.sal.java.api.generator;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.NL;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.RCB;
-import static org.opendaylight.controller.sal.java.api.generator.Constants.TAB;
+import static org.opendaylight.controller.sal.java.api.generator.Constants.*;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.controller.sal.binding.model.api.CodeGenerator;
import org.opendaylight.controller.sal.binding.model.api.Constant;
public class InterfaceGenerator implements CodeGenerator {
+ private Map<String, LinkedHashMap<String, Integer>> imports;
+
public Writer generate(Type type) throws IOException {
Writer writer = new StringWriter();
- if (type instanceof GeneratedType && !(type instanceof GeneratedTransferObject)) {
+ if (type instanceof GeneratedType
+ && !(type instanceof GeneratedTransferObject)) {
GeneratedType genType = (GeneratedType) type;
+ imports = GeneratorUtil.createImports(genType);
+ final String currentPkg = genType.getPackageName();
final List<Constant> constants = genType.getConstantDefinitions();
final List<MethodSignature> methods = genType
.getMethodDefinitions();
final List<Enumeration> enums = genType.getEnumDefintions();
- writer.write(GeneratorUtil.createIfcDeclarationWithPkgName(genType,
- ""));
+ writer.write(GeneratorUtil.createPackageDeclaration(genType
+ .getPackageName()));
+ writer.write(NL);
+
+ List<String> importLines = GeneratorUtil.createImportLines(imports);
+ for (String line : importLines) {
+ writer.write(line + NL);
+ }
+ writer.write(NL);
+
+ writer.write(GeneratorUtil.createIfcDeclaration(genType, "",
+ imports));
writer.write(NL);
if (constants != null) {
for (Constant c : constants) {
- writer.write(GeneratorUtil.createConstant(c, TAB) + NL);
+ writer.write(GeneratorUtil.createConstant(c, TAB, imports,
+ currentPkg) + NL);
}
writer.write(NL);
}
if (methods != null) {
for (MethodSignature m : methods) {
- writer.write(GeneratorUtil.createMethodDeclaration(m, TAB)
- + NL);
+ writer.write(GeneratorUtil.createMethodDeclaration(m, TAB,
+ imports, currentPkg) + NL);
}
writer.write(NL);
}
package org.opendaylight.controller.sal.java.api.generator.test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
import java.io.File;
import java.io.IOException;
propertyCount++;
}
}
-
+
final ClassCodeGenerator clsGen = new ClassCodeGenerator();
try {
final Writer writer = clsGen.generate(genTO);
final String outputStr = writer.toString();
writer.close();
-
+
assertNotNull(outputStr);
assertTrue(outputStr
- .contains("public CompositeKeyListKey(java.lang.String Key2, " +
- "java.lang.Byte Key1)"));
+ .contains("public CompositeKeyListKey(String Key2, "
+ + "Byte Key1)"));
} catch (IOException e) {
e.printStackTrace();
}
-
+
assertEquals(2, propertyCount);
genTOsCount++;
} else if (genTO.getName().equals("InnerListKey")) {
@Test
public void defaultConstructorTest() {
- final GeneratedTOBuilder toBuilder = new GeneratedTOBuilderImpl("simple.pack", "DefCtor");
-
+ final GeneratedTOBuilder toBuilder = new GeneratedTOBuilderImpl(
+ "simple.pack", "DefCtor");
+
GeneratedPropertyBuilder propBuilder = toBuilder.addProperty("foo");
propBuilder.addReturnType(Types.typeForClass(String.class));
propBuilder.setReadOnly(false);
-
+
propBuilder = toBuilder.addProperty("bar");
propBuilder.addReturnType(Types.typeForClass(Integer.class));
propBuilder.setReadOnly(false);
-
+
final GeneratedTransferObject genTO = toBuilder.toInstance();
-
+
final ClassCodeGenerator clsGen = new ClassCodeGenerator();
try {
final Writer writer = clsGen.generate(genTO);
final String outputStr = writer.toString();
writer.close();
-
+
assertNotNull(outputStr);
- assertTrue(outputStr
- .contains("public DefCtor()"));
+ assertTrue(outputStr.contains("public DefCtor()"));
} catch (IOException e) {
e.printStackTrace();
*/
package org.opendaylight.controller.sal.java.api.generator.test;
+import static org.junit.Assert.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
import org.junit.After;
import org.junit.Before;
-import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTypeBuilderImpl;
import org.opendaylight.controller.sal.binding.generator.api.BindingGenerator;
import org.opendaylight.controller.yang.model.api.SchemaContext;
import org.opendaylight.controller.yang.parser.impl.YangParserImpl;
-import javax.tools.JavaCompiler;
-import javax.tools.JavaFileObject;
-import javax.tools.StandardJavaFileManager;
-import javax.tools.ToolProvider;
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-
public class GeneratorJavaFileTest {
private static final String FS = File.separator;
- private static final String PATH = "test-dir";
+ private static final String PATH = "target/test/test-dir";
private final File testDir = new File(PATH);
- private static final String GENERATOR_OUTPUT_PATH = "src/test/resources/src";
+ private static final String GENERATOR_OUTPUT_PATH = "target/test/src";
private static final File GENERATOR_OUTPUT = new File(GENERATOR_OUTPUT_PATH);
- private static final String COMPILER_OUTPUT_PATH = "src/test/resources/bin";
+ private static final String COMPILER_OUTPUT_PATH = "target/test/bin";
private static final File COMPILER_OUTPUT = new File(COMPILER_OUTPUT_PATH);
@Before
public void init() {
- assertTrue(testDir.mkdir());
+ assertTrue(testDir.mkdirs());
assertTrue(COMPILER_OUTPUT.mkdirs());
assertTrue(GENERATOR_OUTPUT.mkdirs());
}
@After
public void cleanUp() {
- deleteTestDir(testDir);
- deleteTestDir(COMPILER_OUTPUT);
- deleteTestDir(GENERATOR_OUTPUT);
+ if(testDir.exists()) {
+ deleteTestDir(testDir);
+ }
+ if(COMPILER_OUTPUT.exists()) {
+ deleteTestDir(COMPILER_OUTPUT);
+ }
+ if(GENERATOR_OUTPUT.exists()) {
+ deleteTestDir(GENERATOR_OUTPUT);
+ }
}
@Test
assertTrue(filesList.contains("Type3.java"));
}
- @Ignore
@Test
public void compilationTest() throws Exception {
final YangParserImpl parser = new YangParserImpl();
grouping_stmt : GROUPING_KEYWORD string (SEMICOLON | (LEFT_BRACE (identifier_stmt |status_stmt | description_stmt | reference_stmt | typedef_stmt | grouping_stmt | data_def_stmt )* RIGHT_BRACE));
value_stmt : VALUE_KEYWORD string stmtend;
max_value_arg : /*UNBOUNDED_KEYWORD |*/ string;
+min_value_arg : /*UNBOUNDED_KEYWORD |*/ string;
max_elements_stmt : MAX_ELEMENTS_KEYWORD max_value_arg stmtend;
-min_elements_stmt : MIN_ELEMENTS_KEYWORD string stmtend;
+min_elements_stmt : MIN_ELEMENTS_KEYWORD min_value_arg stmtend;
error_app_tag_stmt : ERROR_APP_TAG_KEYWORD string stmtend;
error_message_stmt : ERROR_MESSAGE_KEYWORD string stmtend;
must_stmt : MUST_KEYWORD string (SEMICOLON | (LEFT_BRACE (identifier_stmt |error_message_stmt | error_app_tag_stmt | description_stmt | reference_stmt )* RIGHT_BRACE));
path_stmt : PATH_KEYWORD string stmtend;
leafref_specification : path_stmt;
enum_stmt : ENUM_KEYWORD string (SEMICOLON | (LEFT_BRACE (identifier_stmt |value_stmt | status_stmt | description_stmt | reference_stmt )* RIGHT_BRACE));
-enum_specification : enum_stmt (identifier_stmt | enum_stmt )+;
+enum_specification : enum_stmt (identifier_stmt | enum_stmt )*;
default_stmt : DEFAULT_KEYWORD string stmtend;
pattern_stmt : PATTERN_KEYWORD string (SEMICOLON | (LEFT_BRACE (identifier_stmt |error_message_stmt | error_app_tag_stmt | description_stmt | reference_stmt )* RIGHT_BRACE));
length_stmt : LENGTH_KEYWORD string (SEMICOLON | (LEFT_BRACE (identifier_stmt |error_message_stmt | error_app_tag_stmt | description_stmt | reference_stmt )* RIGHT_BRACE));
*/
package org.opendaylight.controller.yang.parser.builder.api;
+import java.util.List;
+import java.util.Set;
+
import org.opendaylight.controller.yang.model.api.GroupingDefinition;
+import org.opendaylight.controller.yang.model.api.Status;
+import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
/**
* Interface for builders of 'grouping' statement.
public interface GroupingBuilder extends ChildNodeBuilder, SchemaNodeBuilder,
TypeDefinitionAwareBuilder {
- DataSchemaNodeBuilder getChildNode(String name);
+ String getDescription();
+
+ String getReference();
+
+ Status getStatus();
GroupingDefinition build();
+ DataSchemaNodeBuilder getChildNode(String name);
+
+ List<UnknownSchemaNodeBuilder> getUnknownNodes();
+
+ Set<GroupingBuilder> getGroupings();
+
+ Set<TypeDefinitionBuilder> getTypedefs();
+
+ Set<UsesNodeBuilder> getUses();
+
}
package org.opendaylight.controller.yang.parser.builder.api;
import java.util.List;
+import java.util.Set;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.UsesNode;
*/
public interface UsesNodeBuilder extends Builder {
+ String getGroupingPathString();
+
SchemaPath getGroupingPath();
+
+ Set<AugmentationSchemaBuilder> getAugmentations();
+
void addAugment(AugmentationSchemaBuilder builder);
+
+ boolean isAugmenting();
+
void setAugmenting(boolean augmenting);
+
List<RefineHolder> getRefines();
+
+ List<SchemaNodeBuilder> getRefineNodes();
+
void addRefine(RefineHolder refine);
+
void addRefineNode(SchemaNodeBuilder refineNode);
+
UsesNode build();
}
import org.opendaylight.controller.yang.model.api.Status;
import org.opendaylight.controller.yang.model.api.UnknownSchemaNode;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
public class AnyXmlBuilder implements DataSchemaNodeBuilder {
+ private boolean built;
private final int line;
private final QName qname;
private SchemaPath path;
@Override
public AnyXmlSchemaNode build() {
- instance.setPath(path);
- instance.setConstraints(constraints.build());
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ if (!built) {
+ instance.setPath(path);
+ instance.setConstraints(constraints.build());
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setConfiguration(configuration);
+
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- instance.setConfiguration(configuration);
+ built = true;
+ }
return instance;
}
@Override
public void setAugmenting(final boolean augmenting) {
- throw new UnsupportedOperationException(
+ throw new YangParseException(line,
"An anyxml node cannot be augmented.");
}
instance.setConfiguration(configuration);
}
- private class AnyXmlSchemaNodeImpl implements AnyXmlSchemaNode {
+ private final class AnyXmlSchemaNodeImpl implements AnyXmlSchemaNode {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.util.YangModelBuilderUtil;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
public class AugmentationSchemaBuilderImpl implements AugmentationSchemaBuilder {
+ private boolean built;
private final AugmentationSchemaImpl instance;
private final int line;
private final String augmentTargetStr;
@Override
public AugmentationSchema build() {
- instance.setTargetPath(finalAugmentTarget);
+ if (!built) {
+ instance.setTargetPath(finalAugmentTarget);
- RevisionAwareXPath whenStmt;
- if (whenCondition == null) {
- whenStmt = null;
- } else {
- whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
- }
- instance.setWhenCondition(whenStmt);
+ RevisionAwareXPath whenStmt;
+ if (whenCondition == null) {
+ whenStmt = null;
+ } else {
+ whenStmt = new RevisionAwareXPathImpl(whenCondition, false);
+ }
+ instance.setWhenCondition(whenStmt);
- // CHILD NODES
- final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- for (DataSchemaNodeBuilder node : childNodes) {
- childs.put(node.getQName(), node.build());
- }
- instance.setChildNodes(childs);
+ // CHILD NODES
+ final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
+ for (DataSchemaNodeBuilder node : childNodes) {
+ childs.put(node.getQName(), node.build());
+ }
+ instance.setChildNodes(childs);
- // GROUPINGS
- final Set<GroupingDefinition> groupingDefinitions = new HashSet<GroupingDefinition>();
- for (GroupingBuilder builder : groupings) {
- groupingDefinitions.add(builder.build());
- }
- instance.setGroupings(groupingDefinitions);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupingDefinitions = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder builder : groupings) {
+ groupingDefinitions.add(builder.build());
+ }
+ instance.setGroupings(groupingDefinitions);
- // USES
- final Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();
- for (UsesNodeBuilder builder : usesNodes) {
- usesNodeDefinitions.add(builder.build());
- }
- instance.setUses(usesNodeDefinitions);
+ // USES
+ final Set<UsesNode> usesNodeDefinitions = new HashSet<UsesNode>();
+ for (UsesNodeBuilder builder : usesNodes) {
+ usesNodeDefinitions.add(builder.build());
+ }
+ instance.setUses(usesNodeDefinitions);
+ built = true;
+ }
return instance;
}
@Override
public void addTypedef(TypeDefinitionBuilder type) {
- throw new UnsupportedOperationException(
+ throw new YangParseException(line,
"Augmentation can not contains type definitions");
}
public int hashCode() {
final int prime = 17;
int result = 1;
- result = prime * result
+ result = prime
+ * result
+ ((augmentTargetStr == null) ? 0 : augmentTargetStr.hashCode());
result = prime * result
+ ((whenCondition == null) ? 0 : whenCondition.hashCode());
return true;
}
-
- private static class AugmentationSchemaImpl implements AugmentationSchema {
+ private final class AugmentationSchemaImpl implements AugmentationSchema {
private SchemaPath targetPath;
private RevisionAwareXPath whenCondition;
private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
public class ChoiceBuilder implements DataSchemaNodeBuilder, ChildNodeBuilder,
AugmentationTargetBuilder {
+ private boolean built;
private final ChoiceNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public ChoiceNode build() {
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setConfiguration(configuration);
- instance.setConstraints(constraints.build());
- instance.setDefaultCase(defaultCase);
-
- // CASES
- final Set<ChoiceCaseNode> choiceCases = new HashSet<ChoiceCaseNode>();
- for (ChoiceCaseBuilder caseBuilder : cases) {
- choiceCases.add(caseBuilder.build());
- }
- instance.setCases(choiceCases);
+ if (!built) {
+ instance.setPath(schemaPath);
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setAugmenting(augmenting);
+ instance.setConfiguration(configuration);
+ instance.setConstraints(constraints.build());
+ instance.setDefaultCase(defaultCase);
+
+ // CASES
+ final Set<ChoiceCaseNode> choiceCases = new HashSet<ChoiceCaseNode>();
+ for (ChoiceCaseBuilder caseBuilder : cases) {
+ choiceCases.add(caseBuilder.build());
+ }
+ instance.setCases(choiceCases);
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for (AugmentationSchemaBuilder builder : addedAugmentations) {
- augmentations.add(builder.build());
- }
- instance.setAvailableAugmentations(augmentations);
+ // AUGMENTATIONS
+ final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
+ for (AugmentationSchemaBuilder builder : addedAugmentations) {
+ augmentations.add(builder.build());
+ }
+ instance.setAvailableAugmentations(augmentations);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
+ built = true;
+ }
return instance;
}
* Choice can not contains grouping statements, so this method always
* returns an empty set.
*
- * @return
+ * @return empty set
*/
public Set<GroupingBuilder> getGroupings() {
return Collections.emptySet();
@Override
public void addGrouping(GroupingBuilder groupingBuilder) {
- throw new IllegalStateException(
+ throw new YangParseException(line,
"Can not add grouping to 'choice' node.");
}
return new HashSet<DataSchemaNodeBuilder>(cases);
}
- private static class ChoiceNodeImpl implements ChoiceNode {
+ private class ChoiceNodeImpl implements ChoiceNode {
private final QName qname;
private SchemaPath path;
private String description;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.controller.yang.parser.util.YangParseException;
public final class ChoiceCaseBuilder extends AbstractChildNodeBuilder implements
DataSchemaNodeBuilder {
@Override
public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
- throw new UnsupportedOperationException(
+ throw new YangParseException(line,
"Can not add type definition to choice case.");
}
@Override
public void setConfiguration(boolean configuration) {
- throw new UnsupportedOperationException(
+ throw new YangParseException(line,
"Can not add config definition to choice case.");
}
sb.append("]");
return sb.toString();
}
-
}
}
public class ContainerSchemaNodeBuilder extends AbstractChildNodeBuilder
implements TypeDefinitionAwareBuilder, AugmentationTargetBuilder,
DataSchemaNodeBuilder {
+ private boolean built;
private final ContainerSchemaNodeImpl instance;
private final int line;
private final ConstraintsBuilder constraints;
@Override
public ContainerSchemaNode build() {
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setPresenceContainer(presence);
- instance.setAugmenting(augmenting);
- instance.setConfiguration(configuration);
-
- // CHILD NODES
- final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- for (DataSchemaNodeBuilder node : childNodes) {
- childs.put(node.getQName(), node.build());
- }
- instance.setChildNodes(childs);
+ if(!built) {
+ instance.setPath(schemaPath);
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setPresenceContainer(presence);
+ instance.setAugmenting(augmenting);
+ instance.setConfiguration(configuration);
+
+ // CHILD NODES
+ final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
+ for (DataSchemaNodeBuilder node : childNodes) {
+ childs.put(node.getQName(), node.build());
+ }
+ instance.setChildNodes(childs);
- // GROUPINGS
- final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
- for (GroupingBuilder builder : groupings) {
- groupingDefs.add(builder.build());
- }
- instance.setGroupings(groupingDefs);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder builder : groupings) {
+ groupingDefs.add(builder.build());
+ }
+ instance.setGroupings(groupingDefs);
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.setTypeDefinitions(typedefs);
- // USES
- final Set<UsesNode> uses = new HashSet<UsesNode>();
- for (UsesNodeBuilder builder : addedUsesNodes) {
- uses.add(builder.build());
- }
- instance.setUses(uses);
+ // USES
+ final Set<UsesNode> uses = new HashSet<UsesNode>();
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ uses.add(builder.build());
+ }
+ instance.setUses(uses);
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for(AugmentationSchemaBuilder builder : addedAugmentations) {
- augmentations.add(builder.build());
- }
- instance.setAvailableAugmentations(augmentations);
+ // AUGMENTATIONS
+ final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
+ for(AugmentationSchemaBuilder builder : addedAugmentations) {
+ augmentations.add(builder.build());
+ }
+ instance.setAvailableAugmentations(augmentations);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- instance.setConstraints(constraints.build());
- instance.setAvailableAugmentations(augmentations);
+ instance.setConstraints(constraints.build());
+ instance.setAvailableAugmentations(augmentations);
+ built = true;
+ }
return instance;
}
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
public class GroupingBuilderImpl implements GroupingBuilder {
+ private boolean built;
private final GroupingDefinitionImpl instance;
private final int line;
+ private final QName qname;
private SchemaPath schemaPath;
+ private String description;
+ private String reference;
+ private Status status;
private final Set<DataSchemaNodeBuilder> childNodes = new HashSet<DataSchemaNodeBuilder>();
private final Set<GroupingBuilder> groupings = new HashSet<GroupingBuilder>();
private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
private final Set<UsesNodeBuilder> usesNodes = new HashSet<UsesNodeBuilder>();
private final List<UnknownSchemaNodeBuilder> addedUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
- GroupingBuilderImpl(final QName qname, final int line) {
+ public GroupingBuilderImpl(final QName qname, final int line) {
+ this.qname = qname;
this.instance = new GroupingDefinitionImpl(qname);
this.line = line;
}
@Override
public GroupingDefinition build() {
- instance.setPath(schemaPath);
+ if (!built) {
+ instance.setPath(schemaPath);
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+
+ // CHILD NODES
+ final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
+ for (DataSchemaNodeBuilder node : childNodes) {
+ childs.put(node.getQName(), node.build());
+ }
+ instance.setChildNodes(childs);
- // CHILD NODES
- final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- for (DataSchemaNodeBuilder node : childNodes) {
- childs.put(node.getQName(), node.build());
- }
- instance.setChildNodes(childs);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder builder : groupings) {
+ groupingDefs.add(builder.build());
+ }
+ instance.setGroupings(groupingDefs);
- // GROUPINGS
- final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
- for (GroupingBuilder builder : groupings) {
- groupingDefs.add(builder.build());
- }
- instance.setGroupings(groupingDefs);
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.setTypeDefinitions(typedefs);
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ // USES
+ final Set<UsesNode> usesNodeDefs = new HashSet<UsesNode>();
+ for (UsesNodeBuilder builder : usesNodes) {
+ usesNodeDefs.add(builder.build());
+ }
+ instance.setUses(usesNodeDefs);
- // USES
- final Set<UsesNode> usesNodeDefs = new HashSet<UsesNode>();
- for (UsesNodeBuilder builder : usesNodes) {
- usesNodeDefs.add(builder.build());
- }
- instance.setUses(usesNodeDefs);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for(UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
+ built = true;
}
- instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
return line;
}
- /**
- * Always returns null.
- */
@Override
public QName getQName() {
- return null;
+ return qname;
+ }
+
+ @Override
+ public Set<TypeDefinitionBuilder> getTypedefs() {
+ return addedTypedefs;
}
@Override
this.schemaPath = schemaPath;
}
+ @Override
+ public String getDescription() {
+ return description;
+ }
+
@Override
public void setDescription(final String description) {
- instance.setDescription(description);
+ this.description = description;
+ }
+
+ @Override
+ public String getReference() {
+ return reference;
}
@Override
public void setReference(final String reference) {
- instance.setReference(reference);
+ this.reference = reference;
+ }
+
+ @Override
+ public Status getStatus() {
+ return status;
}
@Override
public void setStatus(final Status status) {
- instance.setStatus(status);
+ this.status = status;
}
@Override
public DataSchemaNodeBuilder getChildNode(String name) {
DataSchemaNodeBuilder result = null;
- for(DataSchemaNodeBuilder node : childNodes) {
- if(node.getQName().getLocalName().equals(name)) {
+ for (DataSchemaNodeBuilder node : childNodes) {
+ if (node.getQName().getLocalName().equals(name)) {
result = node;
break;
}
return childNodes;
}
+ @Override
+ public Set<GroupingBuilder> getGroupings() {
+ return groupings;
+ }
+
@Override
public void addGrouping(final GroupingBuilder grouping) {
groupings.add(grouping);
}
+ @Override
+ public Set<UsesNodeBuilder> getUses() {
+ return usesNodes;
+ }
+
@Override
public void addUsesNode(final UsesNodeBuilder usesBuilder) {
usesNodes.add(usesBuilder);
}
+ @Override
+ public List<UnknownSchemaNodeBuilder> getUnknownNodes() {
+ return addedUnknownNodes;
+ }
+
@Override
public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
addedUnknownNodes.add(unknownNode);
}
private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if(unknownNodes != null) {
+ if (unknownNodes != null) {
this.unknownNodes = unknownNodes;
}
}
@Override
public void addUnknownSchemaNode(final UnknownSchemaNodeBuilder unknownNode) {
+
+
addedUnknownNodes.add(unknownNode);
}
public class LeafListSchemaNodeBuilder extends AbstractTypeAwareBuilder
implements SchemaNodeBuilder, DataSchemaNodeBuilder {
+ private boolean built;
private final LeafListSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public LeafListSchemaNode build() {
- instance.setConstraints(constraints.build());
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setConfiguration(configuration);
- instance.setUserOrdered(userOrdered);
-
- if (type == null) {
- instance.setType(typedef.build());
- } else {
- instance.setType(type);
- }
+ if (!built) {
+ instance.setConstraints(constraints.build());
+ instance.setPath(schemaPath);
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setAugmenting(augmenting);
+ instance.setConfiguration(configuration);
+ instance.setUserOrdered(userOrdered);
+
+ if (type == null) {
+ instance.setType(typedef.build());
+ } else {
+ instance.setType(type);
+ }
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
+ built = true;
+ }
return instance;
}
public class LeafSchemaNodeBuilder extends AbstractTypeAwareBuilder implements
DataSchemaNodeBuilder, SchemaNodeBuilder {
+ private boolean built;
private final LeafSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public LeafSchemaNode build() {
- instance.setPath(path);
- instance.setConstraints(constraints.build());
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
- // TYPE
- if (type == null) {
- instance.setType(typedef.build());
- } else {
- instance.setType(type);
- }
+ if(!built) {
+ instance.setPath(path);
+ instance.setConstraints(constraints.build());
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setAugmenting(augmenting);
+ instance.setConfiguration(configuration);
+ instance.setDefault(defaultStr);
+ instance.setUnits(unitsStr);
+
+ // TYPE
+ if (type == null) {
+ instance.setType(typedef.build());
+ } else {
+ instance.setType(type);
+ }
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- instance.setAugmenting(augmenting);
- instance.setConfiguration(configuration);
- instance.setDefault(defaultStr);
- instance.setUnits(unitsStr);
+ built = true;
+ }
return instance;
}
this.augmenting = augmenting;
}
+
+
public boolean isConfiguration() {
return configuration;
}
public class ListSchemaNodeBuilder extends AbstractChildNodeBuilder implements
DataSchemaNodeBuilder, AugmentationTargetBuilder,
TypeDefinitionAwareBuilder {
+ private boolean built;
private final ListSchemaNodeImpl instance;
private final int line;
// SchemaNode args
@Override
public ListSchemaNode build() {
- instance.setKeyDefinition(keyDefinition);
- instance.setPath(schemaPath);
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
- instance.setAugmenting(augmenting);
- instance.setConfiguration(configuration);
- instance.setUserOrdered(userOrdered);
-
- // CHILD NODES
- final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- for (DataSchemaNodeBuilder node : childNodes) {
- childs.put(node.getQName(), node.build());
- }
- instance.setChildNodes(childs);
+ if(!built) {
+ instance.setKeyDefinition(keyDefinition);
+ instance.setPath(schemaPath);
+ instance.setDescription(description);
+ instance.setReference(reference);
+ instance.setStatus(status);
+ instance.setAugmenting(augmenting);
+ instance.setConfiguration(configuration);
+ instance.setUserOrdered(userOrdered);
+
+ // CHILD NODES
+ final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
+ for (DataSchemaNodeBuilder node : childNodes) {
+ childs.put(node.getQName(), node.build());
+ }
+ instance.setChildNodes(childs);
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.setTypeDefinitions(typedefs);
- // USES
- final Set<UsesNode> usesNodeDefs = new HashSet<UsesNode>();
- for (UsesNodeBuilder builder : addedUsesNodes) {
- usesNodeDefs.add(builder.build());
- }
- instance.setUses(usesNodeDefs);
+ // USES
+ final Set<UsesNode> usesNodeDefs = new HashSet<UsesNode>();
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ usesNodeDefs.add(builder.build());
+ }
+ instance.setUses(usesNodeDefs);
- // GROUPINGS
- final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
- for (GroupingBuilder builder : groupings) {
- groupingDefs.add(builder.build());
- }
- instance.setGroupings(groupingDefs);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder builder : groupings) {
+ groupingDefs.add(builder.build());
+ }
+ instance.setGroupings(groupingDefs);
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for (AugmentationSchemaBuilder builder : addedAugmentations) {
- augmentations.add(builder.build());
- }
- instance.setAvailableAugmentations(augmentations);
+ // AUGMENTATIONS
+ final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
+ for (AugmentationSchemaBuilder builder : addedAugmentations) {
+ augmentations.add(builder.build());
+ }
+ instance.setAvailableAugmentations(augmentations);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- instance.setConstraints(constraints.build());
- instance.setAvailableAugmentations(augmentations);
+ instance.setConstraints(constraints.build());
+ instance.setAvailableAugmentations(augmentations);
+ built = true;
+ }
return instance;
}
.get(pathToAnyXml);
if (parent != null) {
if (parent instanceof AugmentationSchemaBuilder) {
- throw new UnsupportedOperationException(
+ throw new YangParseException(
"An anyxml node cannot be augmented.");
}
parent.addChildNode(builder);
Builder builder = moduleNodes.get(parentPath);
// current api did not support adding config to deviate
if (!(builder instanceof DeviationBuilder)) {
- DataSchemaNodeBuilder configBuilder = (DataSchemaNodeBuilder) moduleNodes
- .get(parentPath);
- configBuilder.setConfiguration(configuration);
+ if(builder instanceof RefineHolder) {
+ ((RefineHolder)builder).setConfig(configuration);
+ } else {
+ ((DataSchemaNodeBuilder)builder).setConfiguration(configuration);
+ }
}
}
final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();
for (Map.Entry<List<String>, GroupingBuilder> entry : addedGroupings
.entrySet()) {
- if (entry.getKey().size() == 2) {
+ if (entry.getKey().size() == 3) {
groupings.add(entry.getValue().build());
}
}
public class NotificationBuilder extends AbstractChildNodeBuilder implements
TypeDefinitionAwareBuilder, SchemaNodeBuilder {
+ private boolean built;
private final NotificationDefinitionImpl instance;
private final int line;
private SchemaPath schemaPath;
@Override
public SchemaNode build() {
- instance.setPath(schemaPath);
+ if(!built) {
+ instance.setPath(schemaPath);
- // CHILD NODES
- final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
- for (DataSchemaNodeBuilder node : childNodes) {
- childs.put(node.getQName(), node.build());
- }
- instance.setChildNodes(childs);
+ // CHILD NODES
+ final Map<QName, DataSchemaNode> childs = new HashMap<QName, DataSchemaNode>();
+ for (DataSchemaNodeBuilder node : childNodes) {
+ childs.put(node.getQName(), node.build());
+ }
+ instance.setChildNodes(childs);
- // GROUPINGS
- final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
- for (GroupingBuilder builder : groupings) {
- groupingDefs.add(builder.build());
- }
- instance.setGroupings(groupingDefs);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupingDefs = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder builder : groupings) {
+ groupingDefs.add(builder.build());
+ }
+ instance.setGroupings(groupingDefs);
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.setTypeDefinitions(typedefs);
- // USES
- final Set<UsesNode> uses = new HashSet<UsesNode>();
- for (UsesNodeBuilder builder : addedUsesNodes) {
- uses.add(builder.build());
- }
- instance.setUses(uses);
+ // USES
+ final Set<UsesNode> uses = new HashSet<UsesNode>();
+ for (UsesNodeBuilder builder : addedUsesNodes) {
+ uses.add(builder.build());
+ }
+ instance.setUses(uses);
+
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
+ built = true;
}
- instance.setUnknownSchemaNodes(unknownNodes);
return instance;
}
public class RpcDefinitionBuilder implements SchemaNodeBuilder,
TypeDefinitionAwareBuilder {
+ private boolean built;
private final RpcDefinitionImpl instance;
private final int line;
private final QName qname;
@Override
public RpcDefinition build() {
- final ContainerSchemaNode input = inputBuilder.build();
- final ContainerSchemaNode output = outputBuilder.build();
- instance.setInput(input);
- instance.setOutput(output);
-
- instance.setPath(schemaPath);
+ if(!built) {
+ final ContainerSchemaNode input = inputBuilder.build();
+ final ContainerSchemaNode output = outputBuilder.build();
+ instance.setInput(input);
+ instance.setOutput(output);
+
+ instance.setPath(schemaPath);
+
+ // TYPEDEFS
+ final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
+ for (TypeDefinitionBuilder entry : addedTypedefs) {
+ typedefs.add(entry.build());
+ }
+ instance.setTypeDefinitions(typedefs);
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new HashSet<TypeDefinition<?>>();
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
+ // GROUPINGS
+ final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();
+ for (GroupingBuilder entry : addedGroupings) {
+ groupings.add(entry.build());
+ }
+ instance.setGroupings(groupings);
- // GROUPINGS
- final Set<GroupingDefinition> groupings = new HashSet<GroupingDefinition>();
- for (GroupingBuilder entry : addedGroupings) {
- groupings.add(entry.build());
- }
- instance.setGroupings(groupings);
+ // UNKNOWN NODES
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
+ unknownNodes.add(b.build());
+ }
+ instance.setUnknownSchemaNodes(unknownNodes);
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
+ built = true;
}
- instance.setUnknownSchemaNodes(unknownNodes);
-
return instance;
}
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;\r
import org.opendaylight.controller.yang.parser.util.RefineHolder;\r
\r
-final class UsesNodeBuilderImpl implements UsesNodeBuilder {\r
+public final class UsesNodeBuilderImpl implements UsesNodeBuilder {\r
+ private boolean built;\r
private final UsesNodeImpl instance;\r
private final int line;\r
+ private final String groupingPathStr;\r
private final SchemaPath groupingPath;\r
+ private boolean augmenting;\r
private final Set<AugmentationSchemaBuilder> addedAugments = new HashSet<AugmentationSchemaBuilder>();\r
private List<SchemaNodeBuilder> refineBuilders = new ArrayList<SchemaNodeBuilder>();\r
private List<RefineHolder> refines = new ArrayList<RefineHolder>();\r
\r
- UsesNodeBuilderImpl(final String groupingPathStr, final int line) {\r
+ public UsesNodeBuilderImpl(final String groupingPathStr, final int line) {\r
+ this.groupingPathStr = groupingPathStr;\r
this.groupingPath = parseUsesPath(groupingPathStr);\r
this.line = line;\r
instance = new UsesNodeImpl(groupingPath);\r
\r
@Override\r
public UsesNode build() {\r
- // AUGMENTATIONS\r
- final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();\r
- for (AugmentationSchemaBuilder builder : addedAugments) {\r
- augments.add(builder.build());\r
- }\r
- instance.setAugmentations(augments);\r
+ if (!built) {\r
+ instance.setAugmenting(augmenting);\r
\r
- // REFINES\r
- final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();\r
- for (SchemaNodeBuilder refineBuilder : refineBuilders) {\r
- SchemaNode refineNode = refineBuilder.build();\r
- refineNodes.put(refineNode.getPath(), refineNode);\r
- }\r
- instance.setRefines(refineNodes);\r
+ // AUGMENTATIONS\r
+ final Set<AugmentationSchema> augments = new HashSet<AugmentationSchema>();\r
+ for (AugmentationSchemaBuilder builder : addedAugments) {\r
+ augments.add(builder.build());\r
+ }\r
+ instance.setAugmentations(augments);\r
+\r
+ // REFINES\r
+ final Map<SchemaPath, SchemaNode> refineNodes = new HashMap<SchemaPath, SchemaNode>();\r
+ for (SchemaNodeBuilder refineBuilder : refineBuilders) {\r
+ SchemaNode refineNode = refineBuilder.build();\r
+ refineNodes.put(refineNode.getPath(), refineNode);\r
+ }\r
+ instance.setRefines(refineNodes);\r
\r
+ built = true;\r
+ }\r
return instance;\r
}\r
\r
return line;\r
}\r
\r
+ @Override\r
+ public String getGroupingPathString() {\r
+ return groupingPathStr;\r
+ }\r
+\r
@Override\r
public SchemaPath getGroupingPath() {\r
return groupingPath;\r
}\r
\r
+ @Override\r
+ public Set<AugmentationSchemaBuilder> getAugmentations() {\r
+ return addedAugments;\r
+ }\r
+\r
@Override\r
public void addAugment(final AugmentationSchemaBuilder augmentBuilder) {\r
addedAugments.add(augmentBuilder);\r
}\r
\r
+ @Override\r
+ public boolean isAugmenting() {\r
+ return augmenting;\r
+ }\r
+\r
@Override\r
public void setAugmenting(final boolean augmenting) {\r
- instance.setAugmenting(augmenting);\r
+ this.augmenting = augmenting;\r
+ }\r
+\r
+ @Override\r
+ public List<SchemaNodeBuilder> getRefineNodes() {\r
+ return refineBuilders;\r
}\r
\r
@Override\r
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.controller.yang.parser.impl;
+
+import java.net.URI;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
+import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
+import org.opendaylight.controller.yang.model.api.Module;
+import org.opendaylight.controller.yang.model.api.NotificationDefinition;
+import org.opendaylight.controller.yang.model.api.RpcDefinition;
+import org.opendaylight.controller.yang.model.api.SchemaContext;
+
+final class SchemaContextImpl implements SchemaContext {
+ private final Set<Module> modules;
+
+ SchemaContextImpl(final Set<Module> modules) {
+ this.modules = modules;
+ }
+
+ @Override
+ public Set<DataSchemaNode> getDataDefinitions() {
+ final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
+ for (Module m : modules) {
+ dataDefs.addAll(m.getChildNodes());
+ }
+ return dataDefs;
+ }
+
+ @Override
+ public Set<Module> getModules() {
+ return modules;
+ }
+
+ @Override
+ public Set<NotificationDefinition> getNotifications() {
+ final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
+ for (Module m : modules) {
+ notifications.addAll(m.getNotifications());
+ }
+ return notifications;
+ }
+
+ @Override
+ public Set<RpcDefinition> getOperations() {
+ final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
+ for (Module m : modules) {
+ rpcs.addAll(m.getRpcs());
+ }
+ return rpcs;
+ }
+
+ @Override
+ public Set<ExtensionDefinition> getExtensions() {
+ final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
+ for (Module m : modules) {
+ extensions.addAll(m.getExtensionSchemaNodes());
+ }
+ return extensions;
+ }
+
+ @Override
+ public Module findModuleByName(final String name, final Date revision) {
+ if (name != null) {
+ for (final Module module : modules) {
+ if (revision == null) {
+ if (module.getName().equals(name)) {
+ return module;
+ }
+ } else if (module.getName().equals(name)
+ && module.getRevision().equals(revision)) {
+ return module;
+ }
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public Module findModuleByNamespace(final URI namespace) {
+ if (namespace != null) {
+ for (final Module module : modules) {
+ if (module.getNamespace().equals(namespace)) {
+ return module;
+ }
+ }
+ }
+ return null;
+ }
+
+}
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
-import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import org.opendaylight.controller.antlrv4.code.gen.YangLexer;
import org.opendaylight.controller.antlrv4.code.gen.YangParser;
import org.opendaylight.controller.yang.common.QName;
-import org.opendaylight.controller.yang.model.api.DataSchemaNode;
-import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
import org.opendaylight.controller.yang.model.api.Module;
import org.opendaylight.controller.yang.model.api.ModuleImport;
-import org.opendaylight.controller.yang.model.api.MustDefinition;
-import org.opendaylight.controller.yang.model.api.NotificationDefinition;
-import org.opendaylight.controller.yang.model.api.RpcDefinition;
import org.opendaylight.controller.yang.model.api.SchemaContext;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(
final List<InputStream> yangFileStreams) {
- //Linked Hash Map MUST be used because Linked Hash Map preserves ORDER of items stored in map.
+ // Linked Hash Map MUST be used because Linked Hash Map preserves ORDER
+ // of items stored in map.
final Map<String, TreeMap<Date, ModuleBuilder>> modules = new LinkedHashMap<String, TreeMap<Date, ModuleBuilder>>();
final ParseTreeWalker walker = new ParseTreeWalker();
final List<ParseTree> trees = parseStreams(yangFileStreams);
// module dependency graph sorted
List<ModuleBuilder> sorted = ModuleDependencySort.sort(builders);
-
+
for (ModuleBuilder builder : sorted) {
final String builderName = builder.getName();
Date builderRevision = builder.getRevision();
resolveAugments(modules);
// build
- // Linked Hash Set MUST be used otherwise the Set will not maintain order!
+ // Linked Hash Set MUST be used otherwise the Set will not maintain
+ // order!
// http://docs.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html
final Set<Module> result = new LinkedHashSet<Module>();
for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules
/**
* Search for dirty nodes (node which contains UnknownType) and resolve
* unknown types.
- *
+ *
* @param modules
* all available modules
* @param module
}
/**
- * Go through all typedef statements from given module and search for one
- * with given name
- *
- * @param typedefs
- * typedef statements to search
+ * Search for type definition builder by name.
+ *
+ * @param dependentModule
+ * module to search
* @param name
- * name of searched typedef
- * @return typedef with name equals to given name
+ * name of type definition
+ * @param currentModuleName
+ * current module name
+ * @param line
+ * current line in yang model
+ * @return
*/
private TypeDefinitionBuilder findTypedefBuilderByName(
final ModuleBuilder dependentModule, final String name,
final String currentModuleName, final int line) {
- TypeDefinitionBuilder result = null;
final Set<TypeDefinitionBuilder> typedefs = dependentModule
.getModuleTypedefs();
for (TypeDefinitionBuilder td : typedefs) {
if (td.getQName().getLocalName().equals(name)) {
- result = td;
- break;
+ return td;
}
}
- if (result == null) {
- throw new YangParseException(currentModuleName, line,
- "Target module '" + dependentModule.getName()
- + "' does not contain typedef '" + name + "'.");
- }
- return result;
+ throw new YangParseException(currentModuleName, line, "Target module '"
+ + dependentModule.getName() + "' does not contain typedef '"
+ + name + "'.");
}
/**
* Pull restriction from referenced type and add them to given constraints
- *
+ *
* @param referencedType
* @param constraints
*/
}
/**
- * Go through all augmentation definitions and resolve them. This method
- * also finds referenced node and add child nodes to it.
- *
+ * Go through all augment definitions and resolve them. This method also
+ * finds augment target node and add child nodes to it.
+ *
* @param modules
* all available modules
*/
}
/**
- *
+ *
* @param modules
* all available modules
* @param module
.getTargetPath();
final List<QName> path = augmentTargetSchemaPath.getPath();
- int i = 0;
- final QName qname = path.get(i);
+ final QName qname = path.get(0);
String prefix = qname.getPrefix();
if (prefix == null) {
prefix = module.getPrefix();
if (childQName.getLocalName().equals(
qname.getLocalName())) {
currentParent = child;
- i++;
break;
}
}
- for (; i < path.size(); i++) {
+ for (int i = 1; i < path.size(); i++) {
final QName currentQName = path.get(i);
DataSchemaNodeBuilder newParent = null;
for (DataSchemaNodeBuilder child : ((ChildNodeBuilder) currentParent)
/**
* Go through identity statements defined in current module and resolve
* their 'base' statement if present.
- *
+ *
* @param modules
* all modules
* @param module
/**
* Go through uses statements defined in current module and resolve their
* refine statements.
- *
+ *
* @param modules
* all modules
* @param module
.entrySet()) {
final List<String> key = entry.getKey();
final UsesNodeBuilder usesNode = entry.getValue();
+ final int line = usesNode.getLine();
final String groupingName = key.get(key.size() - 1);
for (RefineHolder refine : usesNode.getRefines()) {
- // refine statements
- final String defaultStr = refine.getDefaultStr();
- final Boolean mandatory = refine.isMandatory();
- final MustDefinition must = refine.getMust();
- final Boolean presence = refine.isPresence();
- final Integer min = refine.getMinElements();
- final Integer max = refine.getMaxElements();
- final List<UnknownSchemaNodeBuilder> unknownNodes = refine
- .getUnknownNodes();
-
- Builder refineTarget = getRefineTargetBuilder(groupingName,
+ Builder refineTarget = getRefineNodeBuilderCopy(groupingName,
refine, modules, module);
+ ParserUtils.refineDefault(refineTarget, refine, line);
if (refineTarget instanceof LeafSchemaNodeBuilder) {
final LeafSchemaNodeBuilder leaf = (LeafSchemaNodeBuilder) refineTarget;
- if (defaultStr != null && !("".equals(defaultStr))) {
- leaf.setDefaultStr(defaultStr);
- }
- if (mandatory != null) {
- leaf.getConstraints().setMandatory(mandatory);
- }
- if (must != null) {
- leaf.getConstraints().addMustDefinition(must);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- leaf.addUnknownSchemaNode(unknown);
- }
- }
+ ParserUtils.refineLeaf(leaf, refine, line);
usesNode.addRefineNode(leaf);
} else if (refineTarget instanceof ContainerSchemaNodeBuilder) {
final ContainerSchemaNodeBuilder container = (ContainerSchemaNodeBuilder) refineTarget;
- if (presence != null) {
- container.setPresence(presence);
- }
- if (must != null) {
- container.getConstraints().addMustDefinition(must);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- container.addUnknownSchemaNode(unknown);
- }
- }
+ ParserUtils.refineContainer(container, refine, line);
usesNode.addRefineNode(container);
} else if (refineTarget instanceof ListSchemaNodeBuilder) {
final ListSchemaNodeBuilder list = (ListSchemaNodeBuilder) refineTarget;
- if (must != null) {
- list.getConstraints().addMustDefinition(must);
- }
- if (min != null) {
- list.getConstraints().setMinElements(min);
- }
- if (max != null) {
- list.getConstraints().setMaxElements(max);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- list.addUnknownSchemaNode(unknown);
- }
- }
+ ParserUtils.refineList(list, refine, line);
+ usesNode.addRefineNode(list);
} else if (refineTarget instanceof LeafListSchemaNodeBuilder) {
- final LeafListSchemaNodeBuilder leafList = (LeafListSchemaNodeBuilder) getRefineTargetBuilder(
- groupingName, refine, modules, module);
- if (must != null) {
- leafList.getConstraints().addMustDefinition(must);
- }
- if (min != null) {
- leafList.getConstraints().setMinElements(min);
- }
- if (max != null) {
- leafList.getConstraints().setMaxElements(max);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- leafList.addUnknownSchemaNode(unknown);
- }
- }
+ final LeafListSchemaNodeBuilder leafList = (LeafListSchemaNodeBuilder) refineTarget;
+ ParserUtils.refineLeafList(leafList, refine, line);
+ usesNode.addRefineNode(leafList);
} else if (refineTarget instanceof ChoiceBuilder) {
final ChoiceBuilder choice = (ChoiceBuilder) refineTarget;
- if (defaultStr != null) {
- choice.setDefaultCase(defaultStr);
- }
- if (mandatory != null) {
- choice.getConstraints().setMandatory(mandatory);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- choice.addUnknownSchemaNode(unknown);
- }
- }
+ ParserUtils.refineChoice(choice, refine, line);
+ usesNode.addRefineNode(choice);
} else if (refineTarget instanceof AnyXmlBuilder) {
final AnyXmlBuilder anyXml = (AnyXmlBuilder) refineTarget;
- if (mandatory != null) {
- anyXml.getConstraints().setMandatory(mandatory);
- }
- if (must != null) {
- anyXml.getConstraints().addMustDefinition(must);
- }
- if (unknownNodes != null) {
- for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
- anyXml.addUnknownSchemaNode(unknown);
- }
- }
+ ParserUtils.refineAnyxml(anyXml, refine, line);
+ usesNode.addRefineNode(anyXml);
+ } else if(refineTarget instanceof GroupingBuilder) {
+ usesNode.addRefineNode((GroupingBuilder)refineTarget);
+ } else if(refineTarget instanceof TypedefBuilder) {
+ usesNode.addRefineNode((TypedefBuilder)refineTarget);
}
}
}
}
/**
- * Find original builder of refine node and return copy of this builder.
- *
+ * Find original builder of node to refine and return copy of this builder.
+ * <p>
+ * We must make a copy of builder to preserve original builder, because this
+ * object will be refined (modified) and later added to
+ * {@link UsesNodeBuilder}.
+ * </p>
+ *
* @param groupingPath
* path to grouping which contains node to refine
* @param refine
* all loaded modules
* @param module
* current module
- * @return copy of Builder object of node to be refined if it is present in
- * grouping, null otherwise
+ * @return copy of node to be refined if it is present in grouping, null
+ * otherwise
*/
- private Builder getRefineTargetBuilder(final String groupingPath,
+ private Builder getRefineNodeBuilderCopy(final String groupingPath,
final RefineHolder refine,
final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module) {
} else if (lookedUpBuilder instanceof AnyXmlBuilder) {
result = ParserUtils
.copyAnyXmlBuilder((AnyXmlBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof GroupingBuilder) {
+ result = ParserUtils
+ .copyGroupingBuilder((GroupingBuilder) lookedUpBuilder);
+ } else if (lookedUpBuilder instanceof TypeDefinitionBuilder) {
+ result = ParserUtils
+ .copyTypedefBuilder((TypedefBuilder) lookedUpBuilder);
} else {
throw new YangParseException(module.getName(), refine.getLine(),
"Target '" + refine.getName() + "' can not be refined");
/**
* Find builder of refine node.
- *
+ *
* @param groupingPath
* path to grouping which contains node to refine
- * @param refineNodeName
- * name of node to be refined
+ * @param refine
+ * object containing refine information
* @param modules
* all loaded modules
* @param module
final RefineHolder refine,
final Map<String, TreeMap<Date, ModuleBuilder>> modules,
final ModuleBuilder module) {
+ final String refineNodeName = refine.getName();
final SchemaPath path = ParserUtils.parseUsesPath(groupingPath);
final List<String> builderPath = new ArrayList<String>();
String prefix = null;
final GroupingBuilder builder = (GroupingBuilder) dependentModule
.getNode(builderPath);
- return builder.getChildNode(refine.getName());
+ Builder result = builder.getChildNode(refineNodeName);
+ if(result == null) {
+ Set<GroupingBuilder> grps = builder.getGroupings();
+ for(GroupingBuilder gr : grps) {
+ if(gr.getQName().getLocalName().equals(refineNodeName)) {
+ result = gr;
+ break;
+ }
+ }
+ }
+ if(result == null) {
+ Set<TypeDefinitionBuilder> typedefs = builder.getTypedefs();
+ for(TypeDefinitionBuilder typedef : typedefs) {
+ if(typedef.getQName().getLocalName().equals(refineNodeName)) {
+ result = typedef;
+ break;
+ }
+ }
+ }
+ return result;
}
private QName findFullQName(
/**
* Find dependent module based on given prefix
- *
+ *
* @param modules
* all available modules
* @param module
return dependentModule;
}
- private static class SchemaContextImpl implements SchemaContext {
- private final Set<Module> modules;
-
- private SchemaContextImpl(final Set<Module> modules) {
- this.modules = modules;
- }
-
- @Override
- public Set<DataSchemaNode> getDataDefinitions() {
- final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
- for (Module m : modules) {
- dataDefs.addAll(m.getChildNodes());
- }
- return dataDefs;
- }
-
- @Override
- public Set<Module> getModules() {
- return modules;
- }
-
- @Override
- public Set<NotificationDefinition> getNotifications() {
- final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
- for (Module m : modules) {
- notifications.addAll(m.getNotifications());
- }
- return notifications;
- }
-
- @Override
- public Set<RpcDefinition> getOperations() {
- final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
- for (Module m : modules) {
- rpcs.addAll(m.getRpcs());
- }
- return rpcs;
- }
-
- @Override
- public Set<ExtensionDefinition> getExtensions() {
- final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
- for (Module m : modules) {
- extensions.addAll(m.getExtensionSchemaNodes());
- }
- return extensions;
- }
-
- @Override
- public Module findModuleByName(final String name, final Date revision) {
- if (name != null) {
- for (final Module module : modules) {
- if (revision == null) {
- if (module.getName().equals(name)) {
- return module;
- }
- } else if (module.getName().equals(name)
- && module.getRevision().equals(revision)) {
- return module;
- }
- }
- }
- return null;
- }
-
- @Override
- public Module findModuleByNamespace(final URI namespace) {
- if (namespace != null) {
- for (final Module module : modules) {
- if (module.getNamespace().equals(namespace)) {
- return module;
- }
- }
- }
- return null;
- }
- }
-
}
QName containerQName = new QName(namespace, revision, yangModelPrefix,
containerName);
ContainerSchemaNodeBuilder containerBuilder = moduleBuilder
- .addContainerNode(containerQName, actualPath, ctx.getStart()
- .getLine());
+ .addContainerNode(containerQName, actualPath, ctx.getStart().getLine());
updatePath(containerName);
containerBuilder.setPath(createActualSchemaPath(actualPath, namespace,
import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.controller.yang.model.api.type.BitsTypeDefinition.Bit;
-public final class BitImpl implements BitsTypeDefinition.Bit {
+final class BitImpl implements BitsTypeDefinition.Bit {
private final Long position;
private final QName qname;
private final SchemaPath schemaPath;
import org.opendaylight.controller.yang.model.api.MustDefinition;
import org.opendaylight.controller.yang.model.api.RevisionAwareXPath;
-public final class MustDefinitionImpl implements MustDefinition {
+final class MustDefinitionImpl implements MustDefinition {
private final String mustStr;
private final String description;
private final String reference;
private final String errorAppTag;
private final String errorMessage;
- public MustDefinitionImpl(String mustStr, String description,
- String reference, String errorAppTag, String errorMessage) {
+ MustDefinitionImpl(String mustStr, String description, String reference,
+ String errorAppTag, String errorMessage) {
this.mustStr = mustStr;
this.description = description;
this.reference = reference;
*/
package org.opendaylight.controller.yang.parser.util;
+import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import org.opendaylight.controller.yang.model.api.SchemaPath;
import org.opendaylight.controller.yang.model.api.TypeDefinition;
import org.opendaylight.controller.yang.parser.builder.api.AugmentationSchemaBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.Builder;
import org.opendaylight.controller.yang.parser.builder.api.ChildNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.DataSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.GroupingBuilder;
+import org.opendaylight.controller.yang.parser.builder.api.SchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.api.TypeDefinitionBuilder;
import org.opendaylight.controller.yang.parser.builder.api.UsesNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.AnyXmlBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ChoiceCaseBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ConstraintsBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.GroupingBuilderImpl;
import org.opendaylight.controller.yang.parser.builder.impl.LeafListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.LeafSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ListSchemaNodeBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.TypedefBuilder;
import org.opendaylight.controller.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
+import org.opendaylight.controller.yang.parser.builder.impl.UsesNodeBuilderImpl;
public final class ParserUtils {
private static void correctPath(final ChildNodeBuilder node,
final SchemaPath parentSchemaPath) {
- for(DataSchemaNodeBuilder builder : node.getChildNodes()) {
+ for (DataSchemaNodeBuilder builder : node.getChildNodes()) {
// add correct path
SchemaPath targetNodeSchemaPath = parentSchemaPath;
- List<QName> targetNodePath = new ArrayList<QName>(targetNodeSchemaPath.getPath());
+ List<QName> targetNodePath = new ArrayList<QName>(
+ targetNodeSchemaPath.getPath());
targetNodePath.add(builder.getQName());
builder.setPath(new SchemaPath(targetNodePath, true));
- if(builder instanceof ChildNodeBuilder) {
- ChildNodeBuilder cnb = (ChildNodeBuilder)builder;
+ if (builder instanceof ChildNodeBuilder) {
+ ChildNodeBuilder cnb = (ChildNodeBuilder) builder;
correctPath(cnb, builder.getPath());
}
}
}
+ public static void refineLeaf(LeafSchemaNodeBuilder leaf,
+ RefineHolder refine, int line) {
+ String defaultStr = refine.getDefaultStr();
+ Boolean mandatory = refine.isMandatory();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (defaultStr != null && !("".equals(defaultStr))) {
+ leaf.setDefaultStr(defaultStr);
+ }
+ if (mandatory != null) {
+ leaf.getConstraints().setMandatory(mandatory);
+ }
+ if (must != null) {
+ leaf.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ leaf.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineContainer(ContainerSchemaNodeBuilder container,
+ RefineHolder refine, int line) {
+ Boolean presence = refine.isPresence();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (presence != null) {
+ container.setPresence(presence);
+ }
+ if (must != null) {
+ container.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ container.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineList(ListSchemaNodeBuilder list,
+ RefineHolder refine, int line) {
+ MustDefinition must = refine.getMust();
+ Integer min = refine.getMinElements();
+ Integer max = refine.getMaxElements();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (must != null) {
+ list.getConstraints().addMustDefinition(must);
+ }
+ if (min != null) {
+ list.getConstraints().setMinElements(min);
+ }
+ if (max != null) {
+ list.getConstraints().setMaxElements(max);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ list.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineLeafList(LeafListSchemaNodeBuilder leafList,
+ RefineHolder refine, int line) {
+ MustDefinition must = refine.getMust();
+ Integer min = refine.getMinElements();
+ Integer max = refine.getMaxElements();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (must != null) {
+ leafList.getConstraints().addMustDefinition(must);
+ }
+ if (min != null) {
+ leafList.getConstraints().setMinElements(min);
+ }
+ if (max != null) {
+ leafList.getConstraints().setMaxElements(max);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ leafList.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineChoice(ChoiceBuilder choice, RefineHolder refine,
+ int line) {
+ String defaultStr = refine.getDefaultStr();
+ Boolean mandatory = refine.isMandatory();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (defaultStr != null) {
+ choice.setDefaultCase(defaultStr);
+ }
+ if (mandatory != null) {
+ choice.getConstraints().setMandatory(mandatory);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ choice.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ public static void refineAnyxml(AnyXmlBuilder anyXml, RefineHolder refine,
+ int line) {
+ Boolean mandatory = refine.isMandatory();
+ MustDefinition must = refine.getMust();
+ List<UnknownSchemaNodeBuilder> unknownNodes = refine.getUnknownNodes();
+
+ if (mandatory != null) {
+ anyXml.getConstraints().setMandatory(mandatory);
+ }
+ if (must != null) {
+ anyXml.getConstraints().addMustDefinition(must);
+ }
+ if (unknownNodes != null) {
+ for (UnknownSchemaNodeBuilder unknown : unknownNodes) {
+ anyXml.addUnknownSchemaNode(unknown);
+ }
+ }
+ }
+
+ /**
+ * Perform refine operation of following parameters:
+ * <ul>
+ * <li>description</li>
+ * <li>reference</li>
+ * <li>config</li>
+ * </ul>
+ *
+ * These parameters may be refined for any node.
+ *
+ * @param node
+ * node to refine
+ * @param refine
+ * refine holder containing values to refine
+ * @param line
+ * current line in yang model
+ */
+ public static void refineDefault(Builder node, RefineHolder refine, int line) {
+ Class<? extends Builder> cls = node.getClass();
+
+ String description = refine.getDescription();
+ if (description != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setDescription",
+ String.class);
+ method.invoke(node, description);
+ } catch (Exception e) {
+ throw new YangParseException(line,
+ "Cannot refine description in " + cls.getName(), e);
+ }
+ }
+
+ String reference = refine.getReference();
+ if (reference != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setReference",
+ String.class);
+ method.invoke(node, reference);
+ } catch (Exception e) {
+ throw new YangParseException(line,
+ "Cannot refine reference in " + cls.getName(), e);
+ }
+ }
+
+ Boolean config = refine.isConfig();
+ if (config != null) {
+ try {
+ Method method = cls.getDeclaredMethod("setConfiguration",
+ Boolean.TYPE);
+ method.invoke(node, config);
+ } catch (Exception e) {
+ throw new YangParseException(line, "Cannot refine config in "
+ + cls.getName(), e);
+ }
+ }
+ }
+
public static LeafSchemaNodeBuilder copyLeafBuilder(
final LeafSchemaNodeBuilder old) {
final LeafSchemaNodeBuilder copy = new LeafSchemaNodeBuilder(
for (UsesNodeBuilder use : old.getUsesNodes()) {
copy.addUsesNode(use);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
for (UsesNodeBuilder use : old.getUsesNodes()) {
copy.addUsesNode(use);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
copy.addUnknownSchemaNode(unknown);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
copy.setStatus(old.getStatus());
}
public static ChoiceBuilder copyChoiceBuilder(final ChoiceBuilder old) {
- final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(), old.getLine());
+ final ChoiceBuilder copy = new ChoiceBuilder(old.getQName(),
+ old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (ChoiceCaseBuilder caseBuilder : old.getCases()) {
for (UsesNodeBuilder use : old.getUsesNodes()) {
copy.addUsesNode(use);
}
- for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
- copy.addUnknownSchemaNode(unknown);
- }
copy.setDefaultCase(old.getDefaultCase());
copy.setDescription(old.getDescription());
copy.setReference(old.getReference());
}
public static AnyXmlBuilder copyAnyXmlBuilder(final AnyXmlBuilder old) {
- final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(), old.getLine());
+ final AnyXmlBuilder copy = new AnyXmlBuilder(old.getQName(),
+ old.getLine());
copy.setPath(old.getPath());
copyConstraints(old, copy);
for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
return copy;
}
+ public static GroupingBuilder copyGroupingBuilder(final GroupingBuilder old) {
+ final GroupingBuilder copy = new GroupingBuilderImpl(old.getQName(),
+ old.getLine());
+ copy.setPath(old.getPath());
+ for (DataSchemaNodeBuilder child : old.getChildNodes()) {
+ copy.addChildNode(child);
+ }
+ for (GroupingBuilder grouping : old.getGroupings()) {
+ copy.addGrouping(grouping);
+ }
+ for (TypeDefinitionBuilder typedef : old.getTypedefs()) {
+ copy.addTypedef(typedef);
+ }
+ for (UsesNodeBuilder use : old.getUses()) {
+ copy.addUsesNode(use);
+ }
+ for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
+ copy.addUnknownSchemaNode(unknown);
+ }
+ copy.setDescription(old.getDescription());
+ copy.setReference(old.getReference());
+ copy.setStatus(old.getStatus());
+ return copy;
+ }
+
+ public static TypedefBuilder copyTypedefBuilder(TypedefBuilder old) {
+ final TypedefBuilder copy = new TypedefBuilder(old.getQName(),
+ old.getLine());
+ copy.setPath(old.getPath());
+ copy.setDefaultValue(old.getDefaultValue());
+ copy.setUnits(old.getUnits());
+ copy.setDescription(old.getDescription());
+ copy.setReference(old.getReference());
+ copy.setStatus(old.getStatus());
+
+ copy.setRanges(old.getRanges());
+ copy.setLengths(old.getLengths());
+ copy.setPatterns(old.getPatterns());
+ copy.setFractionDigits(old.getFractionDigits());
+
+ TypeDefinition<?> type = old.getType();
+ if(type == null) {
+ copy.setType(old.getTypedef());
+ } else {
+ copy.setType(old.getType());
+ }
+ copy.setUnits(old.getUnits());
+ for (UnknownSchemaNodeBuilder unknown : old.getUnknownNodes()) {
+ copy.addUnknownSchemaNode(unknown);
+ }
+ return copy;
+ }
+
+ public static UsesNodeBuilder copyUsesNodeBuilder(UsesNodeBuilder old) {
+ final UsesNodeBuilder copy = new UsesNodeBuilderImpl(
+ old.getGroupingPathString(), old.getLine());
+ for (AugmentationSchemaBuilder augment : old.getAugmentations()) {
+ copy.addAugment(augment);
+ }
+ copy.setAugmenting(old.isAugmenting());
+ for (SchemaNodeBuilder refineNode : old.getRefineNodes()) {
+ copy.addRefineNode(refineNode);
+ }
+ return copy;
+ }
+
private static void copyConstraints(final DataSchemaNodeBuilder oldBuilder,
final DataSchemaNodeBuilder newBuilder) {
final ConstraintsBuilder oldConstraints = oldBuilder.getConstraints();
/**
* Marker object representing special 'min' or 'max' values in YANG.
*/
-public final class UnknownBoundaryNumber extends Number {
+final class UnknownBoundaryNumber extends Number {
private static final long serialVersionUID = 1464861684686434869L;
private final String value;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Mandatory_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Mandatory_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Max_elements_stmtContext;
+import org.opendaylight.controller.antlrv4.code.gen.YangParser.Max_value_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Min_elements_stmtContext;
+import org.opendaylight.controller.antlrv4.code.gen.YangParser.Min_value_argContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Must_stmtContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Numerical_restrictionsContext;
import org.opendaylight.controller.antlrv4.code.gen.YangParser.Ordered_by_argContext;
}
if (value < -2147483648 || value > 2147483647) {
throw new YangParseException(
+ ctx.getStart().getLine(),
"Error on enum '"
+ name
+ "': the enum value MUST be in the range from -2147483648 to 2147483647, but was: "
try {
result = Long.valueOf(value);
} catch (NumberFormatException e) {
- throw new YangParseException("Error on line " + line
- + ": Unable to parse range value '" + value + "'.", e);
+ throw new YangParseException(line,
+ "Unable to parse range value '" + value + "'.", e);
}
}
return result;
try {
result = Integer.valueOf(value);
} catch (NumberFormatException e) {
- throw new YangParseException(
+ throw new YangParseException(ctx.getStart().getLine(),
"Unable to parse fraction digits value '" + value
+ "'.", e);
}
}
if (position < 0 || position > 4294967295L) {
throw new YangParseException(
+ ctx.getStart().getLine(),
"Error on bit '"
+ name
+ "': the position value MUST be in the range 0 to 4294967295");
for (int i = 0; i < ctx.getChildCount(); ++i) {
final ParseTree childNode = ctx.getChild(i);
if (childNode instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(childNode));
- constraints.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) childNode);
+ constraints.setMaxElements(max);
} else if (childNode instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(childNode));
+ Integer min = parseMinElements((Min_elements_stmtContext) childNode);
constraints.setMinElements(min);
} else if (childNode instanceof Must_stmtContext) {
MustDefinition must = parseMust((Must_stmtContext) childNode);
}
}
+ private static Integer parseMinElements(Min_elements_stmtContext ctx) {
+ Integer result = null;
+ try {
+ for (int j = 0; j < ctx.getChildCount(); j++) {
+ ParseTree minArg = ctx.getChild(j);
+ if (minArg instanceof Min_value_argContext) {
+ result = Integer.valueOf(stringFromNode(minArg));
+ }
+ }
+ if (result == null) {
+ throw new IllegalArgumentException();
+ }
+ return result;
+ } catch (Exception e) {
+ throw new YangParseException(ctx.getStart().getLine(),
+ "Failed to parse min-elements.", e);
+ }
+ }
+
+ private static Integer parseMaxElements(Max_elements_stmtContext ctx) {
+ Integer result = null;
+ try {
+ for (int j = 0; j < ctx.getChildCount(); j++) {
+ ParseTree maxArg = ctx.getChild(j);
+ if (maxArg instanceof Max_value_argContext) {
+ result = Integer.valueOf(stringFromNode(maxArg));
+ }
+ }
+ if (result == null) {
+ throw new IllegalArgumentException();
+ }
+ return result;
+ } catch (Exception e) {
+ throw new YangParseException(ctx.getStart().getLine(),
+ "Failed to parse max-elements.", e);
+ }
+ }
+
/**
* Parse given context and return yin value.
*
/**
* Parse refine statement.
- * @param refineCtx refine statement
- * @return
+ *
+ * @param refineCtx
+ * refine statement
+ * @param line
+ * current line in yang model
+ * @return RefineHolder object representing this refine statement
*/
public static RefineHolder parseRefine(Refine_stmtContext refineCtx) {
final String refineTarget = stringFromNode(refineCtx);
if (refinePom instanceof Refine_pomContext) {
for (int k = 0; k < refinePom.getChildCount(); k++) {
ParseTree refineStmt = refinePom.getChild(k);
+ parseRefineDefault(refine, refineStmt);
+
if (refineStmt instanceof Refine_leaf_stmtsContext) {
parseRefine(refine,
(Refine_leaf_stmtsContext) refineStmt);
return refine;
}
+ private static void parseRefineDefault(RefineHolder refine,
+ ParseTree refineStmt) {
+ for (int i = 0; i < refineStmt.getChildCount(); i++) {
+ ParseTree refineArg = refineStmt.getChild(i);
+ if (refineArg instanceof Description_stmtContext) {
+ String description = stringFromNode(refineArg);
+ refine.setDescription(description);
+ } else if (refineArg instanceof Reference_stmtContext) {
+ String reference = stringFromNode(refineArg);
+ refine.setReference(reference);
+ } else if (refineArg instanceof Config_stmtContext) {
+ boolean config = parseConfig((Config_stmtContext) refineArg);
+ refine.setConfig(config);
+ }
+ }
+ }
+
private static RefineHolder parseRefine(RefineHolder refine,
Refine_leaf_stmtsContext refineStmt) {
for (int i = 0; i < refineStmt.getChildCount(); i++) {
MustDefinition must = parseMust((Must_stmtContext) refineArg);
refine.setMust(must);
} else if (refineArg instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(refineArg));
- refine.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) refineArg);
+ refine.setMaxElements(max);
} else if (refineArg instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(refineArg));
+ Integer min = parseMinElements((Min_elements_stmtContext) refineArg);
refine.setMinElements(min);
}
}
MustDefinition must = parseMust((Must_stmtContext) refineArg);
refine.setMust(must);
} else if (refineArg instanceof Max_elements_stmtContext) {
- Integer max = Integer.valueOf(stringFromNode(refineArg));
- refine.setMinElements(max);
+ Integer max = parseMaxElements((Max_elements_stmtContext) refineArg);
+ refine.setMaxElements(max);
} else if (refineArg instanceof Min_elements_stmtContext) {
- Integer min = Integer.valueOf(stringFromNode(refineArg));
+ Integer min = parseMinElements((Min_elements_stmtContext) refineArg);
refine.setMinElements(min);
}
}
import org.opendaylight.controller.yang.model.api.ChoiceNode;
import org.opendaylight.controller.yang.model.api.ConstraintDefinition;
import org.opendaylight.controller.yang.model.api.ContainerSchemaNode;
+import org.opendaylight.controller.yang.model.api.DataSchemaNode;
import org.opendaylight.controller.yang.model.api.Deviation;
import org.opendaylight.controller.yang.model.api.Deviation.Deviate;
import org.opendaylight.controller.yang.model.api.ExtensionDefinition;
import org.opendaylight.controller.yang.model.api.FeatureDefinition;
+import org.opendaylight.controller.yang.model.api.GroupingDefinition;
import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
import org.opendaylight.controller.yang.model.api.ListSchemaNode;
import org.opendaylight.controller.yang.model.api.Module;
assertNull(constraints.getWhenCondition());
assertEquals(0, constraints.getMustConstraints().size());
assertFalse(constraints.isMandatory());
- assertNull(constraints.getMinElements());
- assertNull(constraints.getMaxElements());
+ assertEquals(1, (int)constraints.getMinElements());
+ assertEquals(11, (int)constraints.getMaxElements());
// test AugmentationTarget args
Set<AugmentationSchema> availableAugmentations = ifEntry
.getAvailableAugmentations();
assertEquals(1, usesNodes.size());
UsesNode usesNode = usesNodes.iterator().next();
Map<SchemaPath, SchemaNode> refines = usesNode.getRefines();
- assertEquals(2, refines.size());
+ assertEquals(5, refines.size());
+ LeafSchemaNode refineLeaf = null;
+ ContainerSchemaNode refineContainer = null;
+ ListSchemaNode refineList = null;
+ GroupingDefinition refineGrouping = null;
+ TypeDefinition<?> typedef = null;
for (Map.Entry<SchemaPath, SchemaNode> entry : refines.entrySet()) {
SchemaNode value = entry.getValue();
-
if (value instanceof LeafSchemaNode) {
- LeafSchemaNode refineLeaf = (LeafSchemaNode) value;
- assertNotNull(refineLeaf);
- } else {
- ContainerSchemaNode refineContainer = (ContainerSchemaNode) value;
- Set<MustDefinition> mustConstraints = refineContainer
- .getConstraints().getMustConstraints();
- assertEquals(1, mustConstraints.size());
- MustDefinition must = mustConstraints.iterator().next();
- assertEquals("must-condition", must.toString());
- assertEquals("An error message test", must.getErrorMessage());
- assertEquals(("An error app tag test"), must.getErrorAppTag());
+ refineLeaf = (LeafSchemaNode) value;
+ } else if(value instanceof ContainerSchemaNode) {
+ refineContainer = (ContainerSchemaNode) value;
+ } else if(value instanceof ListSchemaNode) {
+ refineList = (ListSchemaNode)value;
+ } else if(value instanceof GroupingDefinition) {
+ refineGrouping = (GroupingDefinition)value;
+ } else if(value instanceof TypeDefinition<?>) {
+ typedef = (TypeDefinition<?>)value;
}
}
+
+ // leaf address
+ assertNotNull(refineLeaf);
+ assertEquals("address", refineLeaf.getQName().getLocalName());
+ assertEquals("description of address defined by refine",
+ refineLeaf.getDescription());
+ assertEquals("address reference added by refine",
+ refineLeaf.getReference());
+ assertFalse(refineLeaf.isConfiguration());
+ assertTrue(refineLeaf.getConstraints().isMandatory());
+ Set<MustDefinition> leafMustConstraints = refineLeaf.getConstraints()
+ .getMustConstraints();
+ assertEquals(1, leafMustConstraints.size());
+ MustDefinition leafMust = leafMustConstraints.iterator().next();
+ assertEquals(
+ "\"ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)\"",
+ leafMust.toString());
+
+ // container port
+ assertNotNull(refineContainer);
+ Set<MustDefinition> mustConstraints = refineContainer.getConstraints()
+ .getMustConstraints();
+ assertEquals(1, mustConstraints.size());
+ MustDefinition must = mustConstraints.iterator().next();
+ assertEquals("must-condition", must.toString());
+ assertEquals("An error message test", must.getErrorMessage());
+ assertEquals(("An error app tag test"), must.getErrorAppTag());
+ assertEquals("description of port defined by refine",
+ refineContainer.getDescription());
+ assertEquals("port reference added by refine",
+ refineContainer.getReference());
+ assertFalse(refineContainer.isConfiguration());
+ assertTrue(refineContainer.isPresenceContainer());
+
+ // list addresses
+ assertNotNull(refineList);
+ assertEquals("description of addresses defined by refine", refineList.getDescription());
+ assertEquals("addresses reference added by refine", refineList.getReference());
+ assertFalse(refineList.isConfiguration());
+ assertEquals(2, (int)refineList.getConstraints().getMinElements());
+ assertEquals(12, (int)refineList.getConstraints().getMaxElements());
+
+ // grouping target-inner
+ assertNotNull(refineGrouping);
+ Set<DataSchemaNode> refineGroupingChildren = refineGrouping.getChildNodes();
+ assertEquals(1, refineGroupingChildren.size());
+ LeafSchemaNode refineGroupingLeaf = (LeafSchemaNode)refineGroupingChildren.iterator().next();
+ assertEquals("inner-grouping-id", refineGroupingLeaf.getQName().getLocalName());
+ assertEquals("new target-inner grouping description", refineGrouping.getDescription());
+
+ // typedef group-type
+ assertNotNull(typedef);
+ assertEquals("new group-type description", typedef.getDescription());
+ assertEquals("new group-type reference", typedef.getReference());
+ assertTrue(typedef.getBaseType() instanceof ExtendedType);
}
@Test
assertNotNull(output.getDataChildByName("data"));
}
+ @Test
+ public void testGrouping() {
+ Module testModule = TestUtils.findModule(modules, "types2");
+ Set<GroupingDefinition> groupings = testModule.getGroupings();
+ assertEquals(1, groupings.size());
+ GroupingDefinition grouping = groupings.iterator().next();
+ Set<DataSchemaNode> children = grouping.getChildNodes();
+ assertEquals(5, children.size());
+ }
+
}
}
grouping target {
+ anyxml data {
+ config true;
+ description "Copy of the source datastore subset.";
+ mandatory false;
+ must "test-condition-text";
+ reference "test-no-reference";
+ status "obsolete";
+ when "test-when-text";
+ }
+ choice how {
+ description "test choice description";
+ default interval;
+ case interval {
+ leaf interval {
+ type uint16;
+ default 30;
+ units minutes;
+ }
+ }
+ case daily {
+ leaf daily {
+ type empty;
+ }
+ leaf time-of-day {
+ type string;
+ units 24-hour-clock;
+ default 1am;
+ }
+ }
+ }
leaf address {
type string;
description "Target IP address";
container port {
description "Target port container";
}
+ list addresses {
+ key "id";
+ leaf id {
+ type int8;
+ }
+ }
+ grouping target-inner {
+ description "target-inner default description";
+ leaf inner-grouping-id {
+ type int8;
+ }
+ }
+ typedef group-type {
+ type my-decimal-type;
+ }
}
container peer {
uses target {
refine address {
default "1.2.3.4";
+ description "description of address defined by refine";
+ reference "address reference added by refine";
+ config false;
+ mandatory true;
+ must "ifType != 'ethernet' or " +
+ "(ifType = 'ethernet' and ifMTU = 1500)" {
+ error-message "An ethernet MTU must be 1500";
+ }
}
refine port {
must "must-condition" {
error-message "An error message test";
error-app-tag "An error app tag test";
}
+ description "description of port defined by refine";
+ reference "port reference added by refine";
+ config false;
+ presence "presence is required";
+ }
+ refine addresses {
+ description "description of addresses defined by refine";
+ reference "addresses reference added by refine";
+ config false;
+ min-elements 2;
+ max-elements 12;
+ }
+ refine target-inner {
+ description "new target-inner grouping description";
+ }
+ refine group-type {
+ description "new group-type description";
+ reference "new group-type reference";
}
}
}
leaf ifMtu {
type int32;
}
+
+ min-elements 1;
+ max-elements 11;
}
}