package lab09;
import java.util.*;
 

/* Lab description:
 * 
 *   We give below "non-generic" versions of Entry, WordListNode, WordListIterator 
 *   and WordList classes. By non-generic we mean that the Entry class is programmed 
 *   to store an Integer keyValue and a String dataValue.
 *    
 *   We wish to allow the Entry class to store arbitrary datatypes for dataKey and dataValue.
 *   Note that dataKey and dataValue can have the same type (e.g., both can be Strings) 
 *   or can be of different types (Integer and String in the above example). We hence 
 *   create a "generic" Entry class with two parameterized types (K & V) that looks
 *   as follows,
 *   
 *   class Entry <K, V> {
 *       K dataKey;    // dataKey is determined by input type K     
 *       V dataValue;  // dataValue is determined by V which can be different from K
 *   
 *      // .... methods in Entry class
 *   }
 *   
 *   Examples: 
 *               Entry<Integer, String> corresponds to an Entry class 
 *                                      with Integer key and String data
 * 
 *               Entry<String, String> corresponds to an Entry class 
 *                                      with String key and String data
 *  
 *   TASKS:
 *       (a) Follow the generic Entry class example above and modify it and other classes 
 *           to create their corresponding generic versions.
 *           Note that some generic class instances are already present 
 *           (e.g., Iterator<Entry>, Iterable<Entry>). Be careful when you modify these.
 *   
 *      (b) Change HashClient.java to use the generic classes that you have created.
 */

  
// The classes below are non-generic, change to their generic implementation
class Entry <K,V> {
    K dataKey;
    V dataValue;
    
    Entry(K newKey, V newValue) {dataKey = newKey; dataValue = newValue;}
    K getKey(){ return dataKey; }
    V getValue(){ return dataValue; }
}
 
class WordListNode<K,V> {
    Entry<K,V> nodeEntry;
    WordListNode<K,V> nextNode;
    
    WordListNode(Entry<K,V> newEntry, WordListNode<K,V> newNext){
        nodeEntry = newEntry;
        nextNode = newNext;
    }
    Entry<K,V> getEntry(){    return nodeEntry; }
    WordListNode<K,V> getNext(){ return nextNode; }
}
 
class WordListIterator<K,V> implements Iterator<Entry<K,V>> {
    WordListNode<K,V> currentWordListNode;
    
    WordListIterator( WordListNode<K,V> wordListHead ) {
        currentWordListNode = wordListHead;
    }
    public boolean hasNext() {
        return (currentWordListNode != null);
    }
    public Entry<K,V> next() {
        Entry<K,V> currentEntry = currentWordListNode.getEntry();
        currentWordListNode = currentWordListNode.getNext();
        return currentEntry;
    }
    public void remove(){}
}
 
public class WordList<K,V> implements Iterable<Entry<K,V>> {
    WordListNode<K,V> wordListHead;
    
    WordList() { wordListHead = null; }
    void addToHead( Entry<K,V> newEntry ) {
        wordListHead = new WordListNode<K,V>( newEntry, wordListHead ); 
    }
    public Iterator<Entry<K,V>> iterator() {
        return new WordListIterator<K,V>( wordListHead );
    }
}