[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('recordset-indexer', function (Y, NAME) {
   9  
  10  /**
  11   * Provides the ability to store multiple custom hash tables referencing records in the recordset.
  12   * @module recordset
  13   * @submodule recordset-indexer
  14   */
  15  /**
  16   * Plugin that provides the ability to store multiple custom hash tables referencing records in the recordset.
  17   * This utility does not support any collision handling. New hash table entries with a used key overwrite older ones.
  18   * @class RecordsetIndexer
  19   */
  20  function RecordsetIndexer(config) {
  21      RecordsetIndexer.superclass.constructor.apply(this, arguments);
  22  }
  23  
  24  Y.mix(RecordsetIndexer, {
  25      NS: "indexer",
  26  
  27      NAME: "recordsetIndexer",
  28  
  29      ATTRS: {
  30          /**
  31          * @description Collection of all the hashTables created by the plugin.
  32          * The individual tables can be accessed by the key they are hashing against.
  33          *
  34          * @attribute hashTables
  35          * @public
  36          * @type object
  37          */
  38          hashTables: {
  39              value: {
  40  
  41              }
  42          },
  43  
  44  
  45          keys: {
  46              value: {
  47  
  48              }
  49          }
  50      }
  51  });
  52  
  53  
  54  Y.extend(RecordsetIndexer, Y.Plugin.Base, {
  55  
  56      initializer: function(config) {
  57          var host = this.get('host');
  58  
  59          //setup listeners on recordset events
  60          this.onHostEvent('add', Y.bind("_defAddHash", this), host);
  61          this.onHostEvent('remove', Y.bind('_defRemoveHash', this), host);
  62          this.onHostEvent('update', Y.bind('_defUpdateHash', this), host);
  63  
  64      },
  65  
  66      destructor: function(config) {
  67  
  68      },
  69  
  70  
  71      /**
  72       * @description Setup the hash table for a given key with all existing records in the recordset
  73       *
  74       * @method _setHashTable
  75       * @param key {string} A key to hash by.
  76       * @return obj {object} The created hash table
  77       * @private
  78       */
  79      _setHashTable: function(key) {
  80          var host = this.get('host'),
  81          obj = {},
  82          i = 0,
  83          len = host.getLength();
  84  
  85          for (; i < len; i++) {
  86              obj[host._items[i].getValue(key)] = host._items[i];
  87          }
  88          return obj;
  89      },
  90  
  91      //---------------------------------------------
  92      // Syncing Methods
  93      //---------------------------------------------
  94  
  95      /**
  96       * @description Updates all hash tables when a record is added to the recordset
  97       *
  98       * @method _defAddHash
  99       * @private
 100       */
 101      _defAddHash: function(e) {
 102          var tbl = this.get('hashTables');
 103  
 104  
 105          //Go through every hashtable that is stored.
 106          //in each hashtable, look to see if the key is represented in the object being added.
 107          Y.each(tbl,
 108          function(v, key) {
 109              Y.each(e.added || e.updated,
 110              function(o) {
 111                  //if the object being added has a key which is being stored by hashtable v, add it into the table.
 112                  if (o.getValue(key)) {
 113                      v[o.getValue(key)] = o;
 114                  }
 115              });
 116          });
 117  
 118      },
 119  
 120      /**
 121       * @description Updates all hash tables when a record is removed from the recordset
 122       *
 123       * @method _defRemoveHash
 124       * @private
 125       */
 126      _defRemoveHash: function(e) {
 127          var tbl = this.get('hashTables'),
 128          reckey;
 129  
 130          //Go through every hashtable that is stored.
 131          //in each hashtable, look to see if the key is represented in the object being deleted.
 132          Y.each(tbl,
 133          function(v, key) {
 134              Y.each(e.removed || e.overwritten,
 135              function(o) {
 136                  reckey = o.getValue(key);
 137  
 138                  //if the hashtable has a key storing a record, and the key and the record both match the record being deleted, delete that row from the hashtable
 139                  if (reckey && v[reckey] === o) {
 140                      delete v[reckey];
 141                  }
 142              });
 143          });
 144      },
 145  
 146      /**
 147       * @description Updates all hash tables when the recordset is updated (a combination of add and remove)
 148       *
 149       * @method _defUpdateHash
 150       * @private
 151       */
 152      _defUpdateHash: function(e) {
 153  
 154          //TODO: It will be more performant to create a new method rather than using _defAddHash, _defRemoveHash, due to the number of loops. See commented code.
 155          e.added = e.updated;
 156          e.removed = e.overwritten;
 157          this._defAddHash(e);
 158          this._defRemoveHash(e);
 159  
 160          /*
 161                      var tbl = this.get('hashTables'), reckey;
 162  
 163                      Y.each(tbl, function(v, key) {
 164                          Y.each(e.updated, function(o, i) {
 165  
 166                              //delete record from hashtable if it has been overwritten
 167                              reckey = o.getValue(key);
 168  
 169                              if (reckey) {
 170                                  v[reckey] = o;
 171                              }
 172  
 173                              //the undefined case is if more records are updated than currently exist in the recordset.
 174                              if (e.overwritten[i] && (v[e.overwritten[i].getValue(key)] === e.overwritten[i])) {
 175                                  delete v[e.overwritten[i].getValue(key)];
 176                              }
 177  
 178                              // if (v[reckey] === o) {
 179                              //  delete v[reckey];
 180                              // }
 181                              //
 182                              // //add the new updated record if it has a key that corresponds to a hash table
 183                              // if (o.getValue(key)) {
 184                              //  v[o.getValue(key)] = o;
 185                              // }
 186  
 187                          });
 188                      });
 189              */
 190      },
 191  
 192      //---------------------------------------------
 193      // Public Methods
 194      //---------------------------------------------
 195  
 196      /**
 197       * @description Creates a new hash table.
 198       *
 199       * @method createTable
 200       * @param key {string} A key to hash by.
 201       * @return tbls[key] {object} The created hash table
 202       * @public
 203       */
 204      createTable: function(key) {
 205          var tbls = this.get('hashTables');
 206          tbls[key] = this._setHashTable(key);
 207          this.set('hashTables', tbls);
 208  
 209          return tbls[key];
 210      },
 211  
 212  
 213      /**
 214       * @description Get a hash table that hashes records by a given key.
 215       *
 216       * @method getTable
 217       * @param key {string} A key to hash by.
 218       * @return table {object} The created hash table
 219       * @public
 220       */
 221      getTable: function(key) {
 222          return this.get('hashTables')[key];
 223      }
 224  
 225  
 226  
 227  
 228  
 229  });
 230  Y.namespace("Plugin").RecordsetIndexer = RecordsetIndexer;
 231  
 232  
 233  
 234  }, '3.17.2', {"requires": ["recordset-base", "plugin"]});