* for all reachable binding objects.
*
* @param type Binding type of augmentation
- * @param node Schema of augmentation
+ * @param schema Schema of augmentation
* @return Source for augmentation node writer
*/
protected abstract DataObjectSerializerSource generateSerializer(GeneratedType type, AugmentationSchema schema);
* <li>name - property name</li>
* <li>type - Java type for property</li>
* <li>value - value to which property should be initialized</li>
- *
+ * </ul>
*/
public class StaticConstantDefinition {
* <ul>
* <li>are generated from <code>context</code> schema nodes and</li>
* <li>are also part of some of the module in <code>modules</code>
- * set</li>.
+ * set.</li>
* </ul>
* @throws IllegalArgumentException
* <ul>
/**
* Returns an instance of {@link ParameterizedType} describing the typed
- * {@link Map}<K,V>
+ * {@link Map}<K,V>
*
* @param keyType
* Key Type
/**
* Returns an instance of {@link ParameterizedType} describing the typed
- * {@link Set}<V> with concrete type of value.
+ * {@link Set}<V> with concrete type of value.
*
* @param valueType
* Value Type
/**
* Returns an instance of {@link ParameterizedType} describing the typed
- * {@link List}<V> with concrete type of value.
+ * {@link List}<V> with concrete type of value.
*
* @param valueType
* Value Type
* @param type
* Input type to be processed
* @return generated JAVA code
- * @throws IOException
*/
String generate(Type type);
package org.opendaylight.yangtools.sal.binding.model.api;
/**
- * Represents an instance of simple parametrized type such as List<String>.
+ * Represents an instance of simple parametrized type such as List<String>.
*
* The parametrized Type is designed to be used to store information of Java
* Generic Type. The array of {@link #getActualTypeArguments()} holds
* Returns array of Types that are defined for Parameterized Type.
* <br>
* (for example if ParameterizedType encapsulates java generic Map that
- * specifies two parameters Map<K,V> and the K is java.lang.Integer and V
+ * specifies two parameters Map<K,V> and the K is java.lang.Integer and V
* is defined as GeneratedType the array will contain two Types to store
* the information of generic parameters.)
*
/**
* Sorts set <code>groupingDefinitions</code> according to the mutual
- * dependencies.<br />
+ * dependencies.<br>
*
* Elements of <code>groupingDefinitions</code> are firstly transformed to
* {@link org.opendaylight.yangtools.yang.parser.util.TopologicalSort.Node
* Node} interfaces and then are sorted by
* {@link org.opendaylight.yangtools.yang.parser.util.TopologicalSort#sort(Set)
- * sort()} method of <code>TopologicalSort</code>.<br />
- * <br />
+ * sort()} method of <code>TopologicalSort</code>.<br>
+ * <br>
*
*
- * <i>Definition of dependency relation:<br />
+ * <i>Definition of dependency relation:<br>
* The first <code>GroupingDefinition</code> object (in this context)
* depends on second <code>GroupingDefinition</code> object if the first one
* contains in its set of <code>UsesNode</code> (obtained through
* also adds marker interface for augmentations (extensions) -
* {@link Augmentable}
*
- * @author Tony Tkacik <ttkacik@cisco.com>
+ * @author Tony Tkacik
* @param <T>
* Base class which should implements this interface and is target
* for augmentation.
*
* <li><code>list</code> - YANG list statement has two representation in event
* stream - unkeyed list and map. Unkeyed list is YANG list which did not
- * specify key.</li>
+ * specify key.
*
* <ul>
* <li><code>Map</code> - Map start event is emitted using
* <li><code>UnkeyedList</code> - Unkeyed list represent list without keys,
* unkeyed list start is emitted using {@link #startUnkeyedList(Class, int)} list
* end is emitted using {@link #endNode()}. Each list item is emitted using
- * {@link #startUnkeyedListItem()} and ended using {@link #endNode()}.</li>
- * </ul>
+ * {@link #startUnkeyedListItem(int)} and ended using {@link #endNode()}.</li>
+ * </ul></li>
*
* <li><code>leaf</code> - Leaf node event is emitted using
* {@link #leafNode(String, Object)}. {@link #endNode()} MUST be not emitted for
* <li><code>leaf-list</code> - Leaf list start is emitted using
* {@link #startLeafSet(String, int)}. Leaf list end is emitted using
* {@link #endNode()}. Leaf list entries are emitted using
- * {@link #leafSetEntryNode(Object).
+ * {@link #leafSetEntryNode(Object)}.
*
* <li><code>anyxml - Anyxml node event is emitted using
* {@link #leafNode(String, Object)}. {@link #endNode()} MUST be not emitted
*
* <p>
* End of unkeyed list event is emitted by invoking {@link #endNode()}.
- * Valid subevents is only {@link #startUnkeyedListItem()}. All other
+ * Valid subevents is only {@link #startUnkeyedListItem(int)}. All other
* methods will throw {@link IllegalArgumentException}.
*
* @param localName
*
* <p>
* Valid sub-events are:
- * <<p>
- * Valid sub-events are:
* <ul>
* <li>{@link #leafNode(String, Object)}</li>
* <li>{@link #startContainerNode(Class, int)}</li>
* Emits start of choice node.
*
* <p>
- * Valid sub-event in {@link #startCase(QName, int)}, which selects case
+ * Valid sub-event in {@link #startCase(Class, int)}, which selects case
* which should be written.
- * <ul>
*
- * @param localName
- * name of node as defined in schema, namespace and revision are
- * derived from parent node.
+ * @param choice
+ * Choice class.
* @param childSizeHint
* Non-negative count of expected direct child nodes or
* {@link #UNKNOWN_SIZE} if count is unknown. This is only hint
* events than count.
* @throws IllegalArgumentException
* @throws IllegalStateException
- * If node was emitted inside <code>map</code>, <code>choice
- * </code> <code>unkeyed list</code> node.
+ * If node was emitted inside <code>map</code>, <code>choice</code>,
+ * <code>unkeyed list</code> node.
* @throws IOException if an underlying IO error occurs
*/
void startChoiceNode(Class<? extends DataContainer> choice, int childSizeHint) throws IOException, IllegalArgumentException;
* <li>{@link #startAugmentationNode(Class)}</li>
* </ul>
*
- * @param name
+ * @param caze Case class
* @throws IllegalArgumentException
* @throws IOException if an underlying IO error occurs
*/
* <p>
* Valid sub-events are:
*
- * <p>
- * Valid sub-events are:
* <ul>
* <li>{@link #leafNode(String, Object)}</li>
* <li>{@link #startContainerNode(Class, int)}</li>
* Note this is only method, which does not require childSizeHint, since
* maximum value is always size of <code>possibleChildren</code>.
*
- * @param module
- * QName module of YANG module in which augmentation was defined
- * @param possibleChildren
- * Local names of all valid children defined by augmentation.
+ * @param augmentationType augmentation class
* @throws IllegalArgumentException
* If augmentation is invalid in current context.
* @throws IOException if an underlying IO error occurs
/**
* Data container is an interface which has structured contents.
*
- *
- * @author Tony Tkacik <ttkacik@cisco.com>
+ * @author Tony Tkacik
*
*/
public interface DataObject extends DataContainer {
* Check whether an instance identifier contains any wildcards. A wildcard
* is an path argument which has a null key.
*
- * @return @true if any of the path arguments has a null key.
+ * @return true if any of the path arguments has a null key.
*/
public final boolean isWildcarded() {
return wildcarded;
* quick checks on their specific fields.
*
* @param other The other identifier, guaranteed to be the same class
- * @return @true if the other identifier cannot be equal to this one.
+ * @return true if the other identifier cannot be equal to this one.
*/
protected boolean fastNonEqual(final InstanceIdentifier<?> other) {
return false;
* non-wildcarded PathArgument counterpart.
*
* @param other Identifier which should be checked for inclusion.
- * @return @true if this identifier contains the other object
+ * @return true if this identifier contains the other object
*/
public final boolean containsWildcarded(final InstanceIdentifier<?> other) {
Preconditions.checkNotNull(other, "other should not be null");
/**
* Create a new InstanceIdentifierBuilder given a base InstanceIdentifier
*
- * @param basePath
+ * @param base
* @param <T>
* @return
*
*
* Example
* <pre>
- * List<PathArgument> path = Arrays.asList(new Item(Nodes.class))
+ * List<PathArgument> path = Arrays.asList(new Item(Nodes.class))
* new InstanceIdentifier(path);
* </pre>
*
* This method uses first generic argument of
* implemented {@link ChildOf} interface.
*
- * @param augmentation
- * {@link Augmentation} subclass for which we want to determine
- * augmentation target.
- * @return Augmentation target - class which augmentation provides
- * additional extensions.
+ * @param childClass
+ * child class for which we want to find the parent class.
+ * @return Parent class, e.g. class of which the childClass is ChildOf.
*/
public static Class<?> findHierarchicalParent(final Class<? extends ChildOf<?>> childClass) {
return ClassLoaderUtils.findFirstGenericArgument(childClass, ChildOf.class);
* This method is shorthand which gets DataObject class by invoking
* {@link DataObject#getImplementedInterface()} and uses {@link #findHierarchicalParent(Class)}.
*
- * @param childClass
- * {@link Augmentation} subclass for which we want to determine
- * augmentation target.
- * @return Augmentation target - class which augmentation provides
- * additional extensions.
+ * @param child
+ * Child object for which the parent needs to be located.
+ * @return Parent class, or null if a parent is not found.
*/
public static Class<?> findHierarchicalParent(final DataObject child) {
if (child instanceof ChildOf) {
/**
* Returns root package name for supplied package name.
*
- * @param pkg Package for which find model root package.
+ * @param name Package for which find model root package.
* @return Package of model root.
*/
public static String getModelRootPackageName(final String name) {
Code Review / mdsal.git / commitdiff