15. Design Patterns IV: Patterns for Layered Data Types¶

// returns a (long) string that lists the name of the current entry
//   and the names of all the Entries within it, if any.
// In the code, note that  "this"  refers to the object being analyzed.
public string contentsOf() {
  string ans = this.Name;
  if (this is TextFile) { // was  this  object constructed from class TextFile?
    ans = ans + " is a text file\r\n";
  } else if (this is Shortcut) {
    ans = ans + " is a shortcut\r\n";
  } else if (this is Folder) {
    ans = ans + " is a folder containing:\r\n";
    List<Entry> contents = ((Folder)this).getListing(); // get all entries in the folder
    foreach (Entry item in contents) {  // get contents of all the entries:
      ans = ans + item.contentsOf();    // RECURSIVE CALL IS HERE
    }
  }
  return ans;
}

// the base name of the composite type:
public abstract class Entry {
  protected string name;  // the entry's name; accessible to the subclass code

  // get and set the value of name:
  public string Name {
    get { return name; }
    set { name = value; }
  }

  // IMPORTANT: The keyword, "abstract", below states that code must be
  // provided by the class that implements abstract class  Entry:
  //    Returns a string that lists the name of the current entry
  //    and the names of all the Entries within it, if any.
  public abstract string contentsOf();    // SEE KEYWORD, "abstract"
}

// models a text file as a sequence (list) of strings
public class TextFile: Entry {
  private List<string> lines;

  public TextFile(string name) {
    base.name = name;  // stores the name in the class Entry part of this object
    lines = new List<string>();  // file is empty at the start
  }

  public string contentsOf() {
    return this.name + " is a text file\r\n";
  }
}

// models a link (shortcut) to an Entry not in the present folder/level
public class Shortcut: Entry {
  public readonly Entry link;

  public Shortcut(string name, Entry link) {
    base.name = name;
    this.link = link;
  }

  public string contentsOf() {
    return this.name + " is a shortcut\r\n";
  }
}

// models a folder as a directory of Entries, indexed by their names:
public class Folder : Entry {
  private Dictionary<string, Entry> directory;

  public Folder(string name) {
    base.name = name;  // save name in class Entry part of this object
    directory = new Dictionary<string, Entry>();  // initially, folder is empty
  }

  // returns a list of all the Entry objects saved in this folder
  public List<Entry> getListing() {
    List<Entry> ans = new List<Entry>();
    foreach (var pair in directory) { ans.Add(pair.Value); }
    return ans;
  }

  public string contentsOf() {
    string ans = this.name + " is a folder containing:\r\n";
    List<Entry> contents = ((Folder)this).getListing();
    foreach (Entry item in contents) {
      ans = ans + item.contentsOf();  // RECURSIVE CALL IS HERE
    }
    return ans;
  }
}

 // models a partial/complete word, entered as a sequence ("path") of chars
 public class Path {
  private string word; // the sequence of chars, e.g., "cat"
  private int count;   // how many times this sequence has been used as a completed word

  private Dictionary<char, Path> suffixes;  // extensions of this word, e.g., "cats" (indexed by 's') or "cattle" (indexed by 't')

  public Path(string wordSoFar) {
    word = wordSoFar;  count = 0;
    suffixes = new Dictionary<char, Path>();
  }

  // "get" methods:
  public string getWord() { return word; }
  public int getCount() { return count; }

  // notify this Path that its word is complete and used in the user's document
  public void finishedWord() { count++; }

  // add another letter, c,  to the word being typed and return path of  word+c
  public Path addLetter(char c) {
    Path ans = null;
    if (suffixes.Contains(c)) {
      ans = suffixes[c];
    } else {
      ans  = new Path(word + c);
      suffixes[c] = ans;
    }
    return ans;
  }

  // returns handle to path for this  word+c. If none exists, returns null
  public Path findNextLetter(char c) {
    Path ans = null;
    if (suffixes.Contains(c)) { ans = suffixes[c]; }
    return ans;
  }
}

Path spellingTree = new Path("");

string inputText = "cats cannot catch cold quickly";
string[] words = inputText.split(' ');  // divide text into its 5 words
foreach (string w in words) {  // add  w  to  spellingTree:
  Path path = spellingTree;
  foreach(char c in w) {
    path = path.addLetter(c);
  }
  path.finishedWord();  // increment count for  w
}

public int countOf(string word) {
  Path p = this;  // start counting at the root of this tree
  foreach (char c in word) { // search tree for word, one char at a time:
    p = p.findNextLetter();
    if (p == null) { return 0; }  // word isn't found
  }
  // else, we found  word  in the tree, so
  return p.countOf();
}