StatementSupport<X, Y, Z> getSupport(final StatementDefinition def, final Class<Z> effectiveClass) {
final var tmp = verifyNotNull(operations.getFromNamespace(StatementSupportNamespace.class,
def.getStatementName()));
- final var repr = tmp.getEffectiveRepresentationClass();
+ final var repr = tmp.definition().getEffectiveRepresentationClass();
verify(effectiveClass.equals(repr), "Unexpected support %s representation %s", tmp, repr);
@SuppressWarnings("unchecked")
@Override
public StatementSupport<?, ?, ?> getFrom(final NamespaceStorageNode storage, final QName key) {
- return statementDefinitions.get(key);
+ return statementDefinitions.getSupport(key);
}
@Override
public Map<QName, StatementSupport<?, ?, ?>> getAllFrom(final NamespaceStorageNode storage) {
- throw new UnsupportedOperationException("StatementSupportNamespace is immutable");
+ throw uoe();
}
@Override
public void addTo(final NamespaceStorageNode storage, final QName key, final StatementSupport<?, ?, ?> value) {
- throw new UnsupportedOperationException("StatementSupportNamespace is immutable");
+ throw uoe();
+ }
+
+ private static UnsupportedOperationException uoe() {
+ return new UnsupportedOperationException("StatementSupportNamespace is immutable");
}
}
if (def == null) {
def = globalContext.getModelDefinedStatementDefinition(name);
if (def == null) {
- final StatementSupport<?, ?, ?> extension = qnameToStmtDefMap.get(name);
+ final StatementSupport<?, ?, ?> extension = qnameToStmtDefMap.getSupport(name);
if (extension != null) {
def = new StatementDefinitionContext<>(extension);
globalContext.putModelDefinedStatementDefinition(name, def);
}
@NonNull QName getStatementName() {
- return support.getStatementName();
+ return support.statementName();
}
@Override
* This code wraps statements encountered inside an extension so they do not get confused with regular
* statements.
*/
- final QName baseQName = getStatementName();
- final QName statementName = QName.create(baseQName, childDef.getStatementName().getLocalName());
+ // FIXME: remove this bit?
+ final QName statementName = QName.create(statementName(), childDef.getStatementName().getLocalName());
- final ModelDefinedStatementDefinition def;
+ final StatementDefinition def;
final Optional<ArgumentDefinition> optArgDef = childDef.getArgumentDefinition();
if (optArgDef.isPresent()) {
- final ArgumentDefinition argDef = optArgDef.get();
+ final ArgumentDefinition argDef = optArgDef.orElseThrow();
def = new ModelDefinedStatementDefinition(statementName, argDef.getArgumentName(), argDef.isYinElement());
} else {
def = new ModelDefinedStatementDefinition(statementName);
return Boolean.FALSE;
} else {
throw new SourceException(ctx, "Invalid '%s' statement %s '%s', it can be either 'true' or 'false'",
- getStatementName(), getArgumentDefinition().get().getArgumentName(), value);
+ statementName(), argumentName(), value);
}
}
* @param <E> Effective Statement representation
*/
public abstract class StatementSupport<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
- implements StatementDefinition, StatementFactory<A, D, E> {
+ implements StatementFactory<A, D, E> {
/**
* A baseline class for implementing the {@link StatementFactory#canReuseCurrent(Current, Current, Collection)}
* contract in a manner which is consistent with a statement's {@link CopyPolicy}.
}
private final @NonNull StatementPolicy<A, D> policy;
- private final @NonNull StatementDefinition def;
+ private final @NonNull StatementDefinition publicDefinition;
private final @NonNull CopyPolicy copyPolicy;
@Beta
protected StatementSupport(final StatementSupport<A, D, E> delegate) {
checkArgument(delegate != this);
- this.def = delegate.def;
+ this.publicDefinition = delegate.publicDefinition;
this.policy = delegate.policy;
this.copyPolicy = delegate.copyPolicy;
}
@Beta
protected StatementSupport(final StatementDefinition publicDefinition, final StatementPolicy<A, D> policy) {
- checkArgument(publicDefinition != this);
- this.def = requireNonNull(publicDefinition);
+ this.publicDefinition = requireNonNull(publicDefinition);
this.policy = requireNonNull(policy);
this.copyPolicy = policy.copyPolicy;
}
* @return public statement definition, which will be present in built statements.
*/
public final @NonNull StatementDefinition getPublicView() {
- return def;
+ return publicDefinition;
+ }
+
+ // Appropriate to most definitions
+ // Non-final for compatible extensions
+ public @NonNull StatementDefinition definition() {
+ return publicDefinition;
}
/**
return false;
}
- @Override
- public final QName getStatementName() {
- return def.getStatementName();
+ public final @NonNull QName statementName() {
+ return publicDefinition.getStatementName();
}
- @Override
- public final Optional<ArgumentDefinition> getArgumentDefinition() {
- return def.getArgumentDefinition();
+ public final @Nullable QName argumentName() {
+ return publicDefinition.getArgumentDefinition().map(ArgumentDefinition::getArgumentName).orElse(null);
}
- @Override
- // Non-final for compatible extensions
- public Class<? extends DeclaredStatement<?>> getDeclaredRepresentationClass() {
- return def.getDeclaredRepresentationClass();
- }
-
- @Override
- // Non-final for compatible extensions
- public Class<? extends EffectiveStatement<?,?>> getEffectiveRepresentationClass() {
- return def.getEffectiveRepresentationClass();
+ public final @NonNull Optional<ArgumentDefinition> getArgumentDefinition() {
+ return publicDefinition.getArgumentDefinition();
}
/**
}
public @NonNull Builder addSupport(final StatementSupport<?, ?, ?> support) {
- final QName identifier = support.getStatementName();
+ final QName identifier = support.statementName();
checkNoParentDefinition(identifier);
checkState(!commonStatements.containsKey(identifier),
}
public @NonNull Builder addVersionSpecificSupport(final YangVersion version,
- final StatementSupport<?, ?, ?> definition) {
+ final StatementSupport<?, ?, ?> support) {
checkArgument(supportedVersions.contains(requireNonNull(version)));
- final QName identifier = definition.getStatementName();
+ final QName identifier = support.statementName();
checkState(!commonStatements.containsKey(identifier),
"Statement %s already defined in common statement bundle.", identifier);
checkState(!versionSpecificStatements.contains(version, identifier),
checkNoParentDefinition(identifier);
checkState(parent.getVersionSpecificStatementDefinition(version, identifier) == null,
"Statement %s already defined for version %s in parent's statement bundle.", identifier, version);
- versionSpecificStatements.put(version, identifier, definition);
+ versionSpecificStatements.put(version, identifier, support);
return this;
}
}
public @NonNull Builder overrideSupport(final StatementSupport<?, ?, ?> support) {
- final QName identifier = support.getStatementName();
+ final QName identifier = support.statementName();
checkNoParentDefinition(identifier);
final StatementSupport<?, ?, ?> previousSupport = commonStatements.replace(identifier, support);
* @param identifier QName of requested statement
* @return StatementDefinition
*/
- StatementDefinition get(QName identifier);
+ @Nullable StatementDefinition get(QName identifier);
/**
* Returns StatementDefinition with specified namespace and localName.
import java.util.HashMap;
import java.util.Map;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.XMLNamespace;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
-public class QNameToStatementDefinitionMap implements QNameToStatementDefinition {
+public final class QNameToStatementDefinitionMap implements QNameToStatementDefinition {
private final Map<QName, StatementSupport<?, ?, ?>> noRevQNameToSupport;
private final Map<QName, StatementSupport<?, ?, ?>> qnameToSupport;
}
@Override
- public StatementSupport<?, ?, ?> get(final QName identifier) {
- return qnameToSupport.get(identifier);
+ public StatementDefinition get(final QName identifier) {
+ return definitionOf(getSupport(identifier));
}
@Override
public StatementDefinition getByNamespaceAndLocalName(final XMLNamespace namespace, final String localName) {
- return noRevQNameToSupport.get(QName.create(namespace, localName));
+ return definitionOf(noRevQNameToSupport.get(QName.create(namespace, localName)));
+ }
+
+ /**
+ * Returns StatementSupport with specified QName.
+ *
+ * @param identifier QName of requested statement
+ * @return StatementSupport
+ */
+ public @Nullable StatementSupport<?, ?, ?> getSupport(final QName identifier) {
+ return qnameToSupport.get(requireNonNull(identifier));
+ }
+
+ private static @Nullable StatementDefinition definitionOf(final @Nullable StatementSupport<?, ?, ?> support) {
+ return support != null ? support.definition() : null;
}
}
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
+import org.junit.Before;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
public class QNameToStatementDefinitionMapTest {
private final QNameToStatementDefinitionMap map = new QNameToStatementDefinitionMap();
private final StatementSupport<?, ?, ?> support = mock(StatementSupport.class);
+ private final StatementDefinition definition = mock(StatementDefinition.class);
+
+ @Before
+ public void before() {
+ doReturn(definition).when(support).definition();
+ }
@Test
public void testPutNullNull() {
@Test
public void testPutNullSome() {
- assertThrows(NullPointerException.class, () -> map.put(null, mock(StatementSupport.class)));
+ assertThrows(NullPointerException.class, () -> map.put(null, support));
}
@Test
@Test
public void testPut() {
map.put(QNAME, support);
- assertSame(support, map.get(QNAME));
+ assertSame(definition, map.get(QNAME));
+ assertSame(support, map.getSupport(QNAME));
}
}