whole_func_string: function(sorters, direction, where, doSort) {
          var me = this,
              sorter,
              newSorters;
  
          if (Ext.isArray(sorters)) {
              doSort = where;
              where = direction;
              newSorters = sorters;
          }
          else if (Ext.isObject(sorters)) {
              doSort = where;
              where = direction;
              newSorters = [sorters];
          }
          else if (Ext.isString(sorters)) {
              sorter = me.sorters.get(sorters);
  
              if (!sorter) {
                  sorter = {
                      property : sorters,
                      direction: direction
                  };
                  newSorters = [sorter];
              }
              else if (direction === undefined) {
                  sorter.toggle();
              }
              else {
                  sorter.setDirection(direction);
              }
          }
  
          if (newSorters && newSorters.length) {
              newSorters = me.decodeSorters(newSorters);
              if (Ext.isString(where)) {
                  if (where === 'prepend') {
                      me.sorters.insert(0, newSorters);
                  }
                  else {
                      me.sorters.addAll(newSorters);
                  }
              }
              else {
                  me.sorters.clear();
                  me.sorters.addAll(newSorters);
              }
          }
  
          if (doSort !== false) {
              me.fireEvent('beforesort', me, newSorters);
              me.onBeforeSort(newSorters);
              
              sorters = me.sorters.items;
              if (sorters.length) {
                  // Sort using a generated sorter function which combines all of the Sorters passed
                  me.doSort(me.generateComparator());
              }
          }
  
          return sorters;
      }
func_code_string: function(sorters, direction, where, doSort) {
          var me = this,
              sorter,
              newSorters;
  
          if (Ext.isArray(sorters)) {
              doSort = where;
              where = direction;
              newSorters = sorters;
          }
          else if (Ext.isObject(sorters)) {
              doSort = where;
              where = direction;
              newSorters = [sorters];
          }
          else if (Ext.isString(sorters)) {
              sorter = me.sorters.get(sorters);
  
              if (!sorter) {
                  sorter = {
                      property : sorters,
                      direction: direction
                  };
                  newSorters = [sorter];
              }
              else if (direction === undefined) {
                  sorter.toggle();
              }
              else {
                  sorter.setDirection(direction);
              }
          }
  
          if (newSorters && newSorters.length) {
              newSorters = me.decodeSorters(newSorters);
              if (Ext.isString(where)) {
                  if (where === 'prepend') {
                      me.sorters.insert(0, newSorters);
                  }
                  else {
                      me.sorters.addAll(newSorters);
                  }
              }
              else {
                  me.sorters.clear();
                  me.sorters.addAll(newSorters);
              }
          }
  
          if (doSort !== false) {
              me.fireEvent('beforesort', me, newSorters);
              me.onBeforeSort(newSorters);
              
              sorters = me.sorters.items;
              if (sorters.length) {
                  // Sort using a generated sorter function which combines all of the Sorters passed
                  me.doSort(me.generateComparator());
              }
          }
  
          return sorters;
      }
func_documentation_string: Sorts the data in the Store by one or more of its properties. Example usage:
  
  //sort by a single field
  myStore.sort('myField', 'DESC');
  
  //sorting by multiple fields
  myStore.sort([
  {
  property : 'age',
  direction: 'ASC'
  },
  {
  property : 'name',
  direction: 'DESC'
  }
  ]);
  
  Internally, Store converts the passed arguments into an array of {@link Ext.util.Sorter} instances, and delegates
  the actual sorting to its internal {@link Ext.util.MixedCollection}.
  
  When passing a single string argument to sort, Store maintains a ASC/DESC toggler per field, so this code:
  
  store.sort('myField');
  store.sort('myField');
  
  Is equivalent to this code, because Store handles the toggling automatically:
  
  store.sort('myField', 'ASC');
  store.sort('myField', 'DESC');
  
  @param {String/Ext.util.Sorter[]} [sorters] Either a string name of one of the fields in this Store's configured
  {@link Ext.data.Model Model}, or an array of sorter configurations.
  @param {String} [direction="ASC"] The overall direction to sort the data by.
  @return {Ext.util.Sorter[]}