All Classes and Interfaces
Class
Description
Abstract base class for
AnydataNode implementations.Abstract base class for
AnyxmlNode implementations.AbstractBooleanStatementSupport<D extends DeclaredStatement<Boolean>,E extends EffectiveStatement<Boolean,D>>
Specialization of
AbstractStatementSupport for statements which carry a Boolean argument and are essentially
context-independent.Base implementation of
CanonicalValueSupport.Abstract base class for implementing validators.
Abstract base class for
ChoiceNode implementations.A type-to-codec factory base class with logic to efficiently lookup and cache codec instances,
also dealing with union type composition.
Abstract base class for
ContainerNode implementations.Schema derived data providing necessary information for mapping between
NormalizedNode and serialization format defined in RFC6020,
since the mapping is not one-to-one.Base stateless superclass for statements which (logically) always have an associated
DeclaredStatement.A stateful version of
AbstractDeclaredEffectiveStatement, which holds (and requires) a declared
statement.An extra building block on top of
AbstractDeclaredEffectiveStatement.Default, which is wiring AbstractDeclaredEffectiveStatement.DefaultArgument.argument() to the declared statement.AbstractDeclaredEffectiveStatement.DefaultArgument.WithSubstatements<A,D extends DeclaredStatement<A>>
A building block on top of
AbstractDeclaredEffectiveStatement.Default, which adds an explicit argument value, which is not related to the
context.AbstractDeclaredEffectiveStatement.DefaultWithArgument.WithSubstatements<A,D extends DeclaredStatement<A>>
Stateful version of
AbstractDeclaredEffectiveStatement.WithDataTree.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithTypedefNamespace<A,D extends DeclaredStatement<A>>
Stateful version of
AbstractDeclaredEffectiveStatement.WithSchemaTree.Base stateless superclass for
DataTreeAwareEffectiveStatements.Base stateless superclass form
SchemaTreeAwareEffectiveStatements.Abstract base class for
DeclaredStatement implementations.An abstract base class for
DeclaredStatement implementations.Simple base class for classes which wish to implement
Delegator interface and are not otherwise constrained
in their class hierarchy.Abstract base class for dynamic resolvers.
AbstractEffectiveModule<D extends DeclaredStatement<UnresolvedQName.Unqualified>,E extends DataTreeAwareEffectiveStatement<UnresolvedQName.Unqualified,D>>
Abstract base class for
EffectiveStatement implementations.A
EffectiveStatementInferences with its attached EffectiveModelContext.A simple capture of an
AbstractEffectiveStatementInference and a list of EffectiveStatements.A declared
AbstractDeclaredEffectiveStatement with UnknownSchemaNode.AbstractEmptyStatementSupport<D extends DeclaredStatement<Empty>,E extends EffectiveStatement<Empty,D>>
Abstract base class for
FileGeneratorFactory implementations.Abstract base class for
GeneratedFiles.The contents of a generated file and its
GeneratedFileLifecycle.An opinionated superclass for implementing
HierarchicalIdentifiers.An abstract
Identifier backed by an immutable object.An abstract base class enforcing nullness contract around
IllegalArgumentCodec interface.An
AbstractCodecFactory which additionally provides services defined in InputStreamNormalizer.AbstractIntegerStringCodec<N extends Number & Comparable<N>,T extends RangeRestrictedTypeDefinition<T,N>>
Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
AbstractInternedStatementSupport<A,D extends DeclaredStatement<A>,E extends EffectiveStatement<A,D>>
A
AbstractStatementSupport specialized for global interning.AbstractInternedStringStatementSupport<D extends DeclaredStatement<String>,E extends EffectiveStatement<String,D>>
A specialization of
AbstractInternedStatementSupport for String arguments.Abstract base class for
LeafNode implementations.Abstract base class for
LeafSetEntryNode implementations.Deprecated, for removal: This API element is subject to removal in a future version.
Abstract base class for
MapEntryNode implementations.Utility base class for implementing
MountPointChild classes.Abstract base class for MountPointContextFactory implementations, which can process RFC8525 mount point definitions.
Definition of a MountPoint, as known to RFC8528.
A
CompositeNodeDataWithSchema which can hold mount-point data.Utility abstract class for tracking parser state, as needed by StAX-like parser.
Abstract base class for implementing the NormalizableAnydata interface.
Abstract base class for
NormalizedNode implementations.Utility registration handle.
Abstract base type for converting ANTLRErrorListener errors to Exceptions.
Convenience base class for
PathExpression implementations.Abstract superclass for sharing QName references, which can either be resolved
QNames or unresolved
UnresolvedQName.Unqualified and UnresolvedQName.Qualifieds.AbstractQNameStatementSupport<D extends DeclaredStatement<QName>,E extends EffectiveStatement<QName,D>>
Specialization of
AbstractStatementSupport for QName statement arguments.Abstract base class for
DeclaredStatement implementations which decorate a statement with a
DeclarationReference.Utility registration handle.
Abstract base class for
SchemaRepository implementations.Abstract base class for cache-type SchemaSourceListeners.
AbstractSchemaTreeStatementSupport<D extends DeclaredStatement<QName>,E extends SchemaTreeEffectiveStatement<D>>
Specialization of
AbstractQNameStatementSupport for SchemaTreeEffectiveStatement implementations.Abstract utility class to handle StatementArgumentDefinition aspect of
StatementDefinition.Baseline implementation class for common
StatementSupport implementations.Utility
Identifier backed by a UUID.Abstract utility class for representations which encode
YangInstanceIdentifier as a
prefix:name tuple.AbstractStringStatementSupport<D extends DeclaredStatement<String>,E extends EffectiveStatement<String,D>>
Specialization of
AbstractStatementSupport for String statement arguments.Abstract base class for implementing
SystemLeafSetNodes.Abstract base class for
SystemMapNode implementations.Stateful version of
AbstractUndeclaredEffectiveStatement.WithDataTree.Stateful version of
AbstractUndeclaredEffectiveStatement.WithSchemaTree.Base stateless superclass form
DataTreeAwareEffectiveStatements.Base stateless superclass form
SchemaTreeAwareEffectiveStatements.Abstract base class for
UnkeyedListEntryNode implementations.Abstract base class for implementing
UnkeyedListNodes.AbstractUnqualifiedStatementSupport<D extends DeclaredStatement<UnresolvedQName.Unqualified>,E extends EffectiveStatement<UnresolvedQName.Unqualified,D>>
Specialization of
AbstractStatementSupport for Unqualified statement arguments.Abstract base class for implementing
UserLeafSetNodes.Abstract base class for
UserMapNode implementations.Utility
Identifier backed by a UUID.Type-safe shim to ensure concrete
YangXPathMathSupport implementations get handed properly-typed
YangNumberExprs.Represents YANG
action statement.Effective representation of a
action statement.Node which can contain
ActionDefinition.ActionNodeContainerCompat<A,D extends DeclaredStatement<A>,E extends SchemaTreeAwareEffectiveStatement<A,D>>
Compatibility bridge between
ActionNodeContainer.findAction(QName) and
SchemaTreeAwareEffectiveStatement.Represents YANG
action statement.Statement which can contain action statements.
Deprecated, for removal: This API element is subject to removal in a future version.
The only user of this trait is MD-SAL's binding component.
Effective statement representation of 'annotation' extension defined in
RFC7952.
Name of an individual YANG annotation, as defined in
RFC7952.
Represents the effect of 'annotation' extension, as defined in
RFC7952, being attached to a SchemaNode.
Interface for entities which can lookup
AnnotationSchemaNodes based on their name.A
SchemaContext which is also AnnotationSchemaNodeAware.Declared statement representation of 'annotation' extension defined in
RFC7952.
Effective representation of a
anydata statement.A NormalizedNode holding the contents of an
anydata node in some object model.A builder of
AnydataNodes.The "anydata" statement defines an interior node in the schema tree.
The "anydata" statement defines an interior node in the schema tree.
Effective representation of a
anyxml statement.A NormalizedNode holding the contents of an
anyxml node in some object model.A builder of
AnyxmlNodes.Utility class used for tracking parser state as needed by a StAX-like parser.
The "anyxml" interface defines an interior node in the schema tree.
Declared representation of a
anyxml statement.Definition of an argument to a YANG statement.
Effective representation of a
argument statement.Declared representation of a
argument statement.Utility class for dealing with arguments encountered by StatementSupport classes.
A
FutureTask that also implements the ListenableFuture interface similar to
guava's ListenableFutureTask.An
ListeningExecutorService implementation that also allows
for an Executor to be specified on construction that is used to execute ListenableFuture callback
Runnables, registered via Futures.addCallback(com.google.common.util.concurrent.ListenableFuture<V>, com.google.common.util.concurrent.FutureCallback<? super V>, java.util.concurrent.Executor) or
ListenableFuture.addListener(java.lang.Runnable, java.util.concurrent.Executor) directly, asynchronously when a task that is run on this executor completes.AugmentationSchema represents augment definition.
Interface for all nodes which are possible targets of augmentation.
Helper namespace for attaching target information to augmentation statements.
Declared representation of a
augment statement.Class providing necessary support for processing YANG 1.1 Augment statement.
Exception thrown when the backend of a
DataTreeSnapshotCursor detects an errors which prevents it from
completing the requested operation.Effective representation of a
base statement.Declared representation of a
base statement.Utility access methods for creating and accessing YANG base type definitions.
Effective representation of a
belongs-to statement.Declared representation of a
belongs-to statement.A BiMap-based implementation of
YangNamespaceContext.Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
The binary built-in type represents any binary data, i.e., a sequence of octets.
Utility builder for
BitsTypeDefinition.Bit instances.Effective representation of a
bit statement.Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
Declared representation of a
bit statement.Makes is possible to access to the individual bits values of this type.
Contains the methods for accessing the data about the individual bit of
bits YANG type.Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
Marker interface which marks that type definition represents the built-in YANG
boolean type.A
CommonStmtCtx which has additionally been bound to a StatementSupport.Intermediate compatibility interface between
StmtContext and EffectiveStmtCtx.Current.Deprecated, for removal: This API element is subject to removal in a future version.
Use
NormalizedNode.BuilderFactory provided by ImmutableNodes.builderFactory() instead.Specification of a single parsing attempt.
Specification of how a source should be processed.
Specification of how a
module source should be processed.Specification of how a
submodule source should be processed.Utility methods for interacting with
ByteBufs.A ThreadPoolExecutor with a specified bounded queue capacity that favors reusing previously
constructed threads, when they are available, over creating new threads.
A opportunistically-caching
DerivedString.Mockito Answer which for un-stubbed methods forwards the call to the real
method if it is implemented on the mocked object (i.e.
A typed value in its internal Java representation.
Support for a
CanonicalValue subclasses.CanonicalValue validator interface.A violation of a
CanonicalValue validation.Effective representation of a
case statement.The CaseSchemaNode interface is used to define branches of the ChoiceSchemaNode.
Declared representation of a
case statement.Utility holder similar to
Optional, except the empty case contains an Exception, which should be
reported, for example via throwing it.Effective representation of a
choice statement.Node representing data instance of
choice.A builder of
ChoiceNodes.A ChoiceSchemaNode defines a set of alternatives.
Declared representation of a
choice statement.Utility methods for working with ClassLoaders and classes.
Abstract cache for codecs.
Common interface for all statement contexts, exposing information which is always available.
A
YangStatementLexer backed by more efficient token factory.Utility class used for tracking parser state as needed by a StAX-like parser.
Policy on how child nodes should be treated when an attempt is made to add them multiple times.
Builder of
TypeDefinitions for use in leaf statements.Support for creating
TypeDefinition instances defined by leaf and leaf-list statements.Effective representation of a
config statement.Declared representation of a
config statement.Exception thrown when a proposed change fails validation before being
applied into the Data Tree because the Data Tree has been modified
in way that a conflicting node is present.
Common interface for statements which contain either a description/reference or a description/reference/status combo.
Contains methods which retrieve values for description, error message, error app tag and reference (to some external
definition, resource or similar).
Effective representation of a
contact statement.Declared representation of a
contact statement.Effective representation of a
container statement.Common interface for common container-like constructs.
Base class supporting
OperationDefinition.toContainerLike() and
NotificationDefinition.toContainerLike().Data subtree with cardinality 0..1 in the context of parent node.
A builder of
ContainerNodes.Utility class used for tracking parser state as needed by a StAX-like parser.
The ContainerSchemaNode is used to define an interior data node in the schema tree.
Deprecated, for removal: This API element is subject to removal in a future version.
This class is deprecated for removal.
Declared representation of a
container statement.Deprecated.
Reactor's view of significant semantic history of a particular statement.
A RejectedExecutionHandler that delegates to a backing RejectedExecutionHandler and counts the
number of rejected tasks.
A
DataTreeModification which allows creation of a DataTreeModificationCursor.A
DataTreeSnapshot which allows creation of a DataTreeSnapshotCursor.A
DistinctContainer containing DataContainerChild children.Marker interface for direct children of
DataContainerNode.Abstract node which does not have value but contains valid
DataContainerChild nodes.Statement that defines new data nodes.
Node which can contains other nodes.
General validator for container like statements, e.g.
Schema derived data providing necessary information for mapping between
NormalizedNode and serialization format defined in RFC6020,
since the mapping is not one-to-one.A
DataSchemaContext containing other DataSchemaContexts.This node is a
NormalizedNode intermediate, not represented in RFC7950 XML encoding.Marker interface for contexts which boil down to a simple, not-structured
ValueNode.Semantic tree binding a
EffectiveModelContext to a NormalizedNode tree.Data Schema Node represents abstract supertype from which all data tree definitions are derived.
Identifier of a RFC8342 (NMDA) datastore.
Interface representing a data tree which can be modified in an MVCC fashion.
Interface implemented by all
SchemaTreeAwareEffectiveStatements which can contain a data tree child.An encapsulation of a validated data tree modification.
Utility serialization/deserialization for
DataTreeCandidate.A single node within a
DataTreeCandidate.Utility class holding methods useful when dealing with
DataTreeCandidate instances.A
DataTreeCandidate which is also a DataTreeTip.DataTree configuration class.
Common interface grouping all
EffectiveStatements which are accessible via
DataTreeAwareEffectiveStatement.dataTreeNodes().Factory interface for creating data trees.
Class encapsulation of set of modifications to a base tree.
Extension to the
DataTreeSnapshotCursor which allows modifying the data tree.Read-only snapshot of a
DataTree.A cursor holding a logical position within a
DataTreeSnapshot.Tip of a data tree instance.
Exception thrown when a proposed change fails validation before being applied into the datastore.
An implementation of ListeningExecutorService that attempts to detect deadlock scenarios that could occur if clients
invoke the returned Future's
get methods synchronously.Dedicated type for YANG's 'type decimal64' type.
Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
Contains methods for getting data from the YANG
type substatement for decimal64 built-in
type.A
DeclarationReference to something which resembles file.A
DeclarationReference to a position within a some text document.Reference to a statement declaration.
Represents declared statement.
Static entry point to enriching
DeclaredStatements covered in the RFC7950 metamodel with
DeclarationReferences.Utility class for formatting
DeclaredStatements.Builder class for instantiation of a customized
DeclaredStatementFormatter.Static entry point to instantiating
DeclaredStatement covered in the RFC7950 metamodel.Effective statement representation of 'default-deny-all' extension defined in
RFC6536.
Represents the effect of 'default-deny-all' extension, as defined in
RFC6536, being attached to a SchemaNode.
Declared statement representation of 'default-deny-all' extension defined in
RFC6536.
Effective statement representation of 'default-deny-write' extension defined in
RFC6536.
Represents the effect of 'default-deny-write' extension, as defined in
RFC6536, being attached to a SchemaNode.
Declared statement representation of 'default-deny-write' extension defined in
RFC6536.
Effective representation of a
default statement.A
JSONValueWriter backed by a JsonWriter.Utility class for instantiating default-configured
CrossSourceStatementReactors.Default implementation of a
SchemaTreeInference.Declared representation of a
default statement.Marker interface for statements which may contain a 'default' statement, as defined in RFC7950.
Default implementation of the
StatementDefinition contract.Default implementation of
YangXPathParserFactory for javax.inject-based dependency injection
frameworks.Reference
YangLibResolver implementation.Reference
YangParserFactory implementation.A
YangTextSource delegating to a CharSource.A
YinTextSource delegating to a ByteSource.Implementation of this interface delegates all its calls to the delegate if not specified otherwise.
Abstract base class for objects which are string-equivalent to canonical string representation specified
in a YANG model.
Builder of
TypeDefinitions for use in typedef statements.YANG defines 'derived type' as a type created through a 'typedef' statement.
Effective representation of a
description statement.Declared representation of a
description statement.Interface describing YANG 'deviate' statement.
Effective representation of a
deviate statement.Enumeration describing
deviate
YANG statement argument.Declared representation of a
deviate statement.Class providing necessary support for processing YANG 1.1 deviate statement.
Interface describing YANG 'deviation' statement.
Effective representation of a
deviation statement.Declared representation of a
deviation statement.A
NormalizedContainer which contains distinctly-addressable children.A
NormalizedNodeContainer which contains directly-addressable children.Common interface for statements which contain either a description/reference or a description/reference/status combo.
Node which can have documentation assigned.
An AnyxmlNode with data in
DOMSource format.Entry describing a duplicate found in a
NormalizedNode tree.Abstract class that calculates and tracks time duration statistics.
EffectiveStatement-based result of YANG parser compilation.An asynchronous factory for building
EffectiveModelContext instances based on a specification of what
SourceIdentifiers are required and dynamic recursive resolution.Effective model statement which should be used to derive application behaviour.
Marker interface for objects which have an equivalent EffectiveStatement.
A base class of an
EffectiveModelContext context reasoning with regards to what logical sequence of
EffectiveStatements were considered.Mix-in interfaces providing services required by SchemaNode et al.
Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and ActionNodeContainer.Deprecated, for removal: This API element is subject to removal in a future version.
See deprecation notice in
AddedByUsesAwareBridge between
EffectiveStatement and AugmentationTarget.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and ConstraintMetaDefinition.Deprecated.
Scheduled for removal with
CopyableNode.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and DataNodeContainer.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and DataSchemaNode.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and DocumentedNode.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and
DocumentedNode.WithStatus.Support interface for various mixins.
Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and MandatoryAware.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and MustConstraintAware.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and NotificationNodeContainer.Helper bridge for
anydata and anyxml opaque data.Helper bridge for operation containers (
input and output).Helper bridge for
rpc and action operations.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and presence statement.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and SchemaNode.Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and UnknownSchemaNode.EffectiveStatementMixins.UserOrderedAwareMixin<A,D extends DeclaredStatement<A>,E extends OrderedByAwareEffectiveStatement<A,D>>
Bridge between
EffectiveStatementMixins.EffectiveStatementWithFlags and ordered-by statement.Helper used to locate the effective
when statement and exposing its argument as per
WhenConditionAware.Static entry point to instantiating declared
EffectiveStatement covered in the RFC7950 metamodel.Significant state captured by an
EffectiveStatement at its instantiation site.Effective view of a
StmtContext for the purposes of creating an EffectiveStatement.Minimum amount of state required to build an accurate effective view of a statement.
Minimum amount of parent state required to build an accurate effective view of a particular child.
Effective
config statement value.A restricted version of
EffectiveStmtCtx.Current, which does not expose the raw argument or the declared statement.Utility holder of a two-variant value.
Contains method which returns various data constraints for a list-like YANG element
(e.g.
Common interface for list-like nodes, which can optionally have constraints on the number of direct children.
Dedicated type for YANG's
type empty value.A specialized always-empty implementation of
Deque.Effective representation of a
enum statement.Utility builder for
EnumTypeDefinition.EnumPair instances.Declared representation of a
enum statement.Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
Makes is possible to access to the individual enumeration values of this type.
Contains the methods for accessing the data about the concrete enumeration item which represents
enum
YANG type.Effective representation of a
error-app-tag statement.Declared representation of a
error-app-tag statement.Effective representation of a
error-message statement.Declared representation of a
error-message statement.Enumeration of
error-severity values, as defined by
RFC4741, section 4.3.Extensible enumeration of
error-tag values, as defined in
RFC6241.Enumeration of
error-type values.Utility exception mapper which translates an Exception to a specified type of Exception.
Utility methods for dealing with
ExecutorServices.Interface specifying access to extensions attached to a particular object.
Contains the methods for getting the data which are part of the YANG
extensoion statement.Effective representation of an
extension statement.Declared representation of a
extension statement.A ThreadPoolExecutor with a specified bounded queue capacity that favors creating new threads
over queuing, as the former is faster.
Interface describing YANG 'feature' statement.
Effective representation of a
feature statement.A set of features.
A builder for a sparse FeatureSet.
Declared representation of a
feature statement.Interface implemented by plugins which can generate files from a
EffectiveModelContext.EffectiveModelContext can be assembled in multiple ways, we hold known modes here.An exception reporting a problem with file generation.
A
ServiceLoader factory for instantiating FileGenerator instances.Cache implementation that stores schemas in form of files under provided folder.
A
YangTextSource backed by a file.A
AbstractYinTextSource backed by a file.Utility methods for working with
FluentFutures.A NormalizedNode holding a value in some foreign object model.
A
NormalizedNodeStreamWriter which formats events into a String, available via #result().Common base class for forwarding implementations of
DeclaredStatement.A
ForwardingObject which additionally masks ForwardingIdentityObject.hashCode()/ForwardingIdentityObject.equals(Object) of a delegate object,
so that it can be a data transfer object with data-dependent implementations of those contracts can be use in
collections and maps which need to work on identity.Utility forwarding implementation of
StatementSupport contract.Effective representation of a
fraction-digits statement.Declared representation of a
fraction-digits statement.The contents of a generated file and its
GeneratedFileLifecycle.Lifecycle policy of a generated file.
A relative path to a generated file.
Type of generated file.
Effective statement representation of 'get-filter-element-attributes' extension defined in
RFC6241.
Represents the effect of 'get-filter-element-attributes' extension, as defined in
RFC6241.
Declared statement representation of 'get-filter-element-attributes' extension defined in
RFC6241.
Support for
GetFilterElementAttributesStatement and its effective view.Interface describing YANG 'grouping' statement.
Effective representation of a
grouping statement.Declared representation of a
grouping statement.Deprecated, for removal: This API element is subject to removal in a future version.
This class has a rather complicated and ugly design.
Utility class for incrementally building object hashCode by hashing together component objects, one by one.
An
Identifier tied to some tree-like structure, similar to how Path is tied to a
conceptual file system.A generalized contract of an object which has an identifier.
General identifier interface.
Utility methods for implementing string-to-identity codecs.
Effective representation of a
identity statement.Contains method for getting data from
identityref built-in YANG type.Interface describing YANG 'identity' statement.
Declared representation of a
identity statement.Contains the method for getting the details about YANG
identity.IETF YANG Module Tags Registry, as defined in
RFC8819 section 7.2, table 2.
Effective representation of a
if-feature statement.A resolved
if-feature expression, implementing a Predicate.Represents YANG if-feature statement.
Utility interface for translation between a external form and an internal form.
Immutable Object - object does not change its externally-observable state during its lifetime.
A
NormalizedNode.BuilderFactory producing builders which produce immutable in-memory normalized nodes.Template for instantiating
UnmodifiableMapPhase instances with a fixed set of keys.A simple
NormalizedNodeStreamWriter.MetadataExtension implementation, which takes care of building NormalizedMetadata based on
additional nesting instructions.Snapshot of currently-open data- and metadatastate.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ImmutableNodes instead.Utilities for creating immutable implementations of various
NormalizedNodes.Immutable implementation of
NormalizedMetadata.A Builder of
ImmutableNormalizedMetadata instances.An immutable
NormalizedMountPoint.Immutable implementation of
NormalizedMountpoints.A Builder of
ImmutableNormalizedMountpoints instances.Implementation of
NormalizedNodeStreamWriter, which constructs immutable instances of
NormalizedNodes.Implementation of the
Map interface which stores a set of immutable mappings using a key-to-offset map and
a backing array.Template for instantiating
ImmutableOffsetMap instances with a fixed set of keys.Immutable implementation of
ThreadFactoryProvider.Builds instances of type
ImmutableThreadFactoryProvider.Immutable implementation of
YangNetconfError.Builds instances of type
ImmutableYangNetconfError.StatementSupport trait for statements which create intermediate parent node for some of its child nodes.An implicit sub-statement, which is implied to be always present in its parent, even if it does not appear in model
source.
Statement-local namespace carrying the versioning information about how the import was satisfied.
Effective representation of a
import statement.Enumeration of various ways of resolving
import statements.Declared representation of a
import statement.Effective representation of a
include statement.Declared representation of a
include statement.Exception thrown when a proposed change fails validation before being applied into the datastore
because of incorrect structure of user supplied data.
A
StatementSourceException indicating an inference problem, e.g.Read-only snapshot of the data tree.
A factory for creating in-memory data trees.
Effective representation of a
input statement.Declared representation of a
input statement.Interface to parsing of
InputStreams containing YANG-modeled data.A DTO capturing the result of
InputStreamNormalizer.parseChildData(EffectiveStatementInference, InputStream).Codec which serializes / deserializes InstanceIdentifier.
Contains methods for getting data from the
instance-identifier YANG built-in type.Type definition derived from int16 type.
Type definition derived from int32 type.
Type definition derived from int64 type.
Type definition derived from int8 type.
Utility class for sharing instances of
LeafSetEntryNodes which have low cardinality -- e.g.Exception thrown from NormalizedNodeInputStreamReader when the input stream does not contain
valid serialized data.
Thrown when there was invalid element in YANG file.
Support methods for reading and writing
IRStatements.An argument composed of multiple concatenated parts.
An argument composed of a single string.
A single YANG statement in its raw string form.
Marker interface for specifying ordering of items.
Items are ordered and their order is significant.
Items are unordered and their order is insignificant.
A codec capable of performing normalized value conversion with a
JsonWriter.Factory for creating JSON equivalents of codecs.
API entry point for acquiring
JSONCodecFactory instances.This implementation will create JSON output as output stream.
This class parses JSON elements from a GSON JsonReader.
A serialized JSON string, indicating what kind of value it represents.
The kind of a
JSONValue.A handler used to write out JSON-encoded values.
Factory Method class for JsonWriter creation.
Effective representation of a
key statement.Declared representation of a
key statement.Lazily-populated CodecCache.
Utility methods for lazily instantiated collections.
Support utilities for dealing with Maps which would normally hold
DataContainerChild values, but are modified
to eliminate LeafNode instances.Effective representation of a
leaf statement.Utility class for sharing instances of
LeafNodes which have low cardinality-- e.g.Utility class used for tracking parser state as needed by a StAX-like parser.
Utility class used for tracking parser state as needed by a StAX-like parser.
Interface describing YANG 'leaf-list' statement.
Declared representation of a
leaf-list statement.Leaf node with multiplicity 0..1.
A builder of
LeafNodes.Utility class used for tracking parser state as needed by a StAX-like parser.
Helper interface aiding resolution of
type leafref chains.Interface describing YANG
leaf statement.Leaf node with multiplicity 0...n.
A builder of
LeafSetEntryNodes.Node representing set of simple leaf nodes.
A builder of
LeafSetNodes.Declared representation of a
leaf statement.Deprecated.
Deprecated.
Deprecated.
A single value length restriction, as expressed by a length statement, as specified by
[RFC-6020] The length Statement.
Effective representation of a
length statement.Interface for
TypeDefinitions which can have their values restricted to a set of allowed lengths.Declared representation of a
length statement.Class used by the
QueuedNotificationManager that contains a snapshot of notification
queue statistics for a listener.Deprecated, for removal: This API element is subject to removal in a future version.
Use
ObjectRegistration insteadDeprecated, for removal: This API element is subject to removal in a future version.
Use
ObjectRegistry insteadUtility class used for tracking parser state as needed by a StAX-like parser.
Utility class used for tracking parser state as needed by a StAX-like parser.
Interface describing YANG 'list' statement.
Declared representation of a
list statement.A
NormalizedNodeStreamWriter which logs the events into a Logger.Mix-in interface for
SchemaNodes which can have a mandatory statement.Effective representation of a
mandatory statement.Declared representation of a
mandatory statement.Marker interface for statements which may contain a 'mandatory' statement, as defined in RFC7950.
A simple layer on top of maps, which performs snapshot mediation and optimization of
what the underlying implementation is.
Instance of Map entry, this node does not contains value, but child nodes.
A builder of
MapEntryNodes.Containment node, which contains
MapEntryNode of the same type, which may be quickly retrieved using a key.A builder of
MapNodes.Maximum allowed access, as defined by
RFC2578 Section 7.3.
Effective representation of a
max-elements statement.Declared representation of a
max-elements statement.Constants associated with RFC7952.
A piece of
NormalizedAnydata with a corresponding piece of NormalizedMetadata.StatementDefinitions for statements defined by RFC7952.Nicer shorter toString() for
Method than it's default.Effective representation of a
min-elements statement.Declared representation of a
min-elements statement.Exception thrown when a the specified schema source is not available.
Thrown when there was Missing element in yang file.
Deprecated, for removal: This API element is subject to removal in a future version.
This interface assumes XML encoding.
Builder for effective model inference action.
User-defined inference action.
The concept of phase execution order, expressed as non-negative values.
Model statement.
A
Map which can be modified and supports efficient conversion to an unmodifiable map.Enumeration of all possible node modification states.
Exception thrown when a proposed change fails validation before being
applied into the Data Tree because tree node which child nodes are
modified or written did not exist when transaction started
and still does not exists when transaction is processed.
Effective representation of a
modifier statement.Enum describing the effect of a YANG modifier statement.
Represents YANG modifier statement.
This interface contains the methods for getting the data from the YANG module.
Creates a module dependency graph from provided
Modules and provides a ModuleDependencySort.sort(Collection) method.Effective view of a
module statement.Interface describing YANG 'import' statement.
This interface contains common methods for getting the schema contents from a YANG module or submodule.
Utility
YangNamespaceContext backed by a SchemaContext, resolving namespaces to their module names.Implementation-internal cache for looking up URI to import prefix.
An SPI-level interface to find the schema source for a particular YANG module, as packaged in the final artifact.
Declared representation of a
module statement.Effective statement representation of 'module-tag' extension defined in
RFC8819.
Declared statement representation of 'module-tag' extension defined in
RFC8819.
StatementDefinitions for statements defined by RFC8819.Parser support for
module-tag statement.More
Answer variants.An unresolved child within a mount point.
A context of either an explicit (RFC8528 Schema Mount instance) or implicit (system root).
An entity able to resolve the SchemaContext for embedded mount points based on generic data provided by the current
interpretation context.
Top-level containers which hold YANG Library information, ordered by descending preference, with more modern
and/or preferred entries first.
YANG Schema Mount-supported data attached to either a
list item or a container.Effective statement representation of 'mount-point' extension defined in
RFC8528.
Exception thrown when a mount-point-related operation cannot be performed.
The name (label) of a YANG schema mount instance, as defined in
RFC8528.
A
NormalizedMountPoint-aware counterpart to NormalizedNodeWriter.Represents the effect of 'mount-point' extension, as defined in
RFC8528, being attached to a SchemaNode.
Declared statement representation of 'mount-point' extension defined in
RFC8528.
Marker interface for
AbstractNodeDataWithSchema specializations which are composed of multiple entries.Mix-in interface for nodes which can define must constraints.
Contains methods for accessing constraint declaration for valid data in form
of XPath expressions.
YANG example:
YANG example:
must "ifType != 'ethernet' or (ifType = 'ethernet' and ifMTU = 1500)";
Effective representation of a
must statement.Declared representation of a
must statement.Mutable object - object may change it's state during lifecycle.
A mutable version of
ImmutableOffsetMap.Mutable statement interface.
A mutable tree node.
Constants associated with RFC6536.
StatementDefinitions for statements defined by RFC6536.Definition / implementation of specific Identifier Namespace behaviour.
NamespaceBehaviours corresponding to ParserNamespaces.Effective representation of a
namespace statement.Namespace key matching criterion.
Thrown when identifier namespace is not available (supported) in a specific model processing phase.
Declared representation of a
namespace statement.Support work with namespace content.
A hierarchical entity storing a portion (or entirety) of a
ParserNamespace.Enumeration of all possible types of storage.
Constants associated with RFC6241.
Enumeration of NETCONF layers, as established in
NETCONF.
StatementDefinitions for statements defined by RFC6241.A no-operation codec cache.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
NoOpObjectRegistration insteadImplementation of
ObjectRegistration which does nothing in its NoOpObjectRegistration.close() method.An
anydata value object model which can be normalized to
NormalizedAnydata when provided with proper context.This exception is typically reported by methods which normalize some external format into a
NormalizationResult.The result of a
NormalizedNodeStreamWriter stream, i.e.Client-allocated result holder for
ImmutableNormalizedNodeStreamWriter operation.The contents of an
anydata node in a normalized format.A piece of
NormalizedData which holds some child NormalizedNodes.A piece of data normalized to a particular
EffectiveModelContext.RFC7952 metadata counterpart to a
NormalizedNode.A utility class to attach
NormalizedMetadata into a NormalizedNode stream, such as the one produced by
NormalizedNodeWriter, so that a target NormalizedNodeStreamWriter sees both data and metadata in
the stream.Normalized representation of a YANG mount point.
RFC8528 mount point counterpart to a
NormalizedNode structure.Node which is normalized according to the YANG schema
is identifiable by a
YangInstanceIdentifier.A builder of
NormalizedNodes.A factory for concrete
NormalizedNode.Builders.Node which is not leaf, but has child
NormalizedNodes as its value.NormalizedNodeContainerBuilder<I extends YangInstanceIdentifier.PathArgument,K extends YangInstanceIdentifier.PathArgument,V extends NormalizedNode,R extends NormalizedNode>
Interface for reading
NormalizedNodes, YangInstanceIdentifiers, YangInstanceIdentifier.PathArguments
and SchemaNodeIdentifiers.Interface for emitting
NormalizedNodes, YangInstanceIdentifiers, YangInstanceIdentifier.PathArguments
and SchemaNodeIdentifiers.A set of utility methods for interacting with
NormalizedNode objects.Enumeration of all stream versions this implementation supports on both input and output.
Event Stream Writer based on Normalized Node tree representation.
Extension interface for
NormalizedNodeStreamWriter.Extension to the NormalizedNodeStreamWriter with metadata support.
An
NormalizedNodeStreamWriter.Extension exposed by stream writers which can handle mount point data, notably providing
the facilities to resolve a mount point schema and normalize mount point contents into a normalized structure.Utility class for tracking schema state underlying a
NormalizedNode structure.This is an experimental iterator over a
NormalizedNode.A tuple of normalized
NormalizedTuple.data(), with corresponding NormalizedTuple.metadata() and NormalizedTuple.mountPoints().Interface describing YANG 'notification' statement.
Effective representation of a
notification statement.Interface for a class that manages queuing and dispatching notifications for multiple listeners.
NotificationNodeContainerCompat<A,D extends DeclaredStatement<A>,E extends SchemaTreeAwareEffectiveStatement<A,D>>
Compatibility bridge between
NotificationNodeContainer.findNotification(QName) and
SchemaTreeAwareEffectiveStatement.Declared representation of a
notification statement.Class providing necessary support for processing YANG 1.1 Notification
statement.
An empty alternative to
Revision.An extension to a concrete
ExtensibleObject.An OID, or ObjectIdentifier, as defined by ITU and ISO/IEC.
Class representing a registration of an object.
Interface implemented by
NamespaceStorages which support dynamic addition of child elements as they
are requested.Constants associated with OpenDaylight extension in yang-ext.yang.
Effective statement corresponding to config's "openconfig-hashed-value" (new name) or "openconfig-encrypted-value"
(old name).
SchemaNode presence in SchemaNode API space.
Declared statement corresponding to config's "openconfig-hashed-value" (new name) or "openconfig-encrypted-value"
(old name).
Effective statement corresponding to openconfig's "posix-pattern".
Declared statement corresponding to config's "posix-pattern" .
Effective statement corresponding to config's "regexp-posix" .
Declared statement corresponding to config's "regexp-posix" .
Constants associated with OpenDaylight extension in yang-ext.yang.
Common interface for action and rpc statements.
Common interface for an operation, such as an
RpcDefinition or an ActionDefinition.A general base exception for an operation failure.
An
EffectiveStatement which can contain an OrderedByEffectiveStatement, controlling ordering of
data elements.Effective representation of a
ordered-by statement.Declared representation of a
ordered-by statement.A
NormalizedContainer which preserves user supplied ordering and allows addressing of child elements by
position.A
NormalizedNodeContainer which preserves user supplied ordering and allows addressing of child elements by
position.Item ordering, as specified by
RFC7950 section 7.7.1.
Marker interfaces for
NormalizedNodeContainers which have distinct ordering requirements.Marker interface for NormalizedNodeContainer implementations which correspond to
ordered-by system.Marker interface for NormalizedNodeContainer implementations which correspond to
ordered-by user.Effective representation of a
organization statement.Declared representation of a
organization statement.Effective representation of a
output statement.Declared representation of a
output statement.An additional trait for
StatementSupport, allowing a parent statement to override the support for a child
statement.ParserNamespace serves as common superclass for namespaces used during parser operation.Baseline
ParserNamespaces mostly derived from YANG specification.Effective representation of a
path statement.An expression as defined in RFC7950 Section 9.9.2,
i.e.
Steps of a PathExpression which is a combination of
deref() function call and a relative path,
corresponding to Errata 5617.Steps of a PathExpression which is a LocationPath, corresponding to RFC7950 base specification.
Abstract base class for expressing steps of a PathExpression.
Declared representation of a
path statement.Contains the method for getting the data from the YANG
pattern which is substatement
of type statement.Effective representation of a
pattern statement.An intermediate capture of the argument to
pattern statement.Declared representation of a
pattern statement.Effective representation of a
position statement.Declared representation of a
position statement.A potential schema source.
Each registered source has a cost associated with it.
Pre-computed thread-safe CodecCache.
YANG Module Tag Prefixes Registry, as defined in
RFC8819.
Effective representation of a
prefix statement.Interface for resolving XML prefixes to their bound
QNameModules.Declared representation of a
prefix statement.Effective representation of a
presence statement.Declared representation of a
presence statement.A capture of a tree-like construct, which can be formatted into a pretty-printed tree.
Utility interface to bridge structures which can be formatted via
PrettyTree.Provides utilities for system properties.
The QName from XML consists of local name of element and XML namespace, but for our use, we added module revision to
it.
Utility methods for parsing and writing QNames.
A
XMLNamespace bound to a particular model Revision.Module-local namespace holding the module's QName.
An object referencing a QName, either resolved or unresolved.
Map of fully qualified statement name to statement definition.
Stateless Normalized Node Stream Writer decorator, which performs QName translation.
Simple
EffectiveStatementState for use with typical SchemaTreeEffectiveStatements.This class manages queuing and dispatching notifications for multiple listeners concurrently.
MXBean interface for
QueuedNotificationManager statistic metrics.A single value range restriction, as expressed by a range statement, as specified by
[RFC-6020] The range Statement.
Effective representation of a
range statement.RangeRestrictedTypeBuilder<T extends RangeRestrictedTypeDefinition<T,N>,N extends Number & Comparable<N>>
Interface for
TypeDefinitions which can have their values restricted to a set of allowed values.Declared representation of a
range statement.A read-only view of a
DataTree.Effective representation of a
reference statement.Declared representation of a
reference statement.Effective representation of a
refine statement.Declared representation of a
refine statement.Convenience
ExceptionMapper which instantiates specified Exception using
reflection.Class representing a registration.
YANG 1.1 AnyData effective statement implementation.
Exception thrown when
min-elements or max-element statement restrictions are violated.Effective representation of a
require-instance statement.Interface for
TypeDefinitions which can be restricted through a require-instance statement.Declared representation of a
require-instance statement.A
QNameReferent referencing a resolved QName.Restricted types are a refinement of the restrictions applied to a particular type.
A reusable variant of
ImmutableNormalizedNodeStreamWriter.Utility marker interface for
NormalizedNodeStreamWriter implementations which can be reused multiple times
and can expose a NormalizedNode result of each complete streaming use.Dedicated object identifying a YANG module revision.
Effective representation of a
revision-date statement.Declared representation of a
revision-date statement.Effective representation of a
revision statement.Declared representation of a
revision statement.A capture of an optional
revision-date.Utility class holding entrypoints for assembling RFC6020/RFC7950 statement
CrossSourceStatementReactors.Common interface capturing general layout of a top-level YANG declared statement -- either a
ModuleStatement
or a SubmoduleStatement.Common interface capturing general layout of a top-level YANG declared statement -- either
a
ModuleEffectiveStatement or a SubmoduleEffectiveStatement.A marker interface for a
StmtContext.Interface describing YANG 'rpc' statement.
Effective representation of a
rpc statement.Representation of an error.
Represents a general result of a call, request, or operation.
A builder for creating RpcResult instances.
Declared representation of a
rpc statement.The interface represents static view of compiled yang files,
contains the methods for obtaining all the top level context
data (data from all modules) like YANG notifications, extensions,
operations...
SchemaContextFactory configuration class.
The Schema Context Util contains support methods for searching through Schema Context modules for specified schema
nodes via Schema Path or Revision Aware XPath.
A state tracking utility for walking
EffectiveModelContext's contents along schema/grouping namespaces.Semantic binding of
EffectiveStatementInference produced by SchemaInferenceStack.Constants associated with RFC8528.
StatementDefinitions for statements defined by RFC7952.SchemaNode represents a node in schema tree.
Represents unique path to every schema node inside the schema node identifier namespace.
An absolute schema node identifier.
A descendant schema node identifier.
This is an iterator over a
NormalizedNode.Interface exposed by repository implementations.
Exception thrown when a Schema Source fails to resolve.
Exception thrown when a failure to acquire a schema source occurs.
A filter of schema sources.
Listener on
SourceRepresentation lifecycle.Schema source provider implementations take care of resolving a
SourceIdentifier
into a particular representation of the schema source.Registry of all potentially available schema sources.
SchemaSourceTransformer.Transformation<S extends SourceRepresentation,D extends SourceRepresentation>
Interface implemented by all
EffectiveStatements which can contain a schema tree child.Common interface grouping all
EffectiveStatements which are accessible via
SchemaTreeAwareEffectiveStatement.schemaTreeNodes().An
EffectiveStatementInference consisting purely of steps along the schema tree axis, so that it
represents a schema tree node based on resolution of absolute-schema-nodeid as specified by
RFC7950 section 6.5.Common interface implemented by entities which act as the root of the
schema tree and are able to resolve an
SchemaNodeIdentifier to a SchemaTreeEffectiveStatement.SchemaValidationFailedException is thrown when an attempt is made to modify the data tree and the modification
does not match the schema context.
A single version according to Semantic Versioning.
A thread-safe lazily-populated codec cache.
A
SchemaRepository which allows sharing of SchemaContext as long as their specification is the same.Implementation of the
Map interface which stores a single mapping.Template for instantiating
SharedSingletonMap instances with a fixed key.Utility class used for tracking parser state as needed by a StAX-like parser.
Simple subclass of
AbstractSchemaContext which performs some amount of indexing to speed up common
SchemaContext operations.A
Set containing a single value.Utility methods for instantiating
Spliterators containing a single element.A simple
AbstractSchemaSourceCache maintaining soft references.Common interface expressing a dependency on a source, be it a
ModuleStatement
or a SubmoduleStatement.A dependency created by a
BelongsToStatement.A dependency created by an
ImportStatement.A dependency created by an
IncludeStatement.Thrown to indicate error in YANG model source.
Utility class for converting ANTLRErrorListener errors to SourceExceptions.
Base class of YANG Schema source identifiers.
Linkage information about a particular
SourceRepresentation.A
SourceInfo about a ModuleStatement-backed source.A
SourceInfo about a submodule.Common interface for schema source representations.
Factory methods for creating
ExecutorService instances with specific configurations.A
StatementSourceReference which acts as its own DeclarationReference, i.e.A
StatementDeclaration which acts as its own DeclarationInText.A
StatementDeclaration.InText which acts as its own DeclarationInFile.Factory for creating default
StatementDeclaration implementations.Definition / model of YANG
DeclaredStatement and EffectiveStatement.Module-specific namespace for holding
StatementDefinitions defined by extension statements.An entity capable of creating
DeclaredStatement and EffectiveStatement instances for a particular
type.Enumeration of possible origins of a statement.
An exception identifying a problem detected at a particular YANG statement.
Reference of statement source.
Statement stream source, which is used for inference of effective model.
Support for processing concrete YANG statement.
Statement context copy policy, indicating how should reactor handle statement copy operations.
Abstract base class for comparators associated with statements with a
StatementSupport.CopyPolicy.DECLARED_COPY copy
policy.A baseline class for implementing the
StatementFactory.canReuseCurrent(Current, Current, List)
contract in a manner which is consistent with a statement's StatementSupport.CopyPolicy.Resumed statement state.
Enumeration describing YANG 'status' statement.
Effective representation of a
status statement.Declared representation of a
status statement.An inference context associated with an instance of a statement.
An mutable view of an inference context associated with an instance of a statement.
Intermediate compatibility interface between
StmtContext and EffectiveStmtCtx.Current.A tree node which has references to its child leaves.
A set of utility methods for interacting with
StoreTreeNode objects.Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
Contains method for getting data from the
string YANG built-in type.A
YangTextSource with content readily available.This interface contains the methods for getting the data from the YANG submodule.
Representation of
submodule statement.Declared representation of a
submodule statement.Constants associated with RFC8639.
StatementDefinitions for statements defined by RFC8639.Exception thrown when indexing of substatements of either a
AbstractDeclaredEffectiveStatement or
AbstractUndeclaredEffectiveStatement fails.LeafSetNode which does not preserve user-supplied ordering.A builder of
SystemLeafSetNodes.MapNode which additionally preserves user-supplied ordering.A builder of
SystemMapNodes.Builder for
ThreadFactory.Mockito Answer which for un-stubbed methods throws an
UnstubbedMethodException (instead of Mockito's default of returning null).
Utility class that provides topological sort.
Interface for edges in graph that can be sorted topologically.
Basic Edge implementation.
Interface for nodes in graph that can be sorted topologically.
Basic Node implementation.
A
LinkedBlockingQueue that tracks the largest queue size for debugging.A very basic data tree node.
DataTree type, specifying which YANG modeled content is valid with a data tree.Marker interface for SchemaNodes which store simple data, for which we have type information.
A codec, which knows what the native representation for a particular data type is.
A
DataSchemaNode which holds values of the same type.Interface implemented by all
EffectiveStatements which can contain a typedef child.Effective model statement which should be used to derive application behaviour related to
typedefs.YANG statement
typedef contains also substatements
default - default value which is compatible with
type,
type - base type from which is typedef derived,
units - textual information about units associated with this
type.
This interface contains the methods for getting the values of the arguments of substatements mentioned above.Interface indicating an entity which acts as a holder of a
TypeDefinition.Declared representation of a
typedef statement.Effective view of a
type statement.Declared representation of a
type statement.Class providing necessary support for processing YANG 1.1 Type statement.
Dedicated type for YANG's
type uint16 type.A codec between Uint16 and some other representation.
Type definition derived from uint16 type.
Dedicated type for YANG's
type uint32 type.A codec between Uint32 and some other representation.
Type definition derived from uint32 type.
Dedicated type for YANG's
type uint64 type.A codec between Uint64 and some other representation.
Type definition derived from uint64 type.
Dedicated type for YANG's
type uint8 type.A codec between Uint8 and some other representation.
Type definition derived from uint8 type.
An entity capable of creating undeclared
EffectiveStatement instances for a particular type.Static entry point to instantiating undeclared
EffectiveStatement covered in the RFC7950 metamodel.Contains the method which access union item in the union type.
Exception thrown when a
unique statement restrictions are violated.Interface describing YANG
unique statement.Declared representation of a
unique statement.Effective representation of a
units statement.Declared representation of a
units statement.List entry node, which does not have value, but child nodes.
A builder of
UnkeyedListNodes.Containment node, which contains
UnkeyedListEntryNode of the same type, which may be quickly retrieved using
key.A builder of
UnkeyedListNodes.Effective counterpart to
UnknownStatement.Contains the methods for getting the details about the unknown node.
A statement not covered by the base metamodel, e.g.
Deprecated, for removal: This API element is subject to removal in a future version.
An unmodifiable view over a
Collection.An unmodifiable view over a
Map.A
Map which cannot be modified and supports efficient conversion to a ModifiableMapPhase.Common interface for unrecognized unknown statements.
A
QName equivalent which has not been resolved.An unresolved, qualified
QName.An unresolved, unqualified
QName.A
QNameReferent referencing an unresolved QName.Exception to be thrown on unstubbed method calls.
Set of utility methods for instantiating parser that deal with untrusted XML sources.
A
YangTextSource backed by a URL.A
AbstractYinTextSource.backed by a URL.LeafSetNode which preserves user-supplied ordering.A builder of
UserLeafSetNodes.MapNode which additionally preserves user-supplied ordering.A builder of
UserMapNodes.Common interface for
DataSchemaNodes which can have an ordered-by substatement.Effective representation of a
uses statement.Contains the methods for getting data and checking properties of the YANG
uses substatement.Declared representation of a
uses statement.Namespace used for validating whether a node is of some type, e.g.
Effective representation of a
value statement.Interface holding the common trait of
LeafSetEntryNode and LeafNode, which both hold a value.YANG specification of a numeric value range.
Declared representation of a
value statement.Wraps around a value object.
The concept of a version, either node version, or a subtree version.
Mix-in interface for nodes which can be conditional on a when statement.
Effective representation of a
when statement.Declared representation of a
when statement.A combination of both
Identifier and WritableObject.Marker interface for an object which can be written out to an
DataOutput.Utility methods for working with
WritableObjects.A codec capable of performing normalized value conversion with a
XMLStreamWriter.A thread-safe factory for instantiating
XmlCodecs.A simple type capture of
namespace statement's argument according to
RFC6020.This class provides functionality for parsing an XML source containing YANG-modeled data.
A
NormalizedNodeStreamWriter which translates the events into an XMLStreamWriter, resulting in an
RFC6020 XML encoding.A binary expression formed of a
YangBinaryExpr.getLeftExpr(), an YangBinaryExpr.getOperator() and a YangBinaryExpr.getRightExpr().YANG XPath binary operator.
Expressions which evaluate to a logical
true or false.Common interface for all YANG XPath constant expressions.
Constant definitions present in RFC documents related to the YANG language.
Constants associated with RFC8040.
Effective statement representation of 'yang-data' extension defined in
RFC 8040.
Identifier of a RESTCONF
yang-data extension template instantiation.Represents 'yang-data' extension statement defined in
RFC8040.
Declared statement representation of 'yang-data' extension defined in
RFC 8040.
StatementDefinitions for statements defined by RFC8040.Common base interface for all YANG Expression components.
Functions known to a YANG XPath.
Function call invocation.
Unique identifier of a particular node instance in the data tree.
Fluent Builder of Instance Identifier instances.
Simple path argument identifying a
ContainerNode or
LeafNode leaf in particular subtree.Composite path argument identifying a
MapEntryNode leaf
overall data tree.Simple path argument identifying a
LeafSetEntryNode leaf
overall data tree.Path argument / component of InstanceIdentifier.
Utility for emitting a
YangInstanceIdentifier into a NormalizedNodeStreamWriter as a set of
startXXXNode events.Dedicated exception for reporting conditions where
error-tag should be reported as invalid-value.A
YangSourceRepresentation backed by an IRStatement.Utility class for extract
SourceInfo from a YangIRSource.A single RFC8525
module-set.A service capable of transforming a
YangLibModuleSet to an EffectiveModelContext.A single RFC8525
submodule list entry.An XPath literal expression.
A step along an axis.
Utility class for handling various naming conventions mentioned in YANG and related specifications.
Interface for mapping between
String prefixes and QNameModule namespaces.A
YangExpr combining a YangNaryOperator with a set of expressions.YANG XPath n-ary operator.
Baseline interface for metadata associated with a NETCONF notion of an 'error'.
Interface exposed from objects which have some association with
YangNetconfError.A number-bearing expression.
Configurable single-use YANG parser.
A configuration of
YangParser wiring for use with YangParserFactory.Base exception reported by
YangParser.Basic entry point into a YANG parser implementation.
Utility class which provides convenience methods for producing effective schema context based on the supplied
YANG/YIN sources or paths to these sources.
Common interface for
YangFilterExpr and YangLocationPath.Step, both of which can contain predicates.An XPath QName expression.
A YANG
SourceRepresentation.This class represents implementation of StatementStreamSource in order to emit YANG statements using supplied
StatementWriter.
Mapping for both RFC6020 and RFC7950 statements.
A YANG text snippet generated from a
DeclaredStatement.YANG text schema source representation.
Enumeration of supported YANG versions.
Effective representation of a
yang-version statement.An exception indicating source-level problem across multiple YANG sources relating to how they are allowed to be
linked between YANG versions.
Declared representation of a
yang-version statement.XPath evaluation axis, as defined in XPath 1.0.
An XPath expression.
A Qualified-bound expression.
An Unqualified-bound expression.
YangXPathParser number compliance knobs.Interface supporting mathematical operations.
XPath node type as defined in XPath 1.0.
Interface for converting a String into a
YangXPathExpression.A
YangXPathParser bound to a YangNamespaceContext, producing Qualified-bound Expressions.A
YangXPathParser bound to a YangNamespaceContext and a default namespace, producing
Unqualified-bound Expressions.Factory for creating
YangXPathParsers.Utility
YinXmlSource exposing a W3C DOMSource representation of YIN model.Effective representation of a
yin-element statement.Declared representation of a
yin-element statement.A YIN
SourceRepresentation.A
StatementStreamSource based on a YinXmlSource.YIN text schema source representation.
A
SchemaSourceTransformer which handles translation of models from YinTextSource representation into
YinDomSource.Factory for creating
XMLEventReader instances reporting events equivalent to reading a YIN document defining
a specified ModuleEffectiveStatement.YIN text schema source representation.