*/
package org.opendaylight.yangtools.rfc7952.parser;
+import static com.google.common.base.Verify.verifyNotNull;
+
import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
Effective(final Current<QName, AnnotationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
super(stmt, substatements);
- path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(argument()));
+ final QName qname = stmt.getArgument();
+ // FIXME: move this into onFullDefinitionDeclared()
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
firstSubstatementOfType(TypeEffectiveStatement.class), stmt,
- "AnnotationStatementSupport %s is missing a 'type' statement", argument());
+ "AnnotationStatementSupport %s is missing a 'type' statement", qname);
final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(),
- path);
+ qname);
final UnitsEffectiveStatement unitsStmt = firstSubstatementOfType(UnitsEffectiveStatement.class);
if (unitsStmt != null) {
builder.setUnits(unitsStmt.argument());
}
type = builder.build();
+
+ path = SchemaPathSupport.wrap(stmt.getEffectiveParent().getSchemaPath().createChild(qname));
}
@Override
public QName getQName() {
- return path.getLastComponent();
+ return verifyNotNull(argument());
}
@Override
import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.data.api.codec.BitsCodec;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder;
*/
public class BitsCodecStringTest {
private static BitsTypeDefinition toBitsTypeDefinition(final String... bits) {
- final BitsTypeBuilder b = BaseTypes.bitsTypeBuilder(mock(SchemaPath.class));
+ final BitsTypeBuilder b = BaseTypes.bitsTypeBuilder(QName.create("foo", "foo"));
long pos = 0;
for (String bit : bits) {
package org.opendaylight.yangtools.yang.data.impl.codec;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
import java.math.BigDecimal;
import org.junit.Test;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.codec.DecimalCodec;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
}
private static DecimalTypeDefinition getType() {
- return BaseTypes.decimalTypeBuilder(mock(SchemaPath.class)).setFractionDigits(2).build();
+ return BaseTypes.decimalTypeBuilder(QName.create("foo", "foo")).setFractionDigits(2).build();
}
}
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Codec;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
}
public static EnumTypeDefinition toEnumTypeDefinition(final String... enums) {
- final EnumerationTypeBuilder b = BaseTypes.enumerationTypeBuilder(mock(SchemaPath.class));
+ final EnumerationTypeBuilder b = BaseTypes.enumerationTypeBuilder(QName.create("foo", "foo"));
int val = 0;
for (String en : enums) {
EnumTypeDefinition.EnumPair mockEnum = mock(EnumPair.class);
package org.opendaylight.yangtools.yang.data.impl.codec;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.mock;
import static org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodecTestHelper.deserializeWithExpectedIllegalArgEx;
import static org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodecTestHelper.getCodec;
import static org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodecTestHelper.toEnumTypeDefinition;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.Empty;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.codec.UnionCodec;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
*/
public class UnionCodecStringTest {
private static UnionTypeDefinition toUnionTypeDefinition(final TypeDefinition<?>... types) {
- final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(mock(SchemaPath.class));
+ final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(QName.create("foo", "foo"));
for (TypeDefinition<?> t : types) {
builder.addType(t);
import java.util.Collection;
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractBaseType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
AbstractBaseType(final QName qname) {
- this(SchemaPath.ROOT.createChild(qname), ImmutableList.of());
+ this(qname, ImmutableList.of());
}
- AbstractBaseType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(path, unknownSchemaNodes);
+ AbstractBaseType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(qname, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
private final @NonNull Status status;
private final String units;
- AbstractDerivedType(final T baseType, final SchemaPath path, final Object defaultValue, final String description,
+ AbstractDerivedType(final T baseType, final QName qname, final Object defaultValue, final String description,
final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(path, unknownSchemNodes);
+ super(qname, unknownSchemNodes);
this.baseType = requireNonNull(baseType);
this.status = requireNonNull(status);
this.defaultValue = defaultValue;
.add("baseType", baseType)
.add("default", defaultValue)
.add("description", description)
- .add("path", getPath())
+ .add("qname", getQName())
.add("reference", reference)
.add("status", status)
.add("units", units).toString();
abstract class AbstractLengthRestrictedBaseType<T extends LengthRestrictedTypeDefinition<T>> extends AbstractBaseType<T>
implements LengthRestrictedTypeDefinition<T> {
-
AbstractLengthRestrictedBaseType(final QName qname) {
super(qname);
}
import java.util.Collection;
import java.util.Optional;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
abstract class AbstractLengthRestrictedDerivedType<T extends LengthRestrictedTypeDefinition<T>>
extends AbstractDerivedType<T> implements LengthRestrictedTypeDefinition<T> {
-
- AbstractLengthRestrictedDerivedType(final T baseType, final SchemaPath path,
+ AbstractLengthRestrictedDerivedType(final T baseType, final QName qname,
final Object defaultValue, final String description, final String reference, final Status status,
final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.LengthRestrictedTypeDefinition;
extends AbstractRestrictedType<T> implements LengthRestrictedTypeDefinition<T> {
private final @Nullable LengthConstraint lengthConstraint;
- AbstractLengthRestrictedType(final T baseType, final SchemaPath path,
+ AbstractLengthRestrictedType(final T baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable LengthConstraint lengthConstraint) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
this.lengthConstraint = lengthConstraint;
}
import java.util.Optional;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
abstract class AbstractRangeRestrictedBaseType<T extends RangeRestrictedTypeDefinition<T, N>,
- N extends Number & Comparable<N>> extends AbstractBaseType<T> implements RangeRestrictedTypeDefinition<T, N> {
+ N extends Number & Comparable<N>> extends AbstractBaseType<T> implements RangeRestrictedTypeDefinition<T, N> {
private static final ConstraintMetaDefinition BUILTIN_CONSTRAINT = new ConstraintMetaDefinition() {
@Override
Range.closed(minValue, maxValue)));
}
- AbstractRangeRestrictedBaseType(final SchemaPath path,
- final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ AbstractRangeRestrictedBaseType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final RangeConstraint<N> rangeConstraint) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.rangeConstraint = requireNonNull(rangeConstraint);
}
import java.util.Collection;
import java.util.Optional;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
N extends Number & Comparable<N>> extends AbstractDerivedType<T>
implements RangeRestrictedTypeDefinition<T, N> {
- AbstractRangeRestrictedDerivedType(final T baseType, final SchemaPath path,
+ AbstractRangeRestrictedDerivedType(final T baseType, final QName qname,
final Object defaultValue, final String description, final String reference, final Status status,
final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
implements RangeRestrictedTypeDefinition<T, N> {
private final @Nullable RangeConstraint<N> rangeConstraint;
- AbstractRangeRestrictedType(final T baseType, final SchemaPath path,
+ AbstractRangeRestrictedType(final T baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<N> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
this.rangeConstraint = rangeConstraint;
}
import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractRestrictedType<T extends TypeDefinition<T>> extends AbstractTypeDefinition<T> {
private final @NonNull T baseType;
- AbstractRestrictedType(final T baseType, final SchemaPath path,
+ AbstractRestrictedType(final T baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.baseType = requireNonNull(baseType);
}
import static com.google.common.base.Verify.verifyNotNull;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
abstract class AbstractRestrictedTypeBuilder<T extends TypeDefinition<T>> extends TypeBuilder<T> {
private boolean touched;
- AbstractRestrictedTypeBuilder(final T baseType, final SchemaPath path) {
- super(baseType, path);
+ AbstractRestrictedTypeBuilder(final T baseType, final QName qname) {
+ super(baseType, qname);
if (baseType != null) {
checkArgument(baseType instanceof AbstractBaseType || baseType instanceof AbstractDerivedType,
"Restricted type has to be based on either a base or derived type, not %s", baseType);
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Immutable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
abstract class AbstractTypeDefinition<T extends TypeDefinition<T>> implements Immutable, TypeDefinition<T> {
private final @NonNull ImmutableList<UnknownSchemaNode> unknownSchemaNodes;
- private final @Nullable SchemaPath path;
+ private final @NonNull QName qname;
- AbstractTypeDefinition(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- this.path = path;
+ AbstractTypeDefinition(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ this.qname = requireNonNull(qname);
this.unknownSchemaNodes = ImmutableList.copyOf(unknownSchemaNodes);
}
@Override
public final QName getQName() {
- return path.getLastComponent();
- }
-
- @Override
- @Deprecated
- public final SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ return qname;
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
final class BaseBitsType extends AbstractBaseType<BitsTypeDefinition> implements BitsTypeDefinition {
private final @NonNull ImmutableList<Bit> bits;
- BaseBitsType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ BaseBitsType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Collection<Bit> bits) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.bits = ImmutableList.copyOf(bits);
}
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Optional;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
private final int fractionDigits;
- BaseDecimalType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ BaseDecimalType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final int fractionDigits, final RangeConstraint<BigDecimal> rangeConstraint) {
- super(path, unknownSchemaNodes, rangeConstraint);
+ super(qname, unknownSchemaNodes, rangeConstraint);
this.fractionDigits = fractionDigits;
}
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
final class BaseEnumerationType extends AbstractBaseType<EnumTypeDefinition> implements EnumTypeDefinition {
private final @NonNull ImmutableList<EnumPair> values;
- BaseEnumerationType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ BaseEnumerationType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Collection<EnumPair> values) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.values = ImmutableList.copyOf(values);
}
import java.util.Collection;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
implements IdentityrefTypeDefinition {
private final @NonNull Set<? extends IdentitySchemaNode> identities;
- BaseIdentityrefType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ BaseIdentityrefType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Set<? extends IdentitySchemaNode> identities) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.identities = requireNonNull(identities);
}
import static java.util.Objects.requireNonNull;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
private final PathExpression pathStatement;
private final boolean requireInstance;
- BaseLeafrefType(final SchemaPath path, final PathExpression pathStatement, final boolean requireInstance,
+ BaseLeafrefType(final QName qname, final PathExpression pathStatement, final boolean requireInstance,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.pathStatement = requireNonNull(pathStatement);
this.requireInstance = requireInstance;
}
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
return BaseBinaryType.INSTANCE;
}
- public static @NonNull BitsTypeBuilder bitsTypeBuilder(final SchemaPath path) {
- return new BitsTypeBuilder(path);
+ public static @NonNull BitsTypeBuilder bitsTypeBuilder(final QName qname) {
+ return new BitsTypeBuilder(qname);
}
public static @NonNull BooleanTypeDefinition booleanType() {
return BaseBooleanType.INSTANCE;
}
- public static @NonNull DecimalTypeBuilder decimalTypeBuilder(final SchemaPath path) {
- return new DecimalTypeBuilder(path);
+ public static @NonNull DecimalTypeBuilder decimalTypeBuilder(final QName qname) {
+ return new DecimalTypeBuilder(qname);
}
public static @NonNull EmptyTypeDefinition emptyType() {
return BaseEmptyType.INSTANCE;
}
- public static @NonNull EnumerationTypeBuilder enumerationTypeBuilder(final SchemaPath path) {
- return new EnumerationTypeBuilder(path);
+ public static @NonNull EnumerationTypeBuilder enumerationTypeBuilder(final QName qname) {
+ return new EnumerationTypeBuilder(qname);
}
- public static @NonNull IdentityrefTypeBuilder identityrefTypeBuilder(final SchemaPath path) {
- return new IdentityrefTypeBuilder(path);
+ public static @NonNull IdentityrefTypeBuilder identityrefTypeBuilder(final QName qname) {
+ return new IdentityrefTypeBuilder(qname);
}
public static @NonNull InstanceIdentifierTypeDefinition instanceIdentifierType() {
return BaseInt64Type.INSTANCE;
}
- public static @NonNull LeafrefTypeBuilder leafrefTypeBuilder(final SchemaPath path) {
- return new LeafrefTypeBuilder(path);
+ public static @NonNull LeafrefTypeBuilder leafrefTypeBuilder(final QName qname) {
+ return new LeafrefTypeBuilder(qname);
}
public static @NonNull StringTypeDefinition stringType() {
return BaseStringType.INSTANCE;
}
- public static UnionTypeBuilder unionTypeBuilder(final SchemaPath path) {
- return new UnionTypeBuilder(path);
+ public static UnionTypeBuilder unionTypeBuilder(final QName qname) {
+ return new UnionTypeBuilder(qname);
}
public static @NonNull Uint8TypeDefinition uint8Type() {
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
final class BaseUnionType extends AbstractBaseType<UnionTypeDefinition> implements UnionTypeDefinition {
private final ImmutableList<TypeDefinition<?>> types;
- BaseUnionType(final SchemaPath path, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
+ BaseUnionType(final QName qname, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final Collection<TypeDefinition<?>> types) {
- super(path, unknownSchemaNodes);
+ super(qname, unknownSchemaNodes);
this.types = ImmutableList.copyOf(types);
}
package org.opendaylight.yangtools.yang.model.util.type;
import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableMap.Builder;
import java.util.Map;
import java.util.TreeMap;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
public final class BitsTypeBuilder extends AbstractRestrictedTypeBuilder<BitsTypeDefinition> {
- private final Builder<String, Bit> builder = ImmutableMap.builder();
+ private final ImmutableMap.Builder<String, Bit> builder = ImmutableMap.builder();
- BitsTypeBuilder(final SchemaPath path) {
- super(null, path);
+ BitsTypeBuilder(final QName qname) {
+ super(null, qname);
}
- BitsTypeBuilder(final BitsTypeDefinition baseType, final SchemaPath path) {
- super(baseType, path);
+ BitsTypeBuilder(final BitsTypeDefinition baseType, final QName qname) {
+ super(baseType, qname);
}
public BitsTypeBuilder addBit(final @NonNull Bit item) {
}
}
- return getBaseType() == null ? new BaseBitsType(getPath(), getUnknownSchemaNodes(), positionMap.values())
- : new RestrictedBitsType(getBaseType(), getPath(), getUnknownSchemaNodes(), positionMap.values());
+ return getBaseType() == null ? new BaseBitsType(getQName(), getUnknownSchemaNodes(), positionMap.values())
+ : new RestrictedBitsType(getBaseType(), getQName(), getUnknownSchemaNodes(), positionMap.values());
}
}
import com.google.common.annotations.Beta;
import java.util.Objects;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
/**
*/
@Beta
public abstract class ConcreteTypeBuilder<T extends TypeDefinition<T>> extends DerivedTypeBuilder<T> {
- ConcreteTypeBuilder(final T baseType, final SchemaPath path) {
- super(baseType, path);
+ ConcreteTypeBuilder(final T baseType, final QName qname) {
+ super(baseType, qname);
setStatus(baseType.getStatus());
baseType.getDescription().ifPresent(this::setDescription);
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNullByDefault;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
// Hidden on purpose
}
- public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final SchemaPath path) {
+ public static ConcreteTypeBuilder<?> concreteTypeBuilder(final TypeDefinition<?> baseType, final QName qname) {
if (baseType instanceof BinaryTypeDefinition) {
- return concreteBinaryBuilder((BinaryTypeDefinition) baseType, path);
+ return concreteBinaryBuilder((BinaryTypeDefinition) baseType, qname);
} else if (baseType instanceof BitsTypeDefinition) {
- return concreteBitsBuilder((BitsTypeDefinition) baseType, path);
+ return concreteBitsBuilder((BitsTypeDefinition) baseType, qname);
} else if (baseType instanceof BooleanTypeDefinition) {
- return concreteBooleanBuilder((BooleanTypeDefinition) baseType, path);
+ return concreteBooleanBuilder((BooleanTypeDefinition) baseType, qname);
} else if (baseType instanceof DecimalTypeDefinition) {
- return concreteDecimalBuilder((DecimalTypeDefinition) baseType, path);
+ return concreteDecimalBuilder((DecimalTypeDefinition) baseType, qname);
} else if (baseType instanceof EmptyTypeDefinition) {
- return concreteEmptyBuilder((EmptyTypeDefinition) baseType, path);
+ return concreteEmptyBuilder((EmptyTypeDefinition) baseType, qname);
} else if (baseType instanceof EnumTypeDefinition) {
- return concreteEnumerationBuilder((EnumTypeDefinition) baseType, path);
+ return concreteEnumerationBuilder((EnumTypeDefinition) baseType, qname);
} else if (baseType instanceof IdentityrefTypeDefinition) {
- return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
+ return concreteIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
} else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
+ return concreteInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
} else if (baseType instanceof Int8TypeDefinition) {
- return concreteInt8Builder((Int8TypeDefinition) baseType, path);
+ return concreteInt8Builder((Int8TypeDefinition) baseType, qname);
} else if (baseType instanceof Int16TypeDefinition) {
- return concreteInt16Builder((Int16TypeDefinition) baseType, path);
+ return concreteInt16Builder((Int16TypeDefinition) baseType, qname);
} else if (baseType instanceof Int32TypeDefinition) {
- return concreteInt32Builder((Int32TypeDefinition) baseType, path);
+ return concreteInt32Builder((Int32TypeDefinition) baseType, qname);
} else if (baseType instanceof Int64TypeDefinition) {
- return concreteInt64Builder((Int64TypeDefinition) baseType, path);
+ return concreteInt64Builder((Int64TypeDefinition) baseType, qname);
} else if (baseType instanceof LeafrefTypeDefinition) {
- return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
+ return concreteLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
} else if (baseType instanceof StringTypeDefinition) {
- return concreteStringBuilder((StringTypeDefinition) baseType, path);
+ return concreteStringBuilder((StringTypeDefinition) baseType, qname);
} else if (baseType instanceof UnionTypeDefinition) {
- return concreteUnionBuilder((UnionTypeDefinition) baseType, path);
+ return concreteUnionBuilder((UnionTypeDefinition) baseType, qname);
} else if (baseType instanceof Uint8TypeDefinition) {
- return concreteUint8Builder((Uint8TypeDefinition) baseType, path);
+ return concreteUint8Builder((Uint8TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint16TypeDefinition) {
- return concreteUint16Builder((Uint16TypeDefinition) baseType, path);
+ return concreteUint16Builder((Uint16TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint32TypeDefinition) {
- return concreteUint32Builder((Uint32TypeDefinition) baseType, path);
+ return concreteUint32Builder((Uint32TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint64TypeDefinition) {
- return concreteUint64Builder((Uint64TypeDefinition) baseType, path);
+ return concreteUint64Builder((Uint64TypeDefinition) baseType, qname);
} else {
throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
}
}
private static ConcreteTypeBuilder<BinaryTypeDefinition> concreteBinaryBuilder(
- final BinaryTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final BinaryTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public BinaryTypeDefinition buildType() {
- return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBinaryType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<BitsTypeDefinition> concreteBitsBuilder(final BitsTypeDefinition baseType,
- final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public BitsTypeDefinition buildType() {
- return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBitsType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<BooleanTypeDefinition> concreteBooleanBuilder(
- final BooleanTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final BooleanTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public BooleanTypeDefinition buildType() {
- return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBooleanType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<DecimalTypeDefinition> concreteDecimalBuilder(
- final DecimalTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final DecimalTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public DecimalTypeDefinition buildType() {
- return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedDecimalType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<EmptyTypeDefinition> concreteEmptyBuilder(final EmptyTypeDefinition baseType,
- final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public EmptyTypeDefinition buildType() {
- return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedEmptyType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<EnumTypeDefinition> concreteEnumerationBuilder(
- final EnumTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final EnumTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public EnumTypeDefinition buildType() {
- return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedEnumerationType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<IdentityrefTypeDefinition> concreteIdentityrefBuilder(
- final IdentityrefTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final IdentityrefTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public IdentityrefTypeDefinition buildType() {
- return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedIdentityrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<InstanceIdentifierTypeDefinition> concreteInstanceIdentifierBuilder(
- final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public InstanceIdentifierTypeDefinition buildType() {
- return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInstanceIdentifierType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
}
};
}
private static ConcreteTypeBuilder<Int8TypeDefinition> concreteInt8Builder(
- final Int8TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Int8TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Int8TypeDefinition buildType() {
- return new DerivedInt8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Int16TypeDefinition> concreteInt16Builder(
- final Int16TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Int16TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Int16TypeDefinition buildType() {
- return new DerivedInt16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Int32TypeDefinition> concreteInt32Builder(
- final Int32TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Int32TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Int32TypeDefinition buildType() {
- return new DerivedInt32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Int64TypeDefinition> concreteInt64Builder(
- final Int64TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Int64TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Int64TypeDefinition buildType() {
- return new DerivedInt64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<LeafrefTypeDefinition> concreteLeafrefBuilder(
- final LeafrefTypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final LeafrefTypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public LeafrefTypeDefinition buildType() {
- return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedLeafrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<StringTypeDefinition> concreteStringBuilder(final StringTypeDefinition baseType,
- final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public StringTypeDefinition buildType() {
- return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedStringType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<UnionTypeDefinition> concreteUnionBuilder(final UnionTypeDefinition baseType,
- final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public DerivedUnionType buildType() {
- return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUnionType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Uint8TypeDefinition> concreteUint8Builder(
- final Uint8TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Uint8TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Uint8TypeDefinition buildType() {
- return new DerivedUint8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Uint16TypeDefinition> concreteUint16Builder(
- final Uint16TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Uint16TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Uint16TypeDefinition buildType() {
- return new DerivedUint16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Uint32TypeDefinition> concreteUint32Builder(
- final Uint32TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Uint32TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Uint32TypeDefinition buildType() {
- return new DerivedUint32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static ConcreteTypeBuilder<Uint64TypeDefinition> concreteUint64Builder(
- final Uint64TypeDefinition baseType, final SchemaPath path) {
- return new ConcreteTypeBuilder<>(baseType, path) {
+ final Uint64TypeDefinition baseType, final QName qname) {
+ return new ConcreteTypeBuilder<>(baseType, qname) {
@Override
public Uint64TypeDefinition buildType() {
- return new DerivedUint64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.base.Preconditions;
import java.math.BigDecimal;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
public final class DecimalTypeBuilder extends RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> {
private Integer fractionDigits;
- DecimalTypeBuilder(final SchemaPath path) {
- super(null, path);
+ DecimalTypeBuilder(final QName qname) {
+ super(null, qname);
}
public DecimalTypeBuilder setFractionDigits(final int fractionDigits) {
- Preconditions.checkState(this.fractionDigits == null, "Fraction digits already defined to %s",
- this.fractionDigits);
+ checkState(this.fractionDigits == null, "Fraction digits already defined to %s", this.fractionDigits);
this.fractionDigits = fractionDigits;
return this;
}
DecimalTypeDefinition buildType() {
Preconditions.checkState(fractionDigits != null, "Fraction digits not defined");
- return new BaseDecimalType(getPath(), getUnknownSchemaNodes(), fractionDigits,
+ return new BaseDecimalType(getQName(), getUnknownSchemaNodes(), fractionDigits,
calculateRangeConstraint(BaseDecimalType.constraintsForDigits(fractionDigits)));
}
}
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
final class DerivedBinaryType extends AbstractLengthRestrictedDerivedType<BinaryTypeDefinition>
implements BinaryTypeDefinition {
- DerivedBinaryType(final BinaryTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedBinaryType(final BinaryTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
final class DerivedBitsType extends AbstractDerivedType<BitsTypeDefinition> implements BitsTypeDefinition {
- DerivedBitsType(final BitsTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ DerivedBitsType(final BitsTypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
final class DerivedBooleanType extends AbstractDerivedType<BooleanTypeDefinition> implements BooleanTypeDefinition {
- DerivedBooleanType(final BooleanTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedBooleanType(final BooleanTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
import java.math.BigDecimal;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
final class DerivedDecimalType extends AbstractRangeRestrictedDerivedType<DecimalTypeDefinition, BigDecimal>
implements DecimalTypeDefinition {
- DerivedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedDecimalType(final DecimalTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
final class DerivedEmptyType extends AbstractDerivedType<EmptyTypeDefinition> implements EmptyTypeDefinition {
- DerivedEmptyType(final EmptyTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedEmptyType(final EmptyTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
import java.util.Collection;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
final class DerivedEnumerationType extends AbstractDerivedType<EnumTypeDefinition> implements EnumTypeDefinition {
- DerivedEnumerationType(final EnumTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemNodes);
+ DerivedEnumerationType(final EnumTypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemNodes);
}
@Override
import java.util.Collection;
import java.util.Set;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
final class DerivedIdentityrefType extends AbstractDerivedType<IdentityrefTypeDefinition>
implements IdentityrefTypeDefinition {
- DerivedIdentityrefType(final IdentityrefTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedIdentityrefType(final IdentityrefTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
implements InstanceIdentifierTypeDefinition {
private final boolean requireInstance;
- DerivedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path,
+ DerivedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final QName qname,
final Object defaultValue, final String description, final String reference, final Status status,
final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final boolean requireInstance) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
this.requireInstance = requireInstance;
}
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
final class DerivedInt16Type extends AbstractRangeRestrictedDerivedType<Int16TypeDefinition, Short>
implements Int16TypeDefinition {
- DerivedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedInt16Type(final Int16TypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
final class DerivedInt32Type extends AbstractRangeRestrictedDerivedType<Int32TypeDefinition, Integer>
implements Int32TypeDefinition {
- DerivedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedInt32Type(final Int32TypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
final class DerivedInt64Type extends AbstractRangeRestrictedDerivedType<Int64TypeDefinition, Long>
implements Int64TypeDefinition {
- DerivedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedInt64Type(final Int64TypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
final class DerivedInt8Type extends AbstractRangeRestrictedDerivedType<Int8TypeDefinition, Byte>
implements Int8TypeDefinition {
- DerivedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedInt8Type(final Int8TypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
final class DerivedLeafrefType extends AbstractDerivedType<LeafrefTypeDefinition> implements LeafrefTypeDefinition {
-
- DerivedLeafrefType(final LeafrefTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedLeafrefType(final LeafrefTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
final class DerivedStringType extends AbstractLengthRestrictedDerivedType<StringTypeDefinition>
implements StringTypeDefinition {
- DerivedStringType(final StringTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
+ DerivedStringType(final StringTypeDefinition baseType, final QName qname, final Object defaultValue,
final String description, final String reference, final Status status, final String units,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.slf4j.Logger;
private Status status = Status.CURRENT;
private String units;
- DerivedTypeBuilder(final T baseType, final SchemaPath path) {
- super(requireNonNull(baseType), path);
+ DerivedTypeBuilder(final T baseType, final QName qname) {
+ super(requireNonNull(baseType), qname);
checkArgument(baseType instanceof AbstractBaseType || baseType instanceof AbstractDerivedType
|| baseType instanceof AbstractRestrictedType,
final Optional<String> baseUnits = getBaseType().getUnits();
if (baseUnits.isPresent() && !units.equals(baseUnits.get())) {
- LOG.warn("Type {} uverrides 'units' of type {} to \"{}\"", getPath(), getBaseType(), units);
+ LOG.warn("Type {} uverrides 'units' of type {} to \"{}\"", getQName(), getBaseType(), units);
}
this.units = units;
import com.google.common.annotations.Beta;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
}
public static @NonNull DerivedTypeBuilder<?> derivedTypeBuilder(final @NonNull TypeDefinition<?> baseType,
- final @Nullable SchemaPath path) {
+ final @NonNull QName qname) {
if (baseType instanceof BinaryTypeDefinition) {
- return derivedBinaryBuilder((BinaryTypeDefinition) baseType, path);
+ return derivedBinaryBuilder((BinaryTypeDefinition) baseType, qname);
} else if (baseType instanceof BitsTypeDefinition) {
- return derivedBitsBuilder((BitsTypeDefinition) baseType, path);
+ return derivedBitsBuilder((BitsTypeDefinition) baseType, qname);
} else if (baseType instanceof BooleanTypeDefinition) {
- return derivedBooleanBuilder((BooleanTypeDefinition) baseType, path);
+ return derivedBooleanBuilder((BooleanTypeDefinition) baseType, qname);
} else if (baseType instanceof DecimalTypeDefinition) {
- return derivedDecimalBuilder((DecimalTypeDefinition) baseType, path);
+ return derivedDecimalBuilder((DecimalTypeDefinition) baseType, qname);
} else if (baseType instanceof EmptyTypeDefinition) {
- return derivedEmptyBuilder((EmptyTypeDefinition) baseType, path);
+ return derivedEmptyBuilder((EmptyTypeDefinition) baseType, qname);
} else if (baseType instanceof EnumTypeDefinition) {
- return derivedEnumerationBuilder((EnumTypeDefinition) baseType, path);
+ return derivedEnumerationBuilder((EnumTypeDefinition) baseType, qname);
} else if (baseType instanceof IdentityrefTypeDefinition) {
- return derivedIdentityrefBuilder((IdentityrefTypeDefinition) baseType, path);
+ return derivedIdentityrefBuilder((IdentityrefTypeDefinition) baseType, qname);
} else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- return derivedInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, path);
+ return derivedInstanceIdentifierBuilder((InstanceIdentifierTypeDefinition) baseType, qname);
} else if (baseType instanceof Int8TypeDefinition) {
- return derivedInt8Builder((Int8TypeDefinition) baseType, path);
+ return derivedInt8Builder((Int8TypeDefinition) baseType, qname);
} else if (baseType instanceof Int16TypeDefinition) {
- return derivedInt16Builder((Int16TypeDefinition) baseType, path);
+ return derivedInt16Builder((Int16TypeDefinition) baseType, qname);
} else if (baseType instanceof Int32TypeDefinition) {
- return derivedInt32Builder((Int32TypeDefinition) baseType, path);
+ return derivedInt32Builder((Int32TypeDefinition) baseType, qname);
} else if (baseType instanceof Int64TypeDefinition) {
- return derivedInt64Builder((Int64TypeDefinition) baseType, path);
+ return derivedInt64Builder((Int64TypeDefinition) baseType, qname);
} else if (baseType instanceof LeafrefTypeDefinition) {
- return derivedLeafrefBuilder((LeafrefTypeDefinition) baseType, path);
+ return derivedLeafrefBuilder((LeafrefTypeDefinition) baseType, qname);
} else if (baseType instanceof StringTypeDefinition) {
- return derivedStringBuilder((StringTypeDefinition) baseType, path);
+ return derivedStringBuilder((StringTypeDefinition) baseType, qname);
} else if (baseType instanceof UnionTypeDefinition) {
- return derivedUnionBuilder((UnionTypeDefinition) baseType, path);
+ return derivedUnionBuilder((UnionTypeDefinition) baseType, qname);
} else if (baseType instanceof Uint8TypeDefinition) {
- return derivedUint8Builder((Uint8TypeDefinition) baseType, path);
+ return derivedUint8Builder((Uint8TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint16TypeDefinition) {
- return derivedUint16Builder((Uint16TypeDefinition) baseType, path);
+ return derivedUint16Builder((Uint16TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint32TypeDefinition) {
- return derivedUint32Builder((Uint32TypeDefinition) baseType, path);
+ return derivedUint32Builder((Uint32TypeDefinition) baseType, qname);
} else if (baseType instanceof Uint64TypeDefinition) {
- return derivedUint64Builder((Uint64TypeDefinition) baseType, path);
+ return derivedUint64Builder((Uint64TypeDefinition) baseType, qname);
} else {
throw new IllegalArgumentException("Unhandled type definition class " + baseType.getClass());
}
}
public static @NonNull DerivedTypeBuilder<BinaryTypeDefinition> derivedBinaryBuilder(
- final @NonNull BinaryTypeDefinition baseType, final @Nullable SchemaPath path) {
- return new DerivedTypeBuilder<BinaryTypeDefinition>(baseType, path) {
+ final @NonNull BinaryTypeDefinition baseType, final @NonNull QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public BinaryTypeDefinition build() {
- return new DerivedBinaryType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBinaryType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<BitsTypeDefinition> derivedBitsBuilder(final BitsTypeDefinition baseType,
- final SchemaPath path) {
- return new DerivedTypeBuilder<BitsTypeDefinition>(baseType, path) {
+ final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public BitsTypeDefinition build() {
- return new DerivedBitsType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBitsType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<BooleanTypeDefinition> derivedBooleanBuilder(
- final @NonNull BooleanTypeDefinition baseType, final @Nullable SchemaPath path) {
- return new DerivedTypeBuilder<BooleanTypeDefinition>(baseType, path) {
+ final @NonNull BooleanTypeDefinition baseType, final @NonNull QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public BooleanTypeDefinition build() {
- return new DerivedBooleanType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedBooleanType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<DecimalTypeDefinition> derivedDecimalBuilder(
- final DecimalTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<DecimalTypeDefinition>(baseType, path) {
+ final DecimalTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public DecimalTypeDefinition build() {
- return new DerivedDecimalType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedDecimalType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<EmptyTypeDefinition> derivedEmptyBuilder(
- final EmptyTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<EmptyTypeDefinition>(baseType, path) {
+ final EmptyTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public EmptyTypeDefinition build() {
- return new DerivedEmptyType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedEmptyType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<EnumTypeDefinition> derivedEnumerationBuilder(
- final EnumTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<EnumTypeDefinition>(baseType, path) {
+ final EnumTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public EnumTypeDefinition build() {
- return new DerivedEnumerationType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedEnumerationType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<IdentityrefTypeDefinition> derivedIdentityrefBuilder(
- final IdentityrefTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<IdentityrefTypeDefinition>(baseType, path) {
+ final IdentityrefTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public IdentityrefTypeDefinition build() {
- return new DerivedIdentityrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedIdentityrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<InstanceIdentifierTypeDefinition> derivedInstanceIdentifierBuilder(
- final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<InstanceIdentifierTypeDefinition>(baseType, path) {
+ final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public InstanceIdentifierTypeDefinition build() {
- return new DerivedInstanceIdentifierType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInstanceIdentifierType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes(), baseType.requireInstance());
}
};
}
private static @NonNull DerivedTypeBuilder<Int8TypeDefinition> derivedInt8Builder(final Int8TypeDefinition baseType,
- final SchemaPath path) {
- return new DerivedTypeBuilder<Int8TypeDefinition>(baseType, path) {
+ final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Int8TypeDefinition build() {
- return new DerivedInt8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<Int16TypeDefinition> derivedInt16Builder(
- final Int16TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Int16TypeDefinition>(baseType, path) {
+ final Int16TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Int16TypeDefinition build() {
- return new DerivedInt16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<Int32TypeDefinition> derivedInt32Builder(
- final Int32TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Int32TypeDefinition>(baseType, path) {
+ final Int32TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Int32TypeDefinition build() {
- return new DerivedInt32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<Int64TypeDefinition> derivedInt64Builder(
- final Int64TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Int64TypeDefinition>(baseType, path) {
+ final Int64TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Int64TypeDefinition build() {
- return new DerivedInt64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedInt64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<LeafrefTypeDefinition> derivedLeafrefBuilder(
- final LeafrefTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<LeafrefTypeDefinition>(baseType, path) {
+ final LeafrefTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public LeafrefTypeDefinition build() {
- return new DerivedLeafrefType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedLeafrefType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<StringTypeDefinition> derivedStringBuilder(
- final StringTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<StringTypeDefinition>(baseType, path) {
+ final StringTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public StringTypeDefinition build() {
- return new DerivedStringType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedStringType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<UnionTypeDefinition> derivedUnionBuilder(
- final UnionTypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<UnionTypeDefinition>(baseType, path) {
+ final UnionTypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public DerivedUnionType build() {
- return new DerivedUnionType(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUnionType(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<Uint8TypeDefinition> derivedUint8Builder(
- final Uint8TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Uint8TypeDefinition>(baseType, path) {
+ final Uint8TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Uint8TypeDefinition build() {
- return new DerivedUint8Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint8Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
private static @NonNull DerivedTypeBuilder<Uint16TypeDefinition> derivedUint16Builder(
- final Uint16TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Uint16TypeDefinition>(baseType, path) {
+ final Uint16TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Uint16TypeDefinition build() {
- return new DerivedUint16Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint16Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<Uint32TypeDefinition> derivedUint32Builder(
- final Uint32TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Uint32TypeDefinition>(baseType, path) {
+ final Uint32TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Uint32TypeDefinition build() {
- return new DerivedUint32Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint32Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
}
public static @NonNull DerivedTypeBuilder<Uint64TypeDefinition> derivedUint64Builder(
- final Uint64TypeDefinition baseType, final SchemaPath path) {
- return new DerivedTypeBuilder<Uint64TypeDefinition>(baseType, path) {
+ final Uint64TypeDefinition baseType, final QName qname) {
+ return new DerivedTypeBuilder<>(baseType, qname) {
@Override
public Uint64TypeDefinition build() {
- return new DerivedUint64Type(getBaseType(), getPath(), getDefaultValue(), getDescription(),
+ return new DerivedUint64Type(getBaseType(), getQName(), getDefaultValue(), getDescription(),
getReference(), getStatus(), getUnits(), getUnknownSchemaNodes());
}
};
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint16;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
final class DerivedUint16Type extends AbstractRangeRestrictedDerivedType<Uint16TypeDefinition, Uint16>
implements Uint16TypeDefinition {
-
- DerivedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,
- final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ DerivedUint16Type(final Uint16TypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
final class DerivedUint32Type extends AbstractRangeRestrictedDerivedType<Uint32TypeDefinition, Uint32>
implements Uint32TypeDefinition {
-
- DerivedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,
- final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ DerivedUint32Type(final Uint32TypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint64;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
final class DerivedUint64Type extends AbstractRangeRestrictedDerivedType<Uint64TypeDefinition, Uint64>
implements Uint64TypeDefinition {
- DerivedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,
- final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ DerivedUint64Type(final Uint64TypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint8;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
final class DerivedUint8Type extends AbstractRangeRestrictedDerivedType<Uint8TypeDefinition, Uint8>
implements Uint8TypeDefinition {
- DerivedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,
- final Object defaultValue, final String description, final String reference, final Status status,
- final String units, final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ DerivedUint8Type(final Uint8TypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
final class DerivedUnionType extends AbstractDerivedType<UnionTypeDefinition> implements UnionTypeDefinition {
- DerivedUnionType(final UnionTypeDefinition baseType, final SchemaPath path, final Object defaultValue,
- final String description, final String reference, final Status status, final String units,
- final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, defaultValue, description, reference, status, units, unknownSchemaNodes);
+ DerivedUnionType(final UnionTypeDefinition baseType, final QName qname, final Object defaultValue,
+ final String description, final String reference, final Status status, final String units,
+ final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
+ super(baseType, qname, defaultValue, description, reference, status, units, unknownSchemaNodes);
}
@Override
import java.util.HashMap;
import java.util.Map;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
public final class EnumerationTypeBuilder extends AbstractRestrictedTypeBuilder<EnumTypeDefinition> {
private final Builder<String, EnumPair> builder = ImmutableMap.builder();
- EnumerationTypeBuilder(final SchemaPath path) {
- super(null, path);
+ EnumerationTypeBuilder(final QName qname) {
+ super(null, qname);
}
- EnumerationTypeBuilder(final EnumTypeDefinition baseType, final SchemaPath path) {
- super(baseType, path);
+ EnumerationTypeBuilder(final EnumTypeDefinition baseType, final QName qname) {
+ super(baseType, qname);
}
public EnumerationTypeBuilder addEnum(final @NonNull EnumPair item) {
}
}
- return getBaseType() == null ? new BaseEnumerationType(getPath(), getUnknownSchemaNodes(), map.values())
- : new RestrictedEnumerationType(getBaseType(), getPath(), getUnknownSchemaNodes(), map.values());
+ return getBaseType() == null ? new BaseEnumerationType(getQName(), getUnknownSchemaNodes(), map.values())
+ : new RestrictedEnumerationType(getBaseType(), getQName(), getUnknownSchemaNodes(), map.values());
}
}
import com.google.common.collect.ImmutableSet.Builder;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
public final class IdentityrefTypeBuilder extends TypeBuilder<IdentityrefTypeDefinition> {
private final Builder<IdentitySchemaNode> builder = ImmutableSet.builder();
- IdentityrefTypeBuilder(final SchemaPath path) {
- super(null, path);
+ IdentityrefTypeBuilder(final QName qname) {
+ super(null, qname);
}
public IdentityrefTypeBuilder addIdentity(final @NonNull IdentitySchemaNode identity) {
@Override
public IdentityrefTypeDefinition build() {
final Set<IdentitySchemaNode> identities = builder.build();
- checkState(!identities.isEmpty(), "No identities specified in %s, at least one is required", getPath());
- return new BaseIdentityrefType(getPath(), getUnknownSchemaNodes(), identities);
+ checkState(!identities.isEmpty(), "No identities specified in %s, at least one is required", getQName());
+ return new BaseIdentityrefType(getQName(), getUnknownSchemaNodes(), identities);
}
}
import static java.util.Objects.requireNonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
public final class InstanceIdentifierTypeBuilder
extends RequireInstanceRestrictedTypeBuilder<InstanceIdentifierTypeDefinition> {
-
- InstanceIdentifierTypeBuilder(final InstanceIdentifierTypeDefinition baseType,
- final SchemaPath path) {
- super(requireNonNull(baseType), path);
+ InstanceIdentifierTypeBuilder(final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+ super(requireNonNull(baseType), qname);
}
@Override
return base;
}
- return new RestrictedInstanceIdentifierType(base, getPath(), getUnknownSchemaNodes(), getRequireInstance());
+ return new RestrictedInstanceIdentifierType(base, getQName(), getUnknownSchemaNodes(), getRequireInstance());
}
}
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
public final class LeafrefTypeBuilder extends RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> {
private PathExpression pathStatement;
- LeafrefTypeBuilder(final SchemaPath path) {
- super(null, path);
+ LeafrefTypeBuilder(final QName qname) {
+ super(null, qname);
}
public LeafrefTypeBuilder setPathStatement(final @NonNull PathExpression pathStatement) {
@Override
LeafrefTypeDefinition buildType() {
- return new BaseLeafrefType(getPath(), pathStatement, getRequireInstance(), getUnknownSchemaNodes());
+ return new BaseLeafrefType(getQName(), pathStatement, getRequireInstance(), getUnknownSchemaNodes());
}
}
import java.util.List;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
extends AbstractRestrictedTypeBuilder<T> {
private LengthConstraint lengthConstraint;
- LengthRestrictedTypeBuilder(final T baseType, final SchemaPath path) {
- super(requireNonNull(baseType), path);
+ LengthRestrictedTypeBuilder(final T baseType, final QName qname) {
+ super(requireNonNull(baseType), qname);
}
/**
import java.util.List;
import java.util.function.Function;
import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.stmt.UnresolvedNumber;
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
private ConstraintMetaDefinition constraint;
private ImmutableList<ValueRange> ranges;
- RangeRestrictedTypeBuilder(final T baseType, final SchemaPath path) {
- super(baseType, path);
+ RangeRestrictedTypeBuilder(final T baseType, final QName qname) {
+ super(baseType, qname);
}
@SuppressWarnings("checkstyle:hiddenField")
import static java.util.Objects.requireNonNull;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.RangeRestrictedTypeDefinition;
abstract class RangeRestrictedTypeBuilderWithBase<T extends RangeRestrictedTypeDefinition<T, N>,
N extends Number & Comparable<N>> extends RangeRestrictedTypeBuilder<T, N> {
-
- RangeRestrictedTypeBuilderWithBase(final T baseType, final SchemaPath path) {
- super(requireNonNull(baseType), path);
+ RangeRestrictedTypeBuilderWithBase(final T baseType, final QName qname) {
+ super(requireNonNull(baseType), qname);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import com.google.common.annotations.Beta;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.RequireInstanceRestrictedTypeDefinition;
@Beta
extends AbstractRestrictedTypeBuilder<T> {
private boolean requireInstance;
- RequireInstanceRestrictedTypeBuilder(final T baseType, final SchemaPath path) {
- super(baseType, path);
+ RequireInstanceRestrictedTypeBuilder(final T baseType, final QName qname) {
+ super(baseType, qname);
requireInstance = baseType == null || baseType.requireInstance();
}
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
final class RestrictedBinaryType extends AbstractLengthRestrictedType<BinaryTypeDefinition>
implements BinaryTypeDefinition {
- RestrictedBinaryType(final BinaryTypeDefinition baseType, final SchemaPath path,
+ RestrictedBinaryType(final BinaryTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable LengthConstraint lengthConstraint) {
- super(baseType, path, unknownSchemaNodes, lengthConstraint);
+ super(baseType, qname, unknownSchemaNodes, lengthConstraint);
}
@Override
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
final class RestrictedBitsType extends AbstractRestrictedType<BitsTypeDefinition> implements BitsTypeDefinition {
private final @NonNull ImmutableList<Bit> bits;
- RestrictedBitsType(final BitsTypeDefinition baseType, final SchemaPath path,
+ RestrictedBitsType(final BitsTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final Collection<Bit> bits) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
this.bits = ImmutableList.copyOf(bits);
}
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
final class RestrictedBooleanType extends AbstractRestrictedType<BooleanTypeDefinition>
implements BooleanTypeDefinition {
- RestrictedBooleanType(final BooleanTypeDefinition baseType, final SchemaPath path,
+ RestrictedBooleanType(final BooleanTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
}
@Override
import java.math.BigDecimal;
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final class RestrictedDecimalType extends AbstractRangeRestrictedType<DecimalTypeDefinition, BigDecimal>
implements DecimalTypeDefinition {
- RestrictedDecimalType(final DecimalTypeDefinition baseType, final SchemaPath path,
+ RestrictedDecimalType(final DecimalTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<BigDecimal> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
final class RestrictedEmptyType extends AbstractRestrictedType<EmptyTypeDefinition> implements EmptyTypeDefinition {
- RestrictedEmptyType(final EmptyTypeDefinition baseType, final SchemaPath path,
+ RestrictedEmptyType(final EmptyTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
}
@Override
import java.util.Collection;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
final class RestrictedEnumerationType extends AbstractRestrictedType<EnumTypeDefinition> implements EnumTypeDefinition {
private final @NonNull ImmutableList<EnumPair> values;
- RestrictedEnumerationType(final EnumTypeDefinition baseType, final SchemaPath path,
+ RestrictedEnumerationType(final EnumTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final Collection<EnumPair> values) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
this.values = ImmutableList.copyOf(values);
}
import java.util.Collection;
import java.util.Set;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
final class RestrictedIdentityrefType extends AbstractRestrictedType<IdentityrefTypeDefinition>
implements IdentityrefTypeDefinition {
- RestrictedIdentityrefType(final IdentityrefTypeDefinition baseType, final SchemaPath path,
+ RestrictedIdentityrefType(final IdentityrefTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
implements InstanceIdentifierTypeDefinition {
private final boolean requireInstance;
- RestrictedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final SchemaPath path,
+ RestrictedInstanceIdentifierType(final InstanceIdentifierTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
this.requireInstance = requireInstance;
}
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int16TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final class RestrictedInt16Type extends AbstractRangeRestrictedType<Int16TypeDefinition, Short>
implements Int16TypeDefinition {
- RestrictedInt16Type(final Int16TypeDefinition baseType, final SchemaPath path,
+ RestrictedInt16Type(final Int16TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Short> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int32TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final class RestrictedInt32Type extends AbstractRangeRestrictedType<Int32TypeDefinition, Integer>
implements Int32TypeDefinition {
- RestrictedInt32Type(final Int32TypeDefinition baseType, final SchemaPath path,
+ RestrictedInt32Type(final Int32TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Integer> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int64TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final class RestrictedInt64Type extends AbstractRangeRestrictedType<Int64TypeDefinition, Long>
implements Int64TypeDefinition {
- RestrictedInt64Type(final Int64TypeDefinition baseType, final SchemaPath path,
+ RestrictedInt64Type(final Int64TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Long> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.Int8TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
final class RestrictedInt8Type extends AbstractRangeRestrictedType<Int8TypeDefinition, Byte>
implements Int8TypeDefinition {
- RestrictedInt8Type(final Int8TypeDefinition baseType, final SchemaPath path,
+ RestrictedInt8Type(final Int8TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Byte> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
package org.opendaylight.yangtools.yang.model.util.type;
import java.util.Collection;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
final class RestrictedLeafrefType extends AbstractRestrictedType<LeafrefTypeDefinition>
implements LeafrefTypeDefinition {
-
private final boolean requireInstance;
- RestrictedLeafrefType(final LeafrefTypeDefinition baseType, final SchemaPath path,
+ RestrictedLeafrefType(final LeafrefTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes, final boolean requireInstance) {
- super(baseType, path, unknownSchemaNodes);
-
+ super(baseType, qname, unknownSchemaNodes);
this.requireInstance = requireInstance;
}
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
implements StringTypeDefinition {
private final @NonNull ImmutableList<PatternConstraint> patternConstraints;
- RestrictedStringType(final StringTypeDefinition baseType, final SchemaPath path,
+ RestrictedStringType(final StringTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable LengthConstraint lengthConstraints,
final List<PatternConstraint> patternConstraints) {
- super(baseType, path, unknownSchemaNodes, lengthConstraints);
+ super(baseType, qname, unknownSchemaNodes, lengthConstraints);
this.patternConstraints = ImmutableList.copyOf(patternConstraints);
}
import java.math.BigDecimal;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
}
public static @NonNull LengthRestrictedTypeBuilder<BinaryTypeDefinition> newBinaryBuilder(
- final @NonNull BinaryTypeDefinition baseType, final @Nullable SchemaPath path) {
- return new LengthRestrictedTypeBuilder<>(baseType, path) {
+ final @NonNull BinaryTypeDefinition baseType, final @NonNull QName qname) {
+ return new LengthRestrictedTypeBuilder<>(baseType, qname) {
@Override
BinaryTypeDefinition buildType(final @Nullable LengthConstraint constraint) {
- return new RestrictedBinaryType(getBaseType(), getPath(), getUnknownSchemaNodes(), constraint);
+ return new RestrictedBinaryType(getBaseType(), getQName(), getUnknownSchemaNodes(), constraint);
}
@Override
};
}
- public static @NonNull BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType,
- final SchemaPath path) {
- return new BitsTypeBuilder(baseType, path);
+ public static @NonNull BitsTypeBuilder newBitsBuilder(final BitsTypeDefinition baseType, final QName qname) {
+ return new BitsTypeBuilder(baseType, qname);
}
public static @NonNull TypeBuilder<BooleanTypeDefinition> newBooleanBuilder(
- final @NonNull BooleanTypeDefinition baseType, final @Nullable SchemaPath path) {
- return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+ final @NonNull BooleanTypeDefinition baseType, final @NonNull QName qname) {
+ return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
@Override
BooleanTypeDefinition buildType() {
- return new RestrictedBooleanType(getBaseType(), getPath(), getUnknownSchemaNodes());
+ return new RestrictedBooleanType(getBaseType(), getQName(), getUnknownSchemaNodes());
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> newDecima64Builder(
- final DecimalTypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+ final DecimalTypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
DecimalTypeDefinition buildType(final RangeConstraint<BigDecimal> rangeConstraint) {
- return new RestrictedDecimalType(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ return new RestrictedDecimalType(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull TypeBuilder<EmptyTypeDefinition> newEmptyBuilder(final EmptyTypeDefinition baseType,
- final SchemaPath path) {
- return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
@Override
EmptyTypeDefinition buildType() {
- return new RestrictedEmptyType(getBaseType(), getPath(), getUnknownSchemaNodes());
+ return new RestrictedEmptyType(getBaseType(), getQName(), getUnknownSchemaNodes());
}
};
}
public static @NonNull EnumerationTypeBuilder newEnumerationBuilder(final EnumTypeDefinition baseType,
- final SchemaPath path) {
- return new EnumerationTypeBuilder(baseType, path);
+ final QName qname) {
+ return new EnumerationTypeBuilder(baseType, qname);
}
public static @NonNull TypeBuilder<IdentityrefTypeDefinition> newIdentityrefBuilder(
- final IdentityrefTypeDefinition baseType, final SchemaPath path) {
- return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+ final IdentityrefTypeDefinition baseType, final QName qname) {
+ return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
@Override
IdentityrefTypeDefinition buildType() {
- return new RestrictedIdentityrefType(getBaseType(), getPath(), getUnknownSchemaNodes());
+ return new RestrictedIdentityrefType(getBaseType(), getQName(), getUnknownSchemaNodes());
}
};
}
public static @NonNull InstanceIdentifierTypeBuilder newInstanceIdentifierBuilder(
- final InstanceIdentifierTypeDefinition baseType, final SchemaPath path) {
- return new InstanceIdentifierTypeBuilder(baseType, path);
+ final InstanceIdentifierTypeDefinition baseType, final QName qname) {
+ return new InstanceIdentifierTypeBuilder(baseType, qname);
}
public static @NonNull RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> newLeafrefBuilder(
- final LeafrefTypeDefinition baseType, final SchemaPath path) {
- return new RequireInstanceRestrictedTypeBuilder<>(baseType, path) {
+ final LeafrefTypeDefinition baseType, final QName qname) {
+ return new RequireInstanceRestrictedTypeBuilder<>(baseType, qname) {
@Override
LeafrefTypeDefinition buildType() {
final LeafrefTypeDefinition base = getBaseType();
if (getRequireInstance() == base.requireInstance()) {
return base;
}
- return new RestrictedLeafrefType(getBaseType(), getPath(), getUnknownSchemaNodes(),
+ return new RestrictedLeafrefType(getBaseType(), getQName(), getUnknownSchemaNodes(),
getRequireInstance());
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Int8TypeDefinition, Byte> newInt8Builder(
- final Int8TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+ final Int8TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
Int8TypeDefinition buildType(final RangeConstraint<Byte> rangeConstraint) {
- return new RestrictedInt8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ return new RestrictedInt8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Int16TypeDefinition, Short> newInt16Builder(
- final Int16TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+ final Int16TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
Int16TypeDefinition buildType(final RangeConstraint<Short> rangeConstraint) {
- return new RestrictedInt16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ return new RestrictedInt16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Int32TypeDefinition, Integer> newInt32Builder(
- final Int32TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+ final Int32TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
Int32TypeDefinition buildType(final RangeConstraint<Integer> rangeConstraint) {
- return new RestrictedInt32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ return new RestrictedInt32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Int64TypeDefinition, Long> newInt64Builder(
- final Int64TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<>(baseType, path) {
+ final Int64TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
Int64TypeDefinition buildType(final RangeConstraint<Long> rangeConstraint) {
- return new RestrictedInt64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ return new RestrictedInt64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
- public static @NonNull StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType,
- final SchemaPath path) {
- return new StringTypeBuilder(baseType, path);
+ public static @NonNull StringTypeBuilder newStringBuilder(final StringTypeDefinition baseType, final QName qname) {
+ return new StringTypeBuilder(baseType, qname);
}
public static @NonNull TypeBuilder<UnionTypeDefinition> newUnionBuilder(final UnionTypeDefinition baseType,
- final SchemaPath path) {
- return new AbstractRestrictedTypeBuilder<>(baseType, path) {
+ final QName qname) {
+ return new AbstractRestrictedTypeBuilder<>(baseType, qname) {
@Override
UnionTypeDefinition buildType() {
- return new RestrictedUnionType(getBaseType(), getPath(), getUnknownSchemaNodes());
+ return new RestrictedUnionType(getBaseType(), getQName(), getUnknownSchemaNodes());
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Uint8TypeDefinition, Uint8> newUint8Builder(
- final Uint8TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<Uint8TypeDefinition, Uint8>(baseType, path) {
+ final Uint8TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
- Uint8TypeDefinition buildType(final RangeConstraint<Uint8> rangeConstraint) {
- return new RestrictedUint8Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ Uint8TypeDefinition buildType(final RangeConstraint<@NonNull Uint8> rangeConstraint) {
+ return new RestrictedUint8Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Uint16TypeDefinition, Uint16> newUint16Builder(
- final Uint16TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<Uint16TypeDefinition, Uint16>(baseType, path) {
+ final Uint16TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
- Uint16TypeDefinition buildType(final RangeConstraint<Uint16> rangeConstraint) {
- return new RestrictedUint16Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ Uint16TypeDefinition buildType(final RangeConstraint<@NonNull Uint16> rangeConstraint) {
+ return new RestrictedUint16Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Uint32TypeDefinition, Uint32> newUint32Builder(
- final Uint32TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<Uint32TypeDefinition, Uint32>(baseType, path) {
+ final Uint32TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
- Uint32TypeDefinition buildType(final RangeConstraint<Uint32> rangeConstraint) {
- return new RestrictedUint32Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ Uint32TypeDefinition buildType(final RangeConstraint<@NonNull Uint32> rangeConstraint) {
+ return new RestrictedUint32Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
public static @NonNull RangeRestrictedTypeBuilder<Uint64TypeDefinition, Uint64> newUint64Builder(
- final Uint64TypeDefinition baseType, final SchemaPath path) {
- return new RangeRestrictedTypeBuilderWithBase<Uint64TypeDefinition, Uint64>(baseType, path) {
+ final Uint64TypeDefinition baseType, final QName qname) {
+ return new RangeRestrictedTypeBuilderWithBase<>(baseType, qname) {
@Override
- Uint64TypeDefinition buildType(final RangeConstraint<Uint64> rangeConstraint) {
- return new RestrictedUint64Type(getBaseType(), getPath(), getUnknownSchemaNodes(), rangeConstraint);
+ Uint64TypeDefinition buildType(final RangeConstraint<@NonNull Uint64> rangeConstraint) {
+ return new RestrictedUint64Type(getBaseType(), getQName(), getUnknownSchemaNodes(), rangeConstraint);
}
};
}
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint16;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.Uint16TypeDefinition;
final class RestrictedUint16Type extends AbstractRangeRestrictedType<Uint16TypeDefinition, Uint16>
implements Uint16TypeDefinition {
- RestrictedUint16Type(final Uint16TypeDefinition baseType, final SchemaPath path,
+ RestrictedUint16Type(final Uint16TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint16> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.Uint32TypeDefinition;
final class RestrictedUint32Type extends AbstractRangeRestrictedType<Uint32TypeDefinition, Uint32>
implements Uint32TypeDefinition {
- RestrictedUint32Type(final Uint32TypeDefinition baseType, final SchemaPath path,
+ RestrictedUint32Type(final Uint32TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint32> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint64;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
final class RestrictedUint64Type extends AbstractRangeRestrictedType<Uint64TypeDefinition, Uint64>
implements Uint64TypeDefinition {
- RestrictedUint64Type(final Uint64TypeDefinition baseType, final SchemaPath path,
+ RestrictedUint64Type(final Uint64TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint64> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint8;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
final class RestrictedUint8Type extends AbstractRangeRestrictedType<Uint8TypeDefinition, Uint8>
implements Uint8TypeDefinition {
- RestrictedUint8Type(final Uint8TypeDefinition baseType, final SchemaPath path,
+ RestrictedUint8Type(final Uint8TypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes,
final @Nullable RangeConstraint<Uint8> rangeConstraint) {
- super(baseType, path, unknownSchemaNodes, rangeConstraint);
+ super(baseType, qname, unknownSchemaNodes, rangeConstraint);
}
@Override
import java.util.Collection;
import java.util.List;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
final class RestrictedUnionType extends AbstractRestrictedType<UnionTypeDefinition> implements UnionTypeDefinition {
- RestrictedUnionType(final UnionTypeDefinition baseType, final SchemaPath path,
+ RestrictedUnionType(final UnionTypeDefinition baseType, final QName qname,
final Collection<? extends UnknownSchemaNode> unknownSchemaNodes) {
- super(baseType, path, unknownSchemaNodes);
+ super(baseType, qname, unknownSchemaNodes);
}
@Override
import java.util.ArrayList;
import java.util.List;
import org.eclipse.jdt.annotation.Nullable;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.type.LengthConstraint;
import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
public final class StringTypeBuilder extends LengthRestrictedTypeBuilder<StringTypeDefinition> {
private final List<PatternConstraint> patternConstraints = new ArrayList<>(0);
- StringTypeBuilder(final StringTypeDefinition baseType, final SchemaPath path) {
- super(baseType, path);
+ StringTypeBuilder(final StringTypeDefinition baseType, final QName qname) {
+ super(baseType, qname);
}
public StringTypeBuilder addPatternConstraint(final PatternConstraint constraint) {
@Override
StringTypeDefinition buildType(final @Nullable LengthConstraint constraint) {
- return new RestrictedStringType(getBaseType(), getPath(), getUnknownSchemaNodes(), constraint,
+ return new RestrictedStringType(getBaseType(), getQName(), getUnknownSchemaNodes(), constraint,
patternConstraints);
}
}
*/
package org.opendaylight.yangtools.yang.model.util.type;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.concepts.Builder;
-import org.opendaylight.yangtools.yang.model.api.SchemaNodeDefaults;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
public abstract class TypeBuilder<T extends TypeDefinition<T>> implements Builder<T> {
private final ImmutableList.Builder<UnknownSchemaNode> unknownSchemaNodes = ImmutableList.builder();
- private final @Nullable SchemaPath path;
+ private final @NonNull QName qname;
private final T baseType;
- TypeBuilder(final T baseType, final SchemaPath path) {
- this.path = path;
+ TypeBuilder(final T baseType, final QName qname) {
+ this.qname = requireNonNull(qname);
this.baseType = baseType;
}
return baseType;
}
- final @Nullable SchemaPath getPath() {
- return SchemaNodeDefaults.throwUnsupportedIfNull(this, path);
+ final @NonNull QName getQName() {
+ return qname;
}
final @NonNull Collection<? extends UnknownSchemaNode> getUnknownSchemaNodes() {
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
public final class UnionTypeBuilder extends TypeBuilder<UnionTypeDefinition> {
private final Builder<TypeDefinition<?>> builder = ImmutableList.builder();
- UnionTypeBuilder(final SchemaPath path) {
- super(null, path);
+ UnionTypeBuilder(final QName qname) {
+ super(null, qname);
}
public UnionTypeBuilder addType(final @NonNull TypeDefinition<?> type) {
@Override
public UnionTypeDefinition build() {
- return new BaseUnionType(getPath(), getUnknownSchemaNodes(), builder.build());
+ return new BaseUnionType(getQName(), getUnknownSchemaNodes(), builder.build());
}
}
import static org.junit.Assert.assertTrue;
import static org.opendaylight.yangtools.yang.model.util.type.BaseTypes.binaryType;
-import java.util.Collections;
import java.util.Optional;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
public class BinaryTypeTest {
-
@Test
public void canCreateBinaryType() {
final BinaryTypeDefinition binType = binaryType();
assertEquals("Base type is null", null, binType.getBaseType());
assertEquals("getQName gives BINARY_QNAME", BaseTypes.BINARY_QNAME, binType.getQName());
assertEquals(Optional.empty(), binType.getUnits());
- assertEquals("getPath gives List of BINARY_QNAME", Collections.singletonList(BaseTypes.BINARY_QNAME),
- binType.getPath().getPathFromRoot());
assertTrue("binType1 should equal to binType", binType.equals(binType1) && binType1.equals(binType));
assertTrue("Hash code of binType and binType1 should be equal",
assertFalse("binType shouldn't equal to null", binType.equals(null));
assertFalse("binType shouldn't equal to object of other type", binType.equals("str"));
}
-
}
import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.Uint32;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
doReturn("toString").when(bit).toString();
QName qname = QName.create("namespace", "localname");
- SchemaPath schemaPath = SchemaPath.create(true, qname);
- BitsTypeDefinition bitsType = BaseTypes.bitsTypeBuilder(schemaPath).addBit(bit).build();
+ BitsTypeDefinition bitsType = BaseTypes.bitsTypeBuilder(qname).addBit(bit).build();
assertFalse(bitsType.getDescription().isPresent());
assertEquals("QName", qname, bitsType.getQName());
assertFalse(bitsType.getReference().isPresent());
assertNull("BaseType should be null", bitsType.getBaseType());
assertEquals(Optional.empty(), bitsType.getDefaultValue());
- assertEquals("getPath should equal schemaPath", schemaPath, bitsType.getPath());
assertEquals("Status should be CURRENT", Status.CURRENT, bitsType.getStatus());
assertEquals("Should be empty list", Collections.emptyList(), bitsType.getUnknownSchemaNodes());
assertEquals("Values should be [enumPair]", Collections.singletonList(bit), bitsType.getBits());
public void canCreateBooleanType() {
final BooleanTypeDefinition boolType = booleanType();
- assertEquals("getPath gives List of BOOLEAN_QNAME",
- Collections.singletonList(BaseTypes.BOOLEAN_QNAME), boolType.getPath().getPathFromRoot());
assertEquals("getQName gives BOOLEAN_QNAME", BaseTypes.BOOLEAN_QNAME, boolType.getQName());
assertFalse(boolType.getDescription().isPresent());
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
public class EmptyTypeTest {
-
@Test
public void canCreateEmptyType() {
EmptyTypeDefinition emptyType = emptyType();
assertEquals("QName", BaseTypes.EMPTY_QNAME, emptyType.getQName());
- assertEquals("Path", Collections.singletonList(BaseTypes.EMPTY_QNAME),
- emptyType.getPath().getPathFromRoot());
assertEquals("BaseType", null, emptyType.getBaseType());
assertEquals("DefaultValue", Optional.empty(), emptyType.getDefaultValue());
assertEquals("Status", Status.CURRENT, emptyType.getStatus());
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
public class LeafrefTest {
-
@Test
public void testMethodsOfLeafrefTest() {
- final SchemaPath schemaPath = SchemaPath.create(false, QName.create("test", "Cont1"),
- QName.create("test", "List1"));
+ final QName qname = QName.create("test", "List1");
final PathExpression revision = new PathExpressionImpl("/test:Cont1/test:List1", false);
final PathExpression revision2 = new PathExpressionImpl("/test:Cont1/test:List2", false);
- final LeafrefTypeDefinition leafref = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision)
- .build();
- final LeafrefTypeDefinition leafref2 = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision2)
- .build();
- final LeafrefTypeDefinition leafref3 = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(revision)
- .build();
+ final LeafrefTypeDefinition leafref = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision).build();
+ final LeafrefTypeDefinition leafref2 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision2).build();
+ final LeafrefTypeDefinition leafref3 = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(revision).build();
final LeafrefTypeDefinition leafref4 = leafref;
assertNotNull("Object 'leafref' shouldn't be null.", leafref);
assertNull("Base type of 'leafref' should be null.", leafref.getBaseType());
assertEquals(Optional.empty(), leafref.getUnits());
assertEquals(Optional.empty(), leafref.getDefaultValue());
- assertEquals(QName.create("test", "List1"), leafref.getQName());
- assertEquals("SchemaPath of 'leafref' is '/Cont1/List1'.", schemaPath, leafref.getPath());
+ assertEquals(qname, leafref.getQName());
assertFalse(leafref.getDescription().isPresent());
assertFalse(leafref.getReference().isPresent());
assertEquals("Status of 'leafref' is current.", Status.CURRENT, leafref.getStatus());
@Test
public void testRequireInstanceSubstatement() {
- final SchemaPath schemaPath = SchemaPath.create(true, QName.create("test", "my-cont"),
- QName.create("test", "my-leafref"));
+ final QName qname = QName.create("test", "my-leafref");
final PathExpression path = new PathExpressionImpl("../my-leaf", false);
- final LeafrefTypeBuilder leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(schemaPath).setPathStatement(path);
+ final LeafrefTypeBuilder leafrefTypeBuilder = BaseTypes.leafrefTypeBuilder(qname).setPathStatement(path);
assertTrue(leafrefTypeBuilder.build().requireInstance());
assertTrue(trueLeafref.requireInstance());
final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> falseBuilder =
- RestrictedTypes.newLeafrefBuilder(falseLeafref, schemaPath);
+ RestrictedTypes.newLeafrefBuilder(falseLeafref, qname);
assertFalse(falseBuilder.build().requireInstance());
final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> trueBuilder =
- RestrictedTypes.newLeafrefBuilder(trueLeafref, schemaPath);
+ RestrictedTypes.newLeafrefBuilder(trueLeafref, qname);
assertTrue(trueBuilder.build().requireInstance());
}
}
import java.util.Collections;
import java.util.List;
import java.util.Optional;
-import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
@Mock
public SchemaNode schemaNode;
- @Before
- public void before() {
+ @Test
+ @Ignore
+ // FIXME: YANGTOOLS-1127: rewrite this test in terms of a real PathExpression
+ public void testFindDummyData() {
doReturn(Optional.empty()).when(mockSchemaContext).findModule(any(QNameModule.class));
doReturn(Optional.empty()).when(mockSchemaContext).findDataTreeChild(any(Iterable.class));
doReturn("test").when(mockModule).getName();
doReturn("test").when(mockModule).getPrefix();
doReturn(QNameModule.create(NAMESPACE)).when(mockModule).getQNameModule();
- }
-
- @Test
- public void testFindDummyData() {
QName qname = QName.create("namespace", "localname");
SchemaPath schemaPath = SchemaPath.create(Collections.singletonList(qname), true);
import org.opendaylight.yangtools.yang.model.api.ConstraintMetaDefinition;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.PathExpression;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
public class TypeTest {
private static final QName Q_NAME = QName.create("test.namespace", "2016-01-01", "test-name");
- private static final SchemaPath SCHEMA_PATH = SchemaPath.create(true, Q_NAME);
private static final PathExpression REVISION_AWARE_XPATH = new PathExpressionImpl("/test", true);
private static final Bit BIT_A = BitBuilder.create(Q_NAME.getLocalName(), Uint32.valueOf(55L))
.setDescription("description")
assertEquals(baseBinaryType1.getLengthConstraint(), baseBinaryType2.getLengthConstraint());
final DerivedBinaryType derivedBinaryType1 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType1,
- SCHEMA_PATH).build();
+ Q_NAME).build();
final DerivedBinaryType derivedBinaryType2 = (DerivedBinaryType)DerivedTypes.derivedTypeBuilder(baseBinaryType2,
- SCHEMA_PATH).build();
+ Q_NAME).build();
hashCodeEqualsToStringTest(derivedBinaryType1, derivedBinaryType2);
final RestrictedBinaryType restrictedBinaryType1 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
- baseBinaryType1, SCHEMA_PATH).buildType();
+ baseBinaryType1, Q_NAME).buildType();
final RestrictedBinaryType restrictedBinaryType2 = (RestrictedBinaryType)RestrictedTypes.newBinaryBuilder(
- baseBinaryType2, SCHEMA_PATH).buildType();
+ baseBinaryType2, Q_NAME).buildType();
hashCodeEqualsToStringTest(restrictedBinaryType1, restrictedBinaryType2);
final LengthRestrictedTypeBuilder<BinaryTypeDefinition> lengthRestrictedTypeBuilder = RestrictedTypes
- .newBinaryBuilder(baseBinaryType1, SCHEMA_PATH);
+ .newBinaryBuilder(baseBinaryType1, Q_NAME);
final BaseBinaryType baseBinaryType = (BaseBinaryType)lengthRestrictedTypeBuilder.build();
assertEquals(baseBinaryType, baseBinaryType1);
concreteBuilderTest(baseBinaryType1, derivedBinaryType1);
hashCodeEqualsToStringTest(baseBooleanType1, baseBooleanType2);
final DerivedBooleanType derivedBooleanType1 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
- baseBooleanType1, SCHEMA_PATH).build();
+ baseBooleanType1, Q_NAME).build();
final DerivedBooleanType derivedBooleanType2 = (DerivedBooleanType)DerivedTypes.derivedTypeBuilder(
- baseBooleanType1, SCHEMA_PATH).build();
+ baseBooleanType1, Q_NAME).build();
hashCodeEqualsToStringTest(derivedBooleanType1, derivedBooleanType2);
- restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, SCHEMA_PATH), RestrictedTypes
- .newBooleanBuilder(baseBooleanType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newBooleanBuilder(baseBooleanType1, Q_NAME), RestrictedTypes
+ .newBooleanBuilder(baseBooleanType2, Q_NAME));
concreteBuilderTest(baseBooleanType1, derivedBooleanType1);
}
@Test
public void identityrefTypeTest() {
- final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(SCHEMA_PATH);
+ final IdentityrefTypeBuilder identityrefTypeBuilder1 = BaseTypes.identityrefTypeBuilder(Q_NAME);
final IdentitySchemaNode identitySchemaNode = mock(IdentitySchemaNode.class);
doReturn("identitySchemaNode").when(identitySchemaNode).toString();
identityrefTypeBuilder1.addIdentity(identitySchemaNode);
final IdentityrefTypeDefinition identityrefTypeDefinition1 = identityrefTypeBuilder1.build();
- final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(SCHEMA_PATH);
+ final IdentityrefTypeBuilder identityrefTypeBuilder2 = BaseTypes.identityrefTypeBuilder(Q_NAME);
identityrefTypeBuilder2.addIdentity(identitySchemaNode);
final IdentityrefTypeDefinition identityrefTypeDefinition2 = identityrefTypeBuilder2.build();
hashCodeEqualsToStringTest(identityrefTypeDefinition1, identityrefTypeDefinition2);
final DerivedIdentityrefType derivedIdentityrefType1 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
- identityrefTypeDefinition1, SCHEMA_PATH).build();
+ identityrefTypeDefinition1, Q_NAME).build();
final DerivedIdentityrefType derivedIdentityrefType2 = (DerivedIdentityrefType)DerivedTypes.derivedTypeBuilder(
- identityrefTypeDefinition2, SCHEMA_PATH).build();
+ identityrefTypeDefinition2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedIdentityrefType1, derivedIdentityrefType2);
concreteBuilderTest(identityrefTypeDefinition1, derivedIdentityrefType1);
- restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, SCHEMA_PATH),
- RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType1, Q_NAME),
+ RestrictedTypes.newIdentityrefBuilder(derivedIdentityrefType2, Q_NAME));
}
@Test
public void decimalTypeTest() {
- final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
+ final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
.setFractionDigits(1)
.buildType();
- final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
+ final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
.setFractionDigits(1)
.buildType();
hashCodeEqualsToStringTest(baseDecimalType1, baseDecimalType2);
assertEquals(baseDecimalType1.getFractionDigits(), baseDecimalType2.getFractionDigits());
final DerivedDecimalType derivedDecimalType1 = (DerivedDecimalType)DerivedTypes
- .derivedTypeBuilder(baseDecimalType1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
final DerivedDecimalType derivedDecimalType2 = (DerivedDecimalType)DerivedTypes
- .derivedTypeBuilder(baseDecimalType1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseDecimalType1, Q_NAME).build();
hashCodeEqualsToStringTest(derivedDecimalType1, derivedDecimalType2);
final RestrictedDecimalType restrictedDecimalType1 = (RestrictedDecimalType)
- RestrictedTypes.newDecima64Builder(baseDecimalType1, SCHEMA_PATH).buildType();
+ RestrictedTypes.newDecima64Builder(baseDecimalType1, Q_NAME).buildType();
final RestrictedDecimalType restrictedDecimalType2 = (RestrictedDecimalType)
- RestrictedTypes.newDecima64Builder(baseDecimalType2, SCHEMA_PATH).buildType();
+ RestrictedTypes.newDecima64Builder(baseDecimalType2, Q_NAME).buildType();
hashCodeEqualsToStringTest(restrictedDecimalType1, restrictedDecimalType2);
concreteBuilderTest(baseDecimalType1, derivedDecimalType1);
}
hashCodeEqualsToStringTest(baseEmptyType1, baseEmptyType2);
final DerivedEmptyType derivedEmptyType1 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
- baseEmptyType1, SCHEMA_PATH).build();
+ baseEmptyType1, Q_NAME).build();
final DerivedEmptyType derivedEmptyType2 = (DerivedEmptyType)DerivedTypes.derivedTypeBuilder(
- baseEmptyType2, SCHEMA_PATH).build();
+ baseEmptyType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedEmptyType1, derivedEmptyType2);
- restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, SCHEMA_PATH),
- RestrictedTypes.newEmptyBuilder(baseEmptyType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newEmptyBuilder(baseEmptyType1, Q_NAME),
+ RestrictedTypes.newEmptyBuilder(baseEmptyType2, Q_NAME));
concreteBuilderTest(baseEmptyType1, derivedEmptyType1);
}
assertFalse(baseInstanceIdentifierType1.requireInstance());
final DerivedInstanceIdentifierType derivedInstanceIdentifierType1 = (DerivedInstanceIdentifierType)
- DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, SCHEMA_PATH).build();
+ DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType1, Q_NAME).build();
final DerivedInstanceIdentifierType derivedInstanceIdentifierType2 = (DerivedInstanceIdentifierType)
- DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, SCHEMA_PATH).build();
+ DerivedTypes.derivedTypeBuilder(baseInstanceIdentifierType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedInstanceIdentifierType1, derivedInstanceIdentifierType2);
final InstanceIdentifierTypeBuilder instanceIdentifierBuilder1 = RestrictedTypes
- .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, SCHEMA_PATH);
+ .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
instanceIdentifierBuilder1.setRequireInstance(true);
final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition1 = instanceIdentifierBuilder1
.buildType();
final InstanceIdentifierTypeBuilder instanceIdentifierBuilder2 = RestrictedTypes
- .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, SCHEMA_PATH);
+ .newInstanceIdentifierBuilder(baseInstanceIdentifierType1, Q_NAME);
instanceIdentifierBuilder2.setRequireInstance(true);
final InstanceIdentifierTypeDefinition instanceIdentifierTypeDefinition2 = instanceIdentifierBuilder2
.buildType();
testInstance(BaseInt64Type.INSTANCE, integerTypeDefinition64);
final RestrictedInt8Type restrictedIntegerType1 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
- integerTypeDefinition8, SCHEMA_PATH).buildType();
+ integerTypeDefinition8, Q_NAME).buildType();
final RestrictedInt8Type restrictedIntegerType2 = (RestrictedInt8Type)RestrictedTypes.newInt8Builder(
- BaseInt8Type.INSTANCE, SCHEMA_PATH).buildType();
+ BaseInt8Type.INSTANCE, Q_NAME).buildType();
hashCodeEqualsToStringTest(restrictedIntegerType1, restrictedIntegerType2);
final Uint8TypeDefinition integerTypeDefinitionu8 = BaseTypes.uint8Type();
testInstance(BaseUint64Type.INSTANCE, BaseTypes.baseTypeOf(integerTypeDefinitionu64));
final DerivedInt8Type derivedIntegerType1 = (DerivedInt8Type)DerivedTypes
- .derivedTypeBuilder(integerTypeDefinition8, SCHEMA_PATH).build();
+ .derivedTypeBuilder(integerTypeDefinition8, Q_NAME).build();
final DerivedInt8Type derivedIntegerType2 = (DerivedInt8Type)DerivedTypes
- .derivedTypeBuilder(BaseInt8Type.INSTANCE, SCHEMA_PATH).build();
+ .derivedTypeBuilder(BaseInt8Type.INSTANCE, Q_NAME).build();
hashCodeEqualsToStringTest(derivedIntegerType1, derivedIntegerType2);
final DerivedUint8Type derivedUnsignedType1 = (DerivedUint8Type)DerivedTypes
- .derivedTypeBuilder(integerTypeDefinitionu8, SCHEMA_PATH).build();
+ .derivedTypeBuilder(integerTypeDefinitionu8, Q_NAME).build();
final DerivedUint8Type derivedUnsignedType2 = (DerivedUint8Type)DerivedTypes
- .derivedTypeBuilder(BaseUint8Type.INSTANCE, SCHEMA_PATH).build();
+ .derivedTypeBuilder(BaseUint8Type.INSTANCE, Q_NAME).build();
hashCodeEqualsToStringTest(derivedUnsignedType1, derivedUnsignedType2);
final RestrictedUint8Type restrictedUnsignedType1 = (RestrictedUint8Type)RestrictedTypes
- .newUint8Builder(integerTypeDefinitionu8, SCHEMA_PATH).buildType();
+ .newUint8Builder(integerTypeDefinitionu8, Q_NAME).buildType();
final RestrictedUint8Type restrictedUnsignedType2 = (RestrictedUint8Type)RestrictedTypes
- .newUint8Builder(BaseUint8Type.INSTANCE, SCHEMA_PATH).buildType();
+ .newUint8Builder(BaseUint8Type.INSTANCE, Q_NAME).buildType();
hashCodeEqualsToStringTest(restrictedUnsignedType1, restrictedUnsignedType2);
concreteBuilderTest(integerTypeDefinition8, derivedIntegerType1);
concreteBuilderTest(integerTypeDefinitionu8, derivedUnsignedType2);
final DerivedTypeBuilder<?> derivedTypeBuilder = DerivedTypes.derivedTypeBuilder(integerTypeDefinition8,
- SCHEMA_PATH);
+ Q_NAME);
derivedTypeBuilder.setDefaultValue(1);
derivedTypeBuilder.setDescription("test-description");
derivedTypeBuilder.setReference("test-reference");
assertEquals(baseStringType1.getPatternConstraints(), baseStringType2.getPatternConstraints());
final DerivedStringType derivedStringType1 = (DerivedStringType)
- DerivedTypes.derivedTypeBuilder(baseStringType1, SCHEMA_PATH).build();
+ DerivedTypes.derivedTypeBuilder(baseStringType1, Q_NAME).build();
final DerivedStringType derivedStringType2 = (DerivedStringType)
- DerivedTypes.derivedTypeBuilder(baseStringType2, SCHEMA_PATH).build();
+ DerivedTypes.derivedTypeBuilder(baseStringType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedStringType1, derivedStringType2);
final RestrictedStringType restrictedStringType1 = (RestrictedStringType)RestrictedTypes
- .newStringBuilder(baseStringType1, SCHEMA_PATH).buildType();
+ .newStringBuilder(baseStringType1, Q_NAME).buildType();
final RestrictedStringType restrictedStringType2 = (RestrictedStringType)RestrictedTypes
- .newStringBuilder(baseStringType2, SCHEMA_PATH).buildType();
+ .newStringBuilder(baseStringType2, Q_NAME).buildType();
hashCodeEqualsToStringTest(restrictedStringType1, restrictedStringType2);
concreteBuilderTest(baseStringType1, derivedStringType1);
- final StringTypeBuilder stringTypeBuilder = new StringTypeBuilder(baseStringType1, SCHEMA_PATH);
+ final StringTypeBuilder stringTypeBuilder = new StringTypeBuilder(baseStringType1, Q_NAME);
final PatternConstraint patternConstraint = BaseConstraints.newPatternConstraint("pattern", ABSENT, ABSENT);
stringTypeBuilder.addPatternConstraint(patternConstraint);
final StringTypeDefinition stringTypeDefinition = stringTypeBuilder.buildType();
@Test
public void bitsTypeTest() {
- final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(SCHEMA_PATH);
+ final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME);
bitsTypeBuilder.addBit(BIT_A);
final BitsTypeDefinition bitsTypeDefinition1 = bitsTypeBuilder.build();
final BitsTypeDefinition bitsTypeDefinition2 = bitsTypeBuilder.build();
assertEquals(bitsTypeDefinition1.getBits(), bitsTypeDefinition1.getBits());
final DerivedBitsType derivedBitsType1 = (DerivedBitsType)DerivedTypes
- .derivedTypeBuilder(bitsTypeDefinition1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(bitsTypeDefinition1, Q_NAME).build();
final DerivedBitsType derivedBitsType2 = (DerivedBitsType)DerivedTypes
- .derivedTypeBuilder(bitsTypeDefinition2, SCHEMA_PATH).build();
+ .derivedTypeBuilder(bitsTypeDefinition2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedBitsType1, derivedBitsType2);
- restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, SCHEMA_PATH),
- RestrictedTypes.newBitsBuilder(bitsTypeDefinition2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newBitsBuilder(bitsTypeDefinition1, Q_NAME),
+ RestrictedTypes.newBitsBuilder(bitsTypeDefinition2, Q_NAME));
concreteBuilderTest(bitsTypeDefinition1, derivedBitsType1);
}
@Test
public void enumerationTypeTest() {
- final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(
- SCHEMA_PATH).build();
- final BaseEnumerationType baseEnumerationType2 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(
- SCHEMA_PATH).build();
+ final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
+ .build();
+ final BaseEnumerationType baseEnumerationType2 = (BaseEnumerationType)BaseTypes.enumerationTypeBuilder(Q_NAME)
+ .build();
hashCodeEqualsToStringTest(baseEnumerationType1, baseEnumerationType2);
assertEquals(baseEnumerationType1.getValues(), baseEnumerationType2.getValues());
final DerivedEnumerationType derivedEnumerationType1 = (DerivedEnumerationType)DerivedTypes
- .derivedTypeBuilder(baseEnumerationType1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseEnumerationType1, Q_NAME).build();
final DerivedEnumerationType derivedEnumerationType2 = (DerivedEnumerationType)DerivedTypes
- .derivedTypeBuilder(baseEnumerationType2, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseEnumerationType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedEnumerationType1, derivedEnumerationType2);
- restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, SCHEMA_PATH),
- RestrictedTypes.newEnumerationBuilder(baseEnumerationType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newEnumerationBuilder(baseEnumerationType1, Q_NAME),
+ RestrictedTypes.newEnumerationBuilder(baseEnumerationType2, Q_NAME));
concreteBuilderTest(baseEnumerationType1, derivedEnumerationType1);
}
@Test
public void leafrefTypeTest() {
- final LeafrefTypeBuilder leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(SCHEMA_PATH);
- final LeafrefTypeBuilder leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(SCHEMA_PATH);
+ final LeafrefTypeBuilder leafrefTypeBuilder1 = BaseTypes.leafrefTypeBuilder(Q_NAME);
+ final LeafrefTypeBuilder leafrefTypeBuilder2 = BaseTypes.leafrefTypeBuilder(Q_NAME);
leafrefTypeBuilder1.setPathStatement(REVISION_AWARE_XPATH);
leafrefTypeBuilder2.setPathStatement(REVISION_AWARE_XPATH);
final BaseLeafrefType baseLeafrefType1 = (BaseLeafrefType)leafrefTypeBuilder1.build();
assertEquals(baseLeafrefType1.getPathStatement(), REVISION_AWARE_XPATH);
final DerivedLeafrefType derivedLeafrefType1 = (DerivedLeafrefType)DerivedTypes
- .derivedTypeBuilder(baseLeafrefType1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseLeafrefType1, Q_NAME).build();
final DerivedLeafrefType derivedLeafrefType2 = (DerivedLeafrefType)DerivedTypes
- .derivedTypeBuilder(baseLeafrefType2, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseLeafrefType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedLeafrefType1, derivedLeafrefType2);
- restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, SCHEMA_PATH),
- RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newLeafrefBuilder(baseLeafrefType1, Q_NAME),
+ RestrictedTypes.newLeafrefBuilder(baseLeafrefType2, Q_NAME));
concreteBuilderTest(baseLeafrefType1, derivedLeafrefType1);
}
@Test
public void unionTypeTest() throws IllegalAccessException, InstantiationException {
- final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
+ final BaseDecimalType baseDecimalType1 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
.setFractionDigits(1)
.buildType();
- final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(SCHEMA_PATH)
+ final BaseDecimalType baseDecimalType2 = (BaseDecimalType)BaseTypes.decimalTypeBuilder(Q_NAME)
.setFractionDigits(1)
.buildType();
- final UnionTypeBuilder unionTypeBuilder1 = BaseTypes.unionTypeBuilder(SCHEMA_PATH);
- final UnionTypeBuilder unionTypeBuilder2 = BaseTypes.unionTypeBuilder(SCHEMA_PATH);
+ final UnionTypeBuilder unionTypeBuilder1 = BaseTypes.unionTypeBuilder(Q_NAME);
+ final UnionTypeBuilder unionTypeBuilder2 = BaseTypes.unionTypeBuilder(Q_NAME);
unionTypeBuilder1.addType(baseDecimalType1);
unionTypeBuilder2.addType(baseDecimalType2);
final BaseUnionType baseUnionType1 = (BaseUnionType)unionTypeBuilder1.build();
assertEquals(baseUnionType1.getTypes(), baseUnionType2.getTypes());
final DerivedUnionType derivedUnionType1 = (DerivedUnionType)DerivedTypes
- .derivedTypeBuilder(baseUnionType1, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseUnionType1, Q_NAME).build();
final DerivedUnionType derivedUnionType2 = (DerivedUnionType)DerivedTypes
- .derivedTypeBuilder(baseUnionType2, SCHEMA_PATH).build();
+ .derivedTypeBuilder(baseUnionType2, Q_NAME).build();
hashCodeEqualsToStringTest(derivedUnionType1, derivedUnionType2);
- restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, SCHEMA_PATH),
- RestrictedTypes.newUnionBuilder(baseUnionType2, SCHEMA_PATH));
+ restrictedBuilderTest(RestrictedTypes.newUnionBuilder(baseUnionType1, Q_NAME),
+ RestrictedTypes.newUnionBuilder(baseUnionType2, Q_NAME));
concreteBuilderTest(baseUnionType1, derivedUnionType1);
}
@Test
public void abstractTypeDefinitionQnameTest() {
final AbstractTypeDefinition<?> abstractTypeDefinition = (AbstractTypeDefinition<?>)
- BaseTypes.decimalTypeBuilder(SCHEMA_PATH).setFractionDigits(1).buildType();
+ BaseTypes.decimalTypeBuilder(Q_NAME).setFractionDigits(1).buildType();
assertEquals(abstractTypeDefinition.getQName(), Q_NAME);
}
public void abstractDerivedTypeTest() {
final BaseBinaryType baseBinaryType1 = BaseBinaryType.INSTANCE;
final AbstractDerivedType<?> abstractDerivedType = (AbstractDerivedType<?>)
- DerivedTypes.derivedTypeBuilder(baseBinaryType1, SCHEMA_PATH).build();
+ DerivedTypes.derivedTypeBuilder(baseBinaryType1, Q_NAME).build();
assertEquals(Optional.empty(), abstractDerivedType.getDescription());
assertEquals(Optional.empty(), abstractDerivedType.getReference());
assertEquals(Status.CURRENT, abstractDerivedType.getStatus());
@Test
public void concreteTypeBuilderBuildTest() {
final BaseEnumerationType baseEnumerationType1 = (BaseEnumerationType)
- BaseTypes.enumerationTypeBuilder(SCHEMA_PATH).build();
+ BaseTypes.enumerationTypeBuilder(Q_NAME).build();
final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(
- baseEnumerationType1, SCHEMA_PATH);
+ baseEnumerationType1, Q_NAME);
final TypeDefinition<?> typeDefinition = concreteTypeBuilder.build();
assertNotNull(typeDefinition);
}
public void constraintTypeBuilderTest() throws InvalidLengthConstraintException {
final BaseBinaryType baseBinaryType = (BaseBinaryType)BaseTypes.binaryType();
final LengthRestrictedTypeBuilder<?> lengthRestrictedTypeBuilder = RestrictedTypes
- .newBinaryBuilder(baseBinaryType, SCHEMA_PATH);
- final Long min = Long.valueOf(0);
+ .newBinaryBuilder(baseBinaryType, Q_NAME);
+ final Long min = (long) 0;
final UnresolvedNumber max = UnresolvedNumber.max();
final List<ValueRange> lengthArrayList = ImmutableList.of(ValueRange.of(min, max));
lengthRestrictedTypeBuilder.setLengthConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
final Int8TypeDefinition integerTypeDefinition8 = BaseTypes.int8Type();
final RangeRestrictedTypeBuilder<?, ?> rangeRestrictedTypeBuilder = RestrictedTypes.newInt8Builder(
- integerTypeDefinition8, SCHEMA_PATH);
+ integerTypeDefinition8, Q_NAME);
rangeRestrictedTypeBuilder.setRangeConstraint(mock(ConstraintMetaDefinition.class), lengthArrayList);
final TypeDefinition<?> typeDefinition1 = rangeRestrictedTypeBuilder.buildType();
assertNotNull(typeDefinition1);
@Test
public void identityrefTypeBuilderException() {
- final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(SCHEMA_PATH);
+ final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(Q_NAME);
assertThrows(IllegalStateException.class, () -> builder.build());
}
@Test
public void invalidBitDefinitionExceptionTest() {
- final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(SCHEMA_PATH)
+ final BitsTypeBuilder bitsTypeBuilder = BaseTypes.bitsTypeBuilder(Q_NAME)
.addBit(BIT_A)
.addBit(BitBuilder.create("test-name-1", Uint32.valueOf(55)).build());
.setReference("reference").setUnknownSchemaNodes(unknown).build();
final EnumPair enumPair2 = EnumPairBuilder.create("enum", 1).setDescription("description")
.setReference("reference").setUnknownSchemaNodes(unknown).build();
- final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(SCHEMA_PATH);
+ final EnumerationTypeBuilder enumerationTypeBuilder = BaseTypes.enumerationTypeBuilder(Q_NAME);
enumerationTypeBuilder.addEnum(enumPair1);
enumerationTypeBuilder.addEnum(enumPair2);
private static void concreteBuilderTest(final TypeDefinition<?> baseTypeDef,
final TypeDefinition<?> derivedTypeDef) {
- final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, SCHEMA_PATH);
+ final ConcreteTypeBuilder<?> concreteTypeBuilder = ConcreteTypes.concreteTypeBuilder(baseTypeDef, Q_NAME);
final TypeDefinition<?> typeDefinition = concreteTypeBuilder.buildType();
assertEquals(typeDefinition.getBaseType(), derivedTypeDef.getBaseType());
}
private TypeDefinition<?> buildType() {
final TypeEffectiveStatement<?> typeStmt = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(),
- getPath());
+ getQName());
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
if (stmt instanceof DefaultEffectiveStatement) {
builder.setDefaultValue(((DefaultEffectiveStatement)stmt).argument());
private TypeDefinition<?> buildType() {
final TypeEffectiveStatement<?> typeStmt = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(),
- getPath());
+ getQName());
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
// NOTE: 'default' is ommitted here on purpose
if (stmt instanceof DescriptionEffectiveStatement) {
throw noBase(stmt);
}
- final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(stmt.wrapSchemaPath());
+ final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(stmt.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof BaseEffectiveStatement) {
final QName identityQName = ((BaseEffectiveStatement) subStmt).argument();
throw noPath(stmt);
}
- final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(stmt.wrapSchemaPath());
+ final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(stmt.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof PathEffectiveStatement) {
return createInstanceIdentifier(stmt, (InstanceIdentifierTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof Int8TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Int16TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Int32TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Int64TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof LeafrefTypeDefinition) {
return createLeafref(stmt, (LeafrefTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof StringTypeDefinition) {
return createString(stmt, (StringTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof Uint8TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Uint16TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Uint32TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof Uint64TypeDefinition) {
return createIntegral(stmt, declared, substatements,
- RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
+ RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveQName(stmt)));
} else if (baseType instanceof UnionTypeDefinition) {
return createUnion(stmt, (UnionTypeDefinition) baseType, declared, substatements);
} else {
}
}
- static final SchemaPath typeEffectiveSchemaPath(final Current<?, ?> stmt) {
+ static final QName typeEffectiveQName(final Current<?, ?> stmt) {
+ // FIXME: this ain't right
final SchemaPath path = stmt.wrapSchemaPath();
if (path == null) {
// SchemaPath is forbidden with a system property
final QName parentQName = parent.getLastComponent();
checkArgument(parentQName != null, "Path %s has an empty parent", path);
- final QName qname = path.getLastComponent().bindTo(parentQName.getModule()).intern();
- return parent.createChild(qname);
+ return path.getLastComponent().bindTo(parentQName.getModule()).intern();
}
/**
final BinaryTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final LengthRestrictedTypeBuilder<BinaryTypeDefinition> builder =
- RestrictedTypes.newBinaryBuilder(baseType, typeEffectiveSchemaPath(ctx));
+ RestrictedTypes.newBinaryBuilder(baseType, typeEffectiveQName(ctx));
for (EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof LengthEffectiveStatement) {
private @NonNull TypeEffectiveStatement<TypeStatement> createBits(final Current<?, ?> ctx,
final BitsTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.wrapSchemaPath());
+ final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof BitEffectiveStatement) {
final BooleanTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newBooleanBuilder(baseType,
- typeEffectiveSchemaPath(ctx)));
+ typeEffectiveQName(ctx)));
}
private static @NonNull TypeEffectiveStatement<TypeStatement> createDecimal(final Current<?, ?> ctx,
final DecimalTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> builder =
- RestrictedTypes.newDecima64Builder(baseType, typeEffectiveSchemaPath(ctx));
+ RestrictedTypes.newDecima64Builder(baseType, typeEffectiveQName(ctx));
for (EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof RangeEffectiveStatement) {
final EmptyTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newEmptyBuilder(baseType,
- typeEffectiveSchemaPath(ctx)));
+ typeEffectiveQName(ctx)));
}
private @NonNull TypeEffectiveStatement<TypeStatement> createEnum(final Current<?, ?> ctx,
final EnumTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.wrapSchemaPath());
+ final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType,
+ ctx.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof EnumEffectiveStatement) {
final IdentityrefTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType,
- typeEffectiveSchemaPath(ctx)));
+ typeEffectiveQName(ctx)));
}
private static @NonNull TypeEffectiveStatement<TypeStatement> createInstanceIdentifier(
final Current<?, ?> ctx, final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType,
- typeEffectiveSchemaPath(ctx));
+ typeEffectiveQName(ctx));
for (EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof RequireInstanceEffectiveStatement) {
final LeafrefTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> builder =
- RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx));
+ RestrictedTypes.newLeafrefBuilder(baseType, AbstractTypeStatementSupport.typeEffectiveQName(ctx));
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof RequireInstanceEffectiveStatement) {
final StringTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final StringTypeBuilder builder = RestrictedTypes.newStringBuilder(baseType,
- AbstractTypeStatementSupport.typeEffectiveSchemaPath(ctx));
+ AbstractTypeStatementSupport.typeEffectiveQName(ctx));
for (EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof LengthEffectiveStatement) {
final UnionTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newUnionBuilder(baseType,
- typeEffectiveSchemaPath(ctx)));
+ typeEffectiveQName(ctx)));
}
}
\ No newline at end of file
throw noBits(stmt);
}
- final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.wrapSchemaPath());
+ final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.argumentAsTypeQName());
Uint32 highestPosition = null;
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof BitEffectiveStatement) {
throw noFracDigits(stmt);
}
- final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(stmt.wrapSchemaPath());
+ final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(stmt.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof FractionDigitsEffectiveStatement) {
builder.setFractionDigits(((FractionDigitsEffectiveStatement) subStmt).argument());
throw noEnum(stmt);
}
- final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(stmt.wrapSchemaPath());
+ final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(stmt.argumentAsTypeQName());
Integer highestValue = null;
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof EnumEffectiveStatement) {
final Current<String, InstanceIdentifierSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(
- BaseTypes.instanceIdentifierType(), stmt.wrapSchemaPath());
+ BaseTypes.instanceIdentifierType(), stmt.argumentAsTypeQName());
// TODO: we could do better here for empty substatements, but its really splitting hairs
for (EffectiveStatement<?, ?> subStmt : substatements) {
throw noType(stmt);
}
- final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(stmt.wrapSchemaPath());
+ final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(stmt.argumentAsTypeQName());
for (final EffectiveStatement<?, ?> subStmt : substatements) {
if (subStmt instanceof TypeEffectiveStatement) {
private @NonNull TypeDefinition<?> loadTypeDefinition() {
final TypeEffectiveStatement<?> type = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
- final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), path);
+ final DerivedTypeBuilder<?> builder = DerivedTypes.derivedTypeBuilder(type.getTypeDefinition(), getQName());
for (final EffectiveStatement<?, ?> stmt : effectiveSubstatements()) {
if (stmt instanceof DefaultEffectiveStatement) {
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
assertEquals(expectedSchemaPath, ds0ChannelNumber.getPath());
assertFalse(ds0ChannelNumber.isAugmenting());
// type of leaf ds0ChannelNumber
- final List<QName> typePath = Collections.singletonList(BaseTypes.STRING_QNAME);
- expectedSchemaPath = SchemaPath.create(typePath, true);
- assertEquals(expectedSchemaPath, ds0ChannelNumber.getType().getPath());
+ assertEquals(BaseTypes.STRING_QNAME, ds0ChannelNumber.getType().getQName());
// leaf interface-id
qname = QName.create(FOO, "interface-id");
import org.opendaylight.yangtools.yang.model.api.Deviation;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
public class Bug7440Test {
-
@Test
public void testRestrictedTypeParentSchemaPathInDeviate() throws Exception {
final SchemaContext schemaContext = StmtTestUtils.parseYangSources("/bugs/bug7440");
assertEquals(1, deviates.size());
final DeviateDefinition deviateReplace = deviates.iterator().next();
- final SchemaPath deviatedTypePath = SchemaPath.create(true, QName.create(bar.getQNameModule(), "test-leaf"),
- QName.create(bar.getQNameModule(), "uint32"));
-
final TypeDefinition<?> deviatedType = deviateReplace.getDeviatedType();
- assertEquals(deviatedTypePath, deviatedType.getPath());
+ assertEquals(QName.create(bar.getQNameModule(), "uint32"), deviatedType.getQName());
}
}
assertEquals("binary", binaryEff.getQName().getLocalName());
assertFalse(binaryEff.getLengthConstraint().isPresent());
assertEquals(Status.CURRENT, binaryEff.getStatus());
- assertEquals("binary", binaryEff.getPath().getPathFromRoot().iterator().next().getLocalName());
assertNotNull(binaryEff.getUnknownSchemaNodes());
assertFalse(binaryEff.getDescription().isPresent());
assertFalse(binaryEff.getReference().isPresent());
assertNull(bitsEff.getBaseType());
assertNotNull(bitsEff.getQName());
assertEquals("bits", bitsEff.getQName().getLocalName());
- assertEquals("bits", bitsEff.getPath().getLastComponent().getLocalName());
assertNotNull(bitsEff.getUnknownSchemaNodes());
assertFalse(bitsEff.getDescription().isPresent());
assertFalse(bitsEff.getReference().isPresent());
assertEquals(Optional.empty(), booleanEff.getUnits());
assertEquals(Optional.empty(), booleanEff.getDefaultValue());
assertEquals("boolean", booleanEff.getQName().getLocalName());
- assertNull(booleanEff.getPath().getParent().getParent());
assertNotNull(booleanEff.getUnknownSchemaNodes());
assertFalse(booleanEff.getDescription().isPresent());
assertFalse(booleanEff.getReference().isPresent());
assertFalse(decimal64Eff.equals(null));
assertFalse(decimal64Eff.equals("test"));
assertTrue(decimal64Eff.equals(decimal64Eff));
- assertEquals("decimal64", decimal64Eff.getPath().getLastComponent().getLocalName());
}
@Test
assertEquals(Optional.empty(), emptyEff.getDefaultValue());
assertNull(emptyEff.getBaseType());
assertEquals("empty", emptyEff.getQName().getLocalName());
- assertNull(emptyEff.getPath().getParent().getParent());
assertNotNull(emptyEff.getUnknownSchemaNodes());
- assertFalse(emptyEff.getDescription().isPresent());
- assertFalse(emptyEff.getReference().isPresent());
+ assertEquals(Optional.empty(), emptyEff.getDescription());
+ assertEquals(Optional.empty(), emptyEff.getReference());
assertEquals("CURRENT", emptyEff.getStatus().toString());
assertNotNull(emptyEff.toString());
}
.getTypeDefinition();
assertEquals("enumeration", enumSpecEff.getQName().getLocalName());
- assertEquals("enumeration", enumSpecEff.getPath().getLastComponent().getLocalName());
assertEquals(Optional.empty(), enumSpecEff.getDefaultValue());
assertEquals(3, enumSpecEff.getValues().size());
assertNull(enumSpecEff.getBaseType());
assertEquals(Optional.empty(), identityRefEff.getDefaultValue());
assertEquals("identityref", identityRefEff.getQName().getLocalName());
- assertEquals("identityref", identityRefEff.getPath().getLastComponent().getLocalName());
assertNull(identityRefEff.getBaseType());
assertNotNull(identityRefEff.getUnknownSchemaNodes());
assertEquals(Status.CURRENT, identityRefEff.getStatus());
assertFalse(instanceIdentEff.requireInstance());
assertEquals("instance-identifier", instanceIdentEff.getQName().getLocalName());
- assertEquals("instance-identifier", instanceIdentEff.getPath().getLastComponent().getLocalName());
assertNull(instanceIdentEff.getBaseType());
assertEquals(Optional.empty(), instanceIdentEff.getDefaultValue());
assertNotNull(instanceIdentEff.getUnknownSchemaNodes());
assertEquals("leafref", leafrefEff.getQName().getLocalName());
assertEquals(Status.CURRENT, leafrefEff.getStatus());
assertNotNull(leafrefEff.getUnknownSchemaNodes());
- assertEquals("leafref", leafrefEff.getPath().getLastComponent().getLocalName());
assertFalse(leafrefEff.getDescription().isPresent());
assertFalse(leafrefEff.getReference().isPresent());
assertNotNull(leafrefEff.hashCode());
assertEquals("leafref", leafrefEff.getQName().getLocalName());
assertEquals(Status.CURRENT, leafrefEff.getStatus());
assertNotNull(leafrefEff.getUnknownSchemaNodes());
- assertEquals("leafref", leafrefEff.getPath().getLastComponent().getLocalName());
assertFalse(leafrefEff.getDescription().isPresent());
assertFalse(leafrefEff.getReference().isPresent());
assertNotNull(leafrefEff.hashCode());
assertFalse(unionEff.equals(null));
assertFalse(unionEff.equals("test"));
assertTrue(unionEff.equals(unionEff));
- assertEquals("union", unionEff.getPath().getLastComponent().getLocalName());
}
@Test
assertFalse(stringEff.equals(null));
assertFalse(stringEff.equals("test"));
assertTrue(stringEff.equals(stringEff));
- assertEquals("string", stringEff.getPath().getLastComponent().getLocalName());
assertFalse(stringEff.getLengthConstraint().isPresent());
assertNotNull(stringEff.getPatternConstraints());
}
assertEquals(expectedPath, version.getPath());
expectedQName = QName.create(UG, "version");
path.offer(expectedQName);
- expectedPath = SchemaPath.create(true, pcreq.getQName(), expectedQName);
- assertEquals(expectedPath, version.getType().getPath());
+ assertEquals(expectedQName, version.getType().getQName());
assertEquals(BaseTypes.uint8Type(), version.getType().getBaseType().getBaseType());
assertTrue(version.isAddedByUses());
// * |-- leaf type
assertEquals(expectedPath, type.getPath());
expectedQName = QName.create(GD, "int-ext");
path.offer(expectedQName);
- expectedPath = SchemaPath.create(true, expectedQName);
- assertEquals(expectedPath, type.getType().getPath());
+ assertEquals(expectedQName, type.getType().getQName());
final UnionTypeDefinition union = (UnionTypeDefinition) type.getType().getBaseType();
- assertEquals(SchemaPath.create(true, expectedQName, QName.create(expectedQName, "union")), union.getPath());
+ assertEquals(QName.create(expectedQName, "union"), union.getQName());
assertEquals(2, union.getTypes().size());
// * |-- list requests
final ListSchemaNode requests = (ListSchemaNode) pcreq.getDataChildByName(QName.create(
}
assertNotNull(intExt);
- SchemaPath expectedPath = SchemaPath.create(true, QName.create(GD, "int-ext"));
- assertEquals(expectedPath, intExt.getPath());
+ assertEquals(QName.create(GD, "int-ext"), intExt.getQName());
final UnionTypeDefinition union = (UnionTypeDefinition) intExt.getBaseType();
}
assertNotNull(uint8);
assertNotNull(pv);
-
- expectedPath = SchemaPath.create(true, QName.create(GD, "int-ext"), QName.create(GD, "union"));
- assertEquals(expectedPath, union.getPath());
+ assertEquals(QName.create(GD, "union"), union.getQName());
}
}
final TypeDefinition<?> nodesType = typedefs.iterator().next();
final QName typedefQName = QName.create(SN, "nodes-type");
assertEquals(typedefQName, nodesType.getQName());
- assertEquals(SN_NODES_PATH.createChild(QName.create(SN, "nodes-type")), nodesType.getPath());
assertFalse(nodesType.getDescription().isPresent());
assertFalse(nodesType.getReference().isPresent());
assertEquals(Status.CURRENT, nodesType.getStatus());
final LeafListSchemaNode added = (LeafListSchemaNode)nodes.getDataChildByName(QName.create(
testModule.getQNameModule(), "added"));
assertEquals(createPath("nodes", "added"), added.getPath());
- assertEquals(createPath("mytype"), added.getType().getPath());
+ assertEquals(createPath("mytype").getLastComponent(), added.getType().getQName());
final ListSchemaNode links = (ListSchemaNode) nodes.getDataChildByName(QName.create(
testModule.getQNameModule(), "links"));
final Collection<? extends GroupingDefinition> groupings = nodes.getGroupings();
assertEquals(1, groupings.size());
final GroupingDefinition nodeGroup = groupings.iterator().next();
- final QName groupQName = QName.create(SN, "node-group");
- assertEquals(groupQName, nodeGroup.getQName());
- final SchemaPath nodeGroupPath = SN_NODES_PATH.createChild(groupQName);
- assertEquals(nodeGroupPath, nodeGroup.getPath());
+ assertEquals(QName.create(SN, "node-group"), nodeGroup.getQName());
final Collection<? extends UsesNode> uses = nodes.getUses();
assertEquals(1, uses.size());
// int32-ext1
final Int32TypeDefinition int32ext1 = (Int32TypeDefinition) TestUtils.findTypedef(types, "int32-ext1");
- final QName int32TypedefQName = QName.create(BAR, "int32-ext1");
- assertEquals(int32TypedefQName, int32ext1.getQName());
-
- final SchemaPath typeSchemaPath = int32ext1.getPath();
- final Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
- final Iterator<QName> typePathIt = typePath.iterator();
- assertEquals(int32TypedefQName, typePathIt.next());
- assertFalse(typePathIt.hasNext());
+ assertEquals(QName.create(BAR, "int32-ext1"), int32ext1.getQName());
// int32-ext1/int32
- final Int32TypeDefinition int32 = int32ext1.getBaseType();
- assertEquals(BaseTypes.int32Type(), int32);
+ assertEquals(BaseTypes.int32Type(), int32ext1.getBaseType());
}
@Test
assertEquals(BAR, myDecTypeQName.getModule());
assertEquals("my-decimal-type", myDecTypeQName.getLocalName());
- final SchemaPath typeSchemaPath = myDecType.getPath();
- final Iterable<QName> typePath = typeSchemaPath.getPathFromRoot();
- final Iterator<QName> typePathIt = typePath.iterator();
- assertEquals(myDecTypeQName, typePathIt.next());
- assertFalse(typePathIt.hasNext());
-
// my-base-int32-type/int32
final DecimalTypeDefinition dec64 = myDecType.getBaseType();
final QName dec64QName = dec64.getQName();
assertEquals(BAR, dec64QName.getModule());
assertEquals("decimal64", dec64QName.getLocalName());
-
- final SchemaPath dec64SchemaPath = dec64.getPath();
- final Iterable<QName> dec64Path = dec64SchemaPath.getPathFromRoot();
- final Iterator<QName> dec64PathIt = dec64Path.iterator();
- assertEquals(myDecTypeQName, dec64PathIt.next());
- assertEquals(dec64QName, dec64PathIt.next());
- assertFalse(dec64PathIt.hasNext());
}
private static void checkOrder(final Collection<Module> modules) {
@Nullable EffectiveStatement<?, ?> original();
+ // FIXME: YANGTOOLS-1216: implement near ReactorStmtCtx.createSchemaPath(), this should always be a 'String'
+ // sub-case as implied by all callers in stmt.type
+ // FIXME: 7.0.0: this method should be moved to stmt.type in some shape or form
+ default @NonNull QName argumentAsTypeQName() {
+ return verifyNotNull(getSchemaPath().getLastComponent());
+ }
+
/**
* Summon the <a href="https://en.wikipedia.org/wiki/Rabbit_of_Caerbannog">Rabbit of Caerbannog</a>.
*
Code Review / yangtools.git / commitdiff