---

map.c

Go to the documentation of this file.

/**********************************************************************
*       FILE:     MAP.c
*       AUTHOR:   E. Otis O
*       DATE:     17 April 1993
*       MODIFIED: 30 April 1993 (5:00 pm)
*       PURPOSE:
*         Functions to store and relay information about the "Scotland
*         Yard" network
***********************************************************************/

#include "map.h"


/**********************************************************************
*       Private Functions
***********************************************************************/

void Map::initialize(int *array, int size)
    { for (int i= 0; i < size; i++) array[i]= 0; }

/************************************************************/

void Map::get_field (int node, mode transportation) {
// Input a transportation field from the map file.

  char ch;
  int  link;

  mapFile >> ch;
  if ( ch != FIELD ) {
    mapFile.putback(ch);
    while ( ch != FIELD ) {
      mapFile >> link >> ch;
      nodes[node].get_link(link, transportation);
      if ( ch == SUB1 ) {  // if a subfield is found...
  while ( ch != SUB2 ) {  // ...loop through the subfield until end
    mapFile >> link >> ch;
    nodes[node].get_join(link);
  }
        mapFile >> ch;  // pattern always ")," or ");"
      }
    }
  }
}





/**********************************************************************
*       Public Functions
***********************************************************************/

void Map::show_map (void) {
// Show a tabular representation of the map for testing/debugging
// purposes.

  for (int i= FIRST; i < numNodes; i++) {
    cout << "\nNODE #" << i << ": ";
    nodes[i].show_node();
  }
  cout << "\nmax x: " << maxX << "\nmax y: " << maxY << EOLN;
}

/************************************************************/

bool Map::load_map (char *mapName) {
// Read in a map and construct a data representation

  const int  BUFFER= 40;    // size of the "node name" input buffer
  const char COMMENT= '/';  // lines beginning with COMMENT are ignored

  char text[BUFFER], ch;
  int nodeNum= 0;

  mapFile.open(mapName, ios::in);

  if ( !mapFile.fail() ) {
    mapFile >> numNodes;

    nodes= new MapNode[numNodes + FIRST];  // store the adjacency list here
    assert (nodes != 0);

    while ( nodeNum < numNodes ) {
      // ignore lines commented with COMMENT
  if (mapFile.peek() == COMMENT) while (mapFile.get() != EOLN) ;
      mapFile >> nodeNum >> ch;

      get_field(nodeNum, Taxi);
      get_field(nodeNum, Bus);
      get_field(nodeNum, Subway);

      mapFile >> nodes[nodeNum].x >> ch;
      if (nodes[nodeNum].x > maxX) maxX= nodes[nodeNum].x; 
      mapFile >> nodes[nodeNum].y >> ch;
      if (nodes[nodeNum].y > maxY) maxY= nodes[nodeNum].y;

      ch= mapFile.get();
      while (ch == ' ') ch= mapFile.get();  // ignore whitespace
      mapFile.putback(ch);  // put the last read character back into the buffer
      mapFile.getline(text, BUFFER, EOLN);  // input node name and...
      // ...store name in adjacency list
      nodes[nodeNum].get_name(text, mapFile.gcount());
    }
  }

  mapFile.close();
  return (bool) mapFile.good();  // return true if all file operations went well
}

/************************************************************/

int Map::connected_to (int node, int link, int join) {

  if ( between(node, FIRST, numNodes) )
    if ( join > -1 )
      return nodes[node].find_join(link, join);
    else {
      return nodes[node].find_link(link);
}  

  else {
    cerr << "Node " << node << " out of range ("
   << FIRST << ".." << numNodes << ")\n";
    return 0;  // node 0 points to NULL
  }
}

/************************************************************/

int Map::num_connections (int node, int join) {

  if ( between(node, FIRST, numNodes) )
    if ( join > -1 ) 
      return nodes[node].num_joins(join);
    else
      return nodes[node].numLinks;
  else {
    cerr << "Node " << node << " out of range ("
   << FIRST << ".." << numNodes << ")\n";
    return 0;  // node 0 points to NULL
  }
}

/************************************************************/

int Map::next_short (int, int, bool, bool, bool) {
// This would have been a function to return the next nearest
// link in a path using Dijkstra's shortest path algorithm.
// Design changes, however, have made this function obsolete.
// A nearest-neighbor algorithm is used instead.  We have
// decided to implement this algorithm outside of the map
// module.

   return 0;
}

---