Fix up code formatting and activate enforcement.
Change-Id: I92419f38833fea7b68fe13a20619b4d1641f68de
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
</dependency>
</dependencies>
- <!--
- Maven Site Configuration
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-checkstyle-plugin</artifactId>
+ <configuration>
+ <propertyExpansion>checkstyle.violationSeverity=error</propertyExpansion>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
- The following configuration is necessary for maven-site-plugin to
- correctly identify the correct deployment path for OpenDaylight Maven
- sites.
- -->
- <url>${odl.site.url}/${project.groupId}/${stream}/${project.artifactId}/</url>
+ <!--
+ Maven Site Configuration
- <distributionManagement>
- <site>
- <id>opendaylight-site</id>
- <url>${nexus.site.url}/${project.artifactId}/</url>
- </site>
- </distributionManagement>
+ The following configuration is necessary for maven-site-plugin to
+ correctly identify the correct deployment path for OpenDaylight Maven
+ sites.
+ -->
+ <url>${odl.site.url}/${project.groupId}/${stream}/${project.artifactId}/</url>
+
+ <distributionManagement>
+ <site>
+ <id>opendaylight-site</id>
+ <url>${nexus.site.url}/${project.artifactId}/</url>
+ </site>
+ </distributionManagement>
</project>
/**
* Resolve a string prefix into the corresponding module.
*
- * @param prefix
+ * @param prefix Prefix
* @return module mapped to prefix, or null if the module cannot be resolved
*/
protected abstract Module moduleForPrefix(@Nonnull String prefix);
/**
* Resolve a string prefix into the corresponding module.
*
- * @param prefix
+ * @param prefix Prefix
* @return module mapped to prefix, or null if the module cannot be resolved
*/
protected abstract Module moduleForPrefix(@Nonnull String prefix);
* prefix:name tuple. Typical uses are RESTCONF/JSON (module:name) and XML (prefix:name).
*/
@Beta
-public abstract class AbstractStringIdentityrefCodec extends AbstractNamespaceCodec implements IdentityrefCodec<String> {
+public abstract class AbstractStringIdentityrefCodec extends AbstractNamespaceCodec
+ implements IdentityrefCodec<String> {
@Override
public String serialize(final QName data) {
return appendQName(new StringBuilder(), data).toString();
* prefix:name tuple. Typical uses are RESTCONF/JSON (module:name) and XML (prefix:name).
*/
@Beta
-public abstract class AbstractStringInstanceIdentifierCodec extends AbstractNamespaceCodec implements InstanceIdentifierCodec<String> {
+public abstract class AbstractStringInstanceIdentifierCodec extends AbstractNamespaceCodec
+ implements InstanceIdentifierCodec<String> {
@Override
public final String serialize(final YangInstanceIdentifier data) {
}
/**
- *
* Returns DataSchemaContextTree associated with SchemaContext for which
* serialization / deserialization occurs.
*
+ * <p>
* Implementations MUST provide non-null Data Tree context, in order
* for correct serialization / deserialization of PathArguments,
* since XML representation does not have Augmentation arguments
* and does not provide path arguments for cases.
*
+ * <p>
* This effectively means same input XPath representation of Path Argument
* may result in different YangInstanceIdentifiers if models are different
* in uses of choices and cases.
*
* @return DataSchemaContextTree associated with SchemaContext for which
- * serialization / deserialization occurs.
+ * serialization / deserialization occurs.
*/
protected abstract @Nonnull DataSchemaContextTree getDataContextTree();
protected abstract Codec<String, Object> codecFor(final TypeDefinition<?> type);
@Override
+ @SuppressWarnings("checkstyle:illegalCatch")
public final String serialize(final Object data) {
for (final TypeDefinition<?> type : typeDefinition.getTypes()) {
Codec<String, Object> codec = codecFor(type);
}
@Override
+ @SuppressWarnings("checkstyle:illegalCatch")
public Object deserialize(final String stringRepresentation) {
if (stringRepresentation == null) {
return null;
final class AugmentationContextNode extends
DataContainerContextNode<AugmentationIdentifier> {
- public AugmentationContextNode(final AugmentationSchema augmentation, final DataNodeContainer schema) {
+ AugmentationContextNode(final AugmentationSchema augmentation, final DataNodeContainer schema) {
super(augmentationIdentifierFrom(augmentation), augmentationProxy(augmentation, schema), null);
}
return getIdentifier().getPossibleChildNames();
}
-}
\ No newline at end of file
+}
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
/**
- *
- * childs - empty augment - only one element can be
- *
+ * childs - empty augment - only one element can be.
*/
class ChoiceNodeDataWithSchema extends CompositeNodeDataWithSchema {
public class CompositeNodeDataWithSchema extends AbstractNodeDataWithSchema {
/**
- * nodes which were added to schema via augmentation and are present in data input
+ * nodes which were added to schema via augmentation and are present in data input.
*/
- private final Multimap<AugmentationSchema, AbstractNodeDataWithSchema> augmentationsToChild = ArrayListMultimap.create();
+ private final Multimap<AugmentationSchema, AbstractNodeDataWithSchema> augmentationsToChild =
+ ArrayListMultimap.create();
/**
* remaining data nodes (which aren't added via augment). Every of one them should have the same QName.
super(schema);
}
+ private AbstractNodeDataWithSchema addChild(final DataSchemaNode schema) {
+ AbstractNodeDataWithSchema newChild = addSimpleChild(schema);
+ return newChild == null ? addCompositeChild(schema) : newChild;
+ }
+
+ public void addChild(final AbstractNodeDataWithSchema newChild) {
+ children.add(newChild);
+ }
+
public AbstractNodeDataWithSchema addChild(final Deque<DataSchemaNode> schemas) {
Preconditions.checkArgument(!schemas.isEmpty(), "Expecting at least one schema");
CaseNodeDataWithSchema casePrevious = ((ChoiceNodeDataWithSchema) nodeDataWithSchema).getCase();
Preconditions.checkArgument(casePrevious.getSchema().getQName().equals(caseCandidate.getQName()),
- "Data from case %s are specified but other data from case %s were specified earlier. Data aren't from the same case.",
- caseCandidate.getQName(), casePrevious.getSchema().getQName());
+ "Data from case %s are specified but other data from case %s were specified earlier."
+ + " Data aren't from the same case.", caseCandidate.getQName(),
+ casePrevious.getSchema().getQName());
return casePrevious;
}
}
}
- private AbstractNodeDataWithSchema addChild(final DataSchemaNode schema) {
- AbstractNodeDataWithSchema newChild = addSimpleChild(schema);
- return newChild == null ? addCompositeChild(schema) : newChild;
- }
-
- public void addChild(final AbstractNodeDataWithSchema newChild) {
- children.add(newChild);
- }
-
/**
* Return a hint about how may children we are going to generate.
* @return Size of currently-present node list.
for (AbstractNodeDataWithSchema child : children) {
child.write(writer);
}
- for (Entry<AugmentationSchema, Collection<AbstractNodeDataWithSchema>> augmentationToChild : augmentationsToChild.asMap().entrySet()) {
+ for (Entry<AugmentationSchema, Collection<AbstractNodeDataWithSchema>> augmentationToChild
+ : augmentationsToChild.asMap().entrySet()) {
final Collection<AbstractNodeDataWithSchema> childsFromAgumentation = augmentationToChild.getValue();
if (!childsFromAgumentation.isEmpty()) {
// FIXME: can we get the augmentation schema?
* @param child child node
* @return augmentation schema
*/
- private static AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent, final DataSchemaNode child) {
+ private static AugmentationSchema findCorrespondingAugment(final DataSchemaNode parent,
+ final DataSchemaNode child) {
if (parent instanceof AugmentationTarget && !(parent instanceof ChoiceSchemaNode)) {
for (AugmentationSchema augmentation : ((AugmentationTarget) parent).getAvailableAugmentations()) {
DataSchemaNode childInAugmentation = augmentation.getDataChildByName(child.getQName());
return null;
}
- public static YangInstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(final AugmentationSchema schema) {
+ public static YangInstanceIdentifier.AugmentationIdentifier getNodeIdentifierForAugmentation(
+ final AugmentationSchema schema) {
final Collection<QName> qnames = Collections2.transform(schema.getChildNodes(), DataSchemaNode::getQName);
return new YangInstanceIdentifier.AugmentationIdentifier(ImmutableSet.copyOf(qnames));
}
return register(potential);
}
- private DataSchemaContextNode<?> fromLocalSchema(final PathArgument child) {
- if (child instanceof AugmentationIdentifier) {
- return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
- .iterator().next());
- }
- return fromSchemaAndQNameChecked(schema, child.getNodeType());
- }
-
@Override
public DataSchemaContextNode<?> getChild(final QName child) {
DataSchemaContextNode<?> potential = byQName.get(child);
return register(potential);
}
+ private DataSchemaContextNode<?> fromLocalSchema(final PathArgument child) {
+ if (child instanceof AugmentationIdentifier) {
+ return fromSchemaAndQNameChecked(schema, ((AugmentationIdentifier) child).getPossibleChildNames()
+ .iterator().next());
+ }
+ return fromSchemaAndQNameChecked(schema, child.getNodeType());
+ }
+
protected DataSchemaContextNode<?> fromLocalSchemaAndQName(final DataNodeContainer schema2, final QName child) {
return fromSchemaAndQNameChecked(schema2, child);
}
private DataSchemaContextNode<?> register(final DataSchemaContextNode<?> potential) {
if (potential != null) {
byArg.put(potential.getIdentifier(), potential);
- for (QName qName : potential.getQNameIdentifiers()) {
- byQName.put(qName, potential);
+ for (QName qname : potential.getQNameIdentifiers()) {
+ byQName.put(qname, potential);
}
}
return potential;
}
-}
\ No newline at end of file
+}
/**
* Returns a DataContextNodeOperation for provided child node
*
+ * <p>
* If supplied child is added by Augmentation this operation returns a
* DataContextNodeOperation for augmentation, otherwise returns a
* DataContextNodeOperation for child as call for
* {@link #fromDataSchemaNode(DataSchemaNode)}.
- *
- *
- * @param parent
- * @param parentAug
- * @param child
- * @return
*/
@Nullable static DataSchemaContextNode<?> fromAugmentation(final DataNodeContainer parent,
final AugmentationTarget parentAug, final DataSchemaNode child) {
* Utility class for sharing instances of {@link LeafNode}s which have low cardinality-- e.g. those which hold
* boolean or enumeration values. Instances containing attributes are not interned.
*
+ * <p>
* Such objects have cardinality which is capped at the product of QNAMES * TYPE_CARDINALITY, where QNAMES is the total
* number of different QNames where the type is used and TYPE_CARDINALITY is the number of possible values for the type.
* Boolean has cardinality of 2, enumerations have cardinality equal to the number of enum statements.
*
+ * <p>
* The theory here is that we tend to have a large number (100K+) of entries in a few places, which could end up hogging
* the heap retained via the DataTree with duplicate objects (same QName, same value, different object). Using this
* utility, such objects will end up reusing the same object, preventing this overhead.
@Nonnull public static <T extends LeafNode<?>> Interner<T> forSchema(@Nullable final LeafSchemaNode schema) {
if (schema != null) {
final TypeDefinition<?> type = schema.getType();
- if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition ||
- type instanceof IdentityrefTypeDefinition) {
+ if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition
+ || type instanceof IdentityrefTypeDefinition) {
return LeafInterner::intern;
}
}
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
final class LeafListEntryContextNode extends AbstractLeafNodeContext<NodeWithValue<?>> {
-
- public LeafListEntryContextNode(final LeafListSchemaNode potential) {
+ LeafListEntryContextNode(final LeafListSchemaNode potential) {
super(new NodeWithValue<>(potential.getQName(), null), potential);
}
public boolean isKeyedEntry() {
return true;
}
-}
\ No newline at end of file
+}
* Utility class for sharing instances of {@link LeafSetEntryNode}s which have low cardinality -- e.g. those which hold
* boolean or enumeration values. Instances containing attributes are not interned.
*
+ * <p>
* Such objects have cardinality which is capped at the product of QNAMES * TYPE_CARDINALITY, where QNAMES is the total
* number of different QNames where the type is used and TYPE_CARDINALITY is the number of possible values for the type.
* Boolean has cardinality of 2, enumerations have cardinality equal to the number of enum statements.
*
+ * <p>
* The theory here is that we tend to have a large number (100K+) of entries in a few places, which could end up hogging
* the heap retained via the DataTree with duplicate objects (same QName, same value, different object). Using this
* utility, such objects will end up reusing the same object, preventing this overhead.
@Nullable public static LeafsetEntryInterner forSchema(@Nullable final LeafListSchemaNode schema) {
if (schema != null) {
final TypeDefinition<?> type = schema.getType();
- if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition ||
- type instanceof IdentityrefTypeDefinition) {
+ if (type instanceof BooleanTypeDefinition || type instanceof EnumTypeDefinition
+ || type instanceof IdentityrefTypeDefinition) {
return INSTANCE;
}
}
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
-import java.util.List;
import java.util.Map;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
public class ListEntryNodeDataWithSchema extends CompositeNodeDataWithSchema {
- private final Map<QName, SimpleNodeDataWithSchema> qNameToKeys = new HashMap<>();
+ private final Map<QName, SimpleNodeDataWithSchema> qnameToKeys = new HashMap<>();
public ListEntryNodeDataWithSchema(final DataSchemaNode schema) {
super(schema);
public void addChild(final AbstractNodeDataWithSchema newChild) {
final DataSchemaNode childSchema = newChild.getSchema();
if (childSchema instanceof LeafSchemaNode && isPartOfKey((LeafSchemaNode) childSchema)) {
- qNameToKeys.put(childSchema.getQName(), (SimpleNodeDataWithSchema)newChild);
+ qnameToKeys.put(childSchema.getQName(), (SimpleNodeDataWithSchema)newChild);
}
super.addChild(newChild);
}
private boolean isPartOfKey(final LeafSchemaNode potentialKey) {
- List<QName> keys = ((ListSchemaNode) getSchema()).getKeyDefinition();
- for (QName qName : keys) {
- if (qName.equals(potentialKey.getQName())) {
+ for (QName qname : ((ListSchemaNode) getSchema()).getKeyDefinition()) {
+ if (qname.equals(potentialKey.getQName())) {
return true;
}
}
return;
}
- Preconditions.checkState(keyDef.size() == qNameToKeys.size(), "Input is missing some of the keys of %s", getSchema().getQName());
+ Preconditions.checkState(keyDef.size() == qnameToKeys.size(), "Input is missing some of the keys of %s",
+ getSchema().getQName());
// Need to restore schema order...
final Map<QName, Object> predicates = new LinkedHashMap<>();
for (QName qname : keyDef) {
- predicates.put(qname, qNameToKeys.get(qname).getValue());
+ predicates.put(qname, qnameToKeys.get(qname).getValue());
}
writer.nextDataSchemaNode(getSchema());
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
final class OrderedLeafListMixinContextNode extends UnorderedLeafListMixinContextNode {
-
- public OrderedLeafListMixinContextNode(final LeafListSchemaNode potential) {
+ OrderedLeafListMixinContextNode(final LeafListSchemaNode potential) {
super(potential);
}
-}
\ No newline at end of file
+}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
final class OrderedMapMixinContextNode extends UnorderedMapMixinContextNode {
-
- public OrderedMapMixinContextNode(final ListSchemaNode list) {
+ OrderedMapMixinContextNode(final ListSchemaNode list) {
super(list);
}
-
-}
\ No newline at end of file
+}
/**
* Returns stack of schema nodes via which it was necessary to pass to get schema node with specified
- * {@code childName} and {@code namespace}
+ * {@code childName} and {@code namespace}.
*
- * @param dataSchemaNode
- * @param childName
- * @param namespace
* @return stack of schema nodes via which it was passed through. If found schema node is direct child then stack
* contains only one node. If it is found under choice and case then stack should contains 2*n+1 element
* (where n is number of choices through it was passed)
final QName childQName = childNode.getQName();
if (childQName.getLocalName().equals(childName) && childQName.getNamespace().equals(namespace)) {
- if (potentialChildNode == null ||
- childQName.getRevision().after(potentialChildNode.getQName().getRevision())) {
+ if (potentialChildNode == null
+ || childQName.getRevision().after(potentialChildNode.getQName().getRevision())) {
potentialChildNode = childNode;
}
}
// try to find data schema node in choice (looking for first match)
for (final ChoiceSchemaNode choiceNode : childChoices) {
for (final ChoiceCaseNode concreteCase : choiceNode.getCases()) {
- final Deque<DataSchemaNode> resultFromRecursion = findSchemaNodeByNameAndNamespace(concreteCase, childName,
- namespace);
+ final Deque<DataSchemaNode> resultFromRecursion = findSchemaNodeByNameAndNamespace(concreteCase,
+ childName, namespace);
if (!resultFromRecursion.isEmpty()) {
resultFromRecursion.push(concreteCase);
resultFromRecursion.push(choiceNode);
private final UnkeyedListItemContextNode innerNode;
- public UnkeyedListMixinContextNode(final ListSchemaNode list) {
+ UnkeyedListMixinContextNode(final ListSchemaNode list) {
super(NodeIdentifier.create(list.getQName()), list);
this.innerNode = new UnkeyedListItemContextNode(list);
}
private final DataSchemaContextNode<?> innerOp;
- public UnorderedLeafListMixinContextNode(final LeafListSchemaNode potential) {
+ UnorderedLeafListMixinContextNode(final LeafListSchemaNode potential) {
super(NodeIdentifier.create(potential.getQName()), potential);
innerOp = new LeafListEntryContextNode(potential);
}
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
class UnorderedMapMixinContextNode extends AbstractMixinContextNode<NodeIdentifier> {
-
private final ListItemContextNode innerNode;
- public UnorderedMapMixinContextNode(final ListSchemaNode list) {
+ UnorderedMapMixinContextNode(final ListSchemaNode list) {
super(NodeIdentifier.create(list.getQName()), list);
this.innerNode = new ListItemContextNode(new NodeIdentifierWithPredicates(list.getQName(),
Collections.emptyMap()), list);
}
return null;
}
-
}
/**
* Iterator which lazily parses {@link PathArgument} from string representation.
*
+ * <p>
* Note that invocation of {@link #hasNext()} or {@link #next()} may result in
* throwing of {@link IllegalArgumentException} if underlying string representation
* is not correctly serialized or does not represent instance identifier valid
class XpathStringParsingPathArgumentBuilder implements Builder<Collection<PathArgument>> {
/**
- * Matcher matching WSP YANG ABNF token
+ * Matcher matching WSP YANG ABNF token.
*/
private static final CharMatcher WSP = CharMatcher.anyOf(" \t");
.or(CharMatcher.inRange('A', 'Z')).or(CharMatcher.is('_')).precomputed();
/**
- * Matcher matching IDENTIFIER token
+ * Matcher matching IDENTIFIER token.
*/
private static final CharMatcher IDENTIFIER = IDENTIFIER_FIRST_CHAR.or(CharMatcher.inRange('0', '9'))
.or(CharMatcher.anyOf(".-")).precomputed();
}
/**
- * Returns true if all characters from input string
- * were consumed.
+ * Returns true if all characters from input string were consumed.
*
- * @return true if all characters from input string
- * were consumed.
+ * @return true if all characters from input string were consumed.
*/
private boolean allCharactersConsumed() {
return offset == data.length();
/**
* Fails parsing if a condition is not met.
*
+ * <p>
* In case of error provides pointer to failed instance identifier,
* offset on which failure occurred with explanation.
*
* @param condition Fails parsing if {@code condition} is false
* @param errorMsg Error message which will be provided to user.
- * @param attributes
*/
private void checkValid(final boolean condition, final String errorMsg, final Object... attributes) {
if (!condition) {
}
/**
- * Increases processing offset by 1
+ * Increases processing offset by 1.
*/
private void skipCurrentChar() {
offset++;
}
/**
- * Skip whitespace characters, sets offset to first following
- * non-whitespace character.
+ * Skip whitespace characters, sets offset to first following non-whitespace character.
*/
private void skipWhitespaces() {
nextSequenceEnd(WSP);
final class YangModeledAnyXmlNodeDataWithSchema extends CompositeNodeDataWithSchema {
- public YangModeledAnyXmlNodeDataWithSchema(final YangModeledAnyXmlSchemaNode yangModeledAnyXml) {
+ YangModeledAnyXmlNodeDataWithSchema(final YangModeledAnyXmlSchemaNode yangModeledAnyXml) {
super(yangModeledAnyXml);
}
super.write(writer);
writer.endNode();
}
-
}
}
protected abstract T binaryCodec(BinaryTypeDefinition type);
+
protected abstract T booleanCodec(BooleanTypeDefinition type);
+
protected abstract T bitsCodec(BitsTypeDefinition type);
+
protected abstract T emptyCodec(EmptyTypeDefinition type);
+
protected abstract T enumCodec(EnumTypeDefinition type);
+
protected abstract T identityRefCodec(IdentityrefTypeDefinition type, QNameModule module);
+
protected abstract T instanceIdentifierCodec(InstanceIdentifierTypeDefinition type);
+
protected abstract T intCodec(IntegerTypeDefinition type);
+
protected abstract T decimalCodec(DecimalTypeDefinition type);
+
protected abstract T stringCodec(StringTypeDefinition type);
+
protected abstract T uintCodec(UnsignedIntegerTypeDefinition type);
+
protected abstract T unionCodec(UnionTypeDefinition type, List<T> codecs);
+
protected abstract T unknownCodec(UnknownTypeDefinition type);
private T getSimpleCodecFor(final TypeDefinition<?> type) {
* Pre-computed CodecCache. All possible codecs are created upfront at instantiation time, after which they are
* available for the cost of a constant lookup.
*
+ * <p>
* Instantiation needs to occur through {@link LazyCodecCache#toPrecomputed()} after the lazy cache has been fully
* populated.
*
Code Review / yangtools.git / commitdiff