NSManagedObject.m

/* Implementation of the NSManagedObject 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 inline BOOL
IsCollection(id object)
{
  if ([object isKindOfClass: [NSSet class]] ||
      [object isKindOfClass: [NSArray class]])
    {
      return YES;
    }
  else
    {
      return NO;
    }
}

static inline void
ConstructComplexError(NSError ** target, NSArray * errors)
{
  unsigned int errorCount = [errors count];
 
  if (errorCount == 1)
    {
      *target = [errors objectAtIndex: 0];
    }
  else if (errorCount > 1)
    {
      NSError * newError;
      NSDictionary * userInfo;
 
      userInfo = [NSDictionary
        dictionaryWithObject: [[errors copy] autorelease]
                      forKey: NSDetailedErrorsKey];
      newError = [NSError errorWithDomain: NSCoreDataErrorDomain
                                     code: NSValidationMultipleErrorsError
                                 userInfo: userInfo];
 
      *target = newError;
    }
}

/*
static BOOL
ValidateAttributeValue(NSAttributeDescription * attribute,
                       id value,
                       NSError ** error)
{
  Class attrClass = NSClassFromString([attribute attributeValueClassName]);
 
  // check the class is correct
  if ([value isKindOfClass: attrClass] == NO)
    {
      NSDictionary * userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
        self, NSValidationObjectErrorKey,
        [attr name], NSValidationKeyErrorKey,
        value, NSValidationValueErrorKey,
        nil];
 
      SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationValueOfIncorrectClassError
                   userInfo: userInfo]);
 
      return NO;
    }
 
  return YES;
}
*/

/*
static BOOL
ValidateRelationshipValue(NSRelationshipDescription * relationship,
                          id value,
                          NSError ** error)
  NSEntityDescription * destEntity = [relationship destinationEntity];
  Class managedObjectClass = [NSManagedObject class];
  NSDictionary * errorUserInfo = [NSDictionary dictionaryWithObjectsAndKeys:
    self, NSValidationObjectErrorKey,
    [relationship name], NSValidationKeyErrorKey,
    value, NSValidationValueErrorKey,
    nil];
 
  // if the relationship is a to-many relationship and the passed
  // object is a collection, check that all contained objects are
  // NSManagedObject's and have the correct entity set.
  if ([rel isToMany] && IsCollection(value))
    {
      NSEnumerator * e;
      id obj;
      int count;
 
      // make sure correct cardinality is kept
      count = [value count];
      if (count < [rel minCount])
        {
          SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationRelationshipLacksMinimumCountError
                   userInfo: errorUserInfo]);
 
          return NO;
        }
      if (count > [rel maxCount])
        {
          SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationRelationshipExceedsMaximumCountError
                   userInfo: errorUserInfo]);
 
          return NO;
        }
 
      e = [value objectEnumerator];
      while ((obj = [e nextObject]) != nil)
        {
          if ([obj isKindOfClass: managedObjectClass] == NO)
            {
              SetNonNullError(error, [NSError
                errorWithDomain: NSCoreDataErrorDomain
                           code: NSValidationValueOfIncorrectClassError
                       userInfo: errorUserInfo]);
 
              return NO;
            }
          if ([[obj entity] _isSubentityOf: destEntity] == NO)
            {
              SetNonNullError(error, [NSError
                errorWithDomain: NSCoreDataErrorDomain
                           code: NSValidationValueHasIncorrectEntityError
                       userInfo: errorUserInfo]);
 
              return NO;
            }
        }
    }
  // otherwise, check the value is an NSManagedObject itself
  else if ([value isKindOfClass: managedObjectClass])
    {
      // make sure correct cardinality is kept
      if ([rel minCount] > 1)
        {
          SetNonNullError(error, [NSError
                errorWithDomain: NSCoreDataErrorDomain
                           code: NSValidationRelationshipLacksMinimumCountError
                       userInfo: errorUserInfo]);
 
          return NO;
        }
      if ([rel maxCount] < 1)
        {
          SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationRelationshipExceedsMaximumCountError
                   userInfo: errorUserInfo]);
 
          return NO;
        }
 
      if ([[value entity] _isSubentityOf: destEntity] == NO)
        {
          SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationValueHasIncorrectEntityError
                   userInfo: errorUserInfo]);
 
          return NO;
        }
    }
  // otherwise fail - incorrect value type
  else
    {
      SetNonNullError(error, [NSError
        errorWithDomain: NSCoreDataErrorDomain
                   code: NSValidationValueOfIncorrectClassError
               userInfo: errorUserInfo]);
 
      return NO;
    }
}*/

@implementation NSManagedObject
 
+ (BOOL) automaticallyNotifiesObserversForKey: (NSString *) aKey
{
  return NO;
}
 
- (void) dealloc
{
  TEST_RELEASE(_entity);
  TEST_RELEASE(_objectID);
  TEST_RELEASE(_changedValues);
  TEST_RELEASE(_data);
 
  [super dealloc];
}

- (id)            initWithEntity: (NSEntityDescription *) entity
  insertIntoManagedObjectContext: (NSManagedObjectContext *) ctxt
{
  if ((self = [super init]))
    {
      if ([entity isAbstract])
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Tried to initialize a managed object "
                                @"from an abstract entity (%@)."),
            [entity name]];
        }
 
      ASSIGN(_entity, entity);
 
      [ctxt insertObject: self];
 
    }
        return self;
}

- (NSManagedObjectContext *) managedObjectContext
{
  return _context;
}

- (NSEntityDescription *) entity
{
  return _entity;
}

- (NSManagedObjectID *) objectID
{
  // get a new temporary object ID, if necessary
  if (_objectID == nil)
    {
      _objectID = [[NSManagedObjectID alloc] _initWithEntity: _entity];
    }
 
  return _objectID;
}

- (BOOL) isInserted
{
  return [[_context insertedObjects] containsObject: self];
}

- (BOOL) isUpdated
{
  return [[_context updatedObjects] containsObject: self];
}

- (BOOL) isDeleted
{
  return _isDeleted;
}

- (BOOL) isFault
{
  return _isFault;
}

- (void) awakeFromFetch
{}

- (void) awakeFromInsert
{}
 
- (NSDictionary *) changedValues
{
  return [[_changedValues copy] autorelease];
}
 
- (void) willSave
{}
 
- (void) didSave
{}
 
- (void) didTurnIntoFault
{}

- (id) valueForKey: (NSString *) key
{
  id value;
 
  // just makes sure the key is valid
  [self _validatedPropertyForKey: key];
 
  [self willAccessValueForKey: key];
  value = [self _primitiveValueForKey: key doValidation: NO];
  [self didAccessValueForKey: key];
 
  return value;
}

- (void) setValue: (id) value
           forKey: (NSString *) key
{
  NSPropertyDescription * property;
 
  property = [self _validatedPropertyForKey: key];
  if ([self _validateValue: &value
                    forKey: key
                     error: NULL
                  property: property] == NO)
    {
      [NSException raise: NSInvalidArgumentException
                  format: _(@"Invalid value for key %@ specified."), key];
    }
 
  [self willChangeValueForKey: key];
  [self _setPrimitiveValue: value forKey: key doValidation: NO];
  [self didChangeValueForKey: key];
}

- (id) primitiveValueForKey: (NSString *) key
{
  return [self _primitiveValueForKey: key doValidation: YES];
}

- (void) setPrimitiveValue: (id) value
                    forKey: (NSString *) key
{
  // Validate the value - internal methods invoke the internal method
  // explicitly, so this method is invoked only by external code from
  // which proper validation can't be expected.
  [self _setPrimitiveValue: value forKey: key doValidation: YES];
}
 
// Validation
 
- (BOOL) validateValue: (id *) value
                forKey: (NSString *) key
                 error: (NSError **) error
{
  return [self _validateValue: value
                       forKey: key
                        error: error
                     property: [self _validatedPropertyForKey: key]];
}

- (BOOL) validateForDelete: (NSError **) error
{
  NSEnumerator * e;
  NSRelationshipDescription * rel;
  NSMutableArray * errors = [NSMutableArray array];
 
  e = [[self _allPropertiesOfSubclass: [NSRelationshipDescription class]]
    objectEnumerator];
  while ((rel = [e nextObject]) != nil)
    {
      NSString * key = [rel name];
      id value = [self _primitiveValueForKey: key doValidation: NO];
 
      if ([rel deleteRule] == NSDenyDeleteRule &&
        (([rel isToMany] && value != nil && [value count] != 0) ||
        (value != nil)))
        {
          if (error == NULL)
            {
              return NO;
            }
          else
            {
              NSError * localError;
              NSDictionary * userInfo;
 
              userInfo = [NSDictionary dictionaryWithObjectsAndKeys:
                value, NSValidationValueErrorKey,
                key,   NSValidationKeyErrorKey,
                nil];
              localError = [NSError
                errorWithDomain: NSCoreDataErrorDomain
                           code: NSValidationRelationshipDeniedDeleteError
                       userInfo: userInfo];
 
              [errors addObject: localError];
            }
        }
    }
 
  if ([errors count] > 0)
    {
      ConstructComplexError(error, errors);
 
      return NO;
    }
  else
    {
      return YES;
    }
}
 
- (BOOL) validateForInsert: (NSError **) error
{
  // NB. What is this method actually supposed to do??
 
  return YES;
}
 
- (BOOL) validateForUpdate: (NSError **) error
{
  NSEnumerator * e;
  NSPropertyDescription * property;
  NSMutableArray * errors = [NSMutableArray array];
 
  e = [[self _allPropertiesOfSubclass: [NSPropertyDescription class]]
    objectEnumerator];
  while ((property = [e nextObject]) != nil)
    {
      NSString * key = [property name];
      id value = [self _primitiveValueForKey: key
                                doValidation: NO];
      NSError * localError;
 
      if ([self _validateValue: &value
                        forKey: key
                         error: &localError
                      property: property] == NO)
        {
          // if no errors are requested, stop at the first one
          if (error == NULL)
            {
              return NO;
            }
          else
            {
              [errors addObject: localError];
            }
        }
    }
 
  if ([errors count] > 0)
    {
      ConstructComplexError(error, errors);
 
      return NO;
    }
  else
    {
      return YES;
    }
}
 
// Key-value observing
 
- (void) didAccessValueForKey: (NSString *) key
{
}
 
- (void) didChangeValueForKey: (NSString *) key
{
  [super didChangeValueForKey: key];
}
 
- (void) didChangeValueForKey: (NSString *) key
              withSetMutation: (NSKeyValueSetMutationKind) mutationKind
                 usingObjects: (NSSet *) objects
{
  [super didChangeValueForKey: key
              withSetMutation: mutationKind
                 usingObjects: objects];
}
 
- (void *) observationInfo
{
  return [super observationInfo];
}
 
- (void) setObservationInfo: (void *) info
{
  [super setObservationInfo: info];
}
 
- (void) willAccessValueForKey: (NSString *) key
{
}
 
- (void) willChangeValueForKey: (NSString *) key
{
  [super willChangeValueForKey: key];
}
 
- (void) willChangeValueForKey: (NSString *) key
               withSetMutation: (NSKeyValueSetMutationKind) mutationKind
                  usingObjects: (NSSet *) objects
{
  [super willChangeValueForKey: key
               withSetMutation: mutationKind
                  usingObjects: objects];
}
 

- (id) _initAsFaultWithEntity: (NSEntityDescription *) entity
               ownedByContext: (NSManagedObjectContext *) context
{
        if ((self = [super init]))
    {
      if ([entity isAbstract])
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Tried to initialize a managed object "
                                @"from an abstract entity (%@)."),
            [entity name]];
        }
 
      ASSIGN(_entity, entity);
 
      _context = context;
      _isFault = YES;
        }
        return self;
 }

- (void) _setObjectID: (NSManagedObjectID *) newID
{
  NSAssert([newID isTemporaryID] == NO, _(@"Tried to assign to a managed "
    @"object a temporary object ID."));
 
  ASSIGN(_objectID, newID);
}

- (void) _setDeleted: (BOOL) flag
{
  _isDeleted = flag;
}

- (void) _setFault: (BOOL) flag
{
  _isFault = flag;
}

- (void) _insertedIntoContext: (NSManagedObjectContext *) ctxt
{
  NSAssert(_context == nil || _context == ctxt, _(@"Tried to re-insert a "
    @"managed object into different managed object context."));
 
  _context = ctxt;
}

- (void) _removedFromContext
{
  NSAssert(_context != nil, _(@"Attempted to remove from a context an "
    @"already removed managed object."));
 
  _context = nil;
}

- (NSPropertyDescription *) _validatedPropertyForKey: (NSString *) key
{
  NSPropertyDescription * desc = nil;
  NSEntityDescription * entity;
 
  // Look for the property by name, running upwards through the
  // entity hierarchy if necessary.
  for (entity = _entity;
       desc == nil && entity != nil;
       entity = [entity superentity])
    {
      desc = [[entity propertiesByName] objectForKey: key];
    }
 
  if (desc != nil)
    {
      return desc;
    }
  else
    {
      [NSException raise: NSInvalidArgumentException //NSUnknownKeyException
                  format: _(@"Invalid key specified. The key does not "
                            @"exist in the model.")];
 
      return nil;
    }
}

- (NSArray *) _allPropertiesOfSubclass: (Class) aClass
{
  NSMutableArray * properties;
  NSEntityDescription * entity;
 
  NSAssert(aClass != nil, _(@"Nil class argument."));
 
  properties = [NSMutableArray array];
 
  for (entity = _entity; entity != nil; entity = [entity superentity])
    {
      NSEnumerator * e;
      NSPropertyDescription * property;
 
      e = [[entity properties] objectEnumerator];
      while ((property = [e nextObject]) != nil)
        {
          if ([property isKindOfClass: aClass])
            {
              [properties addObject: property];
            }
        }
    }
 
  return [[properties copy] autorelease];
}

// TODO - finish this method. Validation is partially broken until
// we have predicate support in Foundation.
- (BOOL) _validateValue: (id *) val
                 forKey: (NSString *) key
                  error: (NSError **) error
               property: (NSPropertyDescription *) property
{
  id value = *val;
  SEL customValidationSel;
 
  // TODO - use predicates to validate the value
 
  if (value != nil)
    {
/*      if ([desc isKindOfClass: [NSAttributeDescription class]])
        {
          if (ValidateAttributeValue((NSAttributeDescription *) desc,
            value, error) == NO)
            {
              return NO;
            }
        }
      else if ([desc isKindOfClass: [NSRelationshipDescription class]])
        {
          if (ValidateRelationshipValue((NSRelationshipDescription *) desc,
            value, error) == NO)
            {
              return NO;
            }
      else
        {
          [NSException raise: NSInternalInconsistencyException
                      format: _(@"Passed non-attribute, non-relationship "
                                @"property description to internal validation "
                                @"method.")];
        }*/
    }
  // if `nil' is specified, the property must be optional
  else
    {
      if ([property isOptional] == NO)
        {
          SetNonNullError(error, [NSError
            errorWithDomain: NSCoreDataErrorDomain
                       code: NSValidationMissingMandatoryPropertyError
                   userInfo: [NSDictionary dictionaryWithObjectsAndKeys:
            self, NSValidationObjectErrorKey,
            key, NSValidationKeyErrorKey,
            nil]]);
 
          return NO;
        }
    }
 
  // now do the customizable "validate<Key>:error:" validation
  customValidationSel = NSSelectorFromString([NSString stringWithFormat:
    @"validate%@:error:", key]);
  if ([self respondsToSelector: customValidationSel])
    {
      BOOL retval;
      NSInvocation * invocation = [[NSInvocation new] autorelease];
 
      [invocation setTarget: self];
      [invocation setSelector: customValidationSel];
      [invocation setArgument: &value
                      atIndex: 2];
      [invocation setArgument: &error
                      atIndex: 3];
      [invocation invoke];
      [invocation getReturnValue: &retval];
 
      return retval;
    }
  else
    {
      return YES;
    }
}

- (id) _primitiveValueForKey: (NSString *) key doValidation: (BOOL) validate
{
  if (validate == YES)
    {
      [self _validatedPropertyForKey: key];
    }
  if (_isFault)
    {
      [self _fireFault];
    }
 
  return [_data objectForKey: key];
}

- (void) _setPrimitiveValue: (id) value
                     forKey: (NSString *) key
               doValidation: (BOOL) validate
{
  NSPropertyDescription * property;
  NSError * error;
 
  property = [self _validatedPropertyForKey: key];
 
  // validate the value if requested
  if (validate)
    {
      if ([self _validateValue: &value
                        forKey: key
                         error: &error
                      property: property] != YES)
        {
          [NSException raise: NSInvalidArgumentException
                      format: _(@"Invalid value for key \"%@\" specified."),
            key];
        }
    }
 
  if (_isFault)
    {
      [self _fireFault];
    }
 
  [_data setObject: value forKey: key];
 
  if ([property isTransient] == NO)
    {
      if (_changedValues == nil)
        {
          _changedValues = [NSMutableDictionary new];
        }
      [_changedValues setObject: value forKey: key];
    }
}
 
@end