स्मृति चिन्ह पैटर्न

स्मृति चिन्ह पैटर्न एक सॉफ्टवेयर डिजाइन पैटर्न है जो किसी ऑब्जेक्ट की व्यक्तिगत आंतरिक स्थिति को उजागर करता है। इसका उपयोग कैसे किया जा सकता है इसका एक उदाहरण किसी ऑब्जेक्ट को उसकी पूर्व स्थिति में पुनर्स्थापित करना है (रोलबैक के माध्यम से पूर्ववत करें), दूसरा संस्करण है, दूसरा कस्टम क्रमांकन है।

स्मृति चिन्ह पैटर्न को तीन ऑब्जेक्ट के साथ लागू किया गया है: प्रवर्तक, एक कार्यवाहक और एक स्मृति चिन्ह। प्रवर्तक कुछ ऐसे ऑब्जेक्ट है जिसकी आंतरिक स्थिति होती है। कार्यवाहक प्रवर्तक के लिए कुछ करने जा रहा है, परन्तु परिवर्तन को पूर्ववत करने में सक्षम होना चाहता है। कार्यवाहक पूर्व प्रवर्तक से स्मृति चिन्ह ऑब्जेक्ट माँगता है। फिर यह जो भी संचालन (या संचालन का क्रम) करता है वह करता है। संचालन से पूर्व स्थिति में वापस आने के लिए, यह स्मृति चिन्ह ऑब्जेक्ट को प्रवर्तक को लौटाता है। स्मृति चिन्ह अपने आप में एक अपारदर्शी ऑब्जेक्ट है (जिसे कार्यवाहक बदल नहीं सकता है या नहीं बदलना चाहिए)। इस पैटर्न का उपयोग करते समय, ध्यान रखा जाना चाहिए कि प्रवर्तक अन्य ऑब्जेक्ट या संसाधनों को बदल सकता है - स्मृति चिन्ह पैटर्न एक ही ऑब्जेक्ट पर संचालित होता है।

स्मृति चिन्ह पैटर्न के उत्कृष्ट उदाहरणों में एक छद्म यादृच्छिक संख्या जनरेटर शामिल है (पीआरएनजी का प्रत्येक उपभोक्ता एक देखभालकर्ता के रूप में कार्य करता है जो एक ही बीज (स्मृति चिन्ह) के साथ पीआरएनजी (प्रवर्तक) को छद्म यादृच्छिक संख्याओं के समान अनुक्रम का उत्पादन करने के लिए प्रारंभ कर सकता है) और स्थिति एक परिमित स्थिति मशीन में।

सिंहावलोकन

स्मृति चिन्ह डिज़ाइन पैटर्न उन तेईस प्रसिद्ध डिज़ाइन पैटर्न में से एक है जो यह वर्णन करता है कि लचीले और पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर को डिज़ाइन करने के लिए आवर्ती डिज़ाइन समस्याओं को कैसे हल किया जाए, अर्थात ऐसी ऑब्जेक्टएँ जिन्हें लागू करना, बदलना, परीक्षण करना और पुन: उपयोग करना आसान है। . स्मृति चिन्ह पैटर्न को शुरुआती एचपी उत्पादों के लिए नूह थॉम्पसन, डेविड एस्पिरिटु और डॉ। ड्रू क्लिंकेनबर्ड द्वारा बनाया गया था।

स्मृति चिन्ह डिज़ाइन पैटर्न किन समस्याओं को हल कर सकता है?

• किसी ऑब्जेक्ट की आंतरिक स्थिति को बाहरी रूप से सहेजा जाना चाहिए ताकि ऑब्जेक्ट को बाद में इस स्थिति में बहाल किया जा सके।
• ऑब्जेक्ट के एनकैप्सुलेशन का उल्लंघन नहीं किया जाना चाहिए।

समस्या यह है कि एक अच्छी तरह से डिज़ाइन की गई ऑब्जेक्ट को एनकैप्सुलेट किया जाता है ताकि उसका प्रतिनिधित्व (डेटा संरचना) ऑब्जेक्ट के अंदर छिपा हुआ है और ऑब्जेक्ट के बाहर से एक्सेस नहीं किया जा सकता है।

स्मृति चिन्ह डिज़ाइन पैटर्न किस समाधान का वर्णन करता है?

किसी ऑब्जेक्ट (प्रवर्तक) को स्वयं के लिए उत्तरदायी बनाएं

• अपनी आंतरिक स्थिति को एक (स्मृति चिन्ह) ऑब्जेक्ट में सहेजना और
• एक (स्मृति चिन्ह) ऑब्जेक्ट से पूर्व स्थिति में बहाल करना।

स्मृति चिन्ह बनाने वाले को ही इसे एक्सेस करने की अनुमति है।

एक ग्राहक (कार्यवाहक) प्रवर्तक से एक स्मृति चिन्ह का अनुरोध कर सकता है (प्रवर्तक की आंतरिक स्थिति को बचाने के लिए) और एक स्मृति चिन्ह को प्रवर्तक को वापस भेज सकता है (पूर्व स्थिति को पुनर्स्थापित करने के लिए)।

यह एक प्रवर्तक की आंतरिक स्थिति को उसके एनकैप्सुलेशन का उल्लंघन किए बिना बचाने और पुनर्स्थापित करने में सक्षम बनाता है।

नीचे यूएमएल क्लास और सीक्वेंस डायग्राम भी देखें।

संरचना

यूएमएल वर्ग और अनुक्रम आरेख

स्मृति चिन्ह डिजाइन पैटर्न के लिए एक नमूना यूएमएल वर्ग और अनुक्रम आरेख।

उपरोक्त यूएमएल वर्ग आरेख में,

Caretaker वर्ग को संदर्भित करता है Originator कक्षा

बचत के लिए (createMemento()) और बहाल करना (restore(memento)) प्रवर्तक की आंतरिक स्थिति।
Originator ई> वर्ग लागू करता है
(1) createMemento() a बनाकर और वापस करके Memento ऑब्जेक्ट जो प्रवर्तक की वर्तमान आंतरिक स्थिति को संग्रहीत करती है और
(2) restore(memento) पारित से स्थिति बहाल करके Memento ऑब्जेक्ट।

एकीकृत मॉडलिंग भाषा अनुक्रम आरेख रन-टाइम इंटरैक्शन दिखाता है:
(1) प्रवर्तक की आंतरिक स्थिति को सहेजना: Caretaker ई> ऑब्जेक्ट कॉल createMemento() पर Originator ऑब्जेक्ट, जो एक बनाता है Memento ऑब्जेक्ट, बचाता है इसकी वर्तमान आंतरिक स्थिति (setState()), और लौटाता है Memento तक Caretaker.
(2) प्रवर्तक की आंतरिक स्थिति को बहाल करना: Caretaker ई> कॉल restore(memento) पर Originator ऑब्जेक्ट और निर्दिष्ट करता है Memento ऑब्जेक्ट जो उस स्थिति को संग्रहीत करता है जिसे पुनर्स्थापित किया जाना चाहिए। Originator ई> स्थिति प्राप्त करता है (getState()) से Memento अपना स्थिति स्थापित करने के लिए।

जावा उदाहरण

निम्नलिखित जावा प्रोग्राम स्मृति चिन्ह पैटर्न के पूर्ववत उपयोग को दिखाता है।

import java.util.List;
import java.util.ArrayList;
class Originator {
    private String state;
    // The class could also contain additional data that is not part of the
    // state saved in the memento..
 
    public void set(String state) {
        this.state = state;
        System.out.println("Originator: Setting state to " + state);
    }
 
    public Memento saveToMemento() {
        System.out.println("Originator: Saving to Memento.");
        return new Memento(this.state);
    }
 
    public void restoreFromMemento(Memento memento) {
        this.state = memento.getSavedState();
        System.out.println("Originator: State after restoring from Memento: " + state);
    }
 
    public static class Memento {
        private final String state;

        public Memento(String stateToSave) {
            state = stateToSave;
        }
 
        // accessible by outer class only
        private String getSavedState() {
            return state;
        }
    }
}
 
class Caretaker {
    public static void main(String[] args) {
        List<Originator.Memento> savedStates = new ArrayList<Originator.Memento>();
 
        Originator originator = new Originator();
        originator.set("State1");
        originator.set("State2");
        savedStates.add(originator.saveToMemento());
        originator.set("State3");
        // We can request multiple mementos, and choose which one to roll back to.
        savedStates.add(originator.saveToMemento());
        originator.set("State4");
 
        originator.restoreFromMemento(savedStates.get(1));   
    }
}

आउटपुट है:

प्रवर्तक: स्थिति को स्थिति1 पर सेट करना
प्रवर्तक: स्थिति को स्थिति2 पर सेट करना
प्रवर्तक: स्मृति चिह्न के लिए सहेजा जा रहा है।
ओरिजिनेटर: स्टेट को स्टेट पर सेट करना3
प्रवर्तक: स्मृति चिह्न के लिए सहेजा जा रहा है।
प्रवर्तक: स्थिति को स्थिति के रूप में स्थापित करना4
प्रवर्तक: स्मृति चिन्ह से पुनर्स्थापित करने के बाद स्थिति: स्थिति 3

यह उदाहरण स्थिति के रूप में एक स्ट्रिंग का उपयोग करता है, जो जावा में एक अपरिवर्तनीय ऑब्जेक्ट है। वास्तविक जीवन के परिदृश्य में स्थिति करेगा लगभग हमेशा एक परिवर्तनशील ऑब्जेक्ट होती है, जिस स्थिति में स्थिति की एक प्रति बनाई जानी चाहिए।

यह कहा जाना चाहिए कि दिखाए गए कार्यान्वयन में एक खामी है: यह एक आंतरिक वर्ग की घोषणा करता है। यह बेहतर होगा यदि यह स्मृति चिन्ह रणनीति एक से अधिक प्रवर्तकों पर लागू हो।

स्मृति चिन्ह प्राप्त करने के मुख्य रूप से तीन अन्य तरीके हैं:

1. क्रमांकन।
2. एक ही पैकेज में घोषित वर्ग।
3. ऑब्जेक्ट को एक प्रॉक्सी के माध्यम से भी एक्सेस किया जा सकता है, जो ऑब्जेक्ट पर किसी भी सेव / रिस्टोर संचालन को प्राप्त कर सकता है।

सी # उदाहरण

स्मृति चिन्ह पैटर्न किसी व्यक्ति को एनकैप्सुलेशन का उल्लंघन किए बिना किसी ऑब्जेक्ट की आंतरिक स्थिति को कैप्चर करने की अनुमति देता है जैसे कि बाद में यदि आवश्यक हो तो परिवर्तनों को पूर्ववत/वापस कर सकता है। यहाँ कोई देख सकता है कि स्मृति चिन्ह ऑब्जेक्ट वास्तव में ऑब्जेक्ट में किए गए परिवर्तनों को वापस लाने के लिए उपयोग की जाती है।

class Memento
{
    private readonly string savedState;

    private Memento(string stateToSave)
    {
        savedState = stateToSave;
    }

    public class Originator
    {
        private string state;
        // The class could also contain additional data that is not part of the
        // state saved in the memento.

        public void Set(string state)
        {
            Console.WriteLine("Originator: Setting state to " + state);
            this.state = state;
        }

        public Memento SaveToMemento()
        {
            Console.WriteLine("Originator: Saving to Memento.");
            return new Memento(state);
        }

        public void RestoreFromMemento(Memento memento)
        {
            state = memento.savedState;
            Console.WriteLine("Originator: State after restoring from Memento: " + state);
        }
    }
}

class Caretaker
{
    static void Main(string[] args)
    {
        var savedStates = new List<Memento>();

        var originator = new Memento.Originator();
        originator.Set("State1");
        originator.Set("State2");
        savedStates.Add(originator.SaveToMemento());
        originator.Set("State3");
        // We can request multiple mementos, and choose which one to roll back to.
        savedStates.Add(originator.SaveToMemento());
        originator.Set("State4");

        originator.RestoreFromMemento(savedStates[1]);
    }
}

पायथन उदाहरण

"""
Memento pattern example.
"""


class Memento:
    def __init__(self, state) -> None:
        self._state = state

    def get_saved_state(self):
        return self._state


class Originator:
    _state = ""

    def set(self, state) -> None:
        print("Originator: Setting state to", state)
        self._state = state

    def save_to_memento(self) -> Memento:
        print("Originator: Saving to Memento.")
        return Memento(self._state)

    def restore_from_memento(self, memento) -> None:
        self._state = memento.get_saved_state()
        print("Originator: State after restoring from Memento:", self._state)


saved_states = []
originator = Originator()
originator.set("State1")
originator.set("State2")
saved_states.append(originator.save_to_memento())

originator.set("State3")
saved_states.append(originator.save_to_memento())

originator.set("State4")

originator.restore_from_memento(saved_states[1])

जावास्क्रिप्ट उदाहरण

// The Memento pattern is used to save and restore the state of an object.
// A memento is a snapshot of an object's state.
var Memento = {// Namespace: Memento
    savedState : null, // The saved state of the object.

    save : function(state) { // Save the state of an object.
        this.savedState = state;
    },

    restore : function() { // Restore the state of an object.
        return this.savedState;
    }
};

// The Originator is the object that creates the memento.
// defines a method for saving the state inside a memento.
var Originator = {// Namespace: Originator
        state : null, // The state to be stored

        // Creates a new originator with an initial state of null
        createMemento : function() { 
            return {
                state : this.state // The state is copied to the memento.
            };
        },
        setMemento : function(memento) { // Sets the state of the originator from a memento
            this.state = memento.state;
        }
    };


// The Caretaker stores mementos of the objects and
// provides operations to retrieve them.
var Caretaker = {// Namespace: Caretaker
        mementos : [], // The mementos of the objects.
        addMemento : function(memento) { // Add a memento to the collection.
            this.mementos.push(memento);
        },
        getMemento : function(index) { // Get a memento from the collection.
            return this.mementos[index];
        }
    };

var action_step = "Foo"; // The action to be executed/the object state to be stored.
var action_step_2 = "Bar"; // The action to be executed/the object state to be stored.

// set the initial state
Originator.state = action_step;
Caretaker.addMemento(Originator.createMemento());// save the state to the history
console.log("Initial State: " + Originator.state); // Foo

// change the state
Originator.state = action_step_2;
Caretaker.addMemento(Originator.createMemento()); // save the state to the history
console.log("State After Change: " + Originator.state); // Bar

// restore the first state - undo
Originator.setMemento(Caretaker.getMemento(0));
console.log("State After Undo: " + Originator.state); // Foo

// restore the second state - redo
Originator.setMemento(Caretaker.getMemento(1));
console.log("State After Redo: " + Originator.state); // Bar

बाहरी संबंध

• Description of Memento Pattern in Ada
• Memento UML Class Diagram with C# and .NET code samples
• SourceMaking Tutorial
• Memento Design Pattern using Java