These classes and functions are also available from the top-level
protocols package. In contrast to the items already covered, these
classes and functions are generally needed only when extending the protocols
framework, as opposed to merely using it.
- class Protocol
Protocol is a base class that implements the IOpenProtocol
interface, supplying internal adapter registries for adapting from other
protocols or types/classes. Note that you do not necessarily need to use this
class (or any other IOpenProtocol implementation) in
your programs. Any object that implements the simpler IProtocol or
IAdaptingProtocol interfaces may be used as protocols for the
adapt() function. Compliance with the IOpenProtocol
interface is only required to use the protocols declaration API.
(That is, functions whose names begin with
To create protocols dynamically, you can create individual Protocol
instances, and then use them with the declaration API. You can also subclass
Protocol to create your own protocol types. If you override
__init__, however, be sure to call Protocol.__init__()
in your subclass' __init__ method.
||baseProtocol [, context=None])|
New in version 0.9.1.
A Variation is a Protocol that "inherits" adapter declarations
from an existing protocol. When you create a Variation, it declares
that it is implied by its baseProtocol, and so any adpater suitable for
adapting to the base protocol is therefore suitable for the Variation.
This allows you to then declare adapters to the variation protocol, without
affecting those declared for the base protocol. In this way, you can have a
protocol object that represents the use of the base protocol in a particular
context. You can optionally specify that context via the context
argument, which will then serve as the context attribute of the
protocol. For more background on how this works and what it might be used for,
see section 1.1.10.
||name, bases, dictionary)|
New in version 0.9.3.
AbstractBaseMeta, a subclass of Protocol and type, is a
metaclass used to create new "ABC-style" protocol objects, using class
statements. You can use this metaclass directly, but it's generally simpler to
just subclass AbstractBase instead. Normally, you will only use
AbstractBaseMeta if you need to combine it with another metaclass.
||name, bases, dictionary)|
InterfaceClass is a subclass of AbstractBaseMeta that implements
the convenience adapation API (see section 1.1.3) for its
instances. This metaclass is used to create new "pure-style" interfaces (i.e.,
protocol objects) using class statements. Normally, you will only use
InterfaceClass directly if you need to combine it with another
metaclass, as it is usually easier just to subclass Interface.
New in version .
This interface represents the ability to iterate over a container-like object,
such as a list or tuple. An IBasicSequence object must have an
__iter__() method. By default, only the built-in list and
tuple types are declared as having instances providing this interface.
If you want to be able to adapt to sequenceOf() protocols from other
sequence types, you should declare that their instances support this protocol.
- class ProviderMixin
If you have a class with a __conform__ method for its instances, but
you also want the instances to support IOpenprovider (so that
adviseObject can be used on them), you may want to include this
class as one of your class' bases. The default adapters for
IOpenprovider can only adapt objects that do not already have a
__conform__ method of their own.
So, to support IOpenprovider with a custom __conform__
method, subclass ProviderMixin, and have your __conform__
method invoke the base __conform__ method as a default, using
supermeta(MyClass,self).__conform__(protocol).) See below for more on
the supermeta() function.
Wrap func in a manner analagous to classmethod or
staticmethod, but as a metaclass-level method that may be redefined
by metaclass instances for their instances. For example, if a metaclass wants
to define a __conform__ method for its instances (i.e. classes), and
those instances (classes) want to define a __conform__ method for
their instances, the metaclass should wrap its __conform__
method with metamethod. Otherwise, the metaclass'
__conform__ method will be hidden by the class-level
__conform__ defined for the class' instances.
Emulates the Python built-in super() function, but with support for
metamethods. If you ordinarily would use super(), but are calling a
metamethod, you should use supermeta() instead. This is
because Python 2.2 does not support using super with properties (which is
effectively what metamethods are).
Note that if you are subclassing ProviderMixin or Protocol, you
will need to use supermeta() to call almost any inherited methods,
since most of the methods provided are wrapped with metamethod().
||protocol, adapter, typ [,
Declare that adapter adapts instances of class or type typ
to protocol, by adapting protocol to IOpenProtocol and
calling its registerImplementation method. If typ is adaptable
to IOpenImplementor, its declareClassImplements method is
called as well.
||protocol, adapter, ob [,
Declare that adapter adapts the object ob to protocol, by
adapting protocol to IOpenProtocol and calling its
registerObject method. Typically, ob must support
IOpenProvider. See section 1.1.6 for details.
||protocol, adapter, proto [,
Declare that adapter adapts objects that provide protocol proto
to protocol, by calling