Re: [Qemu-devel] [PATCH v6 02/12] qapi: Don't use info as witness of implicit object type

[Eric Blake <eblake@redhat.com>]

[-- Attachment #1: Type: text/plain, Size: 2834 bytes --]

On 10/02/2015 10:48 AM, Markus Armbruster wrote:

>>> Do it the OO-way: QAPISchemaEntity.is_implicit() returns False.  Any
>>> subclass that can have implicitly defined instances overrides it:
>>> QAPISchemaObjectType.is_implicit() tests for ':' prefix,
>>> QAPISchemaEnumType.is_implicit() tests for 'Kind' suffix (requires
>>> outlawing it for user enums, if we don't do it already), and so forth.
>>
>> But there's still the issue of filtering by subclass.  For the
>> qapi-types visit_needed() filter, I either write:
>>
>> if isinstance(entity, QAPISchemaObjectType) and entity.is_implicit()
> 
> If is_implicit() is defined on entities, then this shrinks to just
> 
>     entity.is_implicit()
> 
> because no non-type entity is implicit.

QAPISchemaEnumType is not a subclass of QAPISchemaObjectType, but it can
indeed be implicit (currently depends on whether its name ends in
"Kind").  Right now, the code we generate doesn't care about whether
enums are implicit. But having enum.is_implicit() return False merely
because it is not an ObjectType feels wrong; if anything, we'd want to
name it is_implicit_object() if we are only returning whether an object
is implicit.

> 
>> or what I want to write:
>>
>> if entity.is_implicit(QAPISchemaObjectType)
> 
> I'm not even sure what that's supposed to mean :)

If entity is an implicit ObjectType, return True. If it is implicit but
not an object (such as an implicit enum), or is not implicit (regardless
of whether it is an ObjectType), then return False.

And if you don't need filtering by python type, then
entity.is_implicit() (shorthand for entity.is_implicit(None)) then gives
the correct answer whether entity is ObjectType or EnumType or something
else.

> 
>> while still allowing the common case of is_implicit() when I don't care
>> which type is doing the testing.  Since python doesn't allow method
>> overloads, I'd have to repeat the:
>>
>>     def is_implicit(self, type=None):
>>         if type and not isinstance(self, type):
>>             return False
>>
>> prefix in each subclass that overrides the basic version.
> 
> AH, you seem to propose to define E.is_implicit(T) as "E is implicitly
> defined and not an instance of T".  Why not simply keep the two
> predicates seperate?  Am I missing something?

No, I was thinking E.is_implicit(T) is "E is implicitly defined and IS
an instance of T", while E.is_implicit(None) (the default) doesn't care
about type relations.  To get that semantic, each override of the base
class .is_implicit() has to first filter out all non-T, before going
into its class-specific tests (ObjectType for leading ':', EnumType for
trailing 'Kind').

-- 
Eric Blake   eblake redhat com    +1-919-301-3266
Libvirt virtualization library http://libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]