CODEWITHSUNDEEP
objective-cnsmutablearray
Nickool
Nickool

Reputation: 3702

understanding mutable copy

Due to an example from Apress,for a search criteria,it has a soultion:it will firstly get a mutable copy and search the string and then will remove objects that are not in range of that string.

in the Mutable DeepCopy it has function as follow:

@implementation NSDictionary(MutableDeepCopy)
-(NSMutableDictionary *)mutableDeepCopy{
    NSMutableDictionary *returnDict=[[NSMutableDictionary alloc]initWithCapacity:[self count]];
    NSArray *keys=[self allKeys];
    for(id key in keys)
    {
        id oneValue=[self valueForKey:key];
        id oneCopy=nil;
        if([oneValue respondsToSelector:@selector(mutableDeepCopy)])
            oneCopy=[oneValue mutableDeepCopy];
        else if([oneValue respondsToSelector:@selector(mutableCopy)])
            oneCopy=[oneValue mutableCopy];
        if(oneCopy==nil)
            oneCopy=[oneValue copy];
        [returnDict setValue:oneCopy forKey:key];

    }
    return returnDict;
}
@end

when I don't understand any code I will debug it,so I debugged it and in the beginnings when it wants to show the whole array,in the if statement it will go to oneCopy=[oneValue mutableCopy]; I want to know that why it will choose this selector and not the MutableDeep selector? I can't understand this function totally.what is the main purpose of this function?

for searching it has this function

-(void)handleSearchForTerm:(NSString *)searchTerm
{
    NSMutableArray * sectionsToRemove=[[NSMutableArray alloc]init];
    [self resetSearch];
    for(NSString * key in self.keys)
    {
        NSMutableArray * array=[names valueForKey:key];
        NSMutableArray *toRemove=[[NSMutableArray alloc]init];
        for(NSString * name in array)
        {
        if([name rangeOfString:searchTerm options:NSCaseInsensitiveSearch].location==NSNotFound)
            [toRemove addObject:name];
        }
        if([array count]==[toRemove count])
            [sectionsToRemove addObject:key];
        [array removeObjectsInArray:toRemove];
    }
    [self.keys removeObjectsInArray:sectionsToRemove];
    [table reloadData];
}

and for reset the search and recovering whole it has this function below. my problem is that in self.keys we removed objects with help of handleSearchForTerm but when we go to resetsearch it will return again those whole keys without any removal maybe my main problem is that I can't understand Mutablecopy and DeepMutableCopy.

-(void)resetSearch{
    NSMutableDictionary *allNamesCopy=[self.allNames  mutableDeepCopy];
    self.names=allNamesCopy;
    NSMutableArray *keyArray=[[NSMutableArray alloc]init];
    [keyArray addObjectsFromArray:[[self.allNames allKeys]sortedArrayUsingSelector:@selector(compare:)]];
    self.keys=keyArray;

}

Upvotes: 0

Views: 1947

Answers (2)

Anoop Vaidya
Anoop Vaidya

Reputation: 46543

They both have some compare & contrast features...

First comparing: Both are mutable, you can alter the object itself.

Second contrasting/differences:

MutableCopy: Similar to Call-by-Reference.

MutableDeepCopy: Similar to Call-by-Value.

Upvotes: 2

Cocoanetics
Cocoanetics

Reputation: 8247

A copy of a container (e.g. NSArray) copies only the pointers to objects and sends them retain.

A mutableCopy does the same thing, but the resulting container can be modified, i.e. Pointers can be added or removed.

A deep copy would also make copies of the individual elements.

Take for example an NSArray of NSMutableString instances. You cannot modify the array itself, but you can alter each mutable string. Now if you copy the array and modify one of the strings then the copied array also has the changes because it's pointers point to the same instances as the first array.

If you deep copy the array and alter a mutable string, then the new array elements are not modified. In fact copy always makes an immutable copy.

Upvotes: 1

Related Questions