NSManagedObjectModel.m

/* Implementation of the NSManagedObjectModel class for the GNUstep
   Core Data framework.
   Copyright (C) 2005 Free Software Foundation, Inc.
 
   Written by:  Saso Kiselkov <diablos@manga.sk>
   Date: August 2005
 
   This file is part of the GNUstep Core Data framework.
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111 USA.
 */
 
#import "CoreDataHeaders.h"

static void EnsureEntitiesHaveProperNames(NSArray * entities)
{
  NSMutableSet * knownNames;
  NSEnumerator * e;
  NSEntityDescription * entity;
 
  knownNames = [NSMutableSet setWithCapacity: [entities count]];
  e = [entities objectEnumerator];
  while ((entity = [e nextObject]) != nil)
    {
      NSString * entityName = [entity name];
 
      if (entityName == nil)
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Tried to add an entity without a name "
            @"to a managed object model.")];
        }
      if ([knownNames containsObject: entityName])
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Tried to add several entities with the "
            @"same name to a managed object model.")];
        }
      [knownNames addObject: entityName];
    }
}
 
@interface NSManagedObjectModel (GSCoreDataInternal)

- (void) _grabEntities: (NSArray *) entities;

- (void) _ungrabEntities: (NSArray *) entities;

- (void) _ensureEditableWithReason: (NSString *) reason;
 
@end
 
@implementation NSManagedObjectModel (GSCoreDataInternal)
 
- (void) _grabEntities: (NSArray *) entities
{
  NSEnumerator * e;
  NSEntityDescription * ent;
 
  e = [entities objectEnumerator];
  while ((ent = [e nextObject]) != nil)
    {
      if ([ent managedObjectModel] != nil && [ent managedObjectModel] != self)
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Passed an entity to an object model already "
                                @"in use by some other model")];
        }
      [ent _addReferenceToManagedObjectModel: self];
    }
}
 
- (void) _ungrabEntities: (NSArray *) entities
{
  NSEnumerator * e;
  NSEntityDescription * ent;
 
  e = [entities objectEnumerator];
  while ((ent = [e nextObject]) != nil)
    {
      [ent _removeReferenceToManagedObjectModel: self];
    }
}
 
- (void) _ensureEditableWithReason: (NSString *) reason
{
  if (_usedByPersistentStoreCoordinators)
    {
      // which exception to raise??
      [NSException raise: NSGenericException format: _(reason)];
    }
}
 
@end
 
@implementation NSManagedObjectModel
 
- (void) dealloc
{
  NSEnumerator * e;
  NSArray * entities;
 
  // ungrab the entities before we disappear
  [self _ungrabEntities: _entities];
  TEST_RELEASE(_entities);
 
  e = [_configurations objectEnumerator];
  while ((entities = [e nextObject]) != nil)
    {
      [self _ungrabEntities: entities];
    }
  TEST_RELEASE(_configurations);
 
  TEST_RELEASE(_fetchRequests);
 
  [super dealloc];
}
 
+ (NSManagedObjectModel *) modelByMergingModels: (NSArray *) models
{
  NSManagedObjectModel * newModel;
 
  NSMutableArray * entities;
  NSMutableDictionary * confs;
  NSMutableDictionary * fetchRequests;
 
  NSEnumerator * e;
  NSManagedObjectModel * model;
 
  NSString * confName;
  NSString * fetchRequestName;
 
  newModel = [[NSManagedObjectModel new] autorelease];
 
  entities = [NSMutableArray array];
  confs = [NSMutableDictionary dictionary];
  fetchRequests = [NSMutableDictionary dictionary];
 
  // copy and merge all the contents from all models
  e = [models objectEnumerator];
  while ((model = [e nextObject]) != nil)
    {
      [entities addObjectsFromArray: [[[NSArray alloc]
        initWithArray: [model entities] copyItems: YES] autorelease]];
 
      [confs addEntriesFromDictionary: [[[NSDictionary alloc]
        initWithDictionary: [model _configurationsByName] copyItems: YES]
        autorelease]];
 
      // fetch requests can be shared
      [fetchRequests addEntriesFromDictionary:  [model fetchRequestsByName]];
    }
 
  // and set the merged contents into the new model
  [newModel setEntities: entities];
 
  e = [[confs allKeys] objectEnumerator];
  while ((confName = [e nextObject]) != nil)
    {
      [newModel setEntities: [confs objectForKey: confName]
           forConfiguration: confName];
    }
 
  e = [[fetchRequests allKeys] objectEnumerator];
  while ((fetchRequestName = [e nextObject]) != nil)
    {
      [newModel setFetchRequestTemplate: [fetchRequests objectForKey:
        fetchRequestName]
                                forName: fetchRequestName];
    }
 
  return newModel;
}
 
+ (NSManagedObjectModel *) mergedModelFromBundles: (NSArray *) bundles
{
  NSArray * modelPaths;
  NSMutableArray * models;
 
  NSEnumerator * e;
  NSString * modelPath;
 
  // find the involved .gsdatamodel files
  if (bundles != nil)
   // search specified bundles
    {
      NSEnumerator * e;
      NSBundle * bundle;
      NSMutableArray * array;
 
      array = [NSMutableArray array];
 
      e = [bundles objectEnumerator];
      while ((bundle = [e nextObject]) != nil)
        {
          [array addObjectsFromArray:
            [bundle pathsForResourcesOfType: @"gsdatamodel" inDirectory: nil]];
        }
 
      modelPaths = array;
    }
  else
   // search the main bundle
    {
      modelPaths = [[NSBundle mainBundle]
        pathsForResourcesOfType: @"gsdatamodel" inDirectory: nil];
    }
 
 
  // initialize the models from them
  models = [NSMutableArray arrayWithCapacity: [modelPaths count]];
  e = [modelPaths objectEnumerator];
  while ((modelPath = [e nextObject]) != nil)
    {
      [models addObject: [[[NSManagedObjectModel alloc]
        initWithContentsOfFile: modelPath]
        autorelease]];
    }
 
  // and return the merged result
  return [self modelByMergingModels: models];
}
 
- (id) initWithContentsOfURL: (NSURL *) url
{
  NSData * data;
 
  // release the old instance - we'll return a new one
  [self release];
 
  if ((data = [NSData dataWithContentsOfURL: url]) == nil)
    {
      NSLog(_(@"Failed to access managed object model archive at: %@"),
        [url description]);
 
      return nil;
    }
 
  return [NSKeyedUnarchiver unarchiveObjectWithData: data];
}
 
- (id) _initWithContentsOfFile: (NSString *) file
{
  return [self initWithContentsOfURL: [NSURL fileURLWithPath: file]];
}
 
- (id) init
{
        if ((self = [super init]))
    {
      _configurations = [NSMutableDictionary new];
      _fetchRequests = [NSMutableDictionary new];
        }
      return self;
}
 
- (NSArray *) entities
{
  return _entities;
}
 
- (NSDictionary *) entitiesByName
{
  NSMutableDictionary * dict = [NSMutableDictionary
    dictionaryWithCapacity: [_entities count]];
  NSEnumerator * e = [_entities objectEnumerator];
  NSEntityDescription * entity;
 
  while ((entity = [e nextObject]) != nil)
    {
      [dict setObject: entity forKey: [entity name]];
    }
 
  return [[dict copy] autorelease];
}
 
- (void) setEntities: (NSArray *) someEntities
{
  [self _ensureEditableWithReason: @"Tried to set entities of a "
    @"managed object model already in use by an object graph manager."];
  EnsureEntitiesHaveProperNames(someEntities);
 
  if (_entities != nil)
    {
      [self _ungrabEntities: _entities];
      DESTROY(_entities);
    }
  if (someEntities != nil)
    {
      _entities = [someEntities copy];
      [self _grabEntities: _entities];
    }
}
 
- (NSArray *) configurations
{
  return [_configurations allKeys];
}
 
- (NSArray *) entitiesForConfiguration: (NSString *) conf
{
  return [_configurations objectForKey: conf];
}
 
- (void) setEntities: (NSArray *) entities
    forConfiguration: (NSString *) conf
{
  NSArray * oldEntities;
 
  [self _ensureEditableWithReason: @"Tried to set entities "
    @"for a configuration of a managed object model already in use "
    @"by an object graph manager."];
  EnsureEntitiesHaveProperNames(entities);
 
  oldEntities = [_configurations objectForKey: conf];
  if (oldEntities != nil)
    {
      [self _ungrabEntities: oldEntities];
      [_configurations removeObjectForKey: conf];
    }
  if (entities != nil)
    {
      [_configurations setObject: [[entities copy] autorelease]
                          forKey: conf];
      [self _grabEntities: entities];
    }
}
 
- (NSDictionary *) _configurationsByName
{
  return [[_configurations copy] autorelease];
}
 
- (NSFetchRequest *) fetchRequestTemplateForName: (NSString *) aName
{
  return [_fetchRequests objectForKey: aName];
}
 
- (NSFetchRequest *) fetchRequestFromTemplateWithName: (NSString *) name
                                substitutionVariables: (NSDictionary *) vars
{
  NSFetchRequest * req, * template;
 
  template = [_fetchRequests objectForKey: name];
  if (template == nil)
    {
      return nil;
    }
 
  req = [[template copy] autorelease];
  if ([req predicate] != nil)
    {
      [req setPredicate: [[req predicate]
        predicateWithSubstitutionVariables: vars]];
    }
 
  return req;
}
 
- (void) setFetchRequestTemplate: (NSFetchRequest *) request
                         forName: (NSString *) name
{
  if (_usedByPersistentStoreCoordinators)
    {
      [NSException raise: NSGenericException
                  format: _(@"Tried to set a fetch request template "
                             @"for a managed object model already in use "
                             @"by an object graph manager.")];
    }
 
  // N.B. is this the way it should behave?
  if (request != nil)
    {
      [_fetchRequests setObject: request forKey: name];
    }
  else
    {
      [_fetchRequests removeObjectForKey: name];
    }
}
 
- (void) _removeFetchRequestTemplateForName: (NSString *) name
{
  if (_usedByPersistentStoreCoordinators)
    {
      [NSException raise: NSGenericException
                  format: _(@"Tried to remove a fetch request template "
                            @"from a managed object model already in use "
                            @"by an object graph manager.")];
    }
 
  [_fetchRequests removeObjectForKey: name];
}
 
- (NSDictionary *) fetchRequestsByName
{
  return [[_fetchRequests copy] autorelease];
}
 
- (NSDictionary *) localizationDictionary
{
  // FIXME: what is this supposed to do ???
 
  return nil;
}
 
- (void) setLocalizationDictionary: (NSDictionary *) dict
{
  // FIXME: what is this supposed to do ???
}
 
- (BOOL) _isEditable
{
  return (_usedByPersistentStoreCoordinators == 0);
}
 
// NSCoding
 
- (id) initWithCoder: (NSCoder *) coder
{
        if ((self = [super init]))
    {
      if ([coder allowsKeyedCoding])
        {
          ASSIGN(_entities, [coder decodeObjectForKey: @"Entities"]);
          ASSIGN(_configurations, [coder decodeObjectForKey:
            @"Configurations"]);
          ASSIGN(_fetchRequests, [coder decodeObjectForKey: @"FetchRequests"]);
        }
      else
        {
          ASSIGN(_entities, [coder decodeObject]);
          ASSIGN(_configurations, [coder decodeObject]);
          ASSIGN(_fetchRequests, [coder decodeObject]);
        }
        }
      return self;
}
 
- (void) encodeWithCoder: (NSCoder *) coder
{
  if ([coder allowsKeyedCoding])
    {
      [coder encodeObject: _entities forKey: @"Entities"];
      [coder encodeObject: _configurations forKey: @"Configurations"];
      [coder encodeObject: _fetchRequests forKey: @"FetchRequests"];
    }
  else
    {
      [coder encodeObject: _entities];
      [coder encodeObject: _configurations];
      [coder encodeObject: _fetchRequests];
    }
}
 
// NSCopying
 
- (id) copyWithZone: (NSZone *) zone
{
  NSManagedObjectModel * model;
 
  NSEnumerator * e;
  NSString * conf;
  NSString * fetchRequestName;
 
  model = [[NSManagedObjectModel allocWithZone: zone] init];
 
   // We must copy entities and configurations themselves too - they are
   // not shareable between several models. (FIXME: is this true? Apple
   // spec doesn't say a word about this - I just *guessed* it)
  [model setEntities: [[[NSArray alloc]
    initWithArray: _entities copyItems: YES]
    autorelease]];
 
  e = [[_configurations allKeys] objectEnumerator];
  while ((conf = [e nextObject]) != nil)
    {
      [model setEntities: [[[NSArray alloc]
        initWithArray: [_configurations objectForKey: conf]
            copyItems: YES]
        autorelease]
        forConfiguration: conf];
    }
 
   // fetch requests appear to be shareable, so just set them
  e = [[_fetchRequests allKeys] objectEnumerator];
  while ((fetchRequestName = [e nextObject]) != nil)
    {
      [model setFetchRequestTemplate: [_fetchRequests objectForKey:
        fetchRequestName]
                             forName: fetchRequestName];
    }
 
  return model;
}

- (void) _incrementUseCount
{
  _usedByPersistentStoreCoordinators++;
}

- (void) _decrementUseCount
{
  NSAssert(_usedByPersistentStoreCoordinators > 0,
    _(@"Tried to underflow managed object model use count."));
 
  _usedByPersistentStoreCoordinators--;
}
 
@end