qapi: Make BlockdevOptions doc example closer to reality

Although we don't want to repeat the entire BlockdevOptions
QMP command in the example, it helps if we aren't needlessly
diverging (the initial example was written before we had
committed the actual QMP interface).  Use names that match what
is found in qapi/block-core.json, such as '*read-only' rather
than 'readonly', or 'BlockdevRef' rather than 'BlockRef'.

For the simple union example, invent BlockdevOptionsSimple so
that later text is unambiguous which of the two union forms is
meant (telling the user to refer back to two 'BlockdevOptions'
wasn't nice, and QMP has only the flat union form).

Also, mention that the discriminator of a flat union is
non-optional.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <1458254921-17042-14-git-send-email-eblake@redhat.com>
Signed-off-by: Markus Armbruster <armbru@redhat.com>
This commit is contained in:
Eric Blake 2016-03-17 16:48:38 -06:00 committed by Markus Armbruster
parent 32bafa8fdd
commit bd59adce69

View File

@ -297,21 +297,21 @@ be empty.
A simple union type defines a mapping from automatic discriminator
values to data types like in this example:
{ 'struct': 'FileOptions', 'data': { 'filename': 'str' } }
{ 'struct': 'Qcow2Options',
'data': { 'backing-file': 'str', 'lazy-refcounts': 'bool' } }
{ 'struct': 'BlockdevOptionsFile', 'data': { 'filename': 'str' } }
{ 'struct': 'BlockdevOptionsQcow2',
'data': { 'backing': 'str', '*lazy-refcounts': 'bool' } }
{ 'union': 'BlockdevOptions',
'data': { 'file': 'FileOptions',
'qcow2': 'Qcow2Options' } }
{ 'union': 'BlockdevOptionsSimple',
'data': { 'file': 'BlockdevOptionsFile',
'qcow2': 'BlockdevOptionsQcow2' } }
In the Client JSON Protocol, a simple union is represented by a
dictionary that contains the 'type' member as a discriminator, and a
'data' member that is of the specified data type corresponding to the
discriminator value, as in these examples:
{ "type": "file", "data" : { "filename": "/some/place/my-image" } }
{ "type": "qcow2", "data" : { "backing-file": "/some/place/my-image",
{ "type": "file", "data": { "filename": "/some/place/my-image" } }
{ "type": "qcow2", "data": { "backing": "/some/place/my-image",
"lazy-refcounts": true } }
The generated C code uses a struct containing a union. Additionally,
@ -325,29 +325,29 @@ avoids nesting on the wire. All branches of the union must be
complex types, and the top-level members of the union dictionary on
the wire will be combination of members from both the base type and the
appropriate branch type (when merging two dictionaries, there must be
no keys in common). The 'discriminator' member must be the name of an
enum-typed member of the base struct.
no keys in common). The 'discriminator' member must be the name of a
non-optional enum-typed member of the base struct.
The following example enhances the above simple union example by
adding a common member 'readonly', renaming the discriminator to
something more applicable, and reducing the number of {} required on
the wire:
adding an optional common member 'read-only', renaming the
discriminator to something more applicable than the simple union's
default of 'type', and reducing the number of {} required on the wire:
{ 'enum': 'BlockdevDriver', 'data': [ 'file', 'qcow2' ] }
{ 'struct': 'BlockdevCommonOptions',
'data': { 'driver': 'BlockdevDriver', 'readonly': 'bool' } }
{ 'struct': 'BlockdevOptionsBase',
'data': { 'driver': 'BlockdevDriver', '*read-only': 'bool' } }
{ 'union': 'BlockdevOptions',
'base': 'BlockdevCommonOptions',
'base': 'BlockdevOptionsBase',
'discriminator': 'driver',
'data': { 'file': 'FileOptions',
'qcow2': 'Qcow2Options' } }
'data': { 'file': 'BlockdevOptionsFile',
'qcow2': 'BlockdevOptionsQcow2' } }
Resulting in these JSON objects:
{ "driver": "file", "readonly": true,
{ "driver": "file", "read-only": true,
"filename": "/some/place/my-image" }
{ "driver": "qcow2", "readonly": false,
"backing-file": "/some/place/my-image", "lazy-refcounts": true }
{ "driver": "qcow2", "read-only": false,
"backing": "/some/place/my-image", "lazy-refcounts": true }
Notice that in a flat union, the discriminator name is controlled by
the user, but because it must map to a base member with enum type, the
@ -382,7 +382,7 @@ data types (string, integer, number, or object, but currently not
array) on the wire. The definition is similar to a simple union type,
where each branch of the union names a QAPI type. For example:
{ 'alternate': 'BlockRef',
{ 'alternate': 'BlockdevRef',
'data': { 'definition': 'BlockdevOptions',
'reference': 'str' } }
@ -403,7 +403,7 @@ following example objects:
{ "file": "my_existing_block_device_id" }
{ "file": { "driver": "file",
"readonly": false,
"read-only": false,
"filename": "/tmp/mydisk.qcow2" } }
@ -637,11 +637,11 @@ Union types
{ "name": "BlockdevOptions", "meta-type": "object",
"members": [
{ "name": "driver", "type": "BlockdevDriver" },
{ "name": "readonly", "type": "bool"} ],
{ "name": "read-only", "type": "bool", "default": null } ],
"tag": "driver",
"variants": [
{ "case": "file", "type": "FileOptions" },
{ "case": "qcow2", "type": "Qcow2Options" } ] }
{ "case": "file", "type": "BlockdevOptionsFile" },
{ "case": "qcow2", "type": "BlockdevOptionsQcow2" } ] }
Note that base types are "flattened": its members are included in the
"members" array.
@ -652,20 +652,20 @@ discriminator (called "type" on the wire, see section Union types).
A simple union implicitly defines an object type for each of its
variants.
Example: the SchemaInfo for simple union BlockdevOptions from section
Example: the SchemaInfo for simple union BlockdevOptionsSimple from section
Union types
{ "name": "BlockdevOptions", "meta-type": "object",
{ "name": "BlockdevOptionsSimple", "meta-type": "object",
"members": [
{ "name": "type", "type": "BlockdevOptionsKind" } ],
{ "name": "type", "type": "BlockdevOptionsSimpleKind" } ],
"tag": "type",
"variants": [
{ "case": "file", "type": "q_obj-FileOptions-wrapper" },
{ "case": "qcow2", "type": "q_obj-Qcow2Options-wrapper" } ] }
{ "case": "file", "type": "q_obj-BlockdevOptionsFile-wrapper" },
{ "case": "qcow2", "type": "q_obj-BlockdevOptionsQcow2-wrapper" } ] }
Enumeration type "BlockdevOptionsKind" and the object types
"q_obj-FileOptions-wrapper", "q_obj-Qcow2Options-wrapper" are
implicitly defined.
Enumeration type "BlockdevOptionsSimpleKind" and the object types
"q_obj-BlockdevOptionsFile-wrapper", "q_obj-BlockdevOptionsQcow2-wrapper"
are implicitly defined.
The SchemaInfo for an alternate type has meta-type "alternate", and
variant member "members". "members" is a JSON array. Each element is
@ -673,9 +673,9 @@ a JSON object with member "type", which names a type. Values of the
alternate type conform to exactly one of its member types. There is
no guarantee on the order in which "members" will be listed.
Example: the SchemaInfo for BlockRef from section Alternate types
Example: the SchemaInfo for BlockdevRef from section Alternate types
{ "name": "BlockRef", "meta-type": "alternate",
{ "name": "BlockdevRef", "meta-type": "alternate",
"members": [
{ "type": "BlockdevOptions" },
{ "type": "str" } ] }