Adapting a few Java-based singleton objects to Objective-C

Question

I've decide to rewrite a java-based game prototype I've been working on in Objective-C. The iOS platform will be a better fit.

Unfortunately I'm having to learn Obj-C at the same time. In the Java game, there were a few libraries that were instantiated by the main game class, and accessed statically when needed. This meant that I could the overhead of new instances each time.

i.e.:

Game.getRNG().nextInt() or Game.getNoiseGen().noise( x, y )

I'm trying to understand the best method to replicate this in Obj-C. I've looked at examples of singletons and am trying this method, but I'm not sure if this is the best way to do this.

The above code, would apparently translate into something like:

[[[Game getInstance] getNoiseGen] noise]

Is there a better way to create a single instance of library classes and statically reference them from anywhere inside my application code?

Answer 1

For creating a singleton make sure you only create the static instance once, you can do this by using GCD.

+ (id)sharedInstance;
{
    static dispatch_once_t once;
    static id sharedInstance;
    dispatch_once(&once, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

and you can then:

Game *game = [Game sharedInstance];
//... 
CGPoint point = CGPointMake(x, y);
[[game noiseGen] noise:point]
//...

Singletons are considered an anti-pattern and should be avoided if possible.

Just from looking at your example you also violate the Law of Demeter, might be worth a read to see if you can improve there.

Answer 2

If I understand your Java model correctly there is no reason why you cannot translate it directly into Objective-C, which certainly has the advantage that you are familiar with it - helpful while you're learning a new language.

By "there were a few libraries that were instantiated by the main game class, and accessed statically when needed" I take it that either:

1. The main class declared global variables of the appropriate types and initialised them; or
2. The classes themselves have a global variable which holds a reference to an instance of themselves.

You are not generating "singletons" here, just objects you want to share. Also given that your main class created them they always exist. Combined this means you've no need to use any of the "singleton" schemes which delay creation until first use and deal with one-time thread-safe initialisation.

All you need is the model for global variables in Objective-C. In outline this is:

1. Declare the variable as extern in a header file
2. Define the variable in an implementation file

In outline, your MainGame.h:

#import "SharedGameObject.h"

@interface MainGame : NSObject

extern SharedGameObject *TheSharedGameObject;
...
@end

and MainGame.m

#import "MainGame.h"

SharedGameObject *TheSharedGameObject;

- (id) init
{
   TheSharedGameObject = [SharedGameObject new];
   ...
}

Now every other class which import MainGame.h has access to the same shared object using TheSharedGameObject. This is the model Apple used for NSApplication and it associated NSApp global variable.

HTH