1var define = require("../define").define,
         Collection = require("./Collection"),
 		Iterable = require("./Iterable"),
         base = require("../base"),
         multiply = base.string.multiply;
 
1var compare = function(a, b) {
0    var ret = 0;
0    if (a > b) {
0        return 1;
0    } else if (a < b) {
0        return -1;
0    }else if(!b){
0        return 1;
     }
0    return ret;
 
 };
 
1var Tree = define([Collection, Iterable], {
 
     instance : {
 
         /**@lends comb.collections.Tree.prototype*/
 
         /**
          * Prints a node
          * @param node node to print
          * @param level the current level the node is at, Used for formatting
          */
         __printNode : function(node, level) {
             //console.log(level);
0            var str = [];
0            if (node == null || node == undefined) {
0                str.push(multiply('\t', level));
0                str.push("~");
0                console.log(str.join(""));
             } else {
0                this.__printNode(node.right, level + 1);
0                str.push(multiply('\t', level));
0                str.push(node.data + "\n");
0                console.log(str.join(""));
0                this.__printNode(node.left, level + 1);
             }
         },
 
         /**
          * Base Class for all tree implementations
          * @constructs
          * @augments comb.collections.Collection
          * @augments comb.collections.Iterable
          * @memberOf comb.collections
          *
          * @param {Object} options options to initialize the tree
          * @param {Function} options.compare function used to compare items in a tree must return an integer
          *  <ul>
          *      </li>-1 for less than</li>
          *      </li>0 for equal</li>
          *      </li>1 for greater than</li>
          *  </ul>
          *
          */
         constructor : function(options) {
0            options = options || {};
0            this.compare = options.compare || compare;
0            this.__root = null;
         },
 
         /**
          * Inserts an item into the tree
          * @param {Anything} data the item to insert
          */
         insert : function(data) {
0            throw new Error("Not Implemented");
         },
 
         /**
          * Removes an item from the tree
          * @param {Anything} data the item to insert
          */
         remove : function(data) {
0            throw new Error("Not Implemented");
         },
 
         /**
          * Clear all items from a tree
          */
         clear : function() {
0            this.__root = null;
         },
 
         /**
          * Test if a tree is empty
          *
          * @return {Boolean} true if empty false otherwise
          */
         isEmpty : function() {
0            return this.__root == null;
         },
 
         /**
          * Traverse a tree until the callback function returns false
          *
          * <p><b>Not typically used directly</b></p>
          *
          * @param {Object} node the node to start at
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          * @param {Function} callback called for each item, traversal continues until the function returns false
          *
          */
         traverseWithCondition : function(node, order, callback) {
0            var cont = true;
0            if (node) {
0                order = order || Tree.PRE_ORDER;
0                if (order === Tree.PRE_ORDER) {
0                    cont = callback(node.data);
0                    if (cont) {
0                        cont = this.traverseWithCondition(node.left, order, callback);
0                        cont && (cont = this.traverseWithCondition(node.right, order, callback));
 
                     }
0                } else if (order === Tree.IN_ORDER) {
0                    cont = this.traverseWithCondition(node.left, order, callback);
0                    if (cont) {
0                        cont = callback(node.data);
0                        cont && (cont = this.traverseWithCondition(node.right, order, callback));
                     }
0                } else if (order === Tree.POST_ORDER) {
0                    cont = this.traverseWithCondition(node.left, order, callback);
0                    if (cont) {
0                        cont && (cont = this.traverseWithCondition(node.right, order, callback));
0                        cont && (cont = callback(node.data));
                     }
0                } else if (order === Tree.REVERSE_ORDER) {
0                    cont = this.traverseWithCondition(node.right, order, callback);
0                    if (cont) {
0                        cont = callback(node.data);
0                        cont && (cont = this.traverseWithCondition(node.left, order, callback));
                     }
                 }
             }
0            return cont;
         },
 
         /**
          * Traverse a tree
          *
          * <p><b>Not typically used directly</b></p>
          *
          * @param {Object} node the node to start at
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          * @param {Function} callback called for each item
          *
          */
         traverse : function(node, order, callback) {
0            if (node) {
0                order = order || Tree.PRE_ORDER;
0                if (order === Tree.PRE_ORDER) {
0                    callback(node.data);
0                    this.traverse(node.left, order, callback);
0                    this.traverse(node.right, order, callback);
0                } else if (order === Tree.IN_ORDER) {
0                    this.traverse(node.left, order, callback);
0                    callback(node.data);
0                    this.traverse(node.right, order, callback);
0                } else if (order === Tree.POST_ORDER) {
0                    this.traverse(node.left, order, callback);
0                    this.traverse(node.right, order, callback);
0                    callback(node.data);
0                } else if (order === Tree.REVERSE_ORDER) {
0                    this.traverseWithCondition(node.right, order, callback);
0                    callback(node.data);
0                    this.traverseWithCondition(node.left, order, callback);
 
                 }
             }
         },
 
         /**
          * Loop through each item in the tree
          * @param {Function} cb called for each item in the tree
          * @param {Object} [scope=this] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          */
         forEach : function(cb, scope, order) {
0            if (typeof cb !== "function")
0                throw new TypeError();
0            order = order || Tree.IN_ORDER;
0            scope = scope || this;
0            this.traverse(this.__root, order, function(node) {
0                cb.call(scope, node, this);
             });
         },
 
         /**
          * Loop through each item in the tree, collecting the value returned by the callback funciton.
          * @param {Function} cb called for each item in the tree.
          *                   Whatever the function returns is inserted into the return tree
          * @param {Object} [scope=this] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return {comb.collections.Tree} the tree with the mapped items
          */
         map : function(cb, scope, order) {
0            if (typeof cb !== "function")
0                throw new TypeError();
 
0            order = order || Tree.IN_ORDER;
0            scope = scope || this;
0            var construct = this._static;
0            var ret = new this._static();
0            this.traverse(this.__root, order, function(node) {
0                ret.insert(cb.call(scope, node, this));
             });
0            return ret;
         },
 
         /**
          * Filters a tree, only returning items that result in true being returned from the callback
          *
          * @param {Function} cb called for each item in the tree
          * @param {Object} [scope=this] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return {comb.collections.Tree} the tree with items that resulted in true being returned from the callback
          */
         filter : function(cb, scope, order) {
0            if (typeof cb !== "function")
0                throw new TypeError();
 
0            order = order || Tree.IN_ORDER;
0            scope = scope || this;
0            var ret = new this._static();
0            this.traverse(this.__root, order, function(node) {
0                var include = cb.call(scope, node, this);
0                include && ret.insert(node);
             });
0            return ret;
         },
 
         /**
          * Reduces a tree
          *
          * @param {Function} fun called for each item in the tree
          * @param [accumulator=First item in tree(Order dependant)] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return the result of the reduce function
          */
         reduce : function(fun, accumulator, order) {
0            var arr = this.toArray(order);
0            var args = [fun];
0            !base.isUndefinedOrNull(accumulator) && args.push(accumulator)
0            return arr.reduce.apply(arr, args);
         },
 
         /**
          * Reduces from right to left
          *
          * @param {Function} fun called for each item in the tree
          * @param [accumulator=First item in tree(Order dependant)] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return the result of the reduce function
          */
         reduceRight : function(fun, accumulator, order) {
0            var arr = this.toArray(order);
0            var args = [fun];
0            !base.isUndefinedOrNull(accumulator) && args.push(accumulator)
0            return arr.reduceRight.apply(arr, args);
         },
 
         /**
          * Determines if every item meets the condition returned by the callback.
          *
          * @param {Function} cb called for each item in the tree
          * @param {Object} [scope=this] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return {Boolean} True if every item passed false otherwise
          */
         every : function(cb, scope, order) {
0            if (typeof cb !== "function")
0                throw new TypeError();
 
0            order = order || Tree.IN_ORDER;
0            scope = scope || this;
0            var ret = false;
0            this.traverseWithCondition(this.__root, order, function(node) {
0                return (ret = cb.call(scope, node, this));
             });
0            return ret;
         },
 
         /**
          * Determines if some item meet the condition returned by the callback. Traversal ends the first time true is found.
          *
          * @param {Function} cb called for each item in the tree
          * @param {Object} [scope=this] scope to call the function in
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return {Boolean} True if every item passed false otherwise
          */
         some : function(cb, scope, order) {
0            if (typeof cb !== "function")
0                throw new TypeError();
 
0            order = order || Tree.IN_ORDER;
0            scope = scope || this;
0            var ret;
0            this.traverseWithCondition(this.__root, order, function(node) {
0                ret = cb.call(scope, node, this);
0                return !ret;
             });
0            return ret;
         },
 
         /**
          * Converts a tree into an array based on the specified order
          *
          * @param {Tree.PRE_ORDER|Tree.POST_ORDER|Tree.IN_ORDER|Tree.REVERSE_ORDER} [order=Tree.IN_ORDER] the traversal scheme
          *
          * @return {Array} array of all items in the order specified.
          */
         toArray : function(order) {
0            order = order || Tree.IN_ORDER;
0            var arr = [];
0            this.traverse(this.__root, order, function(node) {
0                arr.push(node);
             });
0            return arr;
         },
 
 
 
         /**
          * Determines if a value is contained in the tree
          * @param {*} value the value to find
          *
          * @return {Boolean} true if the tree contains the item false otherwise.
          */
         contains : function(value) {
0            var ret = false;
0            var root = this.__root;
0            while (root != null) {
0                var cmp = this.compare(value, root.data);
0                if (cmp) {
0                    root = root[(cmp == -1) ? "left" : "right"];
                 } else {
0                    ret = true;
0                    root = null;
                 }
             }
0            return ret;
         },
 
         /**
          * Finds a value in the tree
          * @param {*} value the value to find
          *
          * @return the value of the node that matched
          */
         find : function(value) {
0            var ret;
0            var root = this.__root;
0            while (root != null) {
0                var cmp = this.compare(value, root.data);
0                if (cmp) {
0                    root = root[(cmp == -1) ? "left" : "right"];
                 } else {
0                    ret = root.data;
0                    break;
                 }
             }
0            return ret;
         },
 
         /**
          * Find all values less than a value
          * @param {*} value the value to find nodes less than
          * @param {Boolean} [exclusive=false] if true the value will NOT be included in the return array
          *
          * @return {Array} the array containing all values less than
          */
         findLessThan : function(value, exclusive) {
             //find a better way!!!!
0            var ret = [], compare = this.compare;
0            this.traverseWithCondition(this.__root, exports.IN_ORDER, function(v) {
0                var cmp = compare(value, v);
0                if ((!exclusive && cmp == 0) || cmp == 1) {
0                    ret.push(v);
0                    return true;
                 } else {
0                    return false;
                 }
             });
0            return ret;
         },
 
         /**
          * Find all greater than a value
          * @param {*} value the value to find nodes greater than
          * @param {Boolean} [exclusive=false] if true the value will NOT be included in the return array
          *
          * @return {Array} the array containing all values greater than
          */
         findGreaterThan : function(value, exclusive) {
             //find a better way!!!!
0            var ret = [], compare = this.compare;
0            this.traverse(this.__root, exports.REVERSE_ORDER, function(v) {
0                var cmp = compare(value, v);
0                if ((!exclusive && cmp == 0) || cmp == -1) {
0                    ret.push(v);
0                    return true;
                 } else {
0                    return false;
                 }
             });
0            return ret;
         },
 
         /**
          * Prints a tree to the console.
          */
         print : function() {
0            this.__printNode(this.__root, 0);
         }
     },
 
     static : {
     /** @lends comb.collections.Tree */
 
         /**
          * Pre Order
          */
         PRE_ORDER : "pre_order",
 
         /**
          * In Order
          */
         IN_ORDER : "in_order",
 
         /**
          * Post Order
          */
         POST_ORDER:"post_order",
 
         /**
 
          * Reverse Order
          */
         REVERSE_ORDER : "reverse_order"
     }
 });
 /**@ignore*/
1module.exports = exports = Tree;
 

1var define = require("../define").define,
     Collection = require("./Collection"),
     Iterable = require("./Iterable"),
     base = require("../base");
 
1var hashFunction = function (key) {
0    if (typeof key == "string") {
0        return key;
0    } else if (typeof key == "object") {
0        return  key.hashCode ? key.hashCode() : "" + key;
     } else {
0        return "" + key;
     }
 };
 
1var Bucket = define(null, {
 
     instance:{
 
         constructor:function () {
0            this.__entries = [];
         },
 
         pushValue:function (key, value) {
0            this.__entries.push({key:key, value:value});
0            return value;
         },
 
         remove:function (key) {
0            var ret = null, map = this.__entries, val;
0            var i = map.length - 1;
0            for (; i >= 0; i--) {
0                if ((val = map[i]) != null && val.key === key) {
0                    map[i] = null;
0                    return val.value;
                 }
             }
0            return ret;
         },
 
         "set":function (key, value) {
0            var ret = null, map = this.__entries;
0            var i = map.length - 1;
0            for (; i >= 0; i--) {
0                var val = map[i];
0                if (val && key === val.key) {
0                    val.value = value;
0                    ret = value;
0                    break;
                 }
             }
0            if (!ret) {
0                map.push({key:key, value:value});
             }
0            return ret;
         },
 
         find:function (key) {
0            var ret = null, map = this.__entries, val;
0            var i = map.length - 1;
0            for (; i >= 0; i--) {
0                val = map[i];
0                if (val && key === val.key) {
0                    ret = val.value;
0                    break;
                 }
             }
0            return ret;
         },
 
         getEntrySet:function (arr) {
0            var map = this.__entries, l = map.length;
0            if (l) {
0                for (var i = 0; i < l; i++) {
0                    var e = map[i];
0                    if (e) {
0                        arr.push(e);
                     }
                 }
             }
         },
 
         getKeys:function (arr) {
0            var map = this.__entries, l = map.length;
0            if (l) {
0                for (var i = 0; i < l; i++) {
0                    var e = map[i];
0                    if (e) {
0                        arr.push(e.key);
                     }
                 }
             }
0            return arr;
         },
 
         getValues:function (arr) {
0            var map = this.__entries, l = map.length;
0            if (l) {
0                for (var i = 0; i < l; i++) {
0                    var e = map[i];
0                    if (e) {
0                        arr.push(e.value);
                     }
                 }
             }
0            return arr;
         }
     }
 });
 
 /**
  * @ignoreCode
  * @class <p>Implementation of a HashTable for javascript.
  *    This HashTable implementation allows one to use anything as a key.
  *    </p>
  * <b>NOTE: THIS IS ~ 3 times slower than javascript native objects</b>
  *
  * <p> A use case for this collection is when one needs to store items in which the key will not be a string, or number</p>
  *
  * @name HashTable
  * @augments comb.collections.Collection
  * @memberOf comb.collections
  *
  * @property {Array} keys all keys contained in the table
  * @property {Array} values all values contained in the table
  * @property {Array} entrySet an array of objects. Each object contains a key, and value property.
  */
1define([Collection, Iterable], {
 
     instance:{
         /**@lends comb.collections.HashTable.prototype*/
 
         constructor:function () {
0            this.__map = {};
         },
 
         __entrySet:function () {
0            var ret = [], es = [];
0            for (var i in this.__map) {
0                this.__map[i].getEntrySet(ret);
             }
0            return ret;
         },
 
         /**
          * Put a key, value pair into the table
          *
          * <b>NOTE :</b> the collection will not check if the key previously existed.
          *
          * @param {Anything} key the key to look up the object.
          * @param {Anything} value the value that corresponds to the key.
          *
          * @returns the value
          */
         put:function (key, value) {
0            var hash = hashFunction(key);
0            var bucket = null;
0            if ((bucket = this.__map[hash]) == null) {
0                bucket = (this.__map[hash] = new Bucket());
             }
0            bucket.pushValue(key, value);
0            return value;
         },
 
         /**
          * Remove a key value pair from the table.
          *
          * @param key the key of the key value pair to remove.
          *
          * @returns the removed value.
          */
         remove:function (key) {
0            var hash = hashFunction(key), ret = null;
0            var bucket = this.__map[hash];
0            if (bucket) {
0                ret = bucket.remove(key);
             }
0            return ret;
         },
 
         /**
          * Get the value corresponding to the key.
          *
          * @param key the key used to look up the value
          *
          * @returns null if not found, or the value.
          */
         "get":function (key) {
0            var hash = hashFunction(key), ret = null;
0            var bucket = null;
0            if ((bucket = this.__map[hash]) != null) {
0                ret = bucket.find(key);
             }
0            return ret;
         },
 
         /**
          * Set the value of a previously existing key,value pair or create a new entry.
          *
          * @param key the key to be be used
          * @param value the value to be set
          *
          * @returns the value.
          */
         "set":function (key, value) {
0            var hash = hashFunction(key), ret = null, bucket = null, map = this.__map;
0            if ((bucket = map[hash]) != null) {
0                ret = bucket.set(key, value);
             } else {
0                ret = (map[hash] = new Bucket()).pushValue(key, value);
             }
0            return ret;
         },
 
         /**
          * Tests if the table contains a particular key
          * @param key the key to test
          *
          * @returns {Boolean} true if it exitsts false otherwise.
          */
         contains:function (key) {
0            var hash = hashFunction(key), ret = false;
0            var bucket = null;
0            if ((bucket = this.__map[hash]) != null) {
0                ret = bucket.find(key) != null;
             }
0            return ret;
         },
 
         /**
          * Returns a new HashTable containing the values of this HashTable, and the other table.
          * </br>
          * <b> DOES NOT CHANGE THE ORIGINAL!</b>
          * @param {comb.collections.HashTable} hashTable the hash table to concat with this.
          *
          * @returns {comb.collections.HashTable} a new HashTable containing all values from both tables.
          */
         concat:function (hashTable) {
0            if (hashTable instanceof this._static) {
0                var ret = new this._static();
0                var otherEntrySet = hashTable.entrySet.concat(this.entrySet);
0                for (var i = otherEntrySet.length - 1; i >= 0; i--) {
0                    var e = otherEntrySet[i];
0                    ret.put(e.key, e.value);
                 }
0                return ret;
             } else {
0                throw new TypeError("When joining hashtables the joining arg must be a HashTable");
             }
         },
 
         /**
          * Creates a new HashTable containg values that passed the filtering function.
          *
          * @param {Function} cb Function to callback with each item, the first aruguments is an object containing a key and value field
          * @param {Object} scope the scope to call the function.
          *
          * @returns {comb.collections.HashTable} the HashTable containing the values that passed the filter.
          */
         filter:function (cb, scope) {
0            var es = this.__entrySet(), ret = new this._static();
0            es = es.filter.apply(es, arguments);
0            for (var i = es.length - 1; i >= 0; i--) {
0                var e = es[i];
0                ret.put(e.key, e.value);
             }
0            return ret;
         },
 
         /**
          *  Loop through each value in the hashtable
          *
          *  @param {Function} cb the function to call with an object containing a key and value field
          *  @param {Object} scope the scope to call the funciton in
          */
         forEach:function (cb, scope) {
0            var es = this.__entrySet(), l = es.length, f = cb.bind(scope || this);
0            es.forEach.apply(es, arguments);
         },
 
         /**
          * Determines if every item meets the condition returned by the callback.
          *
          * @param {Function} cb Function to callback with each item, the first aruguments is an object containing a key and value field
          * @param {Object} [scope=this] scope to call the function in
          *
          * @returns {Boolean} True if every item passed false otherwise
          */
         every:function () {
0            var es = this.__entrySet();
0            return es.every.apply(es, arguments);
         },
 
         /**
          * Loop through each value in the hashtable, collecting the value returned by the callback function.
          * @param {Function} cb Function to callback with each item, the first aruguments is an object containing a key and value field
          * @param {Object} [scope=this] scope to call the function in
          *
          * @returns {Array} an array containing the mapped values.
          */
         map:function () {
0            var es = this.__entrySet(), ret = new this._static();
0            return es.map.apply(es, arguments);
         },
 
         /**
          * Determines if some items meet the condition returned by the callback.
          *
          * @param {Function} cb Function to callback with each item, the first aruguments is an object containing a key and value field
          * @param {Object} [scope=this] scope to call the function in
          *
          * @returns {Boolean} True if some items passed false otherwise
          */
         some:function () {
0            var es = this.__entrySet();
0            return es.some.apply(es, arguments);
         },
 
         /**
          * Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value.
          *
          * @param {Function} callback Function to execute on each value in the array.
          * @param initialValue Value to use as the first argument to the first call of the callback..
          */
         reduce:function () {
0            var es = this.__entrySet();
0            return es.reduce.apply(es, arguments);
         },
 
         /**
          * Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value.
          *
          * @param {Function} callback Function to execute on each value in the array.
          * @param initialValue Value to use as the first argument to the first call of the callback..
          */
         reduceRight:function () {
0            var es = this.__entrySet();
0            return es.reduceRight.apply(es, arguments);
         },
 
         /**
          * Clears out all items from the table.
          */
         clear:function () {
0            this.__map = {};
         },
 
         getters:{
             keys:function () {
0                var ret = [], es = [];
0                for (var i in this.__map) {
0                    this.__map[i].getKeys(ret);
                 }
0                return ret;
             },
 
             values:function () {
0                var ret = [], es = [];
0                for (var i in this.__map) {
0                    this.__map[i].getValues(ret);
                 }
0                return ret;
             },
 
             entrySet:function () {
0                return this.__entrySet();
             },
 
             isEmpty:function () {
0                return this.keys.length == 0;
             }
         }
     }
 
 }).as(module);
 
 
 

1var define = require("../define").define,
         Collection = require("./Collection"),
         Queue = require("./Queue"),
         base = require("../base");
 
 /**
  * @class Base class for a pool.
  *
  * @name Pool
  * @memberOf comb.collections
  *
  * @property {Number} count the total number of objects in the pool, including free and in use objects.
  * @property {Number} freeCount the number of free objects in this pool.
  * @property {Number} inUseCount the number of objects in use in this pool.
  * @property {Number} [minObjects=0] the minimum number of objects this pool should contain.
  * @property {Number} [maxObjects=1] the maximum number of objects this pool should contain
  * @ignoreCode
  */
1exports = module.exports = define(null, {
     instance : {
         /**@lends comb.collections.Pool.prototype*/
 
         __minObjects : 0,
 
         __maxObjects : 1,
 
         constructor : function(options) {
0            options = options || {};
0            this.__freeObjects = new Queue();
0            this.__inUseObjects = [];
0            this.__minObjects = options.minObjects || 0;
0            this.__maxObjects = options.maxObjects || 1;
0            this.minObjects = this.__minObjects;
0            this.maxObjects = this.__maxObjects;
         },
 
         /**
          * Retrieves an object from this pool.
          * `
          * @return {*} an object to contained in this pool
          */
         getObject : function() {
0            var ret = undefined;
0            if (this.freeCount > 0) {
0                ret = this.__freeObjects.dequeue();
0                this.__inUseObjects.push(ret);
0            } else if (this.__maxObjects > this.count) {
0                ret = this.createObject();
0                this.__inUseObjects.push(ret);
             }
0            return ret;
         },
 
         /**
          * Returns an object to this pool. The object is validated before it is returned to the pool,
          * if the validation fails then it is removed from the pool;
          * @param {*} obj the object to return to the pool
          */
         returnObject : function(obj) {
0            if (this.validate(obj) && this.count <= this.__maxObjects) {
0                this.__freeObjects.enqueue(obj);
0                var index;
0                if ((index = this.__inUseObjects.indexOf(obj)) > -1)
0                    this.__inUseObjects.splice(index, 1);
             } else {
0                this.removeObject(obj);
             }
         },
 
         /**
          * Removes an object from the pool, this can be overriden to provide any
          * teardown of objects that needs to take place.
          *
          * @param {*} obj the object that needs to be removed.
          *
          * @return {*} the object removed.
          */
         removeObject : function(obj) {
0            var index;
0            if (this.__freeObjects.contains(obj)) {
0                this.__freeObjects.remove(obj);
0            } else if ((index = this.__inUseObjects.indexOf(obj)) > -1) {
0                this.__inUseObjects.splice(index, 1);
             }
             //otherwise its not contained in this pool;
0            return obj;
         },
 
         /**
          * Validates an object in this pool.
          * </br>
          * <b>THIS SHOULD BE OVERRIDDEN TO VALIDATE</b>
          *
          * @param {*} obj the object to validate.
          */
         validate : function(obj) {
0            return true;
         },
 
         /**
          * Creates a new object for this pool.
          * * </br>
          * <b>THIS SHOULD BE OVERRIDDEN TO ADD THE CORRECT TYPE OF OBJECT</b>
          *
          * @return {Object} be default just creates an object.
          */
         createObject : function() {
0            return {};
         },
 
         setters : {
             minObjects : function(l) {
 
0                if (l <= this.__maxObjects) {
0                    this.__minObjects = l;
0                    var i;
0                    if ((i = this.count) < l) {
0                        while (i++ < l) {
0                            this.__freeObjects.enqueue(this.createObject());
                         }
                     }
                 } else {
0                    throw "comb.collections.Pool : minObjects cannot be greater than maxObjects.";
                 }
             },
             maxObjects : function(l) {
0                if (l >= this.__minObjects) {
0                    this.__maxObjects = l;
0                    var i = this.count, j = this.freeCount, fo = this.__freeObjects;
0                    while (i > l && j >= 0) {
0                        this.removeObject(fo.dequeue());
0                        j--;
0                        i--;
                     }
                 } else {
0                    throw "comb.collections.Pool : maxObjects cannot be less than maxObjects.";
                 }
 
             }
         },
 
         getters : {
             freeCount : function() {
0                return this.__freeObjects.count;
             },
             inUseCount : function() {
0                return this.__inUseObjects.length;
             },
             count : function() {
0                return  this.__freeObjects.count + this.__inUseObjects.length;
 
             },
 
             minObjects : function() {
0                return this.__minObjects;
             },
             maxObjects : function() {
0                return this.__maxObjects;
             }
         }
     }
 })

1var define = require("../define").define,
         Collection = require("./Collection"),
         base = require("../base");
 
1var padding = function(char, numSpaces) {
0    var ret = [];
0    for (var i = 0; i < numSpaces; i++)
0        ret.push(char);
0    return ret.join("");
 };
 
1module.exports = exports = define(Collection, {
     instance : {
         /**@lends comb.collections.Heap.prototype*/
         __getParentIndex : function(index) {
0            return Math.floor((index - 1) / 2);
         },
 
         __getLeftChildIndex : function(index) {
0            return (index * 2) + 1;
         },
 
         __getRightChildIndex : function(index) {
0            return (index * 2) + 2;
         },
 
         __makeNode : function(key, value) {
0            return {key : key, value : value};
         },
 
 
         /**
          * Base class for Heap Implementations.
          *
          *
          * @constructs
          * @augments comb.collections.Collection
          * @memberOf comb.collections
          *
          * @property {Number} count the current number of elements.
          * @property {Array} keys the keys of all items in the heap.
          * @property {Array} values the values contained in the heap.
          * @property {Boolean} isEmpty true if the Heap is empty.
          */
         constructor : function() {
0            this.__heap = [];
         },
 
         /**
          * Insert a key value into the key
          * @param key
          * @param value
          */
         insert : function(key, value) {
0            if (!base.isString(key)) {
0                var l = this.__heap.push(this.__makeNode(key, value));
0                this.__upHeap(l - 1);
             } else {
0                throw TypeError("Invalid key");
             }
         },
 
         /**
          * Removes the root from the heap
          *
          * @returns the value of the root
          */
         remove : function() {
0            var ret = undefined, heap = this.__heap, l = heap.length;
0            if (l) {
0                ret = heap[0];
0                if (l == 1) {
0                    heap.length = 0;
                 } else {
0                    heap[0] = heap.pop();
0                    this.__downHeap(0);
                 }
             }
0            return ret ? ret.value : ret;
         },
 
         /**
          * Gets he value of the root node with out removing it.
          *
          * @returns the value of the root
          */
         peek : function() {
0            var ret = undefined, heap = this.__heap, l = heap.length;
0            if (l) {
0                ret = heap[0];
             }
0            return ret ? ret.value : ret;
         },
 
         /**
          * Gets the key of the root node without removing it.
          *
          * @returns the key of the root
          */
         peekKey : function() {
0            var ret = undefined, heap = this.__heap, l = heap.length;
0            if (l) {
0                ret = heap[0];
             }
0            return ret ? ret.key : ret;
         },
 
         /**
          * Perform the heapify operation after the an
          * item as been added to the bottom of the heap.
          *
          * @param index the index in which the new item was added
          */
         __upHeap : function(index) {
0            throw Error("NOT IMPLEMENTED");
         },
 
         /**
          * Heapify the heap after the root has been removed
          *
          * @param index the index of the root
          */
         __downHeap : function(index) {
0            throw Error("NOT IMPLEMENTED");
         },
 
         /**
          *
          * Determine if the heap contains a particular key.
          *
          * @param key key to test.
          *
          * @returns {Boolean} true if the key is contained in this heap.
          */
         containsKey : function(key) {
0            var heap = this.__heap;
0            for (var i = heap.length - 1; i >= 0; i--) {
0                if (heap[i].key == key) {
0                    return true;
                 }
             }
0            return false;
         },
 
         /**
          *
          * Determine if the heap contains a particular value.
          *
          * @param value value to test.
          *
          * @returns {Boolean} true if the value is contained in this heap.
          */
         containsValue : function(value) {
0            var heap = this.__heap;
0            for (var i = heap.length - 1; i >= 0; i--) {
0                if (heap[i].value == value) {
0                    return true;
                 }
             }
0            return false;
         },
 
         /**
          * Empty the heap.
          */
         clear : function() {
0            this.__heap.length = 0;
         },
 
         __printNode : function(index, level) {
             //console.log(level);
0            var str = [], node = this.__heap[index];
0            if (node == null || node == undefined) {
0                str.push(padding('\t', level));
0                str.push("~");
0                console.log(str.join(""));
             } else {
0                this.__printNode(this.__getRightChildIndex(index), level + 1);
0                str.push(padding('\t', level));
0                str.push(node.key + " : " + node.value + "\n");
0                console.log(str.join(""));
0                this.__printNode(this.__getLeftChildIndex(index), level + 1);
             }
         },
 
         /**
          * Print the heap.
          */
         print : function() {
0            this.__printNode(0, 0);
         },
 
         getters : {
 
             count : function() {
0                return this.__heap.length;
             },
 
             keys : function() {
0                return this.__heap.map(function(n) {
0                    return n.key;
                 });
             },
 
             values : function() {
0                return this.__heap.map(function(n) {
0                    return n.value;
                 });
             },
 
             isEmpty : function() {
0                return this.__heap.length == 0;
             }
         }
 
 
     }
 });

1var define = require("../define").define,
         Collection = require("./Collection"),
         base = require("../base");
 
 /**
  * @class <p>FIFO Data structure</p>
  * @name Queue
  * @augments comb.collections.Collection
  * @memberOf comb.collections
  *
  * @property {Number} count the current number of elements in this queue
  * @property {Boolean} isEmpty true if this queue is empty
  * @property {Array} values a copy of the values contained in this queue
  * @ignoreCode
  */
1module.exports = exports = define(Collection, {
     instance : {
         /**@lends comb.collections.Queue.prototype*/
 
         constructor : function() {
0            this.__queue = [];
0            this.__next = 0;
0            this.__last = 0;
         },
 
         /**
          * Add data to this queue
          * @param {*} data element to add
          */
         enqueue : function(data) {
0            this.__queue[this.__last++] = data;
         },
 
         /**
          * Removes first item from the head of the queue
          *
          * @return {*} The element removed from this queue. Returns undefined if the queue is empty.
          */
         dequeue : function() {
0            var ret = undefined,next = this.__next, queue;
0            if (next != this.__last) {
0                queue = this.__queue;
0                ret = queue[next];
0                queue[this.__next++] = undefined;
             }
0            return ret;
         },
 
         /**
          * Retrieves the item at the head of the queue without removing it
          *
          * @return {*} The element at the head of the queue. Returns undefined if the queue is empty.
          */
         peek : function() {
0            var ret = undefined, next = this.__next;
0            if (next != this.__last) {
0                ret = this.__queue[next];
             }
0            return ret;
         },
 
         /**
          * Removes all items from this queue
          */
         clear : function() {
0            this.__queue.length = 0;
0            this.__next = 0;
0            this.__last = 0;
         },
 
         /**
          * Determine if this queue contains the element
          * @param {*} obj the object to find
          *
          * @return {Boolean} true if this queue contains the element
          */
         contains : function(obj) {
0            return this.__queue.indexOf(obj) != -1;
         },
         /**
          * Removes an element from this queue.
          * @param {*} obj the data to remove.
          *
          * @return {Boolean} true if the element was removed, false otherwise.
          */
         remove : function(obj) {
0            var index = this.__queue.indexOf(obj), ret = false;
0            if (index != -1) {
0                if (index == this.__next) {
0                    this.dequeue();
                 } else {
0                    this.__queue.splice(index, 1);
0                    this.__last--;
                 }
0                ret = true;
             }
0            return ret;
         },
 
         toString : function(){
0            return this.__queue.toString();
         },
 
         getters : {
 
             count : function() {
0                return this.__last - this.__next;
             },
 
             isEmpty : function() {
0                return this.__last - this.__next == 0;
             },
 
             values : function() {
0                return this.__queue.slice(this.__next, this.__last);
             }
         }
     }
 });

1var define = require("../../define.js").define,
     promise = require("../../promise"),
     Promise = promise.Promise,
     PromiseList = promise.PromiseList,
     base = require("../../base"),
     hitch = base.hitch,
     string = base.string,
     escape = base.regexp.escapeString,
     style = string.style,
     format = string.format,
     FileAppender = require("./fileAppender"),
     Level = require("../level"),
     fs = require("fs"),
     path = require("path");
 
1var conversion = {
     MB:1048576,
     KB:1024,
     GB:1073741824
 };
1var DEFAULT_SIZE = "10MB";
1var convertToBytes = function (str) {
0    var ret = DEFAULT_SIZE;
0    var match = str.match(/(\d+)(MB|KB|GB)$/);
0    if (match && match.length == 3) {
0        var size = parseInt(match[1], 10);
0        ret = size * conversion[match[2]];
     }
0    return ret;
 }
 
 /**
  * @class Appends messages to a file. Rolls files over when a size limit has been reached. Once the max file size has
  * been reached it is rolled over to a file called <logName>.log.n where n is a number.
  * </br></br>
  * <p>Example. RollingFileAppender is current writing to myLog.log, the log reaches is max size to it is
  * renamed to myLog.log.1 and a new myLog.log is created.</p>
  * </br>
  * If maxBackupIndex is reached then the log at that index is deleted. If maxBackupIndex is set to 0 then no log is
  * rolled over.</p>
  *
  * @name RollingFileAppender
  * @augments comb.logging.appenders.FileAppender
  * @memberOf comb.logging.appenders
  *
  * @param {Object} [options] options to assign to this Appender
  * @param {String} [options.name="appender"] the name of this Appender. If you want two of the same type of appender
  *                                           on a logger it must have a different name.
  * @param {String} [options.pattern="[{[yyyy-MM-ddTHH:mm:ss:SSS (z)]timeStamp}] {[- 5]levelName} {[-20]name} - {message}"]
  *  <p>Available Options for formatting see {@link comb.string.format} for formatting options</p>
  *  <ul>
  *      <li>timeStamp - the timestamp of the event being logged</li>
  *      <li>level - the {@link comb.logging.Level} of the event</li>
  *      <li>levelName - the name of the level being logged</li>
  *      <li>name - the name of the logger logging the event</li>
  *      <li>message - the message being logged</li>
  * </ul>
  * @param {comb.logging.Level|String} [options.level=comb.logging.Level.INFO] the logging level of this appender
  *      <p><b>Note:</b> the level can be different from the logger in the case that you want a particular logger
  *      to only log particular event of a level. For example an appender that only logs errors. BEWARE that if the
  *      appenders level is lower than the logger is will not recieve any messages.</p>
  *
  * @param {String} [options.file="./log.log"] the file to log events to.
  * @param {String} [options.encoding="utf8"] the encoding of the file.
  * @param {Boolean} [options.overwrite=false] if true the log file is overwritten otherwise it is appended to.
  * @param {String} [options.maxSize="10MB"] the maxSize of a file. Valid options include "KB", "MB", or "GB"
  *
  * <pre class="code">
  *     maxSize = "100MB"
  *     //or
  *     maxSize = "100KB"
  *     //or
  *     maxSize = "1GB"
  * </pre>
  *
  * @param {Number} [options.maxBackupIndex=10] the maximum number of files to rollOver.
  */
1define(FileAppender, {
     instance:{
 
         __watching:false,
 
         constructor:function (options) {
0            options = options || {};
0            this.maxSize = options.maxSize || DEFAULT_SIZE;
0            !options.name && (options.name = "rollingFileAppender");
0            this.maxBackupIndex = options.maxBackupIndex || 10;
0            this.__queue = [];
0            this.__inRollover = false;
0            this._super([options]);
         },
 
         __startCheck:function () {
0            if (!this.__watching) {
0                this.__watching = true;
0                fs.watchFile(this.__file, hitch(this, "__checkFile"));
0                fs.stat(this.__file, hitch(this, function (err, stat) {
0                    this.__checkFile(stat);
                 }));
             }
         },
 
         __checkFile:function (stats) {
0            var ret = new Promise();
0            if (!this.__inRollover) {
0                if (stats.size >= this.maxSize) {
0                    if (this.maxBackupIndex > 0) {
0                        this.__inRollover = true;
0                        this.__onExit().chain(hitch(this, "__rollover")).then(hitch(this, function () {
0                            var ws = fs.createWriteStream(this.__file, { flags:"w", encoding:this.__encoding});
0                            ws.on("open", hitch(this, function () {
0                                this.__writeStream = ws;
0                                this.__inRollover = false;
0                                this.__checkQueue();
0                                ret.callback();
                             }));
                         }), hitch(ret, "errback", new Error("comb.logging.appenders.RollingFileAppender : error rolling over files")));
                     } else {
0                        this.__writeStream = fs.createWriteStream(this.__file, { flags:"w", encoding:this.__encoding});
0                        ret.callback();
                     }
                 } else {
0                    ret.callback();
                 }
             } else {
0                ret.callback();
             }
0            return ret.promise();
         },
 
 
         append:function (event) {
0            if (this._canAppend(event)) {
0                !this.__watching && this.__startCheck();
0                var ws = this.__writeStream;
0                if (!this.__inRollover && ws && ws.writable) {
0                    this._super(arguments);
                 } else {
0                    this.__queue.push(event);
                 }
             }
         },
 
         __checkQueue:function () {
0            this.__queue.forEach(this.append, this);
0            this.__queue.length = 0;
         },
 
         __rollover:function () {
0            var ret = new Promise(), file = this.__file;
0            var dir = path.dirname(file), baseName = new RegExp("(" + escape(path.basename(path.basename(file))) + ")(?:\\.(\\d*))*");
0            fs.readdir(dir, hitch(this, function (err, files) {
0                files = files.filter(
                     function (f) {
0                        var match = f.match(baseName);
0                        if (match) {
0                            return true;
                         } else {
0                            return false;
                         }
                     });
0                files = files.sort(function (a, b) {
0                    var ret = 0;
0                    if (a > b) {
0                        ret = 0;
0                    } else if (a < b) {
0                        ret = 1;
                     }
0                    return ret;
                 });
0                var count = files.length, i = 0;
0                var checkFile = hitch(this, function () {
0                    if (count > 0) {
0                        var f = dir + "/" + files[i++];
0                        if (count > this.maxBackupIndex) {
                             //drop the file;
0                            count--;
0                            fs.unlink(f, function (err) {
0                                err ? ret.errback(err) : checkFile();
                             });
                         } else {
                             //rename the file
0                            var rn = this.__file + "." + count--;
0                            fs.rename(f, rn, function (err) {
0                                err ? ret.errback(err) : checkFile();
                             });
                         }
                     } else {
0                        ret.callback();
                     }
                 });
0                checkFile();
             }));
0            return ret.promise();
         },
 
 
         getters:{
 
             maxSize:function () {
0                return this.__maxSize;
             }
         },
 
         setters:{
             maxSize:function (size) {
0                this.__maxSize = size ? convertToBytes(size) : DEFAULT_SIZE;
             }
         }
     }
 }).registerType("RollingFileAppender").as(module);

1var define = require("../define").define,
         Tree = require("./Tree"),
         base = require("../base");
 
 /**
  *
  * @ignoreCode
  * @class <p>A Search tree that maintains the following properties</p>
  * <ul>
  *     <li>The left subtree of a node contains only nodes with keys less than the node's key.
  *     <li>The right subtree of a node contains only nodes with keys greater than the node's key.
  *     <li>Both the left and right subtrees must also be binary search trees.
  * </ul>
  *
  * <b>Performance</b>
  * <table>
  *     <tr><td></td><td>Best</td><td>Worst</td></tr>
  *     <tr><td>Space</td><td>O(n)</td><td>O(n)</td></tr>
  *     <tr><td>Search</td><td>O(log n)</td><td>O(n)</td></tr>
  *     <tr><td>Insert</td><td>O(log n)</td><td>O(n)</td></tr>
  *     <tr><td>Delete</td><td>O(log n)</td><td>O(n)</td></tr>
  * <table>
  * @name BinaryTree
  * @augments comb.collections.Tree
  * @memberOf comb.collections
  */
1module.exports = exports = define(Tree, {
     instance : {
         /**@lends comb.collections.BinaryTree.prototype*/
 
         insert : function(data) {
0            if (this.__root == null) {
0                return (this.__root = {
                     data : data,
                     parent : null,
                     left : null,
                     right : null
                 });
             }
0            var compare = this.compare;
0            var root = this.__root;
0            while (root != null) {
0                var cmp = compare(data, root.data);
0                if (cmp) {
0                    var leaf = (cmp == -1) ? "left" : "right";
0                    var next = root[leaf];
0                    if (next == null) {
0                        return (root[leaf] = {data : data, parent : root, left : null, right : null});
                     } else {
0                        root = next;
                     }
                 } else {
0                    return;
                 }
             }
         },
 
         remove : function(data) {
0            if (this.__root != null) {
0                var head = {right : this.__root}, it = head;
0                var p, f = null;
0                var dir = "right";
0                while (it[dir] != null) {
0                    p = it;
0                    it = it[dir];
0                    var cmp = this.compare(data, it.data);
0                    if (!cmp) {
0                        f = it;
                     }
0                    dir = (cmp == -1 ? "left" : "right");
                 }
0                if (f != null) {
0                    f.data = it.data;
0                    p[p.right == it ? "right" : "left"] = it[it.left == null ? "right" : "left"];
                 }
0                this.__root = head.right;
             }
 
         }
     }
 });
 
 

1var define = require("../define").define,
         Collection = require("./Collection"),
         base = require("../base");
 
 /**
  * @class <p>LIFO Data structure</p>
  * @name Stack
  * @augments comb.collections.Collection
  * @memberOf comb.collections
  *
  * @property {Number} count the current number of elements in this queue
  * @property {Boolean} isEmpty true if this queue is empty
  * @property {Array} values a copy of the values contained in this queue
  * @ignoreCode
  */
1module.exports = exports = define(Collection, {
     instance : {
         /**@lends comb.collections.Stack.prototype*/
 
         constructor : function() {
0            this.__stack = [];
0            this.__next = -1;
         },
 
         /**
          * Add an item to the tail of this stack
          * @param {*} data item to qppend to this stack
          *
          */
         push : function(data) {
0            this.__stack[++this.__next] = data;
         },
 
         /**
          * Removes the tail of this static
          * @return {*} the data at the tail of this stack
          */
         pop : function() {
0            var ret = undefined, stack, next = this.__next;
0            if (next >= 0) {
0                stack = this.__stack;
0                ret = stack[next];
0                stack[this.__next--] = undefined;
             }
0            return ret;
         },
 
         /**
          * Retrieves the item at the tail of the stack without removing it
          *
          * @return {*} The element at the tail of the stack. Returns undefined if the stack is empty.
          */
         peek : function() {
0            var ret = undefined,next = this.__next;
0            if (next >= 0) {
0                ret = this.__stack[next];
             }
0            return ret;
         },
 
          /**
          * Removes all items from this stack.
          */
         clear : function() {
0            this.__stack.length = 0;
0            this.__next = -1;
         },
 
         /**
          * Determine if this stack contains the element
          * @param {*} obj the object to find
          *
          * @return {Boolean} true if this stack contains the element
          */
         contains : function(obj) {
0            return this.__stack.indexOf(obj) != -1;
         },
 
         /**
          * Removes an element from this stack.
          * @param {*} obj the data to remove.
          *
          * @return {Boolean} true if the element was removed, false otherwise.
          */
         remove : function(obj) {
0            var index = this.__stack.indexOf(obj), ret = false;
0            if (index != -1) {
0                if (index == this.__next) {
0                    this.pop();
                 } else {
0                    this.__stack.splice(index, 1);
0                    this.__next--;
                 }
0                ret = true;
             }
0            return ret;
         },
 
         toString : function(){
0            return this.__stack.toString();
         },
 
         getters : {
             count : function() {
0                return this.__next + 1;
             },
 
             isEmpty : function() {
0                return this.__next < 0;
             },
 
             values : function() {
0                return this.__stack.slice(0, this.__next + 1).reverse();
             }
         }
     }
 });

1var func = require("../base/functions"),
     obj = require("../base/object"),
     Promise = require("../promise").Promise,
     define = require("../define").define;
 
 
1var Middleware = define(null, {
     instance:{
         /** @lends comb.plugins.Middleware.prototype */
 
 
         __hooks:{pre:{}, post:{}},
 
 
         /**
          * @class Plugin to enable middleware on a class
          *
          * @example
          *
          * var Mammal = define(comb.plugins.Middleware, {
          *  instance : {
          *
          *    constructor: function(options) {
          *        options = options || {};
          *        this.super(arguments);
          *        this._type = options.type || "mammal";
          *    },
          *
          *    speak : function() {
          *        var ret = new comb.Promise();
          *        this._hook("pre", "speak")
          *                .then(comb.hitch(this, "_hook", "post", "speak"), hitch(ret, "errback"))
          *                .then(comb.hitch(ret, "callback"), comb.hitch(ret, "errback"));
          *        return ret;
          *    }
          *  }
          *});
          *
          *  Mammal.pre('speak', function(next){
          *     //do something meaningful
          *     next();
          *  });
          *  var m = new Mammal({color : "gold"});
          *  m.speak();
          *
          * @constructs
          */
         constructor:function () {
0            this.__hooks = obj.merge({}, this.__hooks);
0            this._super(arguments);
         },
 
         /**
          * <p>Protected!</p>
          *
          * <p>Call to initiate middleware for the topic</p>
          * <p><b>NOTE:</b> this function takes a variable number of arguments
          *       whatever comes after the op param will be passed into
          *       the listening function, with the last argument to the listenting
          *       function being the next function</p>
          *
          *
          * @public
          * @param {"pre"|"post"} state the state in which the hook should be called
          * @param {String} op the operation that is being acted upong
          * @param args arguments to be passed into the listening functions.
          * @returns {comb.Promise} a promise to use after middleware chain completes
          *
          */
         _hook:function (state, op, args) {
0            args = args || [];
0            var promise = new Promise();
0            var funcs, length;
0            if (this.__hooks[state] && (funcs = this.__hooks[state][op]) != null && (length = funcs.length) > 0) {
0                var count = 0;
0                var next = func.hitch(this, function (err) {
0                    if (err) {
0                        promise.errback(err);
                     } else {
0                        process.nextTick(func.hitch(this, function () {
                             //if Ive looped through all of them callback
0                            if (count == length) {
0                                promise.callback();
                             } else {
                                 //call next
0                                var nextArgs = args.slice(0);
0                                nextArgs.unshift(next);
0                                funcs[count++].apply(this, nextArgs);
                             }
                         }));
                     }
                 });
0                next();
             } else {
0                promise.callback();
             }
0            return promise.promise();
         },
 
         /**
          * Use to listen to before an event occurred i.e. pre save
          *
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on the instance of an object, not all instances!</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li> When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          *      instance.pre("save", function(args,...., next){
          *          //do something...
          *          //you have to call next!!!!!
          *          next();
          *      });
          *
          * */
         pre:function (fun, callback) {
0            var hook = this.__hooks.pre[fun];
0            if (!hook) {
0                hook = this.__hooks.pre[fun] = [];
             }
0            hook.push(callback);
         },
 
         /**
          * <p>Use to listen to after an event has occurred i.e. post save</p>
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on the instance of an object, NOT all instances!</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          * @example
          *
          * instance.post("save", function(next){
          *                //do something...
          *                 //you have to call next!!!!!
          *                 next();
          *          });
          * */
         post:function (fun, callback) {
0            var hook = this.__hooks.post[fun];
             //if I havent initialized it create it;
0            if (hook == undefined) {
0                hook = this.__hooks.post[fun] = [];
             }
0            hook.push(callback);
         }
     },
 
     static:{
         /** @lends comb.plugins.Middleware */
 
         /**
          *<p> Use to listen to after an event has occurred i.e. post save</p>
          *
          * <b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on ALL instances of an object</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          * Class.pre("save", function(next){
          *               ...
          *               //you must call next
          *          });
          * */
         pre:function (name, cb) {
0            var hooks = this.prototype.__hooks;
0            var hook = hooks.pre[name];
0            if (!hook) {
0                hook = hooks.pre[name] = [];
             }
0            hook.push(cb);
         },
 
         /**
          *<p>Use to listen to after an event has occurred i.e. post save</p>
          *
          *<b>NOTE:</b></br>
          * <ul>
          *     <li>You must call next in order for the middleware chain to complete</li>
          *      <li>This connects to events on ALL instances of an object</li>
          *      <li>Hooks are called in the order they are received!</li>
          *      <li>When connecting your callback will be called in the scope of the class</br>if you want a certain scope use {@link comb.hitch}</li>
          *  </ul>
          *
          * @example
          * Class.post("save", function(next){
          *               ...
          *               //you must call next
          *          });
          * */
         post:function (name, cb) {
0            var hooks = this.prototype.__hooks;
0            var hook = hooks.post[name];
0            if (!hook) {
0                hook = hooks.post[name] = [];
             }
0            hook.push(cb);
         }
     }
 
 });
 
1module.exports = exports = Middleware;

1var func = require("./functions"),
 		obj = require("./object");
 
1var comb = exports;
 
 
1var wrapper = function() {
0	return function() {
0		var c = arguments.callee, listeners = c.__listeners, func = c.func, r;
0		if (func) {
0			r = func.apply(this, arguments);
 		}
0		for (var i = 0; i < listeners.length; i++) {
0			var lis = listeners[i];
0			if (lis) {
0				lis.apply(this, arguments);
 			}
 		}
0		return r;
 
 	}
 };
 
 
1var listeners = {};
1obj.merge(comb, {
             /**@lends comb*/
 			/**
 			 * Disconnects a listener to a function
 			 * @param {handle} A handle returned from comb.connect
 			 */
 			disconnect : function(handle) {
0				if (handle && handle.length == 3) {
0					var obj = handle[0], method = handle[1], cb = handle[2];
0					if (typeof method != "string") throw "comb.disconnect : When calling disconnect the method must be string";
0					var scope = obj || global, ls;
0					if (typeof scope[method] == "function") {
0						ls = scope[method].__listeners;
0						if (ls && cb-- > 0) {
 							//we dont want to splice it because our indexing will get off
0							ls[cb] = null;
 						}
 					} else {
0						throw new Error("unknown method " + method + " in object " + obj);
 					}
 				} else {
0					throw "comb.disconnect : invalid handle"
 				}
 			},
 
 			/**
 			 * Function to listen when other functions are called
 			 *
 			 * @example
 			 *
 			 *  comb.connect(obj, "event", myfunc);
 			 *  comb.connect(obj, "event", "log", console);
 			 *
 			 * @param {Object} obj the object in which the method you are connecting to resides
 			 * @param {String} method the name of the method to connect to
 			 * @param {Function} cb the function to callback
 			 * @param {Object} [scope] the scope to call the specified cb in
 			 *
 			 * @returns {Array} handle to pass to {@link comb.disconnect}
 			 */
 			connect : function(obj, method, cb, scope) {
0				var index;
0				if (typeof method != "string") throw new Error("When calling connect the method must be string");
0				if (!func.isFunction(cb)) throw new Error("When calling connect callback must be a string");
0				var scope = obj || global, listeners, newMethod;
0				if (typeof scope[method] == "function") {
0					listeners = scope[method].__listeners;
0					if (!listeners) {
0						newMethod = wrapper();
0						newMethod.func = obj[method];
0						listeners = (newMethod.__listeners = []);
0						scope[method] = newMethod;
 					}
0					index = listeners.push(cb);
 				} else {
0					throw new Error("unknow method " + method + " in object " + obj);
 				}
0				return [obj, method, index];
 			},
 
 
 			/**
 			 * Broadcasts an event to all listeners
 			 * NOTE : the function takes a variable number of arguments
 			 *        i.e. all arguments after the topic will be passed to the listeners
 			 *
 			 * @example
 			 *
 			 *
 			 * comb.broadcast("hello", "hello world");
 			 * //the args "hello" and "world" will be passed to any listener of the topic
 			 * //"hello"
 			 * comb.broadcast("hello", "hello", "world");
 			 *
 			 * @param  {String} topic the topic to brodcast
 			 * @param params the information to bradcast
 			 */
 			broadcast : function() {
0				var args = Array.prototype.slice.call(arguments);
0				var topic = args.splice(0, 1)[0];
0				if (topic) {
0					var list = listeners[topic];
0					if (list) {
0						for (var i = list.length - 1; i >= 0; i--) {
0							var han = list[i], cb = han.cb;
0							if (cb) {
0								cb.apply(this, args);
 							}
 						}
 					}
 				}
 			},
 
 			/**
 			 * Listen for the broadcast of certain events
 			 *
 			 * @example
 			 *  comb.listen("hello", function(arg1, arg2){
 			 *     console.log(arg1);
 			 *     console.log(arg2);
 			 *  });
 			 *
 			 * @param {String} topic the topic to listen for
 			 * @param {Function} callback the funciton to call when the topic is published
 			 *
 			 * @returns a handle to pass to {@link comb.unListen}
 			 */
 			listen : function(topic, callback) {
0				if (!func.isFunction(callback)) throw new Error("callback must be a function");
0				var handle = {
 					topic : topic,
 					cb : callback,
 					pos : null
 				};
0				var list = listeners[topic];
0				if (!list) {
0					list = (listeners[topic] = []);
 				}
0				list.push(handle);
0				handle.pos = list.length - 1;
0				return handle;
 			},
 
 			/**
 			 * Disconnects a listener
 			 *
 			 * @param handle a handle returned from {@link comb.listen}
 			 */
 			unListen : function(handle) {
0				if (handle) {
0					var topic = handle.topic, list = listeners[topic];
0					if (list) {
0						for (var i = list.length - 1; i >= 0; i--) {
0							if (list[i] == handle) {
0								list.splice(i, 1);
 							}
 						}
0						if (!list.length) {
0							delete listeners[topic];
 						}
 					}
 				}
 			}
 
 		});
 

1var define = require("../define").define,
         Heap = require("./Heap"),
         base = require("../base");
 
 /**
  * @ignoreCode
  *
  * @class <p> Max Heap implementation, lowest value in heap is always at the root.</p>
  * </br>
  * <b>Performance</b>
  * <table>
  *     <tr><td></td><td>Best</td><td>Worst</td></tr>
  *     <tr><td>Insert</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Remove</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Peek</td><td>O(1)</td><td>O(1)</td></tr>
  *     <tr><td>Contains</td><td>O(n)</td><td>O(n)</td></tr>
  * <table>
  * @name MaxHeap
  * @augments comb.collections.Heap
  * @memberOf comb.collections
  */
1exports = module.exports = define(Heap, {
     instance : {
 
 
         __upHeap : function(index) {
0            var heap = this.__heap;
0            var node = heap[index];
0            while (index >= 0) {
0                var parentIndex = this.__getParentIndex(index), parent = heap[parentIndex];
0                if (parent && parent.key < node.key) {
0                    heap[index] = parent;
0                    index = parentIndex;
                 } else {
0                    break;
                 }
             }
0            heap[index] = node;
         },
 
         __downHeap : function(index) {
0            var heap = this.__heap;
0            var node = heap[index], length = heap.length;
0            while (index < Math.floor(length / 2)) {
0                var leftIndex = this.__getLeftChildIndex(index),
                         rightIndex = this.__getRightChildIndex(index), left = heap[leftIndex], right = heap[rightIndex], child, childIndex;
0                if (rightIndex < length && right.key < left.key) {
0                    childIndex = leftIndex;
0                    child = left
                 } else {
0                    childIndex = leftIndex;
0                    child = heap[leftIndex];
                 }
0                if(child.key > node.key){
0                    heap[index] = child;
0                    index = childIndex;
                 }else{
0                    break;
                 }
 
             }
0            heap[index] = node;
         }
 
     }
 });

1var define = require("../../define.js").define,
     base = require("../../base"),
     promise = require("../../promise"),
     string = base.string,
     Promise = promise.Promise,
     PromiseList = promise.PromiseList,
     style = string.style,
     format = string.format,
     Appender = require("./appender"),
     Level = require("../level"),
     fs = require("fs");
 
 
 /**
  * @class Appends messages to a file.
  *
  * @example
  * var fileAppender = new comb.logging.appenders.FileAppender({
  *      file : "/var/log/myLog.log"
  * });
  *
  *
  * @name FileAppender
  * @augments comb.logging.appenders.Appender
  * @memberOf comb.logging.appenders
  *
  * @param {Object} [options] options to assign to this Appender
  * @param {String} [options.name="appender"] the name of this Appender. If you want two of the same type of appender
  *                                           on a logger it must have a different name.
  * @param {String} [options.pattern="[{[yyyy-MM-ddTHH:mm:ss:SSS (z)]timeStamp}] {[- 5]levelName} {[-20]name} - {message}"]
  *  <p>Available Options for formatting see {@link comb.string.format} for formatting options</p>
  *  <ul>
  *      <li>timeStamp - the timestamp of the event being logged</li>
  *      <li>level - the {@link comb.logging.Level} of the event</li>
  *      <li>levelName - the name of the level being logged</li>
  *      <li>name - the name of the logger logging the event</li>
  *      <li>message - the message being logged</li>
  * </ul>
  * @param {comb.logging.Level|String} [options.level=comb.logging.Level.INFO] the logging level of this appender
  *      <p><b>Note:</b> the level can be different from the logger in the case that you want a particular logger
  *      to only log particular event of a level. For example an appender that only logs errors. BEWARE that if the
  *      appenders level is lower than the logger is will not recieve any messages.</p>
  *
  * @param {String} [options.file="./log.log"] the file to log events to.
  * @param {String} [options.encoding="utf8"] the encoding of the file.
  * @param {Boolean} [options.overwrite=false] if true the log file is overwritten otherwise it is appended to.
  * @ignoreCode
  */
1define(Appender, {
     instance:{
 
         constructor:function (options) {
0            options = options || {};
0            !options.name && (options.name = "fileAppender");
0            this.__file = options.file || "./log.log";
0            this.__encoding = options.encoding || "utf8";
0            this.__overwrite = options.overwrite || false;
0            this.__writeStream = options.writeStream || fs.createWriteStream(this.__file, { flags:this.__overwrite ? "w" : 'a', encoding:this.__encoding});
0            this._super([options]);
0            this.__pattern += "\n";
0            base.listenForExit(base.hitch(this, "__onExit"));
         },
 
 
         __onExit:function () {
0            var ret = new Promise();
0            var ws = this.__writeStream;
0            this.__writeStream = null;
0            ws.on("close", base.hitch(ret, "callback"));
0            ws.destroySoon();
0            return ret.promise();
         },
 
         append:function (event) {
0            var ws = this.__writeStream;
0            if (this._canAppend(event) && ws && ws.writable) {
0                var message = format(this.__pattern, event);
0                var level = event.level;
0                ws.write(message);
             }
         }
     }
 }).registerType("FileAppender").as(module);

1var define = require("../../define.js").define,
     base = require("../../base"),
     string = base.string,
     escape = base.regexp.escapeString,
     FileAppender = require("./fileAppender"),
     format = string.format,
     Level = require("../level"),
     fs = require("fs");
 
 
 /**
  * @class Appends messages to a file in JSON format. The messages are logged to an array in a JSON file
  * <b>The file is always overwritten</b>
  *
  * @example
  * //example log.json
  * [
  *    {
  *      "timestamp" : "Wed Jun 08 2011 11:16:20 GMT-0500 (CDT)",
  *      "level" : "INFO",
  *      "name" : "comb",
  *      "message" :  "INFO MESSAGE!!!!"
  *    }
  *  ]
  *
  *
  * @name JSONAppender
  * @augments comb.logging.appenders.FileAppender
  * @memberOf comb.logging.appenders
  *
  * @param {Object} [options] options to assign to this Appender
  * @param {String} [options.name="appender"] the name of this Appender. If you want two of the same type of appender
  *                                           on a logger it must have a different name.
  * @param {String} [options.pattern="{"timestamp" : "{timeStamp}", "level" : "{levelName}", "name" : "{name}", "message" :  "{message}"}"]
  *  <p>Available Options for formatting see {@link comb.string.format} for formatting options</p>
  *  <ul>
  *      <li>timeStamp - the timestamp of the event being logged</li>
  *      <li>level - the {@link comb.logging.Level} of the event</li>
  *      <li>levelName - the name of the level being logged</li>
  *      <li>name - the name of the logger logging the event</li>
  *      <li>message - the message being logged</li>
  * </ul>
  * @param {comb.logging.Level|String} [options.level=comb.logging.Level.INFO] the logging level of this appender
  *      <p><b>Note:</b> the level can be different from the logger in the case that you want a particular logger
  *      to only log particular event of a level. For example an appender that only logs errors. BEWARE that if the
  *      appenders level is lower than the logger is will not recieve any messages.</p>
  *
  * @param {String} [options.file="./log.json"] the file to log events to.
  * @param {String} [options.encoding="utf8"] the encoding of the file.
  *
  * @ignoreCode
  */
1define(FileAppender, {
     instance:{
 
         constructor:function (options) {
0            options = options || {};
0            this.name = options.name || "JSONAppender";
0            this.__count = 0;
0            this.__file = options.file || "./log.json";
0            this.__encoding = options.encoding || "utf8";
0            this.__writeStream = options.writeStream || fs.createWriteStream(this.__file, { flags:"w", encoding:this.__encoding});
0            this.__writeStream.write("[\n");
0            this.level = options.level;
             //explicit overwrite of patter
0            this.__pattern = '{"timestamp" : "{timeStamp}", "level" : "{levelName}", "name" : "{name}", "message" :  "{message}"}';
0            base.listenForExit(base.hitch(this, "__onExit"));
         },
 
         append:function (event) {
0            if (this._canAppend(event)) {
0                event.message = event.message.replace(/\n+/g, "\\n");
0                var message = (this.__count ? ",\n" : "\n") + format(this.__pattern, event);
0                this.__writeStream.write(message);
0                this.__count++;
             }
         },
 
 
         __onExit:function () {
0            this.__writeStream.write("]");
0            this._super(arguments);
         }
     }
 }).registerType("JSONAppender").as(module);

1var define = require("../define").define,
         Tree = require("./Tree"),
         base = require("../base"),
         multiply = base.string.multiply;
 
1var RED = "red", BLACK = "black";
 
1var isRed = function(node) {
0    return node != null && node.red;
 };
 
1var makeNode = function(data, parent) {
0    return {
         data : data,
         red : true,
         left : null,
         right : null
     }
 };
 
1var insert = function(root, data, compare) {
0    if (root == null) {
0        return makeNode(data, null);
 
     } else {
0        var cmp = compare(data, root.data);
0        if (cmp) {
0            var dir = cmp == -1 ? "left" : "right";
0            var otherDir = dir == "left" ? "right" : "left";
0            root[dir] = insert(root[dir], data, compare);
0            var node = root[dir];
 
0            if (isRed(node)) {
 
0                var sibling = root[otherDir];
0                if (isRed(sibling)) {
                     /* Case 1 */
0                    root.red = true;
0                    node.red = false;
0                    sibling.red = false;
                 } else {
 
0                    if (isRed(node[dir])) {
 
0                        root = rotateSingle(root, otherDir);
0                    } else if (isRed(node[otherDir])) {
 
0                        root = rotateDouble(root, otherDir);
                     }
                 }
 
             }
         }
     }
0    return root;
 };
 
1var rotateSingle = function(root, dir) {
0    var otherDir = dir == "left" ? "right" : "left";
0    var save = root[otherDir];
0    root[otherDir] = save[dir];
0    save[dir] = root;
0    root.red = true;
0    save.red = false;
0    return save;
 };
 
1var rotateDouble = function(root, dir) {
0    var otherDir = dir == "left" ? "right" : "left";
0    root[otherDir] = rotateSingle(root[otherDir], otherDir);
0    return rotateSingle(root, dir);
 };
 
 
1var remove = function (root, data, done, compare) {
0    if (root == null) {
0        done.done = true;
     } else {
0        var dir;
0        if (compare(data, root.data) == 0) {
0            if (root.left == null || root.right == null) {
0                var save = root[root.left == null ? "right" : "left"];
                 /* Case 0 */
0                if (isRed(root)) {
0                    done.done = true;
0                } else if (isRed(save)) {
0                    save.red = false;
0                    done.done = true;
                 }
0                return save;
             }
             else {
0                var heir = root.right, p;
0                while (heir.left != null) {
0                    p = heir;
0                    heir = heir.left;
                 }
0                p && (p.left = null);
0                root.data = heir.data;
0                data = heir.data;
             }
         }
0        dir = compare(data, root.data) == -1 ? "left" : "right";
0        root[dir] = remove(root[dir], data, done, compare);
0        !done.done && (root = removeBalance(root, dir, done));
     }
0    return root;
 };
 
1var removeBalance = function(root, dir, done) {
0    var notDir = dir == "left" ? "right" : "left";
0    var p = root, s = p[notDir];
0    if (isRed(s)) {
0        root = rotateSingle(root, dir);
0        s = p[notDir];
     }
0    if (s != null) {
0        if (!isRed(s.left) && !isRed(s.right)) {
0            isRed(p) && (done.done = true);
0            p.red = 0;
0            s.red = 1;
         } else {
0            var save = p.red, newRoot = ( root === p );
0            p = (isRed(s[notDir]) ? rotateSingle : rotateDouble)(p, dir);
0            p.red = save;
0            p.left.red = p.right.red = 0;
0            if (newRoot) {
0                root = p;
             } else {
0                root[dir] = p;
             }
0            done.done = true;
         }
     }
0    return root;
 };
1var RedBlackTree;
 /**
  * @class <p>A RedBlack tree is a form of a self balancing binary tree.</p>
  *
  * <b>Performance</b>
  * <table>
  *     <tr><td></td><td>Best</td><td>Worst</td></tr>
  *     <tr><td>Space</td><td>O(n)</td><td>O(n)</td></tr>
  *     <tr><td>Search</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Insert</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Delete</td><td>O(log n)</td><td>O(log n)</td></tr>
  * <table>
  *     @name RedBlackTree
  * @augments comb.collections.Tree
  * @memberOf comb.collections
  * @ignoreCode
  */
1module.exports = exports  = define(Tree, {
     instance : {
         /**@lends comb.collections.RedBlackTree.prototype*/
         insert : function(data) {
0            this.__root = insert(this.__root, data, this.compare);
0            this.__root.red = false;
         },
 
         remove : function(data) {
0            var done = {done : false};
0            var root = remove(this.__root, data, done, this.compare);
0            if (root != null)
0                root.red = 0;
0            this.__root = root;
         },
 
 
         __printNode : function(node, level) {
0            var str = [];
0            if (node == null || node == undefined) {
0                str.push(multiply('\t', level));
0                str.push("~");
0                console.log(str.join(""));
             } else {
0                this.__printNode(node.right, level + 1);
0                str.push(multiply('\t', level));
0                str.push((node.red ? "RED" : "BLACK") + ":" + node.data + "\n");
0                console.log(str.join(""));
0                this.__printNode(node.left, level + 1);
             }
         }
 
     }
 });
 

1var define = require("../define").define,
         Tree = require("./Tree"),
         base = require("../base"),
         multiply = base.string.multiply;
 
1var abs = Math.abs;
 
 
 
1var makeNode = function(data) {
0    return {
         data : data,
         balance : 0,
         left : null,
         right : null
     }
 };
 
1var rotateSingle = function(root, dir, otherDir) {
0    var save = root[otherDir];
0    root[otherDir] = save[dir];
0    save[dir] = root;
0    return save;
 };
 
 
1var rotateDouble = function(root, dir, otherDir) {
0    root[otherDir] = rotateSingle(root[otherDir], otherDir, dir);
0    return rotateSingle(root, dir, otherDir);
 };
 
1var adjustBalance = function(root, dir, bal) {
0    var otherDir = dir == "left" ? "right" : "left";
0    var n = root[dir], nn = n[otherDir];
0    if (nn.balance == 0)
0        root.balance = n.balance = 0;
0    else if (nn.balance == bal) {
0        root.balance = -bal;
0        n.balance = 0;
     }
     else { /* nn.balance == -bal */
0        root.balance = 0;
0        n.balance = bal;
     }
0    nn.balance = 0;
 };
 
1var insertAdjustBalance = function(root, dir) {
0    var otherDir = dir == "left" ? "right" : "left";
 
0    var n = root[dir];
0    var bal = dir == "left" ? -1 : +1;
 
0    if (n.balance == bal) {
0        root.balance = n.balance = 0;
0        root = rotateSingle(root, otherDir, dir);
     }
     else {
0        adjustBalance(root, dir, bal);
0        root = rotateDouble(root, otherDir, dir);
     }
 
0    return root;
 
 };
 
1var removeAdjustBalance = function(root, dir, done) {
0    var otherDir = dir == "left" ? "right" : "left";
0    var n = root[otherDir];
0    var bal = dir == "left" ? -1 : 1;
0    if (n.balance == -bal) {
0        root.balance = n.balance = 0;
0        root = rotateSingle(root, dir, otherDir);
     }
0    else if (n.balance == bal) {
0        adjustBalance(root, otherDir, -bal);
0        root = rotateDouble(root, dir, otherDir);
     }
     else { /* n.balance == 0 */
0        root.balance = -bal;
0        n.balance = bal;
0        root = rotateSingle(root, dir, otherDir);
0        done.done = true;
     }
0    return root;
 };
 
1var insert = function(root, data, done, compare) {
0    if (root == null || root == undefined)
0        root = makeNode(data);
     else {
0        var dir = compare(data, root.data) == -1 ? "left" : "right";
0        root[dir] = insert(root[dir], data, done, compare);
 
0        if (!done.done) {
             /* Update balance factors */
0            root.balance += dir == "left" ? -1 : 1;
             /* Rebalance as necessary and terminate */
0            if (root.balance == 0)
0                done.done = true;
0            else if (abs(root.balance) > 1) {
0                root = insertAdjustBalance(root, dir);
0                done.done = true;
             }
         }
     }
 
0    return root;
 };
 
1var remove = function(root, data, done, compare) {
0    var dir, cmp, save, b;
0    if (root) {
         //Remove node
0        cmp = compare(data, root.data);
0        if (cmp === 0) {
             // Unlink and fix parent
0            var l = root.left, r = root.right;
0            if (!l || !r) {
0                dir = !l ? "right" : "left";
0                save = root[dir];
0                return save;
             }
             else {
0                var heir = l, r;
0                while ((r = heir.right) != null) {
0                    heir = r;
                 }
0                root.data = heir.data;
                 //reset and start searching
0                data = heir.data;
             }
         }
0        dir = compare(root.data, data) == -1 ? "right" : "left";
0        root[dir] = remove(root[dir], data, done, compare);
0        if (!done.done) {
             /* Update balance factors */
0            b = (root.balance += (dir == "left" ? 1 : -1));
             /* Terminate or rebalance as necessary */
0            var a = abs(b);
0            if (a === 1)
0                done.done = true;
0            else if (a > 1)
0                root = removeAdjustBalance(root, dir, done);
         }
     }
0    return root;
 };
 
 
 /**
  * @ignoreCode
  * @class <p>An AVL tree is a self-balancing binary search tree.
  *    In an AVL tree, the heights of the two child subtrees of any node differ by at most one.
  *    Lookup, insertion, and deletion all take O(log n) time in both the average and worst cases,
  *    where n is the number of nodes in the tree prior to the operation.
  *    Insertions and deletions may require the tree to be rebalanced by one or more tree rotations.</p>
  * <p>AVL trees are more rigidly balanced than red-black trees, leading to slower insertion and removal but faster retrieval</p>
  *
  * <b>Performance</b>
  * <table>
  *     <tr><td></td><td>Best</td><td>Worst</td></tr>
  *     <tr><td>Space</td><td>O(n)</td><td>O(n)</td></tr>
  *     <tr><td>Search</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Insert</td><td>O(log n)</td><td>O(log n)</td></tr>
  *     <tr><td>Delete</td><td>O(log n)</td><td>O(log n)</td></tr>
  * <table>
  * @name AVLTree
  * @augments comb.collections.Tree
  * @memberOf comb.collections
  */
1module.exports = exports  = define(Tree, {
     instance : {
         /**@lends comb.collections.AVLTree.prototype*/
 
         insert : function(data) {
0            var done = {done : false};
0            this.__root = insert(this.__root, data, done, this.compare);
         },
 
 
         remove : function(data) {
0            this.__root = remove(this.__root, data, {done : false}, this.compare);
         },
 
         __printNode : function(node, level) {
0            var str = [];
0            if (node == null) {
0                str.push(multiply('\t', level));
0                str.push("~");
0                console.log(str.join(""));
             } else {
0                this.__printNode(node.right, level + 1);
0                str.push(multiply('\t', level));
0                str.push(node.data + ":" + node.balance + "\n");
0                console.log(str.join(""));
0                this.__printNode(node.left, level + 1);
             }
         }
 
     }
 });