Singleton: Difference between revisions

 

=={{header|ActionScript}}==

{

public class Singleton

}

 

 

=={{header|Ada}}==

===Non Thread Safe===

procedure Set_Data (Value : Integer);

function Get_Data return Integer;

end record;

Instance : Instance_Type;

 

 

--------------

end Get_Data;

 

 

===Thread Safe===

procedure Set_Data (Value : Integer);

function Get_Data return Integer;

Data : Integer := 0;

end Instance_Type;

 

 

--------------

end Instance;

 

 

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_L}}

Translation of python borg pattern

b2 := borg()

msgbox % "b1 is b2? " . (b1 == b2)

brg[1, name] := val

Return val

 

=={{header|C}}==

Since C doesn't really support classes anyhow, there's not much to do. If you want somethin akin to a singleton, what you do is first declare the interface functions in a header (.h) file.

#define SILLY_H

 

extern int PlayFetchWithDog( float weightOfStick);

 

Then in a separate C source (.c) file, define your structures, variables and functions.

#include "silly.h"

 

{ ...

if(weightOfStick < lazyDog.max_stick_weight){...

Code using the singleton includes the header and cannot create a

struct sDog as the definition is only in the C source (or other header privately included by the silly.c source). Only the functions declared in the header may be used externally.

#include "silly.h"

...

JumpOverTheDog( 4);

retrieved = PlayFetchWithDog( 3.1);

 

=={{header|C++}}==

A generic singleton template class (implemented via the "Curiously Recurring Template Pattern"[https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern]). Warning: if using a version of C++ prior to C++11, a [[Mutex#C|mutex]] (or similar) is required to access static variables within a multi-threaded program.

 

#include <stdexcept>

 

controller::instance().work();

}

 

=={{header|Caché ObjectScript}}==

In Caché, each job runs in a self-contained execution environment (i.e. a separate process instead of a thread). However, it is possible for each process to share data through multidimensional storage (global variables). This is because when the Caché virtual machine starts, it allocates a single, large chunk of shared memory to allow all Caché processes to access this data simultaneously. However, it is the responsibility of the application developer to ensure read and write access to objects is properly co-ordinated (or 'synchronized') between processes to prevent concurrency problems. Also, Caché defines any global variable whose name starts with 'CacheTemp' as being temporary, which means changes are not usually written to disk and are instead maintained within the in-memory buffer pool.

 

/// The <CLASS>Singleton</CLASS> class represents a global singleton object that can

/// be instantiated by multiple processes. The 'Get' class method is used to obtain

 

}

 

{{out|Examples}}

 

For a simple example, the following program constructs English sentences without worrying about extra space occurring at points where no text (<code>the-empty-phrase</code>, our singleton) is inserted.

(:documentation "Concatenate two phrases."))

 

(dolist (q (list 'the-empty-phrase

(make-instance 'nonempty-phrase :text "up the hill")))

Thread safety is irrelevant since the singleton is created at load time, not first access.

 

=={{header|D}}==

import std.stdio ;

import std.thread ;

 

x.wait ; y.wait ; z.wait ;

{{out}}

<pre>>>Mary come in.

=={{header|Delphi}} and {{header|Pascal}}==

Detailed explanation [http://www.yanniel.info/2010/10/singleton-pattern-delphi.html here]. (Delphi started out as an object-oriented version of Pascal.)

 

interface

end;

 

 

=={{header|E}}==

Since E uses closure-style objects rather than classes, a singleton is simply an object which is defined at the top level of the program, not inside any method. There are no thread-safety issues since the singleton, like every other object, belongs to some particular [http://www.erights.org/elib/concurrency/vat.html vat] (but can be remotely invoked from other vats).

# ...

 

=={{header|Eiffel}}==

 

'''Implementation:'''

SINGLETON

create {SINGLETON_ACCESS}

feature

-- singleton features go here

SINGLETON_ACCESS

feature

Result /= Void

end

'''Usage:'''

 

=={{header|Elena}}==

Stateless singleton

singleton Singleton

{

// ...

}

Normal singleton

{

object theField;

}

 

 

=={{header|Erlang}}==

Erlang is not object-oriented, so there is no such thing as a singleton class. The singleton is something of an anti-pattern in Erlang, so if you are tempted to do this, there is probably a better architecture. If you do want something akin to a singleton, you start and register a process that maintains its state in a message loop and provides its state to anyone that wants it or needs to change it. Since this is done with message passing, it's safe for concurrent use.

 

-export([get/0, set/1, start/0]).

From ! ok,

loop(NewValue)

 

Here is an example of how to use it (from the shell). It assumes singleton:start/0 was already called from the supervisor tree (as would be typical if you were using something like this).

 

not_set

2> singleton:set(apple).

ok

7> singleton:get().

 

=={{header|Factor}}==

IN: singleton-demo

 

SINGLETON: bar

GENERIC: foo ( obj -- )

( scratchpad ) bar foo

Hello!

Works with any ANS Forth

 

\ A singleton is created by using normal Forth data

s1 printb \ => 9

s2 printa \ => 4

 

=={{header|Go}}==

 

From the Go standard library, sync.Once provides a way to ensure that some "step," effectively an initialization step, is performed no more than once even if it might be attempted from multiple concurrent goroutines. This capability might be considered similar to some mechanism ensuring that singleton constructor code is only run once.

 

import (

w.Wait()

log.Println("after trying both, instance =", instance)

{{out}}

<pre>

 

Because packages cannot be imported multiple times, data declared at package level will only ever have a single instance, and the package as a whole serves as a singleton.

 

// package level data declarations serve as singleton instance variables

func F() int {

return Y - X

Example program using the package:

 

import (

fmt.Println(singlep.X, singlep.Y)

fmt.Println(singlep.F())

{{out}}

<pre>

This example combines the two previous concepts and also shows some additional concepts. It has packages imported with a "diamond" dependency. While both <code>red</code> and <code>blue</code> import <code>single</code>, only a single variable <code>color</code> will exist in memory. The <code>init()</code> mechanism shown above actually runs before <code>main()</code>. In contrast, the <code>sync.Once</code> mechanism can serve as constructor code after <code>main()</code> begins.

 

 

import (

once.Do(func() { color = c })

log.Println("color initialized to", color)

 

import (

log.Println("trying to set red")

single.SetColor("red")

 

import (

log.Println("trying to set blue")

single.SetColor("blue")

 

import (

}

log.Println(single.Color())

{{out}}

<pre>

 

=={{header|Groovy}}==

class SingletonClass {

 

SingletonClass.instance.invokeMe()

}

{{out}}

<pre>invoking method of a singleton class</pre>

==Icon and {{header|Unicon}}==

Icon is not object oriented, but Unicon supports O-O programming.

method print()

write("Hi there.")

Singleton().print()

Singleton().print()

 

This Unicon example uses a number of Icon features.

=={{header|Io}}==

Io does not have globals. But it is easy to make singleton objects:

 

=={{header|J}}==

===Thread-safe===

[[wp:Double-checked locking]]; only use with Java 1.5+

{

private static Singleton myInstance;

 

// Any other methods

 

===Thread-Safe Lazy-Loaded===

This is the [[wp:Initialization-on-demand holder idiom]].

private Singleton() {

// Constructor code goes here.

return LazyHolder.INSTANCE;

}

 

===Non-Thread-Safe===

{

private static Singleton myInstance;

 

// Any other methods

 

=={{header|JavaScript}}==

if(Singleton._instance) return Singleton._instance;

this.set("");

c.append("!!!");

 

 

=={{header|Julia}}==

Julia allows singletons as type declarations without further specifiers. There can be only one instance of such a type, and if more than one variable is bound to such a type they are actually all bound to the same instance in memory:

 

x = IAmaSingleton()

 

println("x == y is $(x == y) and x === y is $(x === y).")

 

=={{header|Kotlin}}==

Kotlin has built-in support for singletons via object declarations. To refer to the singleton, we simply use its name which can be any valid identifier other than a keyword:

 

object Singleton {

fun main(args: Array<String>) {

Singleton.speak()

 

{{out}}

I am a singleton

</pre>

 

=={{header|Lasso}}==

===Server wide singleton===

 

// New definition supersede any current threads.

#b->switch = 'b'

 

 

===Thread level singleton===

 

 

define singleton => type {

#b->switch = 'b'

 

 

=={{header|Lingo}}==

In Lingo a Singleton class can be implemented like this:

 

property _instance

me._someProperty = me._someProperty + x

return me._someProperty

 

=={{header|Logtalk}}==

Logtalk supports both classes and prototypes. A prototype is a much simpler solution for defining a singleton object than defining a class with only an instance.

 

:- public(value/1).

state(0).

 

A simple usage example after compiling and loading the code above:

Value = 0

yes

| ?- singleton::(set_value(1), value(Value)).

Value = 1

 

=={{header|NetRexx}}==

Uses a static field to avoid synchronization problems and the ''flawed'' &quot;double-checked locking&quot; idiom in JVMs. See [http://www.ibm.com/developerworks/java/library/j-dcl/index.html www.ibm.com/developerworks/java/library/j-dcl/index.html] for a detailed explanation.

options replace format comments java crossref symbols binary

 

return info

 

 

{{out}}

=={{header|Nim}}==

In the file <code>singleton.nim</code> we don't export the type, so new objects can't be created:

foo*: int

 

Then in another file we can use the singleton object:

 

single.foo = 12

 

=={{header|Objeck}}==

@singleton : static : Singleton;

 

...

}

 

=={{header|Objective-C}}==

===Non-Thread-Safe===

(Using Cocoa/OpenStep's NSObject as a base class)

@interface SomeSingleton : NSObject

{

+ (SomeSingleton *)sharedInstance;

 

 

@implementation SomeSingleton

 

}

 

 

===Thread-Safe===

Same as above except:

{

static SomeSingleton *sharedInstance = nil;

}

return sharedInstance;

 

===With GCD===

Same as above except:

{

static SomeSingleton *sharedInstance = nil;

});

return sharedInstance;

 

===With class methods===

 

In other words, here the class object serves as the singleton object. The "singleton class" is the metaclass of the class. The downside of this approach is that the "singleton class" (the metaclass of the class) cannot be made to explicitly inherit from a class of the user's choice, or implement a protocol of the user's choice. Also, there is no way to prevent subclasses of the class from being made, thus effectively creating "multiple instances" of the singleton class. Also, one cannot declare properties on the singleton (the class object).

 

=={{header|Oforth}}==

For instance, this Sequence class creates instances that increment an integer and send it. If a task tries to get the next value before it is incremented, it will wait until the channel is no more empty and holds the new value. This won't work if the value is a mutable value (you will get an exception if you try to send a mutable object into channel). A mutable object can't be shared between tasks. Here we send a new integer each time.

 

Sequence method: initialize(initialValue)

Channel newSize(1) := channel

@channel send(initialValue) drop ;

 

 

Usage :

 

: testSequence

| s i |

Sequence new(0) ->s

 

=={{header|ooRexx}}==

a = .singleton~new

b = .singleton~new

a singleton.

::attribute foo

 

=={{header|Oz}}==

Singleton is not a common pattern in Oz programs. It can be implemented by limiting the scope of the class definition such that only the <code>GetInstance</code> function has access to it.

local

class Singleton

end

end

This will work as long as all functors are linked with <code>import</code> statements. If you use multiple calls to <code>Module.link</code> instead, you will get multiple instances of the "Singleton".

 

=={{header|Perl}}==

use strict;

use warnings;

 

my $s2 = Singleton->new;

 

 

=={{header|PHP}}==

protected static $instance = null;

public $test_var;

echo $bar->test_var; //Prints 'One'

 

 

=={{header|PicoLisp}}==

As there is no physical difference between classes and objects, we can use the

class symbol itself.

 

(dm message1> ()

 

(dm message2> ()

{{out}}

<pre>: (message1> '+Singleton)

 

=={{header|Python}}==

In Python we use the [http://code.activestate.com/recipes/66531/ Borg pattern] to share state between instances rather than concentrate on identity.

 

Every instance of the Borg class will share the same state:

__state = {}

def __init__(self):

>>> b1.datum is b2.datum

True

 

An approximation of the singleton can be made using only class attributes to store data instead of the instance attributes, providing at least one abstract instance method (class can not be instantiated then) and making the rest of the methods being class methods. E.g.

 

import abc

 

Singleton.printSelf()

print Singleton.state

When executed this code should print out the following:<br>

<br>

So, instantiation is not possible. Only a single object is available, and it behaves as a singleton.

 

 

 

 

 

 

 

 

 

 

=={{header|Racket}}==

 

Singletons are not very useful in Racket, because functions that use module state are more straightforward. However, classes are first class values, and therefore they follow the same rules as all other bindings. For example, a class can be made and instantiated but not provided to client files:

#lang racket

(provide instance)

(super-new)))

(define instance (new singleton%))

 

Or better, not name the class at all:

#lang racket

(provide instance)

(define/public (foo) 123)

(super-new))))

 

=={{header|Ruby}}==

class MySingleton

include Singleton

a = MySingleton.instance # instance is only created the first time it is requested

b = MySingleton.instance

 

=={{header|Scala}}==

The '''object''' construct in Scala is a singleton.

// any code here gets executed as if in a constructor

 

=={{header|Sidef}}==

static instance;

 

 

s2.name = 'bar'; # change name in s2

 

=={{header|Slate}}==

Clones of Oddball themselves may not be cloned.

Methods and slots may still be defined on them:

 

=={{header|Smalltalk}}==

SomeClass class>>sharedInstance

 

SharedInstance ifNil: [SharedInstance := self basicNew initialize].

^ SharedInstance

 

=={{header|Swift}}==

 

class SingletonClass {

// Usage

let sharedObject = SingletonClass.sharedInstance

 

=={{header|Tcl}}==

 

ref http://wiki.tcl.tk/21595

 

# This is a metaclass, a class that defines the behavior of other classes

return [incr count]

}

Demonstrating in an interactive shell:

::oo::Obj20

% set b [example new] ;# note how this returns the same object name

3

% $b counter

 

=={{header|Tern}}==

Tern has built-in support for singletons via module declarations.

speak() {

println("I am a singleton");

}

 

 

{{out}}

I am a singleton

</pre>

 

=={{header|Vala}}==

static Singleton? instance;

 

print("Equal.\n");

}

 

=={{header|zkl}}==

A class declared static only has one instance, ever.

However, a class with the same name & structure could be created in another scope.

b1 := Borg; b2 := Borg();

b1 == b2 //--> True

{{omit from|AWK}}

{{omit from|GAP}}

{{omit from|Mathematica}}

{{omit from|Maxima}}

{{omit from|Metafont}}

{{omit from|OCaml}}

{{omit from|Octave}}

{{omit from|PARI/GP}}

{{omit from|plainTeX}}

{{omit from|Retro|No OOP}}

{{omit from|TI-83 BASIC}}

{{omit from|TI-89 BASIC|Does not have user-defined data structures or objects.}}

{{omit from|ZX Spectrum Basic|Does not have user-defined data structures or objects.}}