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 registerImplementation ( self, klass, adapter = NO_ADAPTER_NEEDED,
depth = 1 ):
self.__lock.acquire()
try:
if not updateWithSimplestAdapter(
self.__adapters, klass, adapter, depth
):
return self.__adapters[ klass ][ 0 ]
finally:
self.__lock.release()
if adapter is DOES_NOT_SUPPORT:
# Don't register non-support with implied protocols, because
# "X implies Y" and "not X" doesn't imply "not Y". In effect,
# explicitly registering DOES_NOT_SUPPORT for a type is just a
# way to "disinherit" a superclass' claim to support something.
return adapter
for proto, ( extender, d ) in self.getImpliedProtocols():
api.declareAdapterForType(
proto, composeAdapters( adapter, self, extender ), klass,
depth + d
)
return adapter
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 registerImplementation(self,klass,adapter=NO_ADAPTER_NEEDED,depth=1):
self.__lock.acquire()
try:
if not updateWithSimplestAdapter(
self.__adapters,klass,adapter,depth
):
return self.__adapters[klass][0]
finally:
self.__lock.release()
if adapter is DOES_NOT_SUPPORT:
# Don't register non-support with implied protocols, because
# "X implies Y" and "not X" doesn't imply "not Y". In effect,
# explicitly registering DOES_NOT_SUPPORT for a type is just a
# way to "disinherit" a superclass' claim to support something.
return adapter
for proto, (extender,d) in self.getImpliedProtocols():
api.declareAdapterForType(
proto, composeAdapters(adapter,self,extender), klass, depth+d
)
return adapter
