Método Memento: patrones de diseño de Python

Memento Method es un patrón de diseño de comportamiento que brinda la capacidad de restaurar un objeto a su estado anterior. Sin revelar los detalles de implementaciones concretas, le permite guardar y restaurar la versión anterior del objeto. Intenta no perturbar la encapsulación del código y te permite capturar y externalizar el estado interno de un objeto.
 

Problema sin usar Memento Method

Imagina que eres un estudiante que quiere sobresalir en el mundo de la programación competitiva pero te enfrentas a un problema, es decir, encontrar un buen editor de código para programar, pero ninguno de los editores de código actuales satisface tus necesidades, por lo que intentas crear uno para ti. Una de las características más importantes de cualquier editor de código es DESHACER y REHACER , que esencialmente también necesita. Como desarrollador sin experiencia, acaba de utilizar el enfoque directo de almacenar todas las acciones realizadas. ¡Por supuesto, este método funcionará pero de manera ineficiente!
 

Memento-Problema-diagrama

Solución por el Método Memento

Analicemos la solución al problema mencionado anteriormente. Todo el problema se puede resolver fácilmente al no alterar la encapsulación del código. El problema surge cuando algunos objetos intentan realizar tareas extra que no les son asignadas, y por lo que invaden el espacio privado de otros objetos. El patrón Memento representa la creación de instantáneas de estado para el propietario real de ese estado, el objeto originador. Por lo tanto, en lugar de que otros objetos intenten copiar el estado del editor desde «afuera», la clase del editor en sí puede hacer la instantánea ya que tiene acceso total a su propio estado.
De acuerdo con el patrón, debemos almacenar la copia del estado del objeto en un objeto especial llamado Mementoy el contenido de los objetos memento no son accesibles a ningún otro objeto excepto al que los produjo.
 

"""Memento class for saving the data"""
 
class Memento:
 
    """Constructor function"""
    def __init__(self, file, content):
 
        """put all your file content here"""
         
        self.file = file
        self.content = content
 
"""It's a File Writing Utility"""
 
class FileWriterUtility:
 
    """Constructor Function"""
 
    def __init__(self, file):
 
        """store the input file data"""
        self.file = file
        self.content = ""
 
    """Write the data into the file"""
 
    def write(self, string):
        self.content += string
 
    """save the data into the Memento"""
 
    def save(self):
        return Memento(self.file, self.content)
 
    """UNDO feature provided"""
 
    def undo(self, memento):
        self.file = memento.file
        self.content = memento.content
 
"""CareTaker for FileWriter"""
 
class FileWriterCaretaker:
 
    """saves the data"""
 
    def save(self, writer):
        self.obj = writer.save()
 
    """undo the content"""
 
    def undo(self, writer):
        writer.undo(self.obj)
 
 
if __name__ == '__main__':
 
    """create the caretaker object"""
    caretaker = FileWriterCaretaker()
 
    """create the writer object"""
    writer = FileWriterUtility("GFG.txt")
 
    """write data into file using writer object"""
    writer.write("First vision of GeeksforGeeks\n")
    print(writer.content + "\n\n")
 
    """save the file"""
    caretaker.save(writer)
 
    """again write using the writer """
    writer.write("Second vision of GeeksforGeeks\n")
 
    print(writer.content + "\n\n")
 
    """undo the file"""
    caretaker.undo(writer)
 
    print(writer.content + "\n\n")

Diagrama UML

El siguiente es el diagrama UML para Memento’s Method
 

Memento-método-UML-Diagram

Ventajas

• Fomenta la encapsulación: el método Memento puede ayudar a producir el estado del objeto sin romper la encapsulación del código del cliente.
• Código simplificado: podemos aprovechar la ventaja del cuidador que puede ayudarnos a simplificar el código manteniendo el historial del código del creador.
• Implementación de Memento genérico: es mejor usar la serialización para lograr una implementación de patrón de recuerdo que sea más genérica en lugar de un patrón de Memento en el que cada objeto debe tener su propia implementación de clase de Memento.

Desventajas

• Gran consumo de memoria: si el objeto del originador es muy grande, el tamaño del objeto Memento también será enorme y usará mucha memoria, lo que definitivamente no es la forma eficiente de hacer el trabajo.
• Problema con los lenguajes dinámicos: los lenguajes de programación como Ruby , Python y PHP son lenguajes de escritura dinámica, no pueden garantizar que el objeto de recuerdo no se toque.
• Eliminación difícil: no es fácil eliminar el objeto de recuerdo porque el cuidador tiene que rastrear el ciclo de vida del creador para obtener el resultado.

Aplicabilidad

• DESHACER y REHACER: la mayoría de las aplicaciones de software como Paint, IDE de codificación, editor de texto y muchas otras ofrecen funciones de DESHACER y REHACER para comodidad del cliente.
• Proporcionando Encapsulación: Podemos usar el método de Memento para evitar la ruptura de la encapsulación en el código del cliente que se puede producir por el acceso directo a la implementación interna del objeto.

Lectura adicional: método Memento en Java