def addImpliedProtocol ( self, proto, adapter = NO_ADAPTER_NEEDED,
depth = 1 ):
self.__lock.acquire()
try:
key = mkRef( proto )
if not updateWithSimplestAdapter(
self.__implies, key, adapter, depth
):
return self.__implies[ key ][ 0 ]
finally:
self.__lock.release()
# Always register implied protocol with classes, because they should
# know if we break the implication link between two protocols
for klass, ( baseAdapter, d ) in self.__adapters.items():
api.declareAdapterForType(
proto, composeAdapters( baseAdapter, self, adapter ), klass,
depth + d
)
if self.__listeners:
for listener in self.__listeners.keys(): # Must use keys()!
listener.newProtocolImplied( self, proto, adapter, depth )
return adapter
def newRegistry(self,subject):
# Create a registry that's also set up for inheriting declarations
reg = conformsRegistry()
reg.subject = mkRef(subject)
return reg
def addImpliedProtocol(self,proto,adapter=NO_ADAPTER_NEEDED,depth=1):
self.__lock.acquire()
try:
key = mkRef(proto)
if not updateWithSimplestAdapter(
self.__implies, key, adapter, depth
):
return self.__implies[key][0]
finally:
self.__lock.release()
# Always register implied protocol with classes, because they should
# know if we break the implication link between two protocols
for klass,(baseAdapter,d) in self.__adapters.items():
api.declareAdapterForType(
proto,composeAdapters(baseAdapter,self,adapter),klass,depth+d
)
if self.__listeners:
for listener in self.__listeners.keys(): # Must use keys()!
listener.newProtocolImplied(self, proto, adapter, depth)
return adapter
class conformsRegistry(dict):
"""Helper type for objects and classes that need registration support"""
def __call__(self, protocol):
# This only gets called for non-class objects
if protocol in self:
subject = self.subject()
if subject is not None:
return self[protocol][0](subject)
def findImplementation(self, subject, protocol, checkSelf=True):
for cls in getMRO(subject):
conf = cls.__dict__.get('__conform__')
if conf is None:
continue
if not isinstance(conf,conformsRegistry):
raise TypeError(
"Incompatible __conform__ in base class", conf, cls
)
if protocol in conf:
return conf[protocol][0](subject)
def newProtocolImplied(self, srcProto, destProto, adapter, depth):
subject = self.subject()
if subject is None or srcProto not in self:
return
baseAdapter, d = self[srcProto]
adapter = composeAdapters(baseAdapter,srcProto,adapter)
declareAdapterForObject(
destProto, adapter, subject, depth+d
)
def __hash__(self):
# Need this because dictionaries aren't hashable, but we need to
# be referenceable by a weak-key dictionary
return id(self)
def __get__(self,ob,typ=None):
if ob is not None:
raise AttributeError(
"__conform__ registry does not pass to instances"
)
# Return a bound method that adds the retrieved-from class to the
return instancemethod(self.findImplementation, typ, type(typ))
def __getstate__(self):
return self.subject(), self.items()
def __setstate__(self,(subject,items)):
self.clear()
self.update(dict(items))
self.subject = mkRef(subject)
