OoasTools

/*

 Copyright (c) 2003-2007 Niels Kokholm and Peter Sestoft

*/

// IndexedObjects2.cs sketch 2007-07-28

// Maintaining multiple type safe indices on objects using the C5

// library.

// Compile with 

//   csc /r:C5.dll IndexedObjects2.cs 

using System;                           // Console

using System.Text;                      // StringBuilder

using C5; 

using SCG = System.Collections.Generic;

namespace IndexedObjects {

  static class IndexedObjectsMain {

    static void Main(String[] args) {

      // Create some Person objects:

      new Person("Niels",   19470206);

      new Person("Lone",    19600810);

      new Person("Peter",   19620625);

      new Person("Carsten", 19640627);

      new Person("Hanne",   19641209);

      new Person("Dorte",   19660930);

      new Person("Dorte",   19610312);

      new Person("J?rgen",  19340930);

      new Person("Kirsten", 19360114);

      new Person("Henrik",  19360630);

      new Person("Lars",    19640625);

      new Person("Thora",   19091129);

      // Try the indexers:

      Console.WriteLine("\nBorn in 1964:");

      foreach (Person p in Person.Year[1964]) 

        Console.WriteLine(p);

      Console.WriteLine("\nNamed Dorte:");

      foreach (Person p in Person.Name["Dorte"]) 

        Console.WriteLine(p);

      Console.WriteLine("\nBorn on the 30th:");

      foreach (Person p in Person.Day[30]) 

        Console.WriteLine(p);

      Console.WriteLine("\nBorn June-October:");

      foreach (Person p in Person.Month.RangeFromTo(Month.Jun, Month.Nov)) 

        Console.WriteLine(p);

    }

  }

  // The interface IIndex<Q,T> describes an index with keys of type Q

  // on items of type T:

  public interface IIndex<Q,T> { 

    ICollection<T> this[Q x] { get; }

    void Add(T item);

  }

  // A hash-based index supports adding items of type T to the index

  // and looking up items by key of type Q.  The function toKey

  // transforms an item to its index key.

  // The hash-based index is implemented by a hash dictionary that

  // maps each index key to a hash set of items.  The hash dictionary

  // uses the key type's natural equality comparer.  The hash set uses

  // a reference equality comparer for the item type -- it might also

  // use the item type's natural comparer.

  public class HashIndex<Q,T> : IIndex<Q,T> where T : class {

    private readonly Fun<T,Q> toKey;

    private HashDictionary<Q, HashSet<T>> dict;

    public HashIndex(Fun<T,Q> toKey) {

      this.toKey = toKey;

      dict = new HashDictionary<Q, HashSet<T>>();

    }

    public void Add(T item) { 

      Q key = toKey(item);

      if (!dict.Contains(key))

        dict.Add(key, new HashSet<T>(ReferenceEqualityComparer<T>.Default));

      dict[key].Add(item);

    }

    public ICollection<T> this[Q key] {

      get { 

        return new GuardedCollection<T>(dict[key]);

      }

    }

    public override String ToString() {

      return dict.ToString();

    }

  }

  // A tree-based index supports adding items of type T to the index,

  // looking up items by key of type Q, and getting the items within a

  // key range.  The function toKey transforms an item to its index

  // key.  

  // The tree-based index is implemented by a tree dictionary that

  // maps each index key to a hash set of items.  The tree dictionary

  // uses the key type's natural comparer.  The hash set uses a

  // reference equality comparer for the item type -- it might also

  // use the item type's natural comparer.

  public class TreeIndex<Q,T> : IIndex<Q,T> where T : class {

    private readonly Fun<T,Q> toKey;

    private TreeDictionary<Q, HashSet<T>> dict;

    public TreeIndex(Fun<T,Q> toKey) {

      this.toKey = toKey;

      dict = new TreeDictionary<Q, HashSet<T>>();

    }

    public void Add(T item) { 

      Q key = toKey(item);

      if (!dict.Contains(key))

        dict.Add(key, new HashSet<T>(ReferenceEqualityComparer<T>.Default));

      dict[key].Add(item);

    }

    public ICollection<T> this[Q key] {

      get { 

        return new GuardedCollection<T>(dict[key]);

      }

    }

    // Bad implementation from a performance point of view: it may be

    // costly to build the result collection and possibly only its

    // size is ever used:

    public ICollection<T> RangeFromTo(Q x, Q y) {

      HashSet<T> result = new HashSet<T>(ReferenceEqualityComparer<T>.Default);

      foreach (KeyValuePair<Q,HashSet<T>> kv in dict.RangeFromTo(x, y))

	result.AddAll(kv.Value);

      return result;

    }

    public override String ToString() {

      return dict.ToString();

    }

  }

  public enum Month { 

    Jan=1, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec 

  }

  // Sample class with two fields and four different indexes

  // All indexes are defined as static fields and are strongly typed.

  // The definitions would be considerably shorter and clearer in C#

  // 3.0 thanks to lambda notation and better type inference.

  // Note all code related to indexing can be kept in one place, due

  // to the use of an indexing delegate, except for the call

  // Index(this), which must appear at the end of every constructor.

  // By using reflection and a naming convention for the indexing

  // delegate, one might be able to avoid explicitly adding the

  // indexes to the event in the static constructor.  However, the

  // present setup can be implemented using a static aspect weaver

  // such as yiihaw (Johansen and Spangenberg 2007), avoiding the use

  // of runtime reflection.

  // For use with LINQ-to-C5, one can use runtime reflection to find

  // the indexes on a type, as the public static fields of type

  // HashIndex or TreeIndex or IIndex.

  public class Person {

    public readonly String name;

    public readonly int date; // YYYYMMDD as in 20070725

    // Defining the indexes

    public static readonly IIndex<String, Person> Name 

      = new HashIndex<String, Person>(delegate(Person p) { return p.name; });

    public static readonly IIndex<int, Person> Year 

      = new HashIndex<int, Person>(delegate(Person p) { return p.date/10000; });

    public static readonly IIndex<int, Person> Day 

      = new HashIndex<int, Person>(delegate(Person p) { return p.date%100; });

    public static readonly TreeIndex<Month, Person> Month 

      = new TreeIndex<Month, Person>

        (delegate(Person p) { return (Month)(p.date/100%100); });

    // Defining and initializing the indexing delegate

    private static event Act<Person> Index;

    static Person() { 

      Index += Name.Add;

      Index += Year.Add;

      Index += Day.Add;

      Index += Month.Add;

    }

    public Person(String name, int date) {

      this.name = name;

      this.date = date;

      Index(this);

    }

    public override String ToString() {

      return name + " (" + date + ")";

    }

  }

}