Delegacja

Delegacja pozwala zmienić zachowanie jednej (wybranej) metody lub kilku metod klasy bez zmiany jej typu (a przynajmniej - bez zmiany intyerfejsu). Osiąga się to przez schowanie obiektu klasy bazowej w środku obiektu klasy potomnej i odpowiednim przekierowaniu wywołań.

class InnerClass:

    def my_method(self):
        return "metoda wewnętrzna"

class SimpleDelegation:

    def __init__(self,inner):
        self.__inner = inner

    def my_method(self):
        return "nadpisana " + self.__inner.my_method()


if __name__ == "__main__" :

    ic = InnerClass()
    sd = SimpleDelegation(ic)
    for obct in [ic,sd] :
        print(obct.my_method())

Zauważ, że delegacje bardzo przypominają Pythonowe dekoratory.

Note

Delegacja opiera się na zawieraniu obiektu - obiekt klasy InnerClass jest schowany wewnątrz SimpleDelegation. Ten sam efekt można osiągnąć, wykorzystując dziedziczenie

Drugi przykład jest już bardziej praktyczny. Poniżej zdefiniowano klasę bazową AtomSelector, która zaznacza bądź nie zaznacza podane atomy. Klasa ta jest tylko interfejsem, definiuje metodę która pojawi się w klasach potomnych. Następnie zdefiniowano dwa konkretne selektory (SelectCA który zaznacza węgle alfa oraz SelectHeavyBB do zaznaczania ciężkich atomów łańcucha głównego białka).

from sys import argv
from Atom import Atom


class AtomSelector :
    """ Base class for atom selectors
    """
    def __call__(self, atom):
        raise NotImplementedError


class SelectCA(AtomSelector) :
    """ Selects alpha carbons
    """
    def __call__(self, atom):
        if atom.name == " CA " : return True
        return False


class SelectHeavyBB(AtomSelector) :
    """ Selects backbone heavy atoms
    """
    def __call__(self, atom):
        if atom.name == " N  " or atom.name == " CA " \
            or atom.name == " C  " or atom.name == " O  " : 
            return True
        return False


class InvertSelector(AtomSelector) :

    def __init__(self,selector) :
        self.__selector = selector

    def __call__(self, atom):
        return not self.__selector(atom)


class LogicORSelector(AtomSelector) :

    def __init__(self) :
        self.__selectors = []

    def add_selector(self, sel):
        self.__selectors.append(sel)

    def __call__(self, atom):
        for s in self.__selectors :
            if s(atom): return  True
        return False


if __name__ == "__main__" :

    # Read atoms from a PDB file
    atoms = []
    i = 1
    for line in open(argv[1]) : # e.g. "2gb1.pdb"
        if line.startswith("ATOM  ") :
            atoms.append( Atom(i, line[12:16], line[76:78]) )
    
    # Create some selectors
    is_ca = SelectCA()
    is_bb = SelectHeavyBB()
    is_sc = InvertSelector(SelectHeavyBB())
    print("name   is_CA  is_BB  is_SC")
    print("--------------------------")
    for ai in atoms :
        print("%4s   %5s  %5s  %5s" %(ai.name,is_ca(ai), is_bb(ai), is_sc(ai)))

Meritum tego przykładu (wzorzec delegacji) pojawia się w klasie InvertSelector, do odwrócenia zaznaczenia dowolnego obiektu. Sama klasa InvertSelector nie wie, co ma zaznaczyć; jedynie wykorzystuje do tego celu podany selektor (przechowywany jako prywatne pole klasy self.__selector), traktując go jako czarną skrzynkę. Następnie stosuje operator logiczny negacji do otrzymanego wyniku. Zauważ, że efektu tego nie można by uzyskać przez dziedziczenie. Owszem, można np. odziedziczyć po klasie SelectCA aby odwrócić to zaznaczenie:

class SelectNotCA(SelectCA) :

    def __call__(self, atom):
        return not self.__selector(atom)

Klasa InvertSelector jednak może coś więcej: ona odwraca dowolne zaznaczenie, podane jako argument dla jej konstruktora. Kolejnym selektorem z delegacją jest LogicORSelector, który zwraca prawdę, gdy choć jeden z selektorów jest spełniony Zauważ, że InvertSelector oraz LogicORSelector są typu AtomSelector (dziedziczą po nim).