set.js

'use strict';
var inherits     = require('util').inherits
var EventEmitter = require('events').EventEmitter
var Row          = require('./row')
var between      = require('between')

inherits(Set, EventEmitter)

module.exports = Set

//set
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/*
  a set is just a query.
  could expand this to enable replicating a subset of a document.
  that could enable massive documents that are too large to fit in memory.
  as long as they could be partitioned.

  heh, join queries? or rather, recursive queries,
  for when rows have sets.

  that is my vibe. don't make a database you have to
  _map_ to your application. pre-map the database.

  could also specify sets like

  //set of all things
  {type: 'thing'}

  //set of things with thier parts
  { type: 'thing',
    parts: {
      parent_id: function (val) {return val == this.id}
    }
  }

  or use map-reduces. remember, if the the reduce is
  monotonic you don't have to remember each input.
*/

function Set(doc, key, value) {
  var array = this._array = []
  var rows = this.rows =  {}
  var set = this
  var filter

  if ('function' === typeof key) {
    filter = this.filter = key
    key = null
  } else {
    //DO NOT CHANGE once you have created the set.
    if(key === '__proto__') throw new Error('__proto__ is illegal key')
    this.key = key
    this.value = value
  }

  function add(row) {
    if (rows[row.id]) {
      return
    }

    array.push(row)
    rows[row.id] = row
    set.emit('add', row)

    function remove (_, changed) {
      if ((key && row.state[key] === value) ||
          (filter && filter(row.state))
      ) {
        set.emit('changes', row, changed)
        return
      }
      delete rows[row.id]
      var i = array.indexOf(row)
      if(~i) array.splice(i, 1)
      set.emit('changes', row, changed)
      set.emit('remove', row)
      row.removeListener('changes', remove)
    }

    row.on('changes', remove)

  }

  if (!filter) {
    doc.sets.on(key, function (row, changed) {
      if(changed[key] !== value) return
      add(row)
    })
  } else {
    doc.on('create', function (row) {
      if (filter(row.state)) {
        add(row)
      }
    })
  }


  this.rm = this.remove = function (row) {
    row = this.get(row)
    if(!row) return
    if (key) {
      return row.set(key, null)
    } else {
      throw new Error("Set cannot remove rows with arbitary filters")
    }
  }

  for(var id in doc.rows) {
    var row = doc.get(id)
    if (key && row.get(key) === value) {
      add(row)
    } else if (filter && filter(row.state)) {
      add(row)
    }
  }

  this.setMaxListeners(Infinity)

}

Set.prototype.onEach = function (callback) {
  this.forEach(callback)
  this.on("add", callback)
}

Set.prototype.asArray = function () {
  return this._array
}

Set.prototype.toJSON = function () {
  return this._array.map(function (e) {
    return e.state
  }).sort(function (a, b) {
    return between.strord(a._sort || a.id, b._sort || b.id)
  })
}

Set.prototype.each =
Set.prototype.forEach = function (iter) {
  return this._array.forEach(iter)
}

Set.prototype.get = function (id) {
  if(!arguments.length)
    return this.array
  if(id === '__proto__') throw new Error('__proto__ is invalid id')
  return (
      'string' === typeof id ? this.rows[id]
    : 'number' === typeof id ? this.rows[id]
    : id && id.id            ? this.rows[id.id]
    :                          null
  )
}

Set.prototype.has = function (row) {
  return this.get(row)
}