Although writing customized implementations for interfaces NodeMap or EdgeMap is easy, the most frequently used way to get these is conveniently provided by class Graph. Example 4.13, “Creating default node maps” shows one of the two methods that both return default implementations of these interfaces which can be used for most purposes and data types.

The maps returned by these methods hold exactly one value for a given key, i.e., no matter how many calls to any of the setter methods are issued for a given key, only the last value set will be held. Also, the type of the key given with a setter method is restricted to the respective type of graph elements, i.e., restricted to Node or Edge. The type of the value though, is not restricted to be same over the range of all nodes, for example. In fact, it would be perfectly legal to set a double value with one node, and boolean values with every other. This, however, is strongly discouraged, since it definitely leads to problems when the values will be retrieved.

Default map implementations can be created at any time, even when the graph is empty. From the moment of creation on, they will cover all graph elements from the respective set, as well as all respective elements created by the graph thereafter. However, these maps cannot cover elements that are hidden at the time of creation.

Note that these default implementations have to be properly disposed of after usage to release the allocated resources. To this end, class Graph has appropriate methods for either kind of default implementations.

// 'graph' is of type y.base.Graph. 

// Obtain a new y.base.NodeMap default implementation from the graph. 
NodeMap nodeMap = graph.createNodeMap();

// Set values for some of the nodes. 
nodeMap.setDouble(graph.firstNode(), 3.14);
nodeMap.setDouble(graph.lastNode(), 42.0);

// Print the values stored in the node map. 
for (NodeCursor nc = graph.nodes(); nc.ok(); nc.next())
{
  System.out.print("Node " + nc.node() + ": ");
  System.out.println(nodeMap.getDouble(nc.node()));
}

// Finally release the resources previously allocated by the createNodeMap() 
// method. 
graph.disposeNodeMap(nodeMap);

In addition to using the default map implementations provided by class Graph, there are further ways to create either maps or data providers. For example, data providers can be implemented so that the actual data is only implicitly defined, i.e., it is calculated on the fly when the value is asked for. This way, it is possible to "store" large amounts of data without having any memory be allocated. Example 4.14, “Using class DataProviderAdapter to create customized data providers” demonstrates how to use class DataProviderAdapter to elegantly define a custom DataProvider implementation.

// Define a DataProvider implementation that for each node in the graph returns 
// an int that is the square of the node's index. 
final DataProvider implicitDataProvider = new DataProviderAdapter() {
  // This implementation provides only ints. 
  public int getInt(Object dataHolder) {
    if (!dataHolder instanceof Node) {
      throw new UnsupportedOperationException("Key has wrong type.");
    }
    final Node node = (Node)dataHolder;
    return (node.index() * node.index());
  }
};

// Define a DataProvider implementation that for each edge in the graph returns 
// a distance value that is the difference of the values returned by 
// implicitDataProvider for the source and target node. 
final DataProvider edgeLengthProvider = new DataProviderAdapter() {
  // This implementation provides only ints. 
  public int getInt(Object dataHolder) {
    if (!dataHolder instanceof Edge) {
      throw new UnsupportedOperationException("Key has wrong type.");
    }
    final Edge edge = (Edge)dataHolder;
    return (implicitDataProvider.getInt(edge.target()) -
            implicitDataProvider.getInt(edge.source()));
  }
};

// Display the values "stored" (i.e., calculated on the fly) for each edge. 
for (EdgeCursor ec = graph.edges(); ec.ok(); ec.next()) {
  System.out.print("Edge " + ec.edge() + ": ");
  System.out.println(edgeLengthProvider.getInt(ec.edge()));
}

Class DataProviders from package y.util offers a set of static methods to conveniently create several specialized data provider implementations for either nodes or edges. For instance, there are methods to create data providers from constant values, from given arrays, or from existing data providers.

Class Maps from package y.util provides a set of static methods to conveniently create several specialized map implementations:

// 'graph' is of type y.base.Graph. 

// Create an edge map that holds a boolean value for each edge from 
// the edge set of the graph. 
EdgeMap map = Maps.createIndexEdgeMap(new boolean[graph.E()]);

// Store some data into the edge map. 
// (For each edge the map will contain the boolean value indicating whether 
// the edge points from a node with a lower index to a node with 
// a higher index.) 
for (NodeCursor nc = graph.nodes(); nc.ok(); nc.next()) {
  for (EdgeCursor ec = nc.node().edges(); ec.ok(); ec.next()) {
    Edge e = ec.edge();
    map.setBool(e, e.source().index() < e.target().index());
  }
}