1
J'ai une classe qui a des callbacks et sa propre interface, quelque chose comme:callbacks prépondérants éviter la pollution de l'attribut
class Service:
def __init__(self):
connect("service_resolved", self.service_resolved)
def service_resolved(self, a,b c):
''' This function is called when it's triggered
service resolved signal and has a lot of parameters'''
la fonction de connexion est par exemple le gtkwidget.connect, mais je veux que cette connexion est quelque chose de plus général, donc je l'ai décidé d'utiliser un « tordu comme » approche:
class MyService(Service):
def my_on_service_resolved(self, little_param):
''' it's a decorated version of srvice_resolved '''
def service_resolved(self,a,b,c):
super(MyService,self).service_resolved(a,b,c)
little_param = "something that's obtained from a,b,c"
self.my_on_service_resolved(little_param)
Je peux donc utiliser MyService en surchargeant my_on_service_resolved.
Le problème est la pollution "attributs". Dans l'implémentation réelle, Service a certains attributs qui peuvent accidentellement être remplacés dans MyService et ceux qui sous-classe MyService.
Comment puis-je éviter la pollution par attributs?
Ce que j'ai pensé est un « emballage » comme approche, mais je ne sais pas si c'est une bonne solution:
class WrapperService():
def __init__(self):
self._service = service_resolved
# how to override self._service.service_resolved callback?
def my_on_service_resolved(self,param):
'''
'''