Start with the interface file. Modify HotelController.h with the bolded code in Listing 5-6.

@class Trip;
@class Hotel;

@interface HotelController : UITableViewController
                    <NSFetchedResultsControllerDelegate> {
  NSFetchedResultsController *fetchedResultsController;
  Trip                       *trip;
  Hotel                      *hotel;
}
@property (nonatomic, retain) NSFetchedResultsController
                               *fetchedResultsController;
- (id) initWithTrip: (Trip*) aTrip;
@end

First of all, you have made HotelController an NSFetchedResultsControllerDelegate here. You'll see why you did that in the "Creating a fetched results controller" section, later in this chapter.

You've also declared three instance variables. One of them holds a reference to Trip, the second will hold a reference to a new Hotel object when you do finally create one, and the third is the instance variable behind the fetchedResultsController property that you also add.

Finally, you declare the initWithTrip: method you're going to add to HotelController.m.

To implement initWithTrip:, add the bolded code in Listing 5-7 to HotelController.m.

#import "HotelController.h"
#import "MapController.h"
#import "Trip.h"
#import "Hotel.h"
#import "Annotation.h"
#import "Geocoder.h"

@implementation HotelController

@synthesize fetchedResultsController;

- (id) initWithTrip: (Trip*) aTrip{
  if (self = [super initWithNibName:@"HotelController"
                                            bundle:nil]) {
    trip = aTrip;
    [trip retain];
  }
  return self;
}

You'll notice I had you add a number of #import statements. You don't need them now, but you will need them later, so why not get that out of the way?

Working in the same spirit of copy and paste that you used in Chapter 4 of this minibook to add the Core Data Stack, you'll add the template code to HotelController. Here's how:

Admittedly, your work isn't done yet, but this copy and paste stuff has gotten you pretty far, even if you still need to make some (minor) modifications to some of the code. You'll start with viewDidLoad.

Make the modifications indicated in bold in Listing 5-8 to the copy of viewDidLoad in HotelController.m.

- (void)viewDidLoad {
  [super viewDidLoad];

// Set up the edit and add buttons.
//self.navigationItem.leftBarButtonItem =
                                 self.editButtonItem;
self.title = @"Hotels";

UIBarButtonItem *addButton = [[UIBarButtonItem alloc]
   initWithBarButtonSystemItem:UIBarButtonSystemItemAdd
 target:self action:@selector(insertNewObject)];
self.navigationItem.rightBarButtonItem = addButton;
[addButton release];
self.tableView.sectionHeaderHeight = 40.0;


NSError *error = nil;
if (![[self fetchedResultsController]
                                 performFetch:&error]) {

  //Replace this implementation with code to handle the
  // error appropriately.
  SLog(@"Unresolved error %@, %@", error,
                                       error userInfo]);
  abort(); //$$ not in production
  }
}

Looking at Listing 5-8, you see that the template code you got from your CoreData project adds an Edit button, which you won't be using, so I have you delete that. It also adds an Add button, which the user taps to add a new hotel. This Add button has the insertNewObject method as its target.

I also have you add a line of code to set the title of the Navigation bar to "Hotels."

The default table view is plain, and that's what you'll be using. You can, however, also have section titles, but I find the default Height value a little cramped, so I have you set it here.

self.tableView.sectionHeaderHeight = 40.0;

As I mention in the opening of this chapter, if you're using a table view, a fetched results controller (NSFetchedResultsController) can make your life much easier. It, too, tries to minimize the amount of data held in memory by efficiently managing the results returned from a Core Data fetch request to provide data for a UITableView object. You use this class to get the objects you need to create cells in a UITableView, as well as to determine both the number of sections you need and the number of rows for each section.

You create an instance of this class by using a fetch request that specifies the entity, an array containing at least one sort ordering, and optionally a filter predicate. You can also specify a sectionNameKeyPath argument that the controller will use to split the results into sections, or you can pass nil to indicate that the controller should generate a single section. After creating an instance, you invoke performFetch: to actually execute the fetch.

To get all this to work for you, make the modifications in bold in Listing 5-9 to fetchedResultsController method in HotelController.m.

- (NSFetchedResultsController *)fetchedResultsController {

  if (fetchedResultsController != nil) {
    return fetchedResultsController;
  }

// Create the fetch request for the entity.
  NSFetchRequest *fetchRequest =
                            [[NSFetchRequest alloc] init];
   // Edit the entity name as appropriate.
// NSEntityDescription *entity = [NSEntityDescription
   entityForName:@"Event" inManagedObjectContext:managed
   ObjectContext];
  NSEntityDescription *entity = [NSEntityDescription
        entityForName:@"Hotel"
       inManagedObjectContext:trip.managedObjectContext];

[fetchRequest setEntity:entity];

  // Set the batch size to a suitable number.
    [fetchRequest setFetchBatchSize:20];

   // Edit the sort key as appropriate.
    //NSSortDescriptor *sortDescriptor =
         [[NSSortDescriptor alloc] initWithKey:@"timestamp
    NSSortDescriptor *sortDescriptor = [[NSSortDescriptor
     alloc] initWithKey:@"city" ascending:NO];
    NSArray *sortDescriptors = [[NSArray alloc]
     initWithObjects:sortDescriptor, nil];
    [fetchRequest setSortDescriptors:sortDescriptors];

   // Edit the section name key path and cache name
  // nil for section name key path means "no sections".
  //NSFetchedResultsController *aFetchedResultsController =
     [[NSFetchedResultsController alloc] initWithFetchRequest
     :fetchRequest managedObjectContext:managedObjectContext
     sectionNameKeyPath:nil cacheName:@"Root"];
    NSFetchedResultsController *aFetchedResultsController =
     [[NSFetchedResultsController alloc] initWithFetchRequest:
     fetchRequest managedObjectContext:trip.managedObjectContext
     sectionNameKeyPath:@"city" cacheName:@"Root"];
    aFetchedResultsController.delegate = self;
    self.fetchedResultsController =
                                aFetchedResultsController;
    [aFetchedResultsController release];
    [fetchRequest release];
    [sortDescriptor release];
    [sortDescriptors release];

    return fetchedResultsController;
  }

The first thing you do to set up your very own fetched results controller is create the fetch request for the entity. For all practical purposes, this is the same thing you did in loadHotels, so if you aren't clear on what you've just accomplished in that regard with Listing 5-9, refer to the discussion following Listing 5-3.

What's new here is that, after you've created the fetch request, you create the fetched results controller, specify the section name key path and cache name, and then set self as the delegate.

NSFetchedResultsController *aFetchedResultsController =
   [[NSFetchedResultsController alloc] initWithFetchRequest:f
   etchRequest managedObjectContext:trip.managedObjectContext
   sectionNameKeyPath:@"city" cacheName:@"Root"];
aFetchedResultsController.delegate = self;

With this lovely bit of coding, you create an NSFetchedResults Controller, initializing it with the fetchRequest you just created and configured, the managedObjectContext and two other arguments — sectionNameKeyPath and cacheName.

By passing in the sectionNameKeyPath argument @"city", you're telling Core Data you want to assign Hotel objects to sections in the table view based on the City key. That means that when you're done, your HotelController will display hotels by cities, as shown in Figure 5-1.

Figure 5-1. The hotel is listed under its city.

Giving a (optional) cacheName of @"Root" and a delegate — aFetched ResultsController.delegate = self;, (earlier you had the HotelController adopt the NSFetchedResultsControllerDelegate protocol) tells Core Data to cache its results so that if the same data is subsequently asked for again, the work doesn't have to be repeated.

Finally, you clean up by releasing the objects:

self.fetchedResultsController = aFetchedResultsController;
[aFetchedResultsController release];
[fetchRequest release];
[sortDescriptor release];
[sortDescriptors release];

return fetchedResultsController;

Now that you have the fetched results controller set up, it will be easier to understand what you do when you actually add a hotel.

The most exciting method in the HotelController is the one that adds a new object. The insertNewObject method is the target of the Add button you added in Listing 5-8. Although I've added to this method, it is essentially the same one used in the template. In the template, you simply add a new Event object with a single attribute — a time stamp — which you initialize it with. You will be extending that to create the Hotel object and its Annotation and then add it to the managed object context.

To avoid making things more complicated than they need to be, you won't be developing the user interface in this chapter to do that. The Hotel object and its Annotation are hard coded — that will make it easier for you to follow the logic.

In Book VII, however, I'll have you add a user interface as well as show you how you'll be able to use existing contacts in your Address Book to add hotels or, alternatively, add your new hotel to your Address Book contacts.

I've indicated in bold the changes you'll need to make to the template code to add a new Hotel object and its Annotation object. I've left out or summarized most of the comments you'll see in the template code.

Make the modifications in Listing 5-10 to insertNewObject in HotelController.m.

#pragma mark -
#pragma mark Add a new object

- (void)insertNewObject {

// Create a new instance of the entity managed by the fetched
   results controller.

//NSManagedObjectContext *context =
         [fetchedResultsController managedObjectContext];
  NSEntityDescription *entity =
      [[fetchedResultsController fetchRequest] entity];
//NSManagedObject *newManagedObject =
          [NSEntityDescription insertNewObjectForEntityFor
   Name:[entity name] inManagedObjectContext:context];
  hotel = [NSEntityDescription
       insertNewObjectForEntityForName:[entity name]
       inManagedObjectContext:trip.managedObjectContext];
// If appropriate, configure the new managed object.
// [newManagedObject setValue:[NSDate date]
   forKey:@"timeStamp"];
  [hotel setValue:@"Hotel California" forKey:@"name"];
  [hotel setValue:@"1 Dr. Carlton B. Goodlett Place"
                                           forKey:@"street"];
  [hotel setValue:@"San Francisco" forKey:@"city"];
  [hotel setValue:@"California" forKey:@"state"];
  [hotel setValue:@"94102" forKey:@"zip"];

  Annotation *annotation = [NSEntityDescription
       insertNewObjectForEntityForName:@"Annotation"
       inManagedObjectContext:trip.managedObjectContext];
  [annotation setTitle:@"Annotation"];
  [annotation setHotel:hotel];
  [hotel setAnnotation:annotation];

  Geocoder * geocoder = [[Geocoder alloc] init];
  NSString* geocodeString = [[NSString alloc ]
        initWithFormat: @" %@ %@ %@ %@",
        hotel.street, hotel.city, hotel.state, hotel.zip];
  CLLocationCoordinate2D theCoordinate =
                 [geocoder geocodeLocation:geocodeString];

  hotel.annotation.latitude =
      [NSNumber numberWithDouble: theCoordinate.latitude];
  hotel.annotation.longitude =
      [NSNumber numberWithDouble: theCoordinate.longitude];
  hotel.annotation.title = hotel.name;
// Save the context.
  NSError *error = nil;
  if (![trip.managedObjectContext save:&error]) {
   // Replace this implementation with code to handle the
   // error appropriately.
  NSLog(@"Unresolved error %@, %@", error,
                                        [error userInfo]);
  abort();
  }
  [trip loadHotels];
  [trip.mapController refreshAnnotations];
}

Looking at Listing 5-10, you see that you start by creating a new instance of the Hotel entity managed by the fetched results controller. (Remember, when you set up the fetch results controller in the previous section you specified the entity you wanted was Hotel.)

NSEntityDescription *entity =
      [[fetchedResultsController fetchRequest] entity];

Then you create a new object using the entity name Hotel in the managed object context you created in Trip.

hotel = [NSEntityDescription
       insertNewObjectForEntityForName:[entity name]
       inManagedObjectContext:trip.managedObjectContext];

Then you set the attributes for the object. (Later you will be doing this in a dialog where the user can enter the information.)

[hotel setValue:@"Hotel California" forKey:@"name"];
[hotel setValue:@"1 Dr. Carlton B. Goodlett Place"
                                       forKey:@"street"];
[hotel setValue:@"San Francisco" forKey:@"city"];
[hotel setValue:@"California" forKey:@"state"];
[hotel setValue:@"94102" forKey:@"zip"];

Next, you need to create and configure the Annotation.

Annotation *annotation = [NSEntityDescription
       insertNewObjectForEntityForName:@"Annotation"
       inManagedObjectContext:trip.managedObjectContext];
[annotation setTitle:@"Annotation"];
[annotation setHotel:hotel];
[hotel setAnnotation:annotation];

Then you use your old friend the geocoder to get the coordinates needed for the Annotation as well as set them.

Geocoder * geocoder = [[Geocoder alloc] init];
NSString* geocodeString = [[NSString alloc ]
        initWithFormat: @" %@ %@ %@ %@",
        hotel.street, hotel.city, hotel.state, hotel.zip];
CLLocationCoordinate2D theCoordinate =
                 [geocoder geocodeLocation:geocodeString];
hotel.annotation.latitude =
      [NSNumber numberWithDouble: theCoordinate.latitude];
hotel.annotation.longitude =
      [NSNumber numberWithDouble: theCoordinate.longitude];
hotel.annotation.title = hotel.name;

Finally, you save the context

NSError *error = nil;
if (![trip.managedObjectContext save:&error]) {
 // Replace this implementation with code to handle the
 // error appropriately.
NSLog(@"Unresolved error %@, %@", error,
                                      [error userInfo]);
abort();
}

and then load the new Hotel into the hotels array used by Map's createAnnotation method and then send a message to the MapController to refresh the annotations.

[trip loadHotels];
[trip.mapController refreshAnnotations];

Here's where your previous work really pays off — you already have the logic in place to dynamically add and delete annotations as needed.

At this point you have created the infrastructure necessary to add a hotel. Of course, this superb piece of engineering isn't worth much until you add the code to the RoadTrip app that actually displays the hotel you have added.

That's what you will do in this section.

Next you need to make some changes to the default table view methods. You'll start with tableView:cellForRowAtIndexPath:. Make the modifications to HotelController.m shown in bold in Listing 5-11.

- (UITableViewCell *)tableView:(UITableView *)tableView cellF
   orRowAtIndexPath:(NSIndexPath *)indexPath {

  static NSString *CellIdentifier = @"Cell";

  UITableViewCell *cell = [tableView dequeueReusableCellWithI
   dentifier:CellIdentifier];
  if (cell == nil) {
    cell = [[[UITableViewCell alloc] initWithStyle:UITabl
   eViewCellStyleDefault reuseIdentifier:CellIdentifier]
   autorelease];
  }
// Configure the cell.

NSManagedObject *managedObject = [fetchedResultsController
     objectAtIndexPath:indexPath];
  //cell.textLabel.text =_
        [[managedObject valueForKey:@"timeStamp"]
     description];
    cell.textLabel.text = [[managedObject valueForKey:@"name"]
     description];

    return cell;
  }

Fetched results controllers are very helpful in table views because they make it easy to get the right number of sections and rows, as well as the information needed to create the cells. Here, as you can see, all you have to do is pass the fetched results controller the index path you get in this method and then it will return the object that has the data (the name of the hotel) you want to display in the cell.

NSManagedObject *managedObject =
 [fetchedResultsController objectAtIndexPath:indexPath];

You set the text in the cell to the name of the hotel.

cell.textLabel.text =
       [[managedObject valueForKey:@"name"] description];

The template code doesn't come with section heads, so you need to add the method in Listing 5-12 to HotelController.m to take care of the section heads we need.

- (NSString *)tableView:(UITableView *)tableView titleForHead
   erInSection:(NSInteger)section {
  return [[[fetchedResultsController sections]
   objectAtIndex:section] name];
}

Bunches of other table view methods are available out there, but I'll leave you to explore them on your own. I do, however, come back and revisit table View:didSelectRowAtIndexPath: in the "Adding Delete" section, later in the chapter.

If you set a delegate for a fetched results controller, the controller registers to receive change notifications from its managed object context. (I glossed over that when I discussed caching earlier.) Any change in the managed object context to objects or section information needs to be processed and the display in the table view updated accordingly. The controller notifies the delegate when result objects change location or when sections are modified.

Listing 5-13 shows the simplest case — yes, just reloading the table view counts as change.

- (void)controllerDidChangeContent:
            (NSFetchedResultsController *)controller {
   // In the simplest, most efficient, case, reload the table
   view.
   [self.tableView reloadData];
}

This is what you'll be using. There are also a number of other methods available that are beyond the scope of this book. You can read the comments in the generated code and see how they're implemented in the Core Data samples Apple provides.

Finally, because you don't create the managed object context (it is created in Trip), you don't want to delete it either. Make the modifications shown in bold in Listing 5-14 to dealloc in HotelController.m to make sure your managed object context doesn't get tossed.

- (void)dealloc {
   [fetchedResultsController release];
//[managedObjectContext release];
    [super dealloc];
}
@end

At this point, you can compile and run the code. If you select Hotels in the main menu of your RoadTrip app, you'll be faced with the blank screen you see in Figure 5-2.

Figure 5-2. The initial Hotels list.

If you select the Add button (+), you'll see in Figure 5-3 that you have now successfully added a hotel.

Even cooler than that, if you go back to the Map view, you'll see (in Figure 5-4) that the hotel is now nicely displayed — with it annotation no less!

To begin all the undoing, the strategy here is to set up the Undo manager when you add a hotel. Make the changes marked in bold/strikeout in Listing 5-15 to the insertNewObject method in HotelController.h.

#pragma mark -
#pragma mark Add a new object

- (void)insertNewObject {

// Create a new instance of the entity managed by the fetched
   results controller.
  NSEntityDescription *entity =
      [[fetchedResultsController fetchRequest] entity];
  hotel = [NSEntityDescription
       insertNewObjectForEntityForName:[entity name]
       inManagedObjectContext:trip.managedObjectContext];
  [self setUpUndoManager];
  [hotel setValue:@"Hotel California" forKey:@"name"];
  [hotel setValue:@"600 Sutter Street" forKey:@"street"];
  [hotel setValue:@"San Francisco" forKey:@"city"];
  [hotel setValue:@"California" forKey:@"state"];
  [hotel setValue:@"94108" forKey:@"zip"];

  Annotation *annotation = [NSEntityDescription
       insertNewObjectForEntityForName:@"Annotation"
       inManagedObjectContext:trip.managedObjectContext];
  [annotation setTitle:@"Annotation"];
  [annotation setHotel:hotel];
  [hotel setAnnotation:annotation];

  Geocoder * geocoder = [[Geocoder alloc] init];
  NSString* geocodeString = [[NSString alloc ]
        initWithFormat: @" %@ %@ %@ %@",
        hotel.street, hotel.city, hotel.state, hotel.zip];
  CLLocationCoordinate2D theCoordinate =
                 [geocoder geocodeLocation:geocodeString];

  hotel.annotation.latitude =
      [NSNumber numberWithDouble: theCoordinate.latitude];
  hotel.annotation.longitude =

[NSNumber numberWithDouble: theCoordinate.longitude];
  hotel.annotation.title = hotel.name;
// Save the context.
  NSError *error = nil;
  if (![trip.managedObjectContext save:&error]) {
   // Replace this implementation with code to handle the
   // error appropriately.
  NSLog(@"Unresolved error %@, %@", error,
                                        [error userInfo]);
'Tony Bove' abort();
  }
  [trip loadHotels];
  [trip.mapController refreshAnnotations];
}

The modifications spelled out in Listing 5-15 do two things for you. First, you arrange it so that you send a message to yourself to set up the Undo manager.

[self setUpUndoManager];

With that done, you then delete the code you added to save the context and refresh the annotations. That's because you don't want to save or update anything until you're quite sure what the last Undo/Redo action was. I show you later where you'll do that save and update.

Now you will have to implement two methods in HotelController. Start by making the changes to HotelController.h shown in bold in Listing 5-16.

@class Trip;
@class Hotel;

@interface HotelController : UITableViewController
   <NSFetchedResultsControllerDelegate> {
  NSFetchedResultsController *fetchedResultsController;
  Trip                       *trip;
  Hotel                      *hotel;
  NSUndoManager              *undoManager;
}
@property (nonatomic, retain) NSFetchedResultsController
   *fetchedResultsController;
 @property (nonatomic, retain) NSUndoManager *undoManager;
- (void)setUpUndoManager;
- (void)cleanUpUndoManager;

@end

Here you have declared two methods to set up (and then clean up) the Undo manager and a property to hold a reference to the Undo manager.

Next, you need to add the two methods setUpUndoManager and cleanUpUndoManager shown in Listings 5-17 and 5-18, respectively, to TripController.m.

- (void)setUpUndoManager {
  if (hotel.managedObjectContext.undoManager == nil) {
    hotel.managedObjectContext.undoManager =
                                [[NSUndoManager alloc] init];
    [hotel.managedObjectContext.undoManager setActionName:
                   [NSString stringWithString:@"Add Hotel"]];

                      [hotel.managedObjectContext.undoManager
    setLevelsOfUndo:3];
      [hotel.managedObjectContext.undoManager release];
    }
   self.undoManager = hotel.managedObjectContext.undoManager ;

// Register as an observer of the hotel's context's undo
   manager.
  NSNotificationCenter *dnc =
                  [NSNotificationCenter defaultCenter];
 [dnc addObserver:self selector:@
   selector(undoManagerDidUndo:) name:NSUndoManagerDidUndoCha
   ngeNotification object:undoManager];
 [dnc addObserver:self
           selector:@selector(undoManagerDidRedo:) name:NSUnd
   oManagerDidRedoChangeNotification object:undoManager];
}

If the Hotel object's Managed Object Context doesn't already have an Undo manager, then create one and set it for the context and self.

if (hotel.managedObjectContext.undoManager  == nil) {
NSUndoManager *anUndoManager =
                           [[NSUndoManager alloc] init];

You also set what the Undo alert will display (it'll display Add Hotel) and the level of undo (up to 3 undos).

[anUndoManager setActionName:
              [NSString stringWithString:@"Add Hotel"]];
    [anUndoManager setLevelsOfUndo:3];

The view controller needs to keep a reference to the Undo manager it creates so that it can determine whether to remove the Undo manager when editing finishes (in the case of a table view that supports editing) or when the view unloads (in our case). You also assign the newly created Undo manager to the Managed Object Context:

self.undoManager = anUndoManager;
    [anUndoManager release];
    hotel.managedObjectContext.undoManager = undoManager;

Then you register as an observer of the Hotel object's Managed Object Context's Undo manager. You tell the notification center to send the undo ManagerDidUndo: message to self when an undo occurs and the undo ManagerDidRedo: message when a redo occurs.

NSNotificationCenter *dnc =
                  [NSNotificationCenter defaultCenter];
 [dnc addObserver:self selector:@
   selector(undoManagerDidUndo:) name:NSUndoManagerDidUndoCha
   ngeNotification object:undoManager];
 [dnc addObserver:self
   selector:@selector(undoManagerDidRedo:) name:NSUndoManager
   DidRedoChangeNotification object:undoManager];
}

When you no longer need the Undo manager, you'll clean up after yourself. Enter the code in Listing 5-18 to HotelController.m.

- (void)cleanUpUndoManager {

// Remove self as an observer.
  [[NSNotificationCenter defaultCenter]
                                     removeObserver:self];

  if (hotel.managedObjectContext.undoManager ==
                                            undoManager) {
  hotel.managedObjectContext.undoManager = nil;
  self.undoManager = nil;
  }
}

You'll remove self as an observer and set the properties to nil.

You registered with the notification center to have a message sent whenever there was an undo or redo. Add the code in Listing 5-19 to HotelController.m to implement those methods.

- (void)undoManagerDidUndo:(NSNotification *)
                                            notification {
  [self.tableView reloadData];
}


- (void)undoManagerDidRedo:(NSNotification *)
                                            notification {

  [self.tableView reloadData];
}

In both cases, you simply reload the table view to either remove (or add back) the entry.

Finally, a little housekeeping. The view controller must be first responder in order to be able to receive Shake events for undo. To do that, add the code in Listing 5-20 to HotelController.h.

- (BOOL)canBecomeFirstResponder {

  return YES;
}


- (void)viewDidAppear:(BOOL)animated {

  [super viewDidAppear:animated];
  [self becomeFirstResponder];
}

Finally, when the view unloads and undos and redos are no longer possible, you need to save the current Managed Object Context and resign as first responder. Add the code in Listing 5-21 HotelController.m to send the cleanUpUndoManager message.

- (void)viewWillDisappear:(BOOL)animated {
  [super viewWillDisappear:animated];
  [self cleanUpUndoManager];
  // Save the context.
  if (trip.managedObjectContext.hasChanges) {
    NSError *error = nil;
    if (![trip.managedObjectContext save:&error]) {
  /*
   Replace this implementation with code to handle the error
   appropriately.
  */
      NSLog(@"Unresolved error %@, %@", error,
                                        [error userInfo]);
    abort();
    }
  }
  [trip loadHotels];
  [trip.mapController refreshAnnotations];
  [self resignFirstResponder];
}

The viewWillDisappear: message is sent to the view controller, well, when the view is going to disappear. This is the place where you want to commit the changes. First, you send the cleanUpUndoManager method you implemented in Listing 5-18. Then you save the context, and then send the loadHotels and refreshAnnotations messages to ensure that the hotel will appear on the map — this is simply the code you had in insertNewObject previously and does the same thing here. You also resign as first responder because you're ending the Undo/Redo cycle (and the view is disappearing anyway).

When you compile this code, go ahead and add a hotel using the Add button, as I have in Figure 5-5.

At this point, you can only add the hotel you hard coded in the insertNew Object method — but patience, you'll add the code and the user interface in Book VII, Chapter 1 that will allow the user to decide where he or she wants to stay.

Then either shake the device, or choose Hardware

If you touch Undo Add Hotel, your added hotel will be undone, as you can see in Figure 5-7.

Figure 5-5. Adding a hotel.

Figure 5-6. Undo add hotel?

Figure 5-7. The result of Undo Add Hotel.