A generic representation of a number. This type does not make any assumption
about the precision to reach (simple, double etc., decimal32, 64) on the target
computer.
The number format is a string, so the implementation is expected to have parsing
options to convert this value into an appropriate format on the system. For
example, we know that Python is flexible enough to convert such a string into a
float number.
Examples of numbers that can be represented with this type:
-1, 2, 0, +4.5e4, -.5e4, -1.2e-5, 0.34, -5.6e-4 - 16e3j
We want to use this generic representation of a number to express any physical
body without the need for specifying number limit representation (such as
fraction-digit in decimal64 types). This way we can reuse a 'mass' to express
the 'mass of Sun' or a 'mass of a proton' by keeping the same fundamental
unit.
NOTE: For Python users, spaces are allowed in this pattern to make a clear
distinction between the real and the imaginary parts. complex() does not
accept -5.6e-4 - 16e3j as valid format, but prefers -5.6e-4-16e3j. Spaces
need to be replaced first.
variable
union
A variable is a mathematical or physical entity that can be referred to either
as a number for constants, or a name for variables.
This union type helps assign or get values based on numbers or abstract names.
Namespace design needs a special care as name conflict mitigation is outside the
scope of this YANG model. For example, namespace conflict can be solved by using
dots or underscores (see YANG 1.1 instance-reference for XPath resolution).
NOTE: name is an alias, and is not necessarily connected to any variable name on
implementation. The NETCONF server should store a mapping between variable
names and the corresponding attributes on the implementation. This is also
outside the scope of this YANG model.
The NETCONF server should return an <rpc-error> with an error of type
'bad-element' if the variable name cannot be retrieved.
variable-name
union
A generic representation of a variable name. This type validates that the string
identifying a variable is correct from the perspective of many languages.
The implementation is expected having a smart looking up table. For example, we
know that python can get any attribute of a target instance or module by calling
the getattr() function, and providing it the string name of this attribute.
The format of the variable representation is outside of the scope of this YANG
model, and can be language dependent. XML XPath representation can be used if
the NETCONF server has the XPath capability to resolve the variable name. If
the implementation is coded in Python, a path with dot can be used to represent
the target instance. For example 'foo.bar' would refer to attribute 'bar' in
instance or module 'foo'.
The type restriction of this name is believed to encompass as many language
conventions as possible, and must not override the string pattern of a number.
Consequently, a valid name must:
1. Start with an alphabetical character, a dot, a colon, or an underscore
2. Is followed by any number of alphanumerical character, dots, colons and
underscore
3. Prohibit dash and space
It is the XML naming convention, but this restriction allows that the name
starts with 'xml'. For example 'xml12' is a valid variable name (but it is not a
valid xml tag).
When the naming convention cannot be one of the popular languages, then this
type automatically falls back to an instance-identifier, and the name should
correspond to an instance in the data tree, otherwise the NETCONF server will
raise an <rpc-error> message.