ImmutableNormalizedNodeStreamWriter (yangtools 3.0.0-SNAPSHOT API)

java.lang.Object
- org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter

All Implemented Interfaces:

Closeable, Flushable, AutoCloseable, NormalizedNodeStreamWriter
```
public class ImmutableNormalizedNodeStreamWriter
extends Object
implements NormalizedNodeStreamWriter
```
Implementation of NormalizedNodeStreamWriter, which constructs immutable instances of NormalizedNodes.
This writer supports two modes of behaviour one is using from(NormalizedNodeResult) where resulting NormalizedNode will be stored in supplied result object.
Other mode of operation is using from(NormalizedNodeContainerBuilder), where all created nodes will be written to this builder.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class ImmutableNormalizedNodeStreamWriter.NormalizedNodeResultBuilder

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`ImmutableNormalizedNodeStreamWriter.NormalizedNodeResultBuilder`

Field Summary
- Fields inherited from interface org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter
  UNKNOWN_SIZE

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`ImmutableNormalizedNodeStreamWriter(NormalizedNodeContainerBuilder topLevelBuilder)`
`protected`	`ImmutableNormalizedNodeStreamWriter(NormalizedNodeResult result)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`anyxmlNode(YangInstanceIdentifier.NodeIdentifier name, Object value)` Emits anyxml node event.
`void`	`close()`
`void`	`endNode()` Emits end event for node.
`void`	`flush()`
`static @NonNull NormalizedNodeStreamWriter`	`from(NormalizedNodeContainerBuilder<?,?,?,?> builder)` Creates a `NormalizedNodeStreamWriter` which creates instances of supplied `NormalizedNode`s and writes them to supplied builder as child nodes.
`static NormalizedNodeStreamWriter`	`from(NormalizedNodeResult result)` Creates a `NormalizedNodeStreamWriter` which creates one instance of top-level `NormalizedNode` (type of NormalizedNode) is determined by first start event.
`protected Deque<NormalizedNodeContainerBuilder>`	`getBuilders()`
`protected NormalizedNodeContainerBuilder`	`getCurrent()`
`void`	`leafNode(YangInstanceIdentifier.NodeIdentifier name, Object value)` Emits a leaf node event with supplied value.
`void`	`leafSetEntryNode(QName name, Object value)` Emits a leaf set entry node.
`void`	`nextDataSchemaNode(DataSchemaNode schema)` Attach the specified `DataSchemaNode` to the next node which will get started or emitted.
`void`	`startAugmentationNode(YangInstanceIdentifier.AugmentationIdentifier identifier)` Emits start of augmentation node.
`void`	`startChoiceNode(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of a choice node event.
`void`	`startContainerNode(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of new container.
`void`	`startLeafSet(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits a start of leaf set (leaf-list).
`void`	`startMapEntryNode(YangInstanceIdentifier.NodeIdentifierWithPredicates identifier, int childSizeHint)` Emits start of map entry.
`void`	`startMapNode(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of map node event.
`void`	`startOrderedLeafSet(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits a start of leaf set (leaf-list).
`void`	`startOrderedMapNode(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of map node event.
`void`	`startUnkeyedList(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of unkeyed list node event.
`void`	`startUnkeyedListItem(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of new unkeyed list item.
`void`	`startYangModeledAnyXmlNode(YangInstanceIdentifier.NodeIdentifier name, int childSizeHint)` Emits start of new yang modeled anyXml node.
`protected void`	`writeChild(NormalizedNode<?,?> child)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ImmutableNormalizedNodeStreamWriter
```
protected ImmutableNormalizedNodeStreamWriter(NormalizedNodeContainerBuilder topLevelBuilder)
```
  - ImmutableNormalizedNodeStreamWriter
```
protected ImmutableNormalizedNodeStreamWriter(NormalizedNodeResult result)
```
- Method Detail
  - from
```
public static @NonNull NormalizedNodeStreamWriter from(NormalizedNodeContainerBuilder<?,?,?,?> builder)
```
    Creates a NormalizedNodeStreamWriter which creates instances of supplied NormalizedNodes and writes them to supplied builder as child nodes.
    Type of supplied NormalizedNodeContainerBuilder affects, which events could be emitted in order to ensure proper construction of data.
    
    Parameters:
    
    builder - Builder to which data will be written.
    
    Returns:
    
    NormalizedNodeStreamWriter which writes data
  - from
```
public static NormalizedNodeStreamWriter from(NormalizedNodeResult result)
```
    Creates a NormalizedNodeStreamWriter which creates one instance of top-level NormalizedNode (type of NormalizedNode) is determined by first start event.
    Result is built when endNode() associated with that start event is emitted.
    Writer properly creates also nested NormalizedNode instances, if their are supported inside the scope of the first event.
    This method is useful for clients, which knows there will be one top-level node written, but does not know which type of NormalizedNode will be written.
    
    Parameters:
    
    result - NormalizedNodeResult object which will hold result value.
    
    Returns:
    
    NormalizedNodeStreamWriter which will write item to supplied result holder.
  - getBuilders
```
protected Deque<NormalizedNodeContainerBuilder> getBuilders()
```
  - getCurrent
```
protected NormalizedNodeContainerBuilder getCurrent()
```
  - writeChild
```
protected void writeChild(NormalizedNode<?,?> child)
```
  - endNode
```
public void endNode()
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits end event for node.
    
    Specified by:
    
    endNode in interface NormalizedNodeStreamWriter
  - leafNode
```
public void leafNode(YangInstanceIdentifier.NodeIdentifier name,
                     Object value)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits a leaf node event with supplied value.
    
    Specified by:
    
    leafNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    value - Value of leaf node. v
  - startLeafSet
```
public void startLeafSet(YangInstanceIdentifier.NodeIdentifier name,
                         int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits a start of leaf set (leaf-list).
    Emits start of leaf set, during writing leaf set event, only NormalizedNodeStreamWriter.leafSetEntryNode(QName, Object) calls are valid. Leaf set event is finished by calling NormalizedNodeStreamWriter.endNode().
    
    Specified by:
    
    startLeafSet in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - leafSetEntryNode
```
public void leafSetEntryNode(QName name,
                             Object value)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits a leaf set entry node.
    
    Specified by:
    
    leafSetEntryNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of the node as defined in the schema.
    
    value - Value of leaf set entry node. Supplied object MUST BE constant over time.
  - startOrderedLeafSet
```
public void startOrderedLeafSet(YangInstanceIdentifier.NodeIdentifier name,
                                int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits a start of leaf set (leaf-list).
    Emits start of leaf set, during writing leaf set event, only NormalizedNodeStreamWriter.leafSetEntryNode(QName, Object) calls are valid. Leaf set event is finished by calling NormalizedNodeStreamWriter.endNode().
    
    Specified by:
    
    startOrderedLeafSet in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - anyxmlNode
```
public void anyxmlNode(YangInstanceIdentifier.NodeIdentifier name,
                       Object value)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits anyxml node event.
    
    Specified by:
    
    anyxmlNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    value - Value of AnyXml node.
  - startContainerNode
```
public void startContainerNode(YangInstanceIdentifier.NodeIdentifier name,
                               int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    Emits start of new container.
    End of container event is emitted by invoking NormalizedNodeStreamWriter.endNode().
    Valid sub-events are:
    - NormalizedNodeStreamWriter.leafNode(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier, java.lang.Object)
    - #startContainerNode(NodeIdentifier, int)
    - #startChoiceNode(NodeIdentifier, int)
    - #startLeafSet(NodeIdentifier, int)
    - #startMapNode(NodeIdentifier, int)
    - #startUnkeyedList(NodeIdentifier, int)
    - #startAugmentationNode(AugmentationIdentifier)
    Specified by:
    
    startContainerNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startYangModeledAnyXmlNode
```
public void startYangModeledAnyXmlNode(YangInstanceIdentifier.NodeIdentifier name,
                                       int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    Emits start of new yang modeled anyXml node.
    End of yang modeled anyXml node event is emitted by invoking NormalizedNodeStreamWriter.endNode().
    Valid sub-events are:
    Specified by:
    
    startYangModeledAnyXmlNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startUnkeyedList
```
public void startUnkeyedList(YangInstanceIdentifier.NodeIdentifier name,
                             int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits start of unkeyed list node event.
    End of unkeyed list event is emitted by invoking NormalizedNodeStreamWriter.endNode(). Valid subevents is only #startUnkeyedListItem(NodeIdentifier, int). All other methods will throw IllegalArgumentException.
    
    Specified by:
    
    startUnkeyedList in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startUnkeyedListItem
```
public void startUnkeyedListItem(YangInstanceIdentifier.NodeIdentifier name,
                                 int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    Emits start of new unkeyed list item.
    Unkeyed list item event is finished by invoking NormalizedNodeStreamWriter.endNode(). Valid sub-events are:
    - NormalizedNodeStreamWriter.leafNode(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier, java.lang.Object)
    - #startContainerNode(NodeIdentifier, int)
    - #startChoiceNode(NodeIdentifier, int)
    - #startLeafSet(NodeIdentifier, int)
    - #startMapNode(NodeIdentifier, int)
    - #startUnkeyedList(NodeIdentifier, int)
    - #startAugmentationNode(AugmentationIdentifier)
    Specified by:
    
    startUnkeyedListItem in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - Identifier of node
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startMapNode
```
public void startMapNode(YangInstanceIdentifier.NodeIdentifier name,
                         int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits start of map node event.
    End of map node event is emitted by invoking NormalizedNodeStreamWriter.endNode(). Valid subevents is only #startMapEntryNode(NodeIdentifierWithPredicates, int). All other methods will throw IllegalArgumentException.
    
    Specified by:
    
    startMapNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startMapEntryNode
```
public void startMapEntryNode(YangInstanceIdentifier.NodeIdentifierWithPredicates identifier,
                              int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    Emits start of map entry.
    End of map entry event is emitted by invoking NormalizedNodeStreamWriter.endNode().
    Valid sub-events are:
    - NormalizedNodeStreamWriter.leafNode(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier, java.lang.Object)
    - #startContainerNode(NodeIdentifier, int)
    - #startChoiceNode(NodeIdentifier, int)
    - #startLeafSet(NodeIdentifier, int)
    - #startMapNode(NodeIdentifier, int)
    - #startUnkeyedList(NodeIdentifier, int)
    - #startAugmentationNode(AugmentationIdentifier)
    Specified by:
    
    startMapEntryNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    identifier - QName to value pairs of keys of map entry node. Values MUST BE constant over time.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startOrderedMapNode
```
public void startOrderedMapNode(YangInstanceIdentifier.NodeIdentifier name,
                                int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits start of map node event.
    End of map node event is emitted by invoking NormalizedNodeStreamWriter.endNode(). Valid subevents is only #startMapEntryNode(NodeIdentifierWithPredicates, int). All other methods will throw IllegalArgumentException.
    
    Specified by:
    
    startOrderedMapNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startChoiceNode
```
public void startChoiceNode(YangInstanceIdentifier.NodeIdentifier name,
                            int childSizeHint)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Emits start of a choice node event.
    
    Specified by:
    
    startChoiceNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    name - name of node as defined in schema, namespace and revision are derived from parent node.
    
    childSizeHint - Non-negative count of expected direct child nodes or NormalizedNodeStreamWriter.UNKNOWN_SIZE if count is unknown. This is only hint and should not fail writing of child events, if there are more events than count.
  - startAugmentationNode
```
public void startAugmentationNode(YangInstanceIdentifier.AugmentationIdentifier identifier)
```
    Description copied from interface: NormalizedNodeStreamWriter
    Emits start of augmentation node.
    End of augmentation event is emitted by invoking NormalizedNodeStreamWriter.endNode().
    Valid sub-events are:
    - NormalizedNodeStreamWriter.leafNode(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier, java.lang.Object)
    - #startContainerNode(NodeIdentifier, int)
    - #startChoiceNode(NodeIdentifier, int)
    - #startLeafSet(NodeIdentifier, int)
    - #startMapNode(NodeIdentifier, int)
    - #startUnkeyedList(NodeIdentifier, int)
    Specified by:
    
    startAugmentationNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    identifier - Augmentation identifier
  - flush
```
public void flush()
```
    Specified by:
    
    flush in interface Flushable
    
    Specified by:
    
    flush in interface NormalizedNodeStreamWriter
  - close
```
public void close()
```
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface NormalizedNodeStreamWriter
  - nextDataSchemaNode
```
public void nextDataSchemaNode(DataSchemaNode schema)
```
    Description copied from interface: NormalizedNodeStreamWriter
    
    Attach the specified DataSchemaNode to the next node which will get started or emitted. The default implementation does nothing.
    
    Specified by:
    
    nextDataSchemaNode in interface NormalizedNodeStreamWriter
    
    Parameters:
    
    schema - DataSchemaNode

Class ImmutableNormalizedNodeStreamWriter

Nested Class Summary

Field Summary

Fields inherited from interface org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ImmutableNormalizedNodeStreamWriter

ImmutableNormalizedNodeStreamWriter

Method Detail

from

from

getBuilders

getCurrent

writeChild

endNode

leafNode

startLeafSet

leafSetEntryNode

startOrderedLeafSet

anyxmlNode

startContainerNode

startYangModeledAnyXmlNode

startUnkeyedList

startUnkeyedListItem

startMapNode

startMapEntryNode

startOrderedMapNode

startChoiceNode

startAugmentationNode

flush

close

nextDataSchemaNode