Exceção lançada nos acessadores gerados por NSOrderedSet

No meu aplicativo Lion, eu tenho este modelo de dados:

O relacionamento subitemsinterno Item é ordenado .

Xcode 4.1 (compilação 4B110) criou para mim o arquivo Item.h, Item.m, SubItem.he SubItem.h.

Aqui está o conteúdo (gerado automaticamente) de Item.h:

#import <Foundation/Foundation.h>

#import <CoreData/CoreData.h>

@class SubItem;

@interface Item : NSManagedObject {
@private
}

@property (nonatomic, retain) NSString * name;
@property (nonatomic, retain) NSOrderedSet *subitems;
@end

@interface Item (CoreDataGeneratedAccessors)

- (void)insertObject:(SubItem *)value inSubitemsAtIndex:(NSUInteger)idx;
- (void)removeObjectFromSubitemsAtIndex:(NSUInteger)idx;
- (void)insertSubitems:(NSArray *)value atIndexes:(NSIndexSet *)indexes;
- (void)removeSubitemsAtIndexes:(NSIndexSet *)indexes;
- (void)replaceObjectInSubitemsAtIndex:(NSUInteger)idx withObject:(SubItem *)value;
- (void)replaceSubitemsAtIndexes:(NSIndexSet *)indexes withSubitems:(NSArray *)values;
- (void)addSubitemsObject:(SubItem *)value;
- (void)removeSubitemsObject:(SubItem *)value;
- (void)addSubitems:(NSOrderedSet *)values;
- (void)removeSubitems:(NSOrderedSet *)values;

@end

E aqui está o conteúdo (gerado automaticamente) de Item.m:

#import "Item.h"
#import "SubItem.h"

@implementation Item

@dynamic name;
@dynamic subitems;

@end

Como você pode ver, a classe Itemoferece um método chamado addSubitemsObject:. Infelizmente, ao tentar usá-lo desta maneira:

Item *item = [NSEntityDescription insertNewObjectForEntityForName:@"Item" inManagedObjectContext:self.managedObjectContext];
item.name = @"FirstItem";

SubItem *subItem = [NSEntityDescription insertNewObjectForEntityForName:@"SubItem" inManagedObjectContext:self.managedObjectContext];

[item addSubitemsObject:subItem];

este erro aparece:

2011-09-12 10:28:45.236 Test[2002:707] *** -[NSSet intersectsSet:]: set argument is not an NSSet

Pode me ajudar?

Atualizar:

Após apenas 1.787 dias do meu relatório de erros, hoje (1 de agosto de 2016) a Apple me escreveu o seguinte: "Verifique este problema com a versão beta mais recente do iOS 10 e atualize seu relatório de erros em bugreport.apple.com com seus resultados." . Espero que este seja o momento certo :)

Reproduzi sua configuração com seu modelo de dados e um com meus nomes diferentes. Eu recebi o mesmo erro nos dois casos.

Parece um bug no código gerado automaticamente pela Apple.

Concordo que pode haver um erro aqui. Modifiquei a implementação do setter set add para acrescentar corretamente a um NSMutableOrderedSet.

- (void)addSubitemsObject:(SubItem *)value {
    NSMutableOrderedSet* tempSet = [NSMutableOrderedSet orderedSetWithOrderedSet:self.subitems];
    [tempSet addObject:value];
    self.subitems = tempSet;
}

A reatribuição do conjunto como self.subitems garantirá que as notificações Will / DidChangeValue sejam enviadas.

Decidi melhorar a solução implementando todos os métodos necessários:

static NSString *const kItemsKey = @"<#property#>";

- (void)insertObject:(<#Type#> *)value in<#Property#>AtIndex:(NSUInteger)idx {
    NSIndexSet* indexes = [NSIndexSet indexSetWithIndex:idx];
    [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet insertObject:value atIndex:idx];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)removeObjectFrom<#Property#>AtIndex:(NSUInteger)idx {
    NSIndexSet* indexes = [NSIndexSet indexSetWithIndex:idx];
    [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet removeObjectAtIndex:idx];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)insert<#Property#>:(NSArray *)values atIndexes:(NSIndexSet *)indexes {
    [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet insertObjects:values atIndexes:indexes];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)remove<#Property#>AtIndexes:(NSIndexSet *)indexes {
    [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet removeObjectsAtIndexes:indexes];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)replaceObjectIn<#Property#>AtIndex:(NSUInteger)idx withObject:(<#Type#> *)value {
    NSIndexSet* indexes = [NSIndexSet indexSetWithIndex:idx];
    [self willChange:NSKeyValueChangeReplacement valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet replaceObjectAtIndex:idx withObject:value];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeReplacement valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)replace<#Property#>AtIndexes:(NSIndexSet *)indexes with<#Property#>:(NSArray *)values {
    [self willChange:NSKeyValueChangeReplacement valuesAtIndexes:indexes forKey:kItemsKey];
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    [tmpOrderedSet replaceObjectsAtIndexes:indexes withObjects:values];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeReplacement valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)add<#Property#>Object:(<#Type#> *)value {
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    NSUInteger idx = [tmpOrderedSet count];
    NSIndexSet* indexes = [NSIndexSet indexSetWithIndex:idx];
    [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
    [tmpOrderedSet addObject:value];
    [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
    [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
}

- (void)remove<#Property#>Object:(<#Type#> *)value {
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    NSUInteger idx = [tmpOrderedSet indexOfObject:value];
    if (idx != NSNotFound) {
        NSIndexSet* indexes = [NSIndexSet indexSetWithIndex:idx];
        [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
        [tmpOrderedSet removeObject:value];
        [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
        [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
    }
}

- (void)add<#Property#>:(NSOrderedSet *)values {
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    NSMutableIndexSet *indexes = [NSMutableIndexSet indexSet];
    NSUInteger valuesCount = [values count];
    NSUInteger objectsCount = [tmpOrderedSet count];
    for (NSUInteger i = 0; i < valuesCount; ++i) {
        [indexes addIndex:(objectsCount + i)];
    }
    if (valuesCount > 0) {
        [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
        [tmpOrderedSet addObjectsFromArray:[values array]];
        [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
        [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexes forKey:kItemsKey];
    }
}

- (void)remove<#Property#>:(NSOrderedSet *)values {
    NSMutableOrderedSet *tmpOrderedSet = [NSMutableOrderedSet orderedSetWithOrderedSet:[self mutableOrderedSetValueForKey:kItemsKey]];
    NSMutableIndexSet *indexes = [NSMutableIndexSet indexSet];
    for (id value in values) {
        NSUInteger idx = [tmpOrderedSet indexOfObject:value];
        if (idx != NSNotFound) {
            [indexes addIndex:idx];
        }
    }
    if ([indexes count] > 0) {
        [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
        [tmpOrderedSet removeObjectsAtIndexes:indexes];
        [self setPrimitiveValue:tmpOrderedSet forKey:kItemsKey];
        [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexes forKey:kItemsKey];
    }
}

Sim, esse é definitivamente um bug do Core Data. Escrevi uma correção baseada em ObjC-Runtime há um tempo, mas na época achei que seria corrigida em breve. De qualquer forma, não tive essa sorte, então eu publiquei no GitHub como KCOrderedAccessorFix . Solução alternativa do problema em todas as suas entidades:

[managedObjectModel kc_generateOrderedSetAccessors];

Uma entidade em particular:

[managedObjectModel kc_generateOrderedSetAccessorsForEntity:entity];

Ou apenas para um relacionamento:

[managedObjectModel kc_generateOrderedSetAccessorsForRelationship:relationship];

Em vez de fazer uma cópia, sugiro usar o acessador no NSObject para obter acesso ao NSMutableOrderedSet dos relacionamentos.

- (void)addSubitemsObject:(SubItem *)value {
      NSMutableOrderedSet* tempSet = [self mutableOrderedSetValueForKey:@"subitems"];
      [tempSet addObject:value];
 }

por exemplo, as Notas da versão do Core Data para iOS v5.0 se referem a isso.

Em um teste curto, funcionou no meu aplicativo.

Eu rastreei o bug. Isso ocorre em willChangeValueForKey:withSetMutation:usingObjects:.

Essa ligação desencadeia uma cadeia de notificações que podem ser difíceis de rastrear e, é claro, alterações em um atendedor podem ter implicações em outro, o que suspeito é o motivo pelo qual a Apple não fez nada.

No entanto, está tudo bem no Set e são apenas as operações do Set em um OrderedSet que funcionam mal. Isso significa que existem apenas quatro métodos que precisam ser alterados. Portanto, tudo o que fiz foi converter as operações Set em suas operações Array equivalentes. Eles funcionam perfeitamente e com sobrecarga mínima (mas necessária).

Em um nível crítico, esta solução sofre de uma falha crítica; se você estiver adicionando objetos e um dos objetos já existir, ele não será adicionado ou movido para o final da lista ordenada (não sei qual). Em ambos os casos, o índice ordenado esperado do objeto no momento em que chegamos didChangeé diferente do que era antecipado. Isso pode quebrar os aplicativos de algumas pessoas, mas não afeta os meus, pois apenas adiciono novos objetos ou confirmo seus locais finais antes de adicioná-los.

- (void)addChildrenObject:(BAFinancialItem *)value {
    if ([self.children containsObject:value]) {
        return;
    }
    NSIndexSet * indexSet = [NSIndexSet indexSetWithIndex:self.children.count];
    [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexSet forKey:ChildrenKey];
    [[self primitiveValueForKey:ChildrenKey] addObject:value];
    [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexSet forKey:ChildrenKey];
}

- (void)removeChildrenObject:(BAFinancialItem *)value {
    if (![self.children containsObject:value]) {
        return;
    }
    NSIndexSet * indexSet = [NSIndexSet indexSetWithIndex:[self.children indexOfObject:value]];
    [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexSet forKey:ChildrenKey];
    [[self primitiveValueForKey:ChildrenKey] removeObject:value];
    [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexSet forKey:ChildrenKey];
}

- (void)addChildren:(NSOrderedSet *)values {
    if ([values isSubsetOfOrderedSet:self.children]) {
        return;
    }
    NSIndexSet * indexSet = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(self.children.count, values.count)];
    [self willChange:NSKeyValueChangeInsertion valuesAtIndexes:indexSet forKey:ChildrenKey];
    [[self primitiveValueForKey:ChildrenKey] unionOrderedSet:values];
    [self didChange:NSKeyValueChangeInsertion valuesAtIndexes:indexSet forKey:ChildrenKey];
}

- (void)removeChildren:(NSOrderedSet *)values {
    if (![self.children intersectsOrderedSet:values]) {
        return;
    }
    NSIndexSet * indexSet = [self.children indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop) {
        return [values containsObject:obj];
    }];
    [self willChange:NSKeyValueChangeRemoval valuesAtIndexes:indexSet forKey:ChildrenKey];
    [[self primitiveValueForKey:ChildrenKey] minusOrderedSet:values];
    [self didChange:NSKeyValueChangeRemoval valuesAtIndexes:indexSet forKey:ChildrenKey];
}

Claro, existe uma solução mais fácil. é o seguinte;

- (void)addChildrenObject:(BAFinancialItem *)value {
    if ([self.children containsObject:value]) {
        return;
    }
    [self insertObject:value inChildrenAtIndex:self.children.count];
}

- (void)removeChildrenObject:(BAFinancialItem *)value {
    if (![self.children containsObject:value]) {
        return;
    }
    [self removeObjectFromChildrenAtIndex:[self.children indexOfObject:value]];
}

- (void)addChildren:(NSOrderedSet *)values {
    if ([values isSubsetOfOrderedSet:self.children]) {
        return;
    }
    [self insertChildren:values atIndexes:[NSIndexSet indexSetWithIndexesInRange:NSMakeRange(self.children.count, values.count)]];
}

- (void)removeChildren:(NSOrderedSet *)values {
    if (![self.children intersectsOrderedSet:values]) {
        return;
    }
    [self removeChildrenAtIndexes:[self.children indexesOfObjectsPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop) {
        return [values containsObject:obj];
    }]];
}

Os documentos da Apple Para Muitas Relações dizem: você deve acessar o conjunto mutável de proxy ou o conjunto ordenado usando

NSMutableOrderedSet * set = [managedObject mutableOrderedSetValueForKey:@"toManyRelation"];

A modificação deste conjunto adicionará ou removerá relações ao seu objeto gerenciado. Acessando o conjunto ordenado mutável usando o acessador, com [] ou. notação está errada e falhará.

Recebeu o mesmo erro, a solução @LeeIII funcionou para mim (obrigado!). Sugiro modificá-lo ligeiramente:

• use a categoria de objetivo-c para armazenar o novo método (para que não percam nosso método se Item for gerado novamente)
• verifique se já temos conjunto mutável

Conteúdo de Item+category.m:

#import "Item+category.h"

@implementation Item (category)

- (void)addSubitemsObject:(SubItem *)value {
    if ([self.subitems isKindOfClass:[NSMutableOrderedSet class]]) {
        [(NSMutableOrderedSet *)self.subitems addObject:value];
    } else {
        NSMutableOrderedSet* tempSet = [NSMutableOrderedSet orderedSetWithOrderedSet:self.subitems];
        [tempSet addObject:value];
        self.subitems = tempSet;
    }
}

@end

Se você estiver usando o mogenerator, em vez de

[parentObject add<Child>sObject:childObject];

basta usar:

[[parent object <child>sSet] addObject:childObject];

Pessoalmente, acabei de substituir as chamadas para os métodos gerados pelo CoreData por chamadas diretas ao método, conforme descrito em outra solução por @Stephan:

NSMutableOrderedSet* tempSet = [self mutableOrderedSetValueForKey:@"subitems"];
      [tempSet addObject:value];
[tempSet addObject:value];

Isso elimina a necessidade de categorias que posteriormente possam entrar em conflito com uma solução da Apple para o código gerado quando o bug for corrigido.

Isso tem a vantagem adicional de ser a maneira oficial de fazê-lo!

Parece que se você vincular o pai ao filho, definindo o pai para o filho e não o contrário, funcionará sem travar.

Então, se você fizer:

[child setParent:parent]

ao invés de

[parent setChildObects:child]

Deve funcionar, pelo menos funciona no iOS 7 e não teve problemas com o relacionamento.

Eu tive o mesmo problema, mas apenas quando tentei algo diferente do que estava fazendo. Não consigo ver o código do subItem, mas assumirei que ele possui um link reverso para o item. Vamos chamar esse link de reverência, "parentItem", então a solução mais fácil é a seguinte:

Item *item = [NSEntityDescription insertNewObjectForEntityForName:@"Item" inManagedObjectContext:self.managedObjectContext];
item.name = @"FirstItem";

SubItem *subItem = [NSEntityDescription insertNewObjectForEntityForName:@"SubItem" inManagedObjectContext:self.managedObjectContext];

//[item addSubitemsObject:subItem];
subItem.parentItem = item;

O efeito é que ele usa o próprio código da apple e é simples e limpo. Além disso, o conjunto é adicionado automaticamente e todos os observadores são atualizados. Sem problemas.

Acabei de entrar em conflito com esse problema e resolvi-o usando uma implementação muito mais simples do que as outras descritas aqui. Simplesmente uso os métodos disponíveis NSManagedObjectpara lidar com relacionamentos quando não estou usando subclasses.

Um exemplo de implementação para inserir uma entidade em um NSOrderedSetrelacionamento ficaria assim:

- (void)addAddress:(Address *)address
{
    if ([self.addresses containsObject:address]) {
        return;
    }
    // Use NSManagedObject's methods for inserting an object
    [[self mutableOrderedSetValueForKey:@"addresses"] addObject:address];
}

Isso funciona perfeitamente e é o que eu estava usando antes de passar para as NSManagedObjectsubclasses.

Este problema ocorreu ao migrar um projeto do Objective-C para o Swift 2 com o XCode 7 . Esse projeto funcionou e por um bom motivo: eu estava usando o MOGenerator que tinha métodos de substituição para corrigir esse bug. Mas nem todos os métodos exigem uma substituição.

Então, aqui está a solução completa com uma classe de exemplo, contando com acessadores padrão o máximo possível.

Digamos que tenhamos uma lista com itens solicitados

Primeiro, uma vitória rápida, se você tiver um relacionamento de um para muitos, o mais fácil é:

item.list = list

ao invés de

list.addItemsObject(item)

Agora, se isso não for uma opção , eis o que você pode fazer:

// Extension created from your DataModel by selecting it and
// clicking on "Editor > Create NSManagedObject subclass…"

extension List {
  @NSManaged var items: NSOrderedSet?
}

class List

  // Those two methods work out of the box for free, relying on
  // Core Data's KVC accessors, you just have to declare them
  // See release note 17583057 https://developer.apple.com/library/prerelease/tvos/releasenotes/DeveloperTools/RN-Xcode/Chapters/xc7_release_notes.html
  @NSManaged func removeItemsObject(item: Item)
  @NSManaged func removeItems(items: NSOrderedSet)

  // The following two methods usually work too, but not for NSOrderedSet
  // @NSManaged func addItemsObject(item: Item)
  // @NSManaged func addItems(items: NSOrderedSet)

  // So we'll replace them with theses

  // A mutable computed property
  var itemsSet: NSMutableOrderedSet {
    willAccessValueForKey("items")
    let result = mutableOrderedSetValueForKey("items")
    didAccessValueForKey("items")
    return result
  }

  func addItemsObject(value: Item) {
    itemsSet.addObject(value)
  }

  func addItems(value: NSOrderedSet) {
    itemsSet.unionOrderedSet(value)
  }
end

Obviamente, se você estiver usando o Objective-C, poderá fazer exatamente a mesma coisa, pois foi aí que eu tive a ideia em primeiro lugar :)

Eu concordo que talvez haja um bug aqui. Modifiquei a implementação do add object> setter para acrescentar corretamente a um NSMutableOrderedSet.

- (void)addSubitemsObject:(SubItem *)value {
     NSMutableOrderedSet* tempSet = [NSMutableOrderedSet orderedSetWithOrderedSet:self.subitems];
     [tempSet addObject:value];
     self.subitems = tempSet;
}

A reatribuição do conjunto como self.subitems garantirá que as notificações Will / DidChangeValue> sejam enviadas.

Leelll, você tem certeza de que, após a configuração personalizada dos valores NSMutableOrderedSet armazenados nesse conjunto, serão salvos no banco de dados corretamente pelo CoreData? Não verifiquei isso, mas parece que o CoreData não sabe nada sobre NSOrderedSet e espera que o NSSet seja um contêiner de relacionamento com muitos.

Acho que todo mundo está perdendo o problema real. Não está nos métodos do acessador, mas no fato de NSOrderedSetnão ser uma subclasse de NSSet. Portanto, quando -interSectsSet:é chamado com um conjunto ordenado como argumento, ele falha.

NSOrderedSet* setA = [NSOrderedSet orderedSetWithObjects:@"A",@"B",@"C",nil];
NSSet* setB = [NSSet setWithObjects:@"C",@"D", nil];

 [setB intersectsSet:setA];

falha com *** -[NSSet intersectsSet:]: set argument is not an NSSet

Parece que a correção é alterar a implementação dos operadores de conjunto para que eles manipulem os tipos de maneira transparente. Não há razão para que a -intersectsSet:deva funcionar com um conjunto ordenado ou não ordenado.

A exceção acontece na notificação de alteração. Presumivelmente no código que lida com o relacionamento inverso. Como isso só acontece se eu estabelecer um relacionamento inverso.

O seguinte fez o truque para mim

@implementation MF_NSOrderedSetFixes

+ (void) fixSetMethods
{
    NSArray* classes = [NSArray arrayWithObjects:@"NSSet", @"NSMutableSet", @"NSOrderedSet", @"NSMutableOrderedSet",nil];

    [classes enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
        NSString* name = obj;
        Class aClass = objc_lookUpClass([name UTF8String]);
        [MF_NSOrderedSetFixes fixMethodWithSetArgument:@selector(intersectsSet:) forClass:aClass];
        [MF_NSOrderedSetFixes fixMethodWithSetArgument:@selector(isSubsetOfSet:) forClass:aClass];
    }];
}

typedef BOOL (*BoolNSetIMP)(id _s,SEL sel, NSSet*);

/*
    Works for all methods of type - (BOOL) method:(NSSet*) aSet
*/
+ (void) fixMethodWithSetArgument:(SEL) aSel forClass:(Class) aClass 
{
    /* Check that class actually implements method first */
    /* can't use get_classInstanceMethod() since it checks superclass */
    unsigned int count,i;
    Method method = NULL;
    Method* methods = class_copyMethodList(aClass, &count);
    if(methods) {
        for(i=0;i<count;i++) {
            if(method_getName(methods[i])==aSel) {
                method = methods[i];
            }
        }
        free(methods);
    }
    if(!method) {
        return;
    }

   // Get old implementation
   BoolNSetIMP originalImp  = (BoolNSetIMP) method_getImplementation(method);
   IMP newImp = imp_implementationWithBlock(^BOOL(NSSet *_s, NSSet *otherSet) {
        if([otherSet isKindOfClass:[NSOrderedSet class]]) {
            otherSet = [(NSOrderedSet*)otherSet set];
        }
        // Call original implementation
        return originalImp(_s,aSel,otherSet);
    });
    method_setImplementation(method, newImp);
}
@end

Acabei de receber o problema no Swift (Xcode 6.1.1).

A resposta foi NÃO CODIFICAR QUALQUER MÉTODO OU COISA ADICIONAL nas subclasses do NSManagedObject. Eu acho que é um erro do compilador. Bug muito estranho ..

Espero que ajude ..

Resolvi esse problema definindo o inverso como No Inverse, não sei por que, talvez exista o Apple Bug.

Eu tenho a mesma situação com um item chamado "sinais" em vez de "subitens". A solução com tempset funciona nos meus testes. Além disso, tive um problema com o método removeSignals:. Essa substituição parece funcionar:

- (void)removeSignals:(NSOrderedSet *)values {
    NSMutableOrderedSet* tempset = [NSMutableOrderedSet orderedSetWithOrderedSet:self.signals];
    for (Signal* aSignal in values) {
        [tempset removeObject:aSignal];
    }
    self.signals = tempset;
}

Se houver uma maneira melhor de fazer isso, entre em contato. Minha entrada de valores nunca é superior a 10 a 20 itens, portanto o desempenho não é uma grande preocupação - no entanto, aponte algo relevante.

Obrigado,

Damien

Encontrei essa pergunta pesquisando a mensagem de erro no Google e só queria salientar que encontrei esse erro de uma maneira ligeiramente diferente (sem usar conjuntos ordenados). Essa não é uma resposta para a pergunta em questão, mas estou postando aqui para o caso de ser útil para qualquer pessoa que se deparar com essa pergunta enquanto estiver pesquisando.

Eu estava adicionando uma nova versão do modelo, adicionei alguns relacionamentos aos modelos existentes e defini os métodos add * Object no arquivo de cabeçalho. Quando tentei ligar para eles, recebi o erro acima.

Depois de revisar meus modelos, percebi que havia me esquecido estupidamente de marcar a caixa de seleção "Relacionamento com muitos".

Portanto, se você estiver enfrentando isso e não estiver usando conjuntos ordenados, verifique seu modelo.

Encontrei uma correção para esse bug que funciona para mim. Eu apenas substituo isso:

[item addSubitemsObject:subItem];

com isso:

item.subitemsObject = subItem;

Melhor versão da resposta correta no SWIFT

var tempSet = NSMutableOrderedSet()
if parent!.subItems != nil {
    tempSet = NSMutableOrderedSet(orderedSet: parent!.subItems!)
}

tempSet.add(newItem)
parent!.subItems = tempSet

Descobri que o método de LeeIII funcionava, mas na criação de perfis, era drasticamente lento. Demorou 15 segundos para analisar 1000 itens. Comentar o código para adicionar o relacionamento transformou 15 segundos em 2 segundos.

Minha solução alternativa (que é mais rápida, mas muito mais feia) envolve a criação de uma matriz mutável temporária e a cópia no conjunto ordenado quando toda a análise é concluída. (isso é apenas uma vitória no desempenho se você deseja adicionar muitos relacionamentos).

@property (nonatomic, retain) NSMutableArray* tempItems;
 ....
@synthesize tempItems = _tempItems;
 ....

- (void) addItemsObject:(KDItem *)value 
{
    if (!_tempItems) {
        self.tempItems = [NSMutableArray arrayWithCapacity:500];
    }
    [_tempItems addObject:value];
}

// Call this when you have added all the relationships
- (void) commitRelationships 
{
    if (_tempItems) {
        self.items = [NSOrderedSet orderedSetWithArray:self.tempItems];
        self.tempItems = nil;
    }
}

Espero que isso ajude outra pessoa!

Robert,

Concordo que sua resposta funcionará para isso, mas lembre-se de que já existe um método criado automaticamente para adicionar todo um conjunto de valores a um relacionamento. A documentação da Apple ( como pode ser vista aqui na seção "Relacionamentos para muitos" ou aqui na seção "Métodos personalizados de acessor de relacionamento para muitos") os implementa da seguinte maneira:

- (void)addEmployees:(NSSet *)value
{
[self willChangeValueForKey:@"employees"
      withSetMutation:NSKeyValueUnionSetMutation
      usingObjects:value];
[[self primitiveEmployees] unionSet:value];
[self didChangeValueForKey:@"employees"
      withSetMutation:NSKeyValueUnionSetMutation
      usingObjects:value];
}

- (void)removeEmployees:(NSSet *)value
{
[self willChangeValueForKey:@"employees"
      withSetMutation:NSKeyValueMinusSetMutation
      usingObjects:value];
[[self primitiveEmployees] minusSet:value];
[self didChangeValueForKey:@"employees"
      withSetMutation:NSKeyValueMinusSetMutation
      usingObjects:value];
}

Você pode compilar facilmente seu conjunto de relacionamentos fora dos dados principais e adicioná-los todos de uma vez usando esse método. Pode ser menos feio do que o método que você sugeriu;)

Tenho certeza de que finalmente foi corrigido no iOS 10 beta 6 !