diff options
Diffstat (limited to 'library/jslider/js/jshashtable-2.1_src.js')
| -rw-r--r-- | library/jslider/js/jshashtable-2.1_src.js | 370 |
1 files changed, 0 insertions, 370 deletions
diff --git a/library/jslider/js/jshashtable-2.1_src.js b/library/jslider/js/jshashtable-2.1_src.js deleted file mode 100644 index 086f3de5b..000000000 --- a/library/jslider/js/jshashtable-2.1_src.js +++ /dev/null @@ -1,370 +0,0 @@ -/**
- * Copyright 2010 Tim Down.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * jshashtable
- *
- * jshashtable is a JavaScript implementation of a hash table. It creates a single constructor function called Hashtable
- * in the global scope.
- *
- * Author: Tim Down <tim@timdown.co.uk>
- * Version: 2.1
- * Build date: 21 March 2010
- * Website: http://www.timdown.co.uk/jshashtable
- */
-
-var Hashtable = (function() {
- var FUNCTION = "function";
-
- var arrayRemoveAt = (typeof Array.prototype.splice == FUNCTION) ?
- function(arr, idx) {
- arr.splice(idx, 1);
- } :
-
- function(arr, idx) {
- var itemsAfterDeleted, i, len;
- if (idx === arr.length - 1) {
- arr.length = idx;
- } else {
- itemsAfterDeleted = arr.slice(idx + 1);
- arr.length = idx;
- for (i = 0, len = itemsAfterDeleted.length; i < len; ++i) {
- arr[idx + i] = itemsAfterDeleted[i];
- }
- }
- };
-
- function hashObject(obj) {
- var hashCode;
- if (typeof obj == "string") {
- return obj;
- } else if (typeof obj.hashCode == FUNCTION) {
- // Check the hashCode method really has returned a string
- hashCode = obj.hashCode();
- return (typeof hashCode == "string") ? hashCode : hashObject(hashCode);
- } else if (typeof obj.toString == FUNCTION) {
- return obj.toString();
- } else {
- try {
- return String(obj);
- } catch (ex) {
- // For host objects (such as ActiveObjects in IE) that have no toString() method and throw an error when
- // passed to String()
- return Object.prototype.toString.call(obj);
- }
- }
- }
-
- function equals_fixedValueHasEquals(fixedValue, variableValue) {
- return fixedValue.equals(variableValue);
- }
-
- function equals_fixedValueNoEquals(fixedValue, variableValue) {
- return (typeof variableValue.equals == FUNCTION) ?
- variableValue.equals(fixedValue) : (fixedValue === variableValue);
- }
-
- function createKeyValCheck(kvStr) {
- return function(kv) {
- if (kv === null) {
- throw new Error("null is not a valid " + kvStr);
- } else if (typeof kv == "undefined") {
- throw new Error(kvStr + " must not be undefined");
- }
- };
- }
-
- var checkKey = createKeyValCheck("key"), checkValue = createKeyValCheck("value");
-
- /*----------------------------------------------------------------------------------------------------------------*/
-
- function Bucket(hash, firstKey, firstValue, equalityFunction) {
- this[0] = hash;
- this.entries = [];
- this.addEntry(firstKey, firstValue);
-
- if (equalityFunction !== null) {
- this.getEqualityFunction = function() {
- return equalityFunction;
- };
- }
- }
-
- var EXISTENCE = 0, ENTRY = 1, ENTRY_INDEX_AND_VALUE = 2;
-
- function createBucketSearcher(mode) {
- return function(key) {
- var i = this.entries.length, entry, equals = this.getEqualityFunction(key);
- while (i--) {
- entry = this.entries[i];
- if ( equals(key, entry[0]) ) {
- switch (mode) {
- case EXISTENCE:
- return true;
- case ENTRY:
- return entry;
- case ENTRY_INDEX_AND_VALUE:
- return [ i, entry[1] ];
- }
- }
- }
- return false;
- };
- }
-
- function createBucketLister(entryProperty) {
- return function(aggregatedArr) {
- var startIndex = aggregatedArr.length;
- for (var i = 0, len = this.entries.length; i < len; ++i) {
- aggregatedArr[startIndex + i] = this.entries[i][entryProperty];
- }
- };
- }
-
- Bucket.prototype = {
- getEqualityFunction: function(searchValue) {
- return (typeof searchValue.equals == FUNCTION) ? equals_fixedValueHasEquals : equals_fixedValueNoEquals;
- },
-
- getEntryForKey: createBucketSearcher(ENTRY),
-
- getEntryAndIndexForKey: createBucketSearcher(ENTRY_INDEX_AND_VALUE),
-
- removeEntryForKey: function(key) {
- var result = this.getEntryAndIndexForKey(key);
- if (result) {
- arrayRemoveAt(this.entries, result[0]);
- return result[1];
- }
- return null;
- },
-
- addEntry: function(key, value) {
- this.entries[this.entries.length] = [key, value];
- },
-
- keys: createBucketLister(0),
-
- values: createBucketLister(1),
-
- getEntries: function(entries) {
- var startIndex = entries.length;
- for (var i = 0, len = this.entries.length; i < len; ++i) {
- // Clone the entry stored in the bucket before adding to array
- entries[startIndex + i] = this.entries[i].slice(0);
- }
- },
-
- containsKey: createBucketSearcher(EXISTENCE),
-
- containsValue: function(value) {
- var i = this.entries.length;
- while (i--) {
- if ( value === this.entries[i][1] ) {
- return true;
- }
- }
- return false;
- }
- };
-
- /*----------------------------------------------------------------------------------------------------------------*/
-
- // Supporting functions for searching hashtable buckets
-
- function searchBuckets(buckets, hash) {
- var i = buckets.length, bucket;
- while (i--) {
- bucket = buckets[i];
- if (hash === bucket[0]) {
- return i;
- }
- }
- return null;
- }
-
- function getBucketForHash(bucketsByHash, hash) {
- var bucket = bucketsByHash[hash];
-
- // Check that this is a genuine bucket and not something inherited from the bucketsByHash's prototype
- return ( bucket && (bucket instanceof Bucket) ) ? bucket : null;
- }
-
- /*----------------------------------------------------------------------------------------------------------------*/
-
- function Hashtable(hashingFunctionParam, equalityFunctionParam) {
- var that = this;
- var buckets = [];
- var bucketsByHash = {};
-
- var hashingFunction = (typeof hashingFunctionParam == FUNCTION) ? hashingFunctionParam : hashObject;
- var equalityFunction = (typeof equalityFunctionParam == FUNCTION) ? equalityFunctionParam : null;
-
- this.put = function(key, value) {
- checkKey(key);
- checkValue(value);
- var hash = hashingFunction(key), bucket, bucketEntry, oldValue = null;
-
- // Check if a bucket exists for the bucket key
- bucket = getBucketForHash(bucketsByHash, hash);
- if (bucket) {
- // Check this bucket to see if it already contains this key
- bucketEntry = bucket.getEntryForKey(key);
- if (bucketEntry) {
- // This bucket entry is the current mapping of key to value, so replace old value and we're done.
- oldValue = bucketEntry[1];
- bucketEntry[1] = value;
- } else {
- // The bucket does not contain an entry for this key, so add one
- bucket.addEntry(key, value);
- }
- } else {
- // No bucket exists for the key, so create one and put our key/value mapping in
- bucket = new Bucket(hash, key, value, equalityFunction);
- buckets[buckets.length] = bucket;
- bucketsByHash[hash] = bucket;
- }
- return oldValue;
- };
-
- this.get = function(key) {
- checkKey(key);
-
- var hash = hashingFunction(key);
-
- // Check if a bucket exists for the bucket key
- var bucket = getBucketForHash(bucketsByHash, hash);
- if (bucket) {
- // Check this bucket to see if it contains this key
- var bucketEntry = bucket.getEntryForKey(key);
- if (bucketEntry) {
- // This bucket entry is the current mapping of key to value, so return the value.
- return bucketEntry[1];
- }
- }
- return null;
- };
-
- this.containsKey = function(key) {
- checkKey(key);
- var bucketKey = hashingFunction(key);
-
- // Check if a bucket exists for the bucket key
- var bucket = getBucketForHash(bucketsByHash, bucketKey);
-
- return bucket ? bucket.containsKey(key) : false;
- };
-
- this.containsValue = function(value) {
- checkValue(value);
- var i = buckets.length;
- while (i--) {
- if (buckets[i].containsValue(value)) {
- return true;
- }
- }
- return false;
- };
-
- this.clear = function() {
- buckets.length = 0;
- bucketsByHash = {};
- };
-
- this.isEmpty = function() {
- return !buckets.length;
- };
-
- var createBucketAggregator = function(bucketFuncName) {
- return function() {
- var aggregated = [], i = buckets.length;
- while (i--) {
- buckets[i][bucketFuncName](aggregated);
- }
- return aggregated;
- };
- };
-
- this.keys = createBucketAggregator("keys");
- this.values = createBucketAggregator("values");
- this.entries = createBucketAggregator("getEntries");
-
- this.remove = function(key) {
- checkKey(key);
-
- var hash = hashingFunction(key), bucketIndex, oldValue = null;
-
- // Check if a bucket exists for the bucket key
- var bucket = getBucketForHash(bucketsByHash, hash);
-
- if (bucket) {
- // Remove entry from this bucket for this key
- oldValue = bucket.removeEntryForKey(key);
- if (oldValue !== null) {
- // Entry was removed, so check if bucket is empty
- if (!bucket.entries.length) {
- // Bucket is empty, so remove it from the bucket collections
- bucketIndex = searchBuckets(buckets, hash);
- arrayRemoveAt(buckets, bucketIndex);
- delete bucketsByHash[hash];
- }
- }
- }
- return oldValue;
- };
-
- this.size = function() {
- var total = 0, i = buckets.length;
- while (i--) {
- total += buckets[i].entries.length;
- }
- return total;
- };
-
- this.each = function(callback) {
- var entries = that.entries(), i = entries.length, entry;
- while (i--) {
- entry = entries[i];
- callback(entry[0], entry[1]);
- }
- };
-
- this.putAll = function(hashtable, conflictCallback) {
- var entries = hashtable.entries();
- var entry, key, value, thisValue, i = entries.length;
- var hasConflictCallback = (typeof conflictCallback == FUNCTION);
- while (i--) {
- entry = entries[i];
- key = entry[0];
- value = entry[1];
-
- // Check for a conflict. The default behaviour is to overwrite the value for an existing key
- if ( hasConflictCallback && (thisValue = that.get(key)) ) {
- value = conflictCallback(key, thisValue, value);
- }
- that.put(key, value);
- }
- };
-
- this.clone = function() {
- var clone = new Hashtable(hashingFunctionParam, equalityFunctionParam);
- clone.putAll(that);
- return clone;
- };
- }
-
- return Hashtable;
-})();
\ No newline at end of file |