//  AppController.h

//  SimpleUserDefaults

//

//  Created by Biao Huang on 12/22/11.

//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.

//

#import <Foundation/Foundation.h>

extern NSString * const DefaultsFavoriteBookKey;

extern NSString * const DefaultsFavoriteCityKey;

extern NSString * const DefaultsFavoriteFoodKey;

extern NSString * const DefaultsFavoriteColorKey;

@interface AppController : NSObject {

    IBOutlet NSTextField *bookField;

    IBOutlet NSTextField *cityField;

    IBOutlet NSTextField *foodField;

    IBOutlet NSTextField *colorField;

    NSUserDefaults *preferences;

}

- (IBAction)textFieldChanged:(id)sender;

@end

//

//  AppController.m

//  SimpleUserDefaults

//

//  Created by Biao Huang on 12/22/11.

//  Copyright (c) 2011 __MyCompanyName__. All rights reserved.

//

#import "AppController.h"

NSString * const DefaultsFavoriteBookKey = @"Favorite Book";

NSString * const DefaultsFavoriteCityKey = @"Favorite City";

NSString * const DefaultsFavoriteFoodKey = @"Favorite Food";

NSString * const DefaultsFavoriteColorKey = @"Favorite Color";

@implementation AppController

+ (void)initialize {

    if (self != [AppController class]) {

        return;

    }

    NSMutableDictionary *defaultPrefs = [NSMutableDictionary dictionary];

    [defaultPrefs setObject:@"Cocoa Programming" forKey:DefaultsFavoriteBookKey];

    [defaultPrefs setObject:@"Braunschweig" forKey:DefaultsFavoriteCityKey];

    [defaultPrefs setObject:@"Fleisch" forKey:DefaultsFavoriteFoodKey];

    [defaultPrefs setObject:@"Schwarz" forKey:DefaultsFavoriteColorKey];

    // Regisgter factory preferences.

    [[NSUserDefaults standardUserDefaults] registerDefaults:defaultPrefs];

}

- (id)init {

    self = [super init];

    if (self) {        

        preferences = [[NSUserDefaults standardUserDefaults] retain];

    }

    return self;

}

- (void)dealloc {

    [preferences release];

    [super dealloc];

}

- (void)awakeFromNib {

    [bookField setStringValue:[preferences stringForKey:DefaultsFavoriteBookKey]];

    [cityField setStringValue:[preferences stringForKey:DefaultsFavoriteCityKey]];

    [foodField setStringValue:[preferences stringForKey:DefaultsFavoriteFoodKey]];

    [colorField setStringValue:[preferences stringForKey:DefaultsFavoriteColorKey]];    

}

- (IBAction)textFieldChanged:(id)sender {

    NSString *favorite = [sender stringValue];

    if (sender == bookField) {

        [preferences setObject:favorite forKey:DefaultsFavoriteBookKey];

    } else if (sender == cityField) {

        [preferences setObject:favorite forKey:DefaultsFavoriteCityKey];

    } else if (sender == foodField) {

        [preferences setObject:favorite forKey:DefaultsFavoriteFoodKey];

    } else if (sender == colorField) {

        [preferences setObject:favorite forKey:DefaultsFavoriteColorKey];

    }

}

@end

那如果我们想要对象.方法的方式来调用一个方法并获取到方法的返回值，那就需要使用@property配合@dynamic了。

 这样就可以使用对象.firstArrayValue来获取到_array数组中的第一个值了，很显然，这种方法并不适用于需要传递参数的方法。

其实使用@dynamic关键字是告诉编译器由我们自己来实现访问方法。

如果使用的是@synthesize，那么这个工作编译器就会帮你实现了。 这时候你也可以自己实现此属性的Accessor，系统会调用你的实现代替系统的实现。虽然使用@property减少了代码，但是在我们的代码中，为了统一，最好还是使用[obj attribute]的方式来调用Accessors，不要一会使用obj.attribute，一会使用[obj attribute]，让代码不够统一。

说明：代码只为示例代码，实际使用时每句代码要放到相应位置的。

当你想使用Cocoa的集合来存储非对象型数据时，NSValue和NSNumber是非常有用的。NSNumber是NSValue的子类，所以 NSValue更灵活一些。
我们先看看NSValue能做什么：

                 一个NSValue对 象是用来存储一个C或者Objective－C数据的简单容器。它可以保存任意类型的数据，比如int，float，char，当然也可以是指pointers, structures, and object ids。NSValue类的目标就是允许以上数据类型的数据结构能够被添加到集合里，例如那些需要其元素是对象的数据结构，如NSArray或者NSSet 的实例。需要注意的是NSValue对象一直是不可枚举的。

所以下面的代码是可行的：

 
            // assume ImaginaryNumber defined:
            typedef struct {
            float real;
            float imaginary;
            } ImaginaryNumber;
             
            ImaginaryNumber miNumber;
            miNumber.real = 1.1;
            miNumber.imaginary = 1.41;
             
            NSValue *miValue = [NSValue value:miNumber
            withObjCType:@encode(ImaginaryNumber)]; // encode using the type name
             
            ImaginaryNumber miNumber2;
            [miValue getValue:&miNumber2];
             

是不是影像很深刻呢？然而不管怎样，苹果的文档里有一 行看起来有点含混的解释：

时刻记住你的struct类型必须是定长的。你不可以存储C字符串，不定长数组和结构和其他的一些不定长 的数据类型到NSValue中去。你应该使用NSString或者NSData来存储此类不定长数据。当然你可以把一个指向变长对象的指针存储在 NSValue对象中。

这是什么意思呢？如果你的数据不是定长的会发生什么？它能被正确的存储下来吗？

 
            typedef struct {
            int dataSize;
            char *data;
            int year;
            } myStructType1;
             

当data指向一个字符数组时，它能被正确的编码吗？
回 答是很简单的，它是变长的，所以它指向的数据不会被编码。
只有这个指针地址被编码了。所以，如果你有一个服务线程编码了一个 myStructTyle1的数据发布出去，并释放了这快内存，那么客户线程拿到这个数据解码并试图获取data的原始数据时，那就只能得到data的指 针地址，而不是数据内容。所以不要期望它能存储你的data。你应该使用NSData或者NSArchiver来代替NSValue以达到期望目标。

我 们再看这个例子：

 
            typedef struct {
            int age;
            int month;
            int day;
            } innerType;
             
            typedef struct {
            int dataSize;
            innerType *innerData;
            } myStructType2;
             

恩，innerTyle是一个定长的类型变量，那么它会被正确 编码吗？
不会，苹果的文档并没有说明此类情况。它依然只编码指针而不是内容。
所以在这种情况下，依然得使用NSData。
总结， 使用NSValue只能是对那些没有变量是指针的struct。
Then how the NSValue stores? It is kind of shallow copy. Please read this.
Here the address of myCString is passed (&myCString), so the address of the first character of the string is stored in theValue. Note that the NSValue object doesn’t copy the contents of the string, but the pointer itself. If you create an NSValue object with an allocated data item, don’t deallocate its memory while the NSValue object exists.

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ 我是引用分割线＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

不管是NSValue还是NSData，都是可以对非对象进行编码存储的。但在我的工 程里，线程之间通信的数据是需要进行序列化的，我使用了NSKeyedArchiver来序列化。
在使用过程中发现NSValue存储的数据不可 被序列化，而NSData可以。我的struct是定长的。

所以最好包装时都使用NSData吧，如果时rect， point之类的倒是可以用NSvalue，它已经提供好接口供你使用了。

 

Cocoa and Objective-C: Up and Running (by me) is now available from O'Reilly.

NSArray and KVC

Even more on simplifying code with generic programming! NSArray's -valueForKey: has a feature that may not be immediately obvious. You can use it to return an array of values buried within a tree of objects. Here's a working example:


NSMutableArray * tree = [NSMutableArray array];

NSDictionary   * p = nil;   // parent
NSDictionary   * c = nil;   // child     
NSNumber       * n = nil;   // value

int i;
for ( i = 0; i < 10; i++ )
{
  n = [NSNumber numberWithInt: i];

  c = [NSDictionary dictionaryWithObject: n
                                  forKey: @"someKey"];

  p = [NSDictionary dictionaryWithObject: c
                                  forKey: @"storage"];

  [tree addObject: p];
}


NSLog (@"%@", tree);


// here's the important part!

NSArray * justValues;
justValues = [tree valueForKeyPath: @"storage.someKey"];


NSLog (@"%@", justValues);




The first NSLog spits this out -- just a two-level property list:


NSLog (@"%@", tree);



(
    {storage = {someKey = 0; }; }, 
    {storage = {someKey = 1; }; }, 
    {storage = {someKey = 2; }; }, 
    {storage = {someKey = 3; }; }, 
    {storage = {someKey = 4; }; }, 
    {storage = {someKey = 5; }; }, 
    {storage = {someKey = 6; }; }, 
    {storage = {someKey = 7; }; }, 
    {storage = {someKey = 8; }; }, 
    {storage = {someKey = 9; }; }
)



The second NSLog spits out an array of values collected by asking each contained object for the value at @"storage.someKey":


NSArray * justValues;
justValues = [tree valueForKeyPath: @"storage.someKey"];

NSLog (@"%@", justValues);



(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)



I find this really convenient in Core Data when working with a sorted array of  managed objects -- you can pull out an array of values for just one attribute.

NSArray and KVC
Posted Oct 04, 2005 — 4 comments below

 

Abhi Beckert — Oct 12, 05 431

*ching*

Now I finally understand how the binding key for a table column works! Thanks ;)

Dirk — Mar 09, 06 923

Unfortunately, I do not. I tried to show the results in "justvalues" in a TableView column using bindings. I use an ArrayController whose content outlet is connected to an instance of the class. The column of the TableView is bound to the ArrayController, controller key is arranged objects, model key path is tree.storage.someKey.
This does not work unfortunately. If I switch to another application, the TableView will eventually show the (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) - but in just one row! :-( 
I am looking for an really easy example to this since - well, very long. I've gone through a lot of them on the web - but since I am very new to cocoa, I found them to complicated. Maybe you could give some hints? Thanks in advance and greetings ;-)

Bagelturf — Mar 24, 07 3807

Dirk,

Try my ten-part KVC tutorial at:

http://www.bagelturf.com/cocoa/kvc1/kvc1.html

It is *very* simple and includes downloadable projects for each step. I did it to convince myself that I understood KVC.

(The links to the download page in the text are incorrect. Use the one from the menu on the right.)

Ben — May 20, 09 6778

Can i extend this to traverse a sequence of KVC items e.g. first.second.third.fourth

Also can this mechanism just deal with to-one relationships or is there a way to make it link to an array and then follow into the items returned by the array items.

Comments Feed

 

Comments Temporarily Disabled

I had to temporarily disable comments due to spam. I'll re-enable them soon.

Technorati Profile
Copyright © Scott Stevenson 2004-2008

http://theocacao.com/document.page/165

 

Cocoa and Objective-C: Up and Running (by me) is now available from O'Reilly.

Key-Value Coding (KVC) and Generic Programming

Key-Value Coding (KVC) is a Cocoa protocol for getting and setting values generically. In programming, the term "generically" describes a way of doing things that applies to many different situations.

Generic code can reduce to total amount of code in a project (which is always good) and helps software to handle situations that the programmer didn't anticipate. Generic, reusable code is emphasized throughout Cocoa.

For example, here's a non-generic way to set a first name and last name on an object:


[person setFirstName: @"Scott"];
[person setLastName:  @"Stevenson"];



This works fine, but I can use KVC messages to write more generic code:


[person setValue:@"Scott" forKey:@"firstName"];
[person setValue:@"Stevenson" forKey:@"lastName"];



Beginners might wonder what the point is here. In fact, it actually seems like the KVC version requires more typing. Let's choose another scenario where KVC's value is more apparent.

First, let's define the class:


@interface CDCPerson : NSObject
{
    NSString * firstName;
    NSString * lastName;
    NSNumber * phoneNumber;
    NSString * emailAddress;
}
- (void) setFirstName:    (NSString *)value;
- (void) setLastName:     (NSString *)value;
- (void) setPhoneNumber:  (NSNumber *)value;
- (void) setEmailAddress: (NSString *)value;
@end



Now, some actual code:


// assume inputValues contains values we want to
// set on the person

NSDictionary * inputValues;
CDCPerson    * person = [[CDCPerson alloc] init];
                                  
NSEnumerator *e = [inputValues keyEnumerator];
id dictKey, dictValue;

while ( dictKey = [e nextObject] )
{ 
    dictValue = [inputValues valueForKey: dictKey];
    [person setValue: dictValue forKey: dictKey];
}



This snippet of code is generic, meaning that we don't need to change it everytime new instance variables are added to the Person class.

But it gets better! Here's an even simpler version of the code above:


// assume inputValues contains values we want to
// set on the person

NSDictionary * inputValues;
CDCPerson    * person = [[CDCPerson alloc] init];

[person setValuesForKeysWithDictionary: inputValues];



Intrigued? Here's Apple explanation of what's happening in -setValuesForKeysWithDictionary:

Sets properties of the receiver with values from keyedValues, using its keys to identify the properties. The default implementation invokes setValue:forKey: for each key-value pair, substituting nil for NSNull values in keyedValues.

In other words, essentially the same as the first example. But what is -setValue:forKey: actually doing? This is where the KVC magic comes in. It will actually find the -setFirstName:, -setLastName:, -setPhoneNumber: and -setEmailAddress: implementations and call those. If it can't find these, KVC will try quite a few different options before ultimately just setting a value on the instance variable itself.

KVC can also be used to pull values out of an object:


// assume person already exists and is populated with values

CDCPerson * person;

NSMutableDictionary * outputValues;
outputValues = [NSMutableDictionary dictionary];

NSArray * keys;
keys = [NSArray arrayWithObjects: @"firstName",
                                  @"lastName",
                                  @"phoneNumber",
                                  @"emailAddress",
                                  nil];

NSEnumerator *e = [keys objectEnumator];
id key, value;

while ( key = [e nextObject] )
{ 
    value = [person valueForKey: key];
    [outputValues setValue: value forKey: key];
}




Or, the simpler version:


// assume person already exists and is populated with values

CDCPerson    * person;
NSArray      * keys;

keys = [NSArray arrayWithObjects: @"firstName",
                                  @"lastName",
                                  @"phoneNumber",
                                  @"emailAddress",
                                  nil];

NSDictionary * outputValues;
outputValues = [person dictionaryWithValuesForKeys: keys];



Just as with setting values, getting values with -valueForKey: will cause KVC to look for a method the same name as the key:


// this will cause KVC to look for a method called -firstName;

NSString * name = [person valueForKey:@"firstName"];



Key-value coding is key element in Cocoa Bindings and Core Data, so it really pays to understand the basic ideas. KVC can handle keypaths, such as:


// getting
[obj valueForKeyPath: @"storage.firstName"];

// setting
[obj setValue: @"Scott" forKeyPath: @"storage.firstName"];



This is similar to doing:


// getting
[[obj storage] firstName];

// setting
[[obj storage] setFirstName:@"Scott"];



For more details on Key-value coding, take a look at this page on ADC.

Key-Value Coding (KVC) and Generic Programming
Posted Oct 03, 2005 — 11 comments below

 

SteveJ — Oct 03, 05 403

In two places where you send the CDCPerson class the allocate message, you don't need the "]" after the class "CDCPerson" and before the message "allocate".

Scott Stevenson — Oct 03, 05 404 

Fixed, thanks. I think this was partially due to a smart editing rule in the text editor.

Daniel Jalkut — Oct 03, 05 405

Just a vote of confidence for this "experiment." I think you have a great writing style and the formatting of your articles is very accessible. The approach you're taking now could produce a sigfnicant "FAQ-like" resource for newbies and oldbies alike.

Samo Korosec — Oct 04, 05 406

Aren't such articles what Cocoa Dev Central is about anyway? Will you repost them there, too?

Jesper — Oct 04, 05 407

Samo: Scott uses the CDC prefix for one-off classes in the article, so it seems like the goal is to get it there later on, but to publish it here now so that people can read it in the meantime.

Scott Stevenson — Oct 04, 05 408 

Jesper's is basically on the right track. It's easier to experiment quickly here on the blog, and move stuff to CDC once it's cleaned up a bit.

Samo Korosec — Oct 04, 05 415

Ah, okies. I've just read over the CDC* stuff not thinking about it. Great idea to post such Cocoa helplets, though.

Tito Ciuro — Mar 31, 06 997

Thanks for the article! I'd like to see keypaths explained a little better. For example, if CDCPerson had an NSArray *siblings (with a few CDCPerson), how could we obtain the list the siblings?

I'd think we would call it via [person valueForKeyPath: @"siblings.firstName"], but I'm not sure if I'd need extra accessors, especially if we start dealing with a fairly nested dictionary. How would that work?

Thanks again!

Scott Stevenson — Apr 03, 06 1000 

I'd think we would call it via [person valueForKeyPath: @"siblings.firstName"]

That should work fine.

hisham — Dec 29, 08 6577

Great. I'm new to KVC and this really helped :)

Thanks so much,
Hisham

Daniel — Mar 20, 09 6626

"Beginners might wonder what the point is here. In fact, it actually seems like the KVC version requires more typing. Let's choose another scenario where KVC's value is more apparent."

That's exactly why I was googling for more info. :) Thanks! Good info.

Comments Feed

 

Comments Temporarily Disabled

I had to temporarily disable comments due to spam. I'll re-enable them soon.

Technorati Profile
Copyright © Scott Stevenson 2004-2008

From: http://theocacao.com/document.page/161

 

Cocoa and Objective-C: Up and Running (by me) is now available from O'Reilly.

Inline Arrays of NSSortDescriptors

NSSortDescriptor is Cocoa's standard class for sorting an NSTableView (or NSArray) by multiple criteria. Sort descriptors are created automatically when the user clicks on a column, but there are a number of situations where you need to create them in code. The API is really simple but the process of getting these things into the table is fairly verbose. Here's a clean and simple way to automate the process, using a category with varargs as input:


@interface NSSortDescriptor (CDCExtensions)

+ (NSArray *) ascendingDescriptorsForKeys: (NSString *)firstKey,...;

@end

You can use it like this:

NSArray *descriptors = [NSSortDescriptor
             ascendingDescriptorsForKeys: @"subject", @"date", nil];
        
[tableView setSortDescriptors: descriptors];

Or this:

NSArray *descriptors = [NSSortDescriptor
             ascendingDescriptorsForKeys: @"subject", @"date", nil];
        
NSArray *sorted = [someArray sortedArrayUsingDescriptors: descriptors];


Grab zip file with the the .h and .m files. Here's the implementation (formatting adjusted for site):

@implementation  NSSortDescriptor (CDCAdditions)

+ (NSArray *) ascendingDescriptorsForKeys: (NSString *)firstKey,...
{    
  id returnArray   = [[NSMutableArray arrayWithCapacity: 5] retain];
  va_list           keyList;
    
  NSString          * oneKey;
  NSSortDescriptor  * oneDescriptor;
  
  if (firstKey)
  {
    oneDescriptor = [[NSSortDescriptor alloc] initWithKey: firstKey
                                                ascending: YES];
    [returnArray addObject: oneDescriptor];
    [oneDescriptor release];
    
    va_start (keyList, firstKey);
    
    while (oneKey = va_arg(keyList, NSString *))
    {
      oneDescriptor = [[NSSortDescriptor alloc] initWithKey: oneKey
                                                  ascending: YES];
      [returnArray addObject: oneDescriptor];
      [oneDescriptor release];
    }
    
    va_end (keyList);
  }
  
  return [returnArray autorelease];
  
}

@end


Inline Arrays of NSSortDescriptors
Posted Mar 15, 2005 — 3 comments below

 

Hayssam — Mar 15, 05 114

Hi!

I think there might be a typo in your 
>   NSSortDescriptor  * descriptor;
as "descriptor" is never used while "OneDescriptor" is used but not declared.

Thanks for sharing this snippet !

Scott Stevenson — Mar 16, 05 115 

Fixed, thanks. I had tweaked a few things to fit the code on the page, and this was an artifact of that. The code in the zip file was fine, though.

Scott Stevenson — Mar 16, 05 116 

Update: I added some discussion about sorting NSArrays.

Comments Feed

 

Comments Temporarily Disabled

I had to temporarily disable comments due to spam. I'll re-enable them soon.

Technorati Profile
Copyright © Scott Stevenson 2004-2008

From: http://theocacao.com/document.page/87

STDARG(3)                               BSD Library Functions Manual                               STDARG(3)

NAME

     stdarg -- variable argument lists

SYNOPSIS

     #include <stdarg.h>

     void va_start(va_list ap, last);

     type va_arg(va_list ap, type);

     void va_copy(va_list dest, va_list src);

     void va_end(va_list ap);

DESCRIPTION

     A function may be called with a varying number of arguments of varying types.  The include file

     <stdarg.h> declares a type (va_list) and defines three macros for stepping through a list of arguments

     whose number and types are not known to the called function.

     The called function must declare an object of type va_list which is used by the macros va_start(),

     va_arg(), va_copy(), and va_end().

     The va_start() macro must be called first, and it initializes ap, which can be passed to va_arg() for

     each argument to be processed.  Calling va_end() signals that there are no further arguments, and

     causes ap to be invalidated.  Note that each call to va_start() must be matched by a call to va_end(),

     from within the same function.

     The parameter last is the name of the last parameter before the variable argument list, i.e., the last

     parameter of which the calling function knows the type.

     Because the address of this parameter is used in the va_start() macro, it should not be declared as a

     register variable, or as a function or an array type.

     The va_arg() macro expands to an expression that has the type and value of the next argument in the

     call.  The parameter ap is the va_list ap initialized by va_start().  Each call to va_arg() modifies ap

     so that the next call returns the next argument.  The parameter type is a type name specified so that

     the type of a pointer to an object that has the specified type can be obtained simply by adding a * to

     type.

     If there is no next argument, or if type is not compatible with the type of the actual next argument

     (as promoted according to the default argument promotions), random errors will occur.

     The first use of the va_arg() macro after that of the va_start() macro returns the argument after last.

     Successive invocations return the values of the remaining arguments.

     The va_copy() macro copies the state of the variable argument list, src, previously initialized by

     va_start(), to the variable argument list, dest, which must not have been previously initialized by

     va_start(), without an intervening call to va_end().  The state preserved in dest is equivalent to

     calling va_start() and va_arg() on dest in the same way as was used on src.  The copied variable argu-

     ment list can subsequently be passed to va_arg(), and must finally be passed to va_end() when through

     with it.

     After a variable argument list is invalidated by va_end(), it can be reinitialized with va_start() or

     made a copy of another variable argument list with va_copy().

EXAMPLES

     The function foo takes a string of format characters and prints out the argument associated with each

     format character based on the type.

           void foo(char *fmt, ...)

           {

                   va_list ap, ap2;

                   int d;

                   char c, *s;

                   va_start(ap, fmt);

                   va_copy(ap2, ap);

                   while (*fmt)

                           switch(*fmt++) {

                           case 's':                       /* string */

                                   s = va_arg(ap, char *);

                                   printf("string %s\n", s);

                                   break;

                           case 'd':                       /* int */

                                   d = va_arg(ap, int);

                                   printf("int %d\n", d);

                                   break;

                           case 'c':                       /* char */

                                   /* Note: char is promoted to int. */

                                   c = va_arg(ap, int);

                                   printf("char %c\n", c);

                                   break;

                           }

                   va_end(ap);

                   ...

                   /* use ap2 to iterate over the arguments again */

                   ...

                   va_end(ap2);

           }

COMPATIBILITY

     These macros are not compatible with the historic macros they replace.  A backward compatible version

     can be found in the include file <varargs.h>.

STANDARDS

     The va_start(), va_arg(), va_copy(), and va_end() macros conform to ISO/IEC 9899:1999 (``ISO C99'').

BUGS

     Unlike the varargs macros, the stdarg macros do not permit programmers to code a function with no fixed

     arguments.  This problem generates work mainly when converting varargs code to stdarg code, but it also

     creates difficulties for variadic functions that wish to pass all of their arguments on to a function

     that takes a va_list argument, such as vfprintf(3).