À l'aide d'un NSString dans une instruction switch

- Je utiliser ces macros dans mon application.

#define CASE(str)                       if ([__s__ isEqualToString:(str)]) 
#define SWITCH(s)                       for (NSString *__s__ = (s); ; )
#define DEFAULT   

SWITCH (string) {
    CASE (@"AAA") {
        break;
    }
    CASE (@"BBB") {
        break;
    }
    CASE (@"CCC") {
        break;
    }
    DEFAULT {
        break;
    }
 }

Instruction Switch ne fonctionne pas avec NSString: il fonctionne uniquement avec les int.

If/Else est trop de code et ne sont souvent pas optimale.

Solution optimale consiste à utiliser un NSDictionary indexés par le NSString (ou autres objets) possibilités. Ensuite, vous accédez directement sur la droite de la valeur/fonction.

L'exemple 1, lorsque vous voulez tester @"A" ou"B" et d'effectuer methodA ou methodB:

NSDictionary *action = @{@"A" : [NSValue valueWithPointer:@selector(methodA)],
                         @"B" : [NSValue valueWithPointer:@selector(methodB)],
                         };
[self performSelector:[action[stringToTest] pointerValue]];

Exemple 2, si vous voulez tester par @"A" ou"B" et d'effectuer blockA ou blockB:

NSDictionary *action = @{@"A" : ^{ NSLog (@"Block A"); },
                         @"B" : ^{ NSLog (@"Block B"); },
                         };
((void (^)())action[stringToTest])();

Je sais que je suis un peu en retard à la fête, mais voici ma présentation pour un objectif-c de l'instruction switch. C'est un peu complexe, donc en tenir avec le laid macros.

Caractéristiques:

• semble comme une instruction switch
• A thread atomicité intégré
• Fonctionne avec tous objective-c les objets, pas seulement NSString (à l'aide de la -isEqual: sélecteur)
• Pourrait être étendu à travailler avec C-types, comme le bien, sauf structs (comme ils n'ont pas de == opérateur)
• Un seul cas de l'étiquette peut être évaluée par instruction switch (break n'est pas nécessaire)
• Sans risque de boucle infinie si aucun cas n'est jamais sélectionné (break n'est pas nécessaire)
• Seule réserve un nom de variable, ____dontuse_switch_var (tous les autres sont dans la statique de la portée et peut être écrasé dans la portée locale)
• N'a pas en tout bizarre de conserver questions (utilise __weak références)

Inconvénients:

• Très difficile de comprendre la source de
• Tous les cas consolidés sont évalués avant que l'un d'eux est choisi (les plus fréquentes en haut)
• Fil atomicité arrive à un coût de la performance, il ne nécessite pas de verrous, mais il n'utilisez NSThread assez largement.
• Sans l'aide de crochets { ou }, Xcode n'aime pas le format des déclarations correctement (ce qui est dû à l'implicite goto étiquette là.
• Pas d'en-tête uniquement (nécessite une .m fichier de travail, pour NSValue faible refs)

Exemple:

#include "OBJC_SWITCH.h"

int main()
{
    NSArray *items = @[ @"A", @"B", @"C", @"D", @"E", @"F" ];

    for (int i = 0; i < items.count; i++)
    {
        $switch(items[i]) {
            $case(@"A"):
            {
                NSLog(@"It was A!");
                break;
            }
            $case(@"B"): //no brackets, no break, still works
                NSLog(@"It was B!");

            $case(@"C"): //continue works as well, there's no difference
            {
                NSLog(@"It was C!");
                continue;
            }

            $default: //brackets, but no break.
            {
                NSLog(@"Neither A, B, or C.");
            } 
        }
    }
}

Sans plus tarder, voici le (vilain) code:

OBJC_SWITCH.h:

#import "NSValue+WeakRef.h"
//mapping of threads to the values being switched on
static NSMutableDictionary *____dontuse_switch_variable_dictionary;
//boolean flag to indicate whether or not to stop switching
static NSMutableDictionary *____dontuse_switch_bool_dictionary;
//simple function to return the current thread's switch value
static inline id current_thread_switch_value()
{
//simple initializer block
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if (!____dontuse_switch_variable_dictionary)
____dontuse_switch_variable_dictionary = [NSMutableDictionary dictionary];
});
return [[____dontuse_switch_variable_dictionary objectForKey:[NSValue valueWithWeakObject:[NSThread currentThread]]] weakObjectValue];
}
//simple function to set the current thread's switch value
static inline void set_current_thread_switch_value(id val)
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if (!____dontuse_switch_variable_dictionary)
____dontuse_switch_variable_dictionary = [NSMutableDictionary dictionary];
});
[____dontuse_switch_variable_dictionary setObject:[NSValue valueWithWeakObject:val] forKey:[NSValue valueWithWeakObject:[NSThread currentThread]]];
}
//check if the current thread has switched yet
static inline BOOL current_thread_has_switched()
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if (!____dontuse_switch_bool_dictionary)
____dontuse_switch_bool_dictionary = [NSMutableDictionary dictionary];
});
return [[____dontuse_switch_bool_dictionary objectForKey:[NSValue valueWithWeakObject:[NSThread currentThread]]] boolValue];
}
//set the current thread's switch state
static inline void set_current_thread_has_switched(BOOL b)
{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
if (!____dontuse_switch_bool_dictionary)
____dontuse_switch_bool_dictionary = [NSMutableDictionary dictionary];
});
[____dontuse_switch_bool_dictionary setObject:[NSNumber numberWithBool:b] forKey:[NSValue valueWithWeakObject:[NSThread currentThread]]];
}
//concatenate two tokens
#define $_concat(A, B) A ## B
#define $concat(A, B) $_concat(A, B)
/* start of switch statement */
#define $switch(value) { \
/* set this thread's switch value */ \
set_current_thread_switch_value(value); \
/* make sure we reset the switched value for the thread */ \
set_current_thread_has_switched(0); \
/* if statement to ensure that there is a scope after the `switch` */ \
} if (1)
/* a case 'label' */
#define $case(value) \
/* make sure we haven't switched yet */ \
if(!current_thread_has_switched() && \
/* check to see if the values are equal */ \
[current_thread_switch_value() isEqual:value]) \
/* basically, we are creating a 'for' loop that only iterates once, so that we support the 'break' statement, without any harm */ \
/* this also sets the 'switched' value for this thread */ \
for (int ____dontuse_switch_var = 0; set_current_thread_has_switched(1), ____dontuse_switch_var != 1; ____dontuse_switch_var++) \
/* this creates the case label (which does nothing) so that it 'looks' like a switch statement. */ \
/* technically, you could to a goto with this, but I don't think anyone would purposely do that */ \
$concat(__objc_switch_label, __COUNTER__)
/* the default 'label' */
#define $default \
/* this only evaluates if we haven't switched yet (obviously) */ \
if (!current_thread_has_switched()) \
/* exact same loop as for the 'case' statement, which sets that we have switched, and only executes once. */ \
for (int ____dontuse_switch_var = 0; set_current_thread_has_switched(1), ____dontuse_switch_var != 1; ____dontuse_switch_var++) \
/* once again, create a case label to make it look like a switch statement */ \
$concat(__objc_switch_label, __COUNTER__)

Je ne vais pas vous fournir de la documentation à ce, car il est auto-explicatif. Si c'est vraiment difficile à comprendre, à laisser un commentaire & je vais documenter le code.

NSValue+WeakRef.h:

#import <Foundation/Foundation.h>
@interface NSValue(WeakRef)
+(id) valueWithWeakObject:(__weak id) val;
-(id) initWithWeakObject:(__weak id) val;
-(__weak id) weakObjectValue;
@end

NSValue+WeakRef.m:

#import "NSValue+WeakRef.h"
@interface ConcreteWeakValue : NSValue
{
__weak id _weakValue;
}
@end
@implementation NSValue(WeakRef)
+(id) valueWithWeakObject:(id) val
{
return [ConcreteWeakValue valueWithWeakObject:val];
}
-(id) initWithWeakObject:(id)val
{
return [NSValue valueWithWeakObject:val];
}
-(id) weakObjectValue
{
[self doesNotRecognizeSelector:_cmd];
return nil;
}
@end
@implementation ConcreteWeakValue
+(id) valueWithWeakObject:(__weak id)val
{
return [[self alloc] initWithWeakObject:val];
}
-(id) initWithWeakObject:(__weak id)val
{
if ((self = [super init]))
{
_weakValue = val;
}
return self;
}
-(const char *) objCType
{
return @encode(__weak id);
}
-(__weak id) weakObjectValue
{
return _weakValue;
}
-(void) getValue:(void *)value
{
* ((__weak id *) value) = _weakValue;
}
-(BOOL) isEqual:(id)object
{
if (![object isKindOfClass:[self class]])
return NO;
return [object weakObjectValue] == [self weakObjectValue];
}
@end

C'est généralement là que j'utilise quelque chose comme un enum. Si je dois gérer beaucoup de valeurs, je viens de créer un enum avec le même nom que la chaîne je serait passé autrement et de le transmettre, par exemple:

enum {
EGLFieldSelectionToolbarItem = 0,
EGLTextSelectionToolbarItem,
};
+(NSImage *)iconForIdentifier:(int)alias WithSize:(NSSize)size; //Alias should be an enum value with the same name
NSImage *icon = [[NSImage alloc]initWithSize:size];
NSBezierPath *bezierPath = [NSBezierPath bezierPath];
[icon lockFocus];
switch (alias) {
case EGLFieldSelectionToolbarItem:
…//Drawing code
break;
case EGLTextSelectionToolbarItem:
…//More drawing code
default:
break;
}
[bezierPath stroke];
[icon unlockFocus];
return icon;
}