NSFetchRequest.m

/* Implementation of the NSFetchRequest 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"

@implementation NSFetchRequest
 
- (void) dealloc
{
  TEST_RELEASE(_affectedStores);
  TEST_RELEASE(_entity);
  TEST_RELEASE(_predicate);
 
  [super dealloc];
}

- (id) _initWithAffectedStores: (NSArray *) affectedStores
                       entity: (NSEntityDescription *) entity
                   fetchLimit: (unsigned int) fetchLimit
                    predicate: (NSPredicate *) predicate
              sortDescriptors: (NSArray *) sortDescriptors
{
  if ((self = [self init]))
    {
      ASSIGN(_affectedStores, affectedStores);
      ASSIGN(_entity, entity);
      _fetchLimit = fetchLimit;
      ASSIGN(_predicate, predicate);
      ASSIGN(_sortDescriptors, sortDescriptors);
 
    }
        return self;
}

- (NSArray *) affectedStores
{
  return _affectedStores;
}

- (void) setAffectedStores: (NSArray *) stores
{
  ASSIGN(_affectedStores, stores);
}

- (NSEntityDescription *) entity
{
  return _entity;
}

- (void) setEntity: (NSEntityDescription *) entity
{
  ASSIGN(_entity, entity);
}

- (unsigned int) fetchLimit
{
  return _fetchLimit;
}

- (void) setFetchLimit: (unsigned int) aLimit
{
  _fetchLimit = aLimit;
}

- (NSPredicate *) predicate
{
  return _predicate;
}

- (void) setPredicate: (NSPredicate *) predicate
{
  ASSIGN(_predicate, predicate);
}

- (NSArray *) sortDescriptors
{
  return _sortDescriptors;
}

- (void) setSortDescriptors: (NSArray *) sortDescriptors
{
  ASSIGN(_sortDescriptors, sortDescriptors);
}
 
// NSCopying
 
- (id) copyWithZone: (NSZone *) zone
{
  return [[NSFetchRequest allocWithZone: zone]
    _initWithAffectedStores: _affectedStores
                    entity: _entity
                fetchLimit: _fetchLimit
                 predicate: _predicate
           sortDescriptors: _sortDescriptors];
}
 
// NSCoding
 
- (void) encodeWithCoder: (NSCoder *) coder
{
  if ([coder allowsKeyedCoding])
    {
      [coder encodeObject: _affectedStores forKey: @"AffectedStores"];
      [coder encodeObject: _entity forKey: @"Entity"];
      [coder encodeInt: _fetchLimit forKey: @"FetchLimit"];
      [coder encodeObject: _predicate forKey: @"Predicate"];
      [coder encodeObject: _sortDescriptors forKey: @"SortDescriptors"];
    }
  else
    {
      [coder encodeObject: _affectedStores];
      [coder encodeObject: _entity];
      [coder encodeValueOfObjCType: @encode(unsigned int) at: &_fetchLimit];
      [coder encodeObject: _predicate];
      [coder encodeObject: _sortDescriptors];
    }
}
 
- (id) initWithCoder: (NSCoder *) coder
{
        if ((self = [self init]))
    {
      if ([coder allowsKeyedCoding])
        {
          ASSIGN(_affectedStores, [coder
            decodeObjectForKey: @"AffectedStores"]);
          ASSIGN(_entity, [coder decodeObjectForKey: @"Entity"]);
          _fetchLimit = [coder decodeIntForKey: @"FetchLimit"];
          ASSIGN(_predicate, [coder decodeObjectForKey: @"Predicate"]);
          ASSIGN(_sortDescriptors, [coder
            decodeObjectForKey: @"SortDescriptors"]);
        }
      else
        {
          ASSIGN(_affectedStores, [coder decodeObject]);
          ASSIGN(_entity, [coder decodeObject]);
          [coder decodeValueOfObjCType: @encode(unsigned int)
                                    at: &_fetchLimit];
          ASSIGN(_predicate, [coder decodeObject]);
          ASSIGN(_sortDescriptors, [coder decodeObject]);
        }
 
    }
        return self;
}
 
@end