Easy JavaScript Generic List Implementation

/*******************************************************************************************
   Title:  Javascript Generic List Implementation
   Description:  An implementation of a Generic List with LINQ support (based off .NET).
   Author:  Julius Friedman / Shawn Lawsure
   Usage Example:

        function Car(make, model)
        {
            this.make = make;
            this.model = model;
        }

        var myList = new List();
        myList.Add(new Car("Honda", "Civic"));
        myList.Add(new Car("Nissan", "Sentra"));
        myList.Add(new Car("Honda", "Cr-V"));
        myList.Add(new Car("Honda", "Cr-V"));

        var selList = myList.Where("make == 'Honda'").OrderByDescending("model").Distinct();
         
*********************************************************************************************/

function List() {

    // ===============  Private Attributes  =================================================

    var oType = undefined;      // Used to ensure that all objects added to the list are of the same type.
    var listArray = [];         // Stores all the list data.

    //If supported
    if (this.__defineGetter__) {

        // Public Properties
        this.__defineGetter__("array", function () {
            return listArray;
        });

        this.__defineSetter__("array", function (val) {
            listArray = val;
        });

        this.__defineGetter__("$key", function () {
            return key;
        });
    };

    // ===============  Private Methods  ====================================================

    // Method:  copy
    // Description:  Create a copy of this List object using the passed in array of data.
    function copy(array)
    {
        var newList = new List();
        for (property in this)
            newList[property] = this[property];

        newList.array = array;

        return newList;
    }

    // Method:  validate
    // Description:  Make sure that all objects added to the List are of the same type.
    function validate(object)
    {
        if (typeof(object) != oType)
            throw "Only one object type is allowed in a list";
    }

    // Method:  select
    // Description:  Return a copy of this List object with only the elements that meet the criteria
    //               as defined by the 'query' parameter.
    // Usage Example:  
    //              var selList = select("make == 'Honda'").
    function select(query)
    {
        var selectList = copy([]);

        for (var arrIndex = 0; arrIndex < listArray.length; arrIndex++)
            with (listArray[arrIndex])
                if (eval(query))
                    selectList.Add(listArray[arrIndex]);

        return selectList;
    }

    // Method:  genericSort
    // Description:  Sort comparison function using an object property name.  Pass this function to
    //               the Javascript sort function to sort the list by a given property name.
    // Usage Example:
    //              var sortedList = listArray.sort(genericSort('model'));
    function genericSort(property)
    {
        return function (a, b)
        {
            return (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        }
    } 

    // ===============  Public Methods  ======================================================

    // Method:  Add
    // Description:  Add an element to the end of the list.
    this.Add = function(object)
    {
        if (!oType)
            oType = typeof(object);

        validate(object);

        listArray.push(object);
    }

    // Method:  ElementAt
    // Description:  Get the element at a specific index in the list.
    this.ElementAt = function(index)
    {
        if (index >= this.Count() || index < 0)
            throw "Invalid index parameter in call to List.ElementAt";
        return listArray[index];
    }

    // Method:  Where
    // Description:  Return a copy of this List object with only the elements that meet the criteria
    //               as defined by the 'query' parameter.
    this.Where = function (query)
    {
        return select(query);
    }

    // Method:  FirstOrDefault
    // Description:  Return the first object in the list that meets the 'query' criteria or null if
    //               no objects are found.
    this.FirstOrDefault = function (query)
    {
        var list = select(query);
        return list ? list.ElementAt(0) : null;
    }

    // Method:  Count
    // Description:  Return the number of elements in the list.
    this.Count = function()
    {
        return listArray.length;
    }
    //Method: Reverse
    //Description: Reverses the list
    this.Reverse = function () {
        listArray.reverse();
    }
    //Alias
    this.reverse = this.Reverse;

    // Method:  OrderBy
    // Description:  Order (ascending) the objects in the list by the given object property name.
    this.OrderBy = function (property/*, desc*/) {
        var r = copy(listArray.slice(0).sort(genericSort(property))),
        desc = arguments[1] || false;
        if (desc) r.reverse();            
        return r;
    }

    // Method:  OrderByDescending
    // Description:  Order (descending) the objects in the list by the given object property name.
    this.OrderByDescending = function (property) {
        return this.OrderBy(property, true);
    }

    // Method: Contains
    // Description: Determines if the given object is contained in the List
    this.Contains = function (object) {
        var contained = false;
        listArray.forEach(function (tEl) {
            Object.keys(object).forEach(function (key) {
                try {
                    if (tEl[key] === object[key]) contained = true;
                    else throw new Error();
                } catch (e) { contained = false; }
            });
        });
        return contained;
    }

    // Method: Distinct
    // Description: Gets a copy of the list with only unique elements.
    this.Distinct = function () {
        var results = new List();
        try {
            listArray.forEach(function (tEl) {
                if (!results.Contains(tEl)) {
                    results.Add(tEl);
                }
            });
        } catch (E) { }
        return results;
    }

    //Destructor
    this.Dispose = function () {
        List.instances[this.$key] = null;
        delete List.instances[this.$key];

        if (Object.keys(List.instances).length === 0) {
            List = null;
            delete List;
        };

        for (var p in this) {
            if (this.hasOwnProperty(p)) {
                if (this[p] instanceof Array) {
                    this[p].length = 0;
                };
                this.p = null;
                delete this.p;
            };
        };
    }
    this.dispose = this.Dispose;

    //Cleanup prototype
    for (var p in this) if (!this.hasOwnProperty(p)) delete this.p;

    //Add destructor
    window.addEventListener('unload', function () { this.Dispose(); } .bind(this));

    //If supported
    if (Object.freeze) Object.freeze(this);

    //Keep track
    var key = ++List.created;
    List.instances[key] = this;
}

// ===============  Static Methods  ======================================================
List.created = 0;
List.instances = {};
if (Object.freeze) Object.freeze(List);

//Method: indexOf
//Description adds logic to retrieve the index of an element from an array if present, otherwise -1
if (!Array.prototype.indexOf) {
    Array.prototype.indexOf = function (elt /*, from*/) {
        var len = this.length,
        from = Number(arguments[1]) || 0;
        from = (from < 0) ? Math.ceil(from) : Math.floor(from);
        if (from < 0) from += len;
        for (; from < len; from++)
            if (from in this && this[from] === elt) 
                return from;
        return -1;
    };
}

if (!Array.prototype.forEach) {
    Array.prototype.forEach = function () { };
}

if (!Object.prototype.keys) {
    Object.prototype.keys = function () { };
}