import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
+import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.UniqueConstraint;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
public final class ListEffectiveStatementImpl extends AbstractEffectiveSimpleDataNodeContainer<ListStatement> implements
ListSchemaNode, DerivableSchemaNode {
+ private static final String ORDER_BY_USER_KEYWORD = "user";
private final boolean userOrdered;
private final List<QName> keyDefinition;
- private static final String ORDER_BY_USER_KEYWORD = "user";
private final ListSchemaNode original;
+ private final Set<ActionDefinition> actions;
+ private final Set<NotificationDefinition> notifications;
+ private final Collection<UniqueConstraint> uniqueConstraints;
public ListEffectiveStatementImpl(
final StmtContext<QName, ListStatement, EffectiveStatement<QName, ListStatement>> ctx) {
this.original = ctx.getOriginalCtx() == null ? null : (ListSchemaNode) ctx.getOriginalCtx().buildEffective();
- OrderedByEffectiveStatementImpl orderedByStmt = firstEffective(OrderedByEffectiveStatementImpl.class);
- if (orderedByStmt != null && orderedByStmt.argument().equals(ORDER_BY_USER_KEYWORD)) {
+ final OrderedByEffectiveStatementImpl orderedByStmt = firstEffective(OrderedByEffectiveStatementImpl.class);
+ if (orderedByStmt != null && ORDER_BY_USER_KEYWORD.equals(orderedByStmt.argument())) {
this.userOrdered = true;
} else {
this.userOrdered = false;
}
// initKeyDefinition
- List<QName> keyDefinitionInit = new LinkedList<>();
- KeyEffectiveStatementImpl keyEffectiveSubstatement = firstEffective(KeyEffectiveStatementImpl.class);
-
+ final List<QName> keyDefinitionInit = new LinkedList<>();
+ final KeyEffectiveStatementImpl keyEffectiveSubstatement = firstEffective(KeyEffectiveStatementImpl.class);
if (keyEffectiveSubstatement != null) {
- Set<QName> possibleLeafQNamesForKey = new HashSet<>();
-
+ final Set<QName> possibleLeafQNamesForKey = new HashSet<>();
for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof LeafSchemaNode) {
possibleLeafQNamesForKey.add(((LeafSchemaNode) effectiveStatement).getQName());
}
}
-
- Collection<SchemaNodeIdentifier> keys = keyEffectiveSubstatement.argument();
- for (SchemaNodeIdentifier key : keys) {
+ for (final SchemaNodeIdentifier key : keyEffectiveSubstatement.argument()) {
final QName keyQName = key.getLastComponent();
if (!possibleLeafQNamesForKey.contains(keyQName)) {
throw new InferenceException(ctx.getStatementSourceReference(),
- "Key '%s' misses node '%s' in list '%s'", keyEffectiveSubstatement.getDeclared().rawArgument(),
- keyQName.getLocalName(), ctx.getStatementArgument());
+ "Key '%s' misses node '%s' in list '%s'", keyEffectiveSubstatement.getDeclared()
+ .rawArgument(), keyQName.getLocalName(), ctx.getStatementArgument());
}
-
keyDefinitionInit.add(keyQName);
}
}
-
this.keyDefinition = ImmutableList.copyOf(keyDefinitionInit);
+ this.uniqueConstraints = ImmutableList.copyOf(allSubstatementsOfType(UniqueConstraint.class));
+
+ final ImmutableSet.Builder<ActionDefinition> actionsBuilder = ImmutableSet.builder();
+ final Builder<NotificationDefinition> notificationsBuilder = ImmutableSet.builder();
+ for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
+ if (effectiveStatement instanceof ActionDefinition) {
+ actionsBuilder.add((ActionDefinition) effectiveStatement);
+ }
+
+ if (effectiveStatement instanceof NotificationDefinition) {
+ notificationsBuilder.add((NotificationDefinition) effectiveStatement);
+ }
+ }
+
+ this.actions = actionsBuilder.build();
+ this.notifications = notificationsBuilder.build();
}
@Override
return keyDefinition;
}
+ @Override
+ public Set<ActionDefinition> getActions() {
+ return actions;
+ }
+
+ @Override
+ public Set<NotificationDefinition> getNotifications() {
+ return notifications;
+ }
+
+ @Override
+ @Nonnull
+ public Collection<UniqueConstraint> getUniqueConstraints() {
+ return uniqueConstraints;
+ }
+
@Override
public boolean isUserOrdered() {
return userOrdered;