സിംഗൾട്ടൺ പാറ്റേൺ

സോഫ്റ്റ്‌വേർ എൻജിനീയറിങ്ങിൽ ഉപയോഗിക്കപ്പെടുന്ന ഒരു ഡിസൈൻ പാറ്റേണാണ്‌ സിംഗൾട്ടൺ പാറ്റേൺ, ഒരു ക്ലാസിന്റെ ഒബ്ജക്റ്റുകളുടെ പതിപ്പ് ഒരെണ്ണത്തിൽ പരിമിതപ്പെടുത്തുന്നതിനാണ്‌ ഈ പാറ്റേൺ ഉപയോഗിക്കപ്പെടുന്നത്. ഒരു വ്യൂഹത്തിൽ ഉദ്ദേശിക്കപ്പെട്ട ക്ലാസിന്റെ പ്രവർത്തനമണ്ഡലത്തിലെ പ്രവർത്തനങ്ങളെ എകോപിപ്പിച്ച് നടത്തുവാൻ ഒരു ഒബ്ജക്റ്റ് മതിയാകുമെന്ന അവസരത്തിലാണ്‌ ഈ പാറ്റേൺ ഉപയോഗപ്രദമാകുക. ഒരു ഒബ്ജക്റ്റ് മാത്രം ഉള്ള അവസരത്തിൽ കൂടുതൽ കാര്യക്ഷമതയോടെ പ്രവർത്തിക്കുന്ന വ്യൂഹങ്ങൾക്ക് വേണ്ടി ഈ ധാരണ സാമന്യവൽക്കരിക്കപ്പെട്ടിട്ടുണ്ട്. അനവസരങ്ങളിലും ഈ പാറ്റേൺ പ്രയോഗിക്കപ്പെടുന്നുവെന്നും, ഒരു ഒബ്ജക്റ്റും ആവശ്യമില്ലാത്ത സന്ദർഭങ്ങൾ ഇവ വ്യൂഹത്തിന്‌ അനാവശ്യമായ പരിമിതികൾ സൃഷ്ടിക്കുന്നുവെന്നും കരുതുന്നവരുമുണ്ട്.

ക്ലാസ്സ് രൂപരേഖ (Class diagram)

പ്രത്യക്ഷവൽക്കരണം

നിർദ്ദിഷ്ട ക്ലാസിന്റെ ഒരു ഒബ്ജക്റ്റ് മാത്രം സൃഷ്ടിക്കപ്പെടുന്നുവെന്നും ആഗോളതല സമീപന തത്ത്വങ്ങൾ പ്രകാരം അത് ലഭ്യമാകുന്നുണ്ടെന്നും സിംഗൾട്ടൺ പാറ്റേണിന്റെ പ്രത്യക്ഷവൽക്കരണത്തിൽ ഉറപ്പുവരുത്തേണ്ടതുണ്ട്. ഇതിൽ ആ ക്ലാസ്സിന്റെ ഒബ്ജക്റ്റ് പ്രത്യേകമായി നിർമ്മിക്കാതെ അതിനെ ലഭ്യമാക്കാനും അതിന്റെ അവസ്ഥ നിലനിർത്തുവാനുമുള്ള സം‌വിധാനങ്ങൾ ഉൾപ്പെടുത്തിയിരിക്കണം. ക്ലാസിന്റെ ഒരു പതിപ്പ് നിലവിലില്ലെങ്കിൽ അത് സൃഷ്ടിക്കുന്ന ഒരു മെത്തേഡ് ഉള്ള ഒരു ക്ലാസ്സ് നിർമ്മിക്കുന്നതുവഴിയാണ്‌ സിംഗൾട്ടൺ പാറ്റേൺ പ്രയോഗിക്കപ്പെടുന്നത്. ക്ലാസിന്റെ പതിപ്പ് നിലവിലുണ്ടെങ്കിൽ അതിന്റെ ഒരു റഫറൻസ് തിരിച്ചു നൽകുക മാത്രം ചെയ്യുന്നു. മറ്റ് വഴികളിലൂടെ ക്ലാസിന്റെ പതിപ്പ് സൃഷ്ടിക്കപ്പെടുന്നില്ല എന്നുറപ്പ് വരുത്തുവാൻ ക്ലാസിന്റെ കൺസ്ട്രക്റ്റർ മെത്തേഡ് പ്രൊട്ടെക്ട്ടഡ് ആയി നിർവ്വചിക്കുന്നു. ഇവിടെ ക്ലാസിന്റെ സ്റ്റാറ്റിക്ക് പതിപ്പും സിംഗൾട്ടൺ പതിപ്പും തമ്മിലുള്ള വ്യത്യാസം ശ്രദ്ധിക്കേണ്ടതാണ്‌: സ്റ്റാറ്റിക്ക് പതിപ്പായി സിംഗൾട്ടൺ പ്രത്യക്ഷവൽക്കരിക്കപ്പെടാവുന്നതാണ്‌, പക്ഷേ ഒരു മാർക്കർ മാത്രമായ ഇന്റർഫേസുകളെയല്ലാതെ അവയ്ക്ക് ഒരു പ്രത്യക്ഷവൽക്കരിക്കാൻ സാധിക്കുകയില്ല. അതായത് ഒരു ക്ലാസിന്‌ ഏതെങ്കിലും ഒരു ഇന്റർഫേസ് നിർവ്വചിക്കുന്ന വ്യവഹാരങ്ങളെ പ്രത്യക്ഷവൽക്കരിക്കേണ്ടതുണ്ടെങ്കിൽ അവ എന്തായാലും ഒരു സിംഗൾട്ടൺ തന്നെയായിരിക്കണം.

പ്രത്യക്ഷവൽക്കരണത്തിനുള്ള ഉദാഹരണങ്ങൾ

സി ഷാർപ്പ് (C #)

/// <summary>
/// Thread-safe singleton example without using locks
/// </summary>
public sealed class Singleton
{
    private static readonly Singleton instance = new Singleton();

    // Explicit static constructor to tell C# compiler
    // not to mark type as beforefieldinit
    static Singleton()
    {
    }

    private Singleton()
    {
    }

    /// <summary>
    /// The public Instance property to use
    /// </summary>
    public static Singleton Instance
    {
        get { return instance; }
    }
}

പൈത്തൺ

class Singleton(type):
    def __init__(self, name, bases, dict):
        super(Singleton, self).__init__(name, bases, dict)
        self.instance = None

    def __call__(self, *args, **kw):
        if self.instance is None:
            self.instance = super(Singleton, self).__call__(*args, **kw)
        
        return self.instance

class MyClass(object):
    __metaclass__ = Singleton

print MyClass()
print MyClass()

പി.എച്ച്.പി.

final class Singleton 
{

    protected static $_instance;

    protected function __construct() # we don't permit an explicit call of the constructor! (like $v = new Singleton())
    { }

    protected function __clone() # we don't permit cloning the singleton (like $x = clone $v)
    { }

    public static function getInstance() 
    {
      if( self::$_instance === NULL ) {
        self::$_instance = new self();
      }
      return self::$_instance;
    }
}

$instance = Singleton::getInstance();