elasticlunr

sorted_set.js is added only to make elasticlunr.js compatible with lunr-languages.
if elasticlunr.js support different languages by default, this will make elasticlunr.js
much bigger that not good for browser usage.

SortedSet

constructor
lunr.SortedSet()

lunr.SortedSets are used to maintain an array of uniq values in a sorted
order.

lunr.SortedSet = function () {
  this.length = 0
  this.elements = []
}

load

method
lunr.SortedSet.load()

Option name Type Description
serialisedData Array

The serialised set to load.

Loads a previously serialised sorted set.

lunr.SortedSet.load = function (serialisedData) {
  var set = new this

  set.elements = serialisedData
  set.length = serialisedData.length

  return set
}

add

method
lunr.SortedSet.prototype.add()

Option name Type Description
The Object

objects to add to this set.

Inserts new items into the set in the correct position to maintain the
order.

lunr.SortedSet.prototype.add = function () {
  var i, element

  for (i = 0; i < arguments.length; i++) {
    element = arguments[i]
    if (~this.indexOf(element)) continue
    this.elements.splice(this.locationFor(element), 0, element)
  }

  this.length = this.elements.length
}

toArray

method
lunr.SortedSet.prototype.toArray()

Converts this sorted set into an array.

lunr.SortedSet.prototype.toArray = function () {
  return this.elements.slice()
}

map

method
lunr.SortedSet.prototype.map()

Option name Type Description
fn Function

The function that is called on each element of the set.

ctx Object

An optional object that can be used as the context for the function fn.

Creates a new array with the results of calling a provided function on every
element in this sorted set.

Delegates to Array.prototype.map and has the same signature.

lunr.SortedSet.prototype.map = function (fn, ctx) {
  return this.elements.map(fn, ctx)
}

forEach

method
lunr.SortedSet.prototype.forEach()

Option name Type Description
fn Function

The function that is called on each element of the set.

ctx Object

An optional object that can be used as the context

Executes a provided function once per sorted set element.

Delegates to Array.prototype.forEach and has the same signature.

lunr.SortedSet.prototype.forEach = function (fn, ctx) {
  return this.elements.forEach(fn, ctx)
}

indexOf

method
lunr.SortedSet.prototype.indexOf()

Option name Type Description
elem Object

The object to locate in the sorted set.

Returns the index at which a given element can be found in the
sorted set, or -1 if it is not present.

lunr.SortedSet.prototype.indexOf = function (elem) {
  var start = 0,
      end = this.elements.length,
      sectionLength = end - start,
      pivot = start + Math.floor(sectionLength / 2),
      pivotElem = this.elements[pivot]

  while (sectionLength > 1) {
    if (pivotElem === elem) return pivot

    if (pivotElem < elem) start = pivot
    if (pivotElem > elem) end = pivot

    sectionLength = end - start
    pivot = start + Math.floor(sectionLength / 2)
    pivotElem = this.elements[pivot]
  }

  if (pivotElem === elem) return pivot

  return -1
}

locationFor

method
lunr.SortedSet.prototype.locationFor()

Option name Type Description
elem Object

The elem to find the position for in the set

Returns the position within the sorted set that an element should be
inserted at to maintain the current order of the set.

This function assumes that the element to search for does not already exist
in the sorted set.

lunr.SortedSet.prototype.locationFor = function (elem) {
  var start = 0,
      end = this.elements.length,
      sectionLength = end - start,
      pivot = start + Math.floor(sectionLength / 2),
      pivotElem = this.elements[pivot]

  while (sectionLength > 1) {
    if (pivotElem < elem) start = pivot
    if (pivotElem > elem) end = pivot

    sectionLength = end - start
    pivot = start + Math.floor(sectionLength / 2)
    pivotElem = this.elements[pivot]
  }

  if (pivotElem > elem) return pivot
  if (pivotElem < elem) return pivot + 1
}

intersect

method
lunr.SortedSet.prototype.intersect()

Option name Type Description
otherSet lunr.SortedSet

The set to intersect with this set.

Creates a new lunr.SortedSet that contains the elements in the intersection
of this set and the passed set.

lunr.SortedSet.prototype.intersect = function (otherSet) {
  var intersectSet = new lunr.SortedSet,
      i = 0, j = 0,
      a_len = this.length, b_len = otherSet.length,
      a = this.elements, b = otherSet.elements

  while (true) {
    if (i > a_len - 1 || j > b_len - 1) break

    if (a[i] === b[j]) {
      intersectSet.add(a[i])
      i++, j++
      continue
    }

    if (a[i] < b[j]) {
      i++
      continue
    }

    if (a[i] > b[j]) {
      j++
      continue
    }
  };

  return intersectSet
}

clone

method
lunr.SortedSet.prototype.clone()

Makes a copy of this set

lunr.SortedSet.prototype.clone = function () {
  var clone = new lunr.SortedSet

  clone.elements = this.toArray()
  clone.length = clone.elements.length

  return clone
}

union

method
lunr.SortedSet.prototype.union()

Option name Type Description
otherSet lunr.SortedSet

The set to union with this set.

Creates a new lunr.SortedSet that contains the elements in the union
of this set and the passed set.

lunr.SortedSet.prototype.union = function (otherSet) {
  var longSet, shortSet, unionSet

  if (this.length >= otherSet.length) {
    longSet = this, shortSet = otherSet
  } else {
    longSet = otherSet, shortSet = this
  }

  unionSet = longSet.clone()

  for(var i = 0, shortSetElements = shortSet.toArray(); i < shortSetElements.length; i++){
    unionSet.add(shortSetElements[i])
  }

  return unionSet
}

toJSON

method
lunr.SortedSet.prototype.toJSON()

Returns a representation of the sorted set ready for serialisation.

lunr.SortedSet.prototype.toJSON = function () {
  return this.toArray()
}