prefix, NormalizationResult result) {
/**
* Default constructor.
*
* @param prefix {@link YangInstanceIdentifier} steps that need to be concatenated to the request path to form
* a {@link YangInstanceIdentifier} pointing to the immediate parent of {@link #result}.
* @param result parsed data
*/
public PrefixAndResult {
prefix = List.copyOf(prefix);
requireNonNull(result);
}
}
/**
* Parse the contents of an {@link InputStream} as the contents of a data store.
*
*
* This method's signature is a bit counter-intuitive. {@code rootNamespace} and {@code rootName} collectively
* encode the expected root element, which may not be expressed in the underlying YANG data model.
*
*
* The reason for this is that YANG does not define an explicit {@link NodeIdentifier} of the datastore root
* resource, but protocol encodings require this conceptual root to be encapsulated in protocol documents and the
* approaches taken differ from protocol to protocol. NETCONF operates in terms of YANG-modeled RPC operations,
* where this conceptual root is given an anchor -- {@code get-config} output's {@code anyxml data}. RESTCONF
* operates in terms of HTTP payloads and while it models such an anchor, it is rather unnatural
* {@code container data} with description defining its magic properties and it is not feasible for YANG parser
* to help us with that.
*
*
* Therefore this method takes the name of the root element in two arguments, which together define its value in
* both JSON-based (module + localName} and XML-based (namespace + localName) encodings. Implementations of this
* method are expected to use this information and treat the root element outside of their usual YANG-informed
* processing.
*
*
* For example, XML parsers will pick {@code containerName.getNodeType().getNamespace()} to match the root element's
* namespace and {@code containerName.getNodeType().getLocalName()} to match the element's local name. JSON parsers,
* on the other hand, will use {@code moduleName} and {@code rootName.getLocalName()} to match the top-level JSON
* object's sole named member.
*
* @param containerName expected root container name
* @param moduleName module name corresponding to {@code containerName}
* @param stream the {@link InputStream} to parse
* @return parsed {@link ContainerNode} corresponding to the data store root, with its {@link ContainerNode#name()}
* equal to {@code containerName}.
* @throws NullPointerException if any argument is {@code null}
* @throws NormalizationException if an error occurs
*/
NormalizationResult parseDatastore(NodeIdentifier containerName, Unqualified moduleName,
InputStream stream) throws NormalizationException;
/**
* Parse the contents of an {@link InputStream} as a data resource.
*
* @param inference pointer to the data resource
* @param stream the {@link InputStream} to parse
* @return Parsed {@link NormalizedNode} corresponding the requested resource
* @throws NullPointerException if any argument is {@code null}
* @throws IllegalArgumentException if {@code inference} does not to point to a resource recognized by this parser
* @throws NormalizationException if an error occurs
*/
NormalizationResult parseData(EffectiveStatementInference inference, InputStream stream)
throws NormalizationException;
/**
* Parse the contents of an {@link InputStream} as a child data resource.
*
* @param parentInference pointer to the parent of the data resource
* @param stream the {@link InputStream} to parse
* @return A {@link PrefixAndResult} containing parsed resource data and any {@link YangInstanceIdentifier} steps
* that need to be appended between {@code inference} and the parsed {@link NormalizedNode}
* @throws NullPointerException if any argument is {@code null}
* @throws IllegalArgumentException if {@code inference} does not to point to a resource recognized by this parser
* @throws NormalizationException if an error occurs
*/
PrefixAndResult parseChildData(EffectiveStatementInference parentInference, InputStream stream)
throws NormalizationException;
/**
* Parse the contents of an {@link InputStream} as an operation {@code input}.
*
* @param operationInference pointer to the operation
* @param stream the {@link InputStream} to parse
* @return Parsed {@link ContainerNode} corresponding to the operation input
* @throws NullPointerException if any argument is {@code null}
* @throws IllegalArgumentException if {@code inference} does not to point to an operation recognized by this parser
* @throws NormalizationException if an error occurs
*/
NormalizationResult parseInput(EffectiveStatementInference operationInference, InputStream stream)
throws NormalizationException;
/**
* Parse the contents of an {@link InputStream} as on operation {@code output}.
*
* @param operationInference pointer to the operation
* @param stream the {@link InputStream} to parse
* @return Parsed {@link ContainerNode} corresponding to the operation output
* @throws NullPointerException if any argument is {@code null}
* @throws IllegalArgumentException if {@code inference} does not to point to an operation recognized by this parser
* @throws NormalizationException if an error occurs
*/
NormalizationResult parseOutput(EffectiveStatementInference operationInference, InputStream stream)
throws NormalizationException;
}