1. module xml-stream
   1. function xml-stream (stream, encoding)
   2. function xml-stream.finite_automata ()
   3. function xml-stream.super_ ()
   4. function xml-stream.xml_stream (stream, encoding)
   5. object xml-stream.finite_automata.prototype
   6. object xml-stream.xml_stream.prototype
2. module xml-stream.finite_automata
   1. function xml-stream.finite_automata ()
3. module xml-stream.finite_automata.prototype
   1. function xml-stream.finite_automata.prototype.enter (symbol, args)
   2. function xml-stream.finite_automata.prototype.go (symbol, args)
   3. function xml-stream.finite_automata.prototype.isDeterministic ()
   4. function xml-stream.finite_automata.prototype.leave (args)
   5. function xml-stream.finite_automata.prototype.nextState (symbol)
   6. function xml-stream.finite_automata.prototype.on (type, state, cb)
   7. function xml-stream.finite_automata.prototype.run (state, args)
   8. function xml-stream.finite_automata.prototype.setState (state, args)
   9. function xml-stream.finite_automata.prototype.transition (stateFrom, symbol, stateTo)
4. module xml-stream.xml_stream
   1. function xml-stream.xml_stream (stream, encoding)
   2. function xml-stream.xml_stream.super_ ()
5. module xml-stream.xml_stream.prototype
   1. function xml-stream.xml_stream.prototype.collect (selector)
   2. function xml-stream.xml_stream.prototype.on (eventName, listener)
   3. function xml-stream.xml_stream.prototype.pause ()
   4. function xml-stream.xml_stream.prototype.preserve (selector, whitespace)
   5. function xml-stream.xml_stream.prototype.resume ()

module xml-stream

function xml-stream (stream, encoding)

• description and source-code

  function XmlStream(stream, encoding) {
    events.EventEmitter.call(this);
    this._stream = stream;
    this._fa = new FiniteAutomata();
    this._lastState = 0;
    this._startState = {};
    this._finalStates = {};
    this._emitData = false;
    this._bufferLevel = 0;
    this._preserveLevel = 0;
    this._preserveWhitespace = 0;
    this._preserveAll = false;
    this._collect = false;
    this._parser = undefined;
  
    // Set input stream encoding and create an iconv instance,
    // if conversion is required. Default working encoding is UTF-8,
    // so iconv is used when input is anything else, but UTF-8.
    this._encoding = encoding || null;
    this._encoder = makeEncoder(this._encoding);
  
    var scope = this;
  
    // Start parsing.
    process.nextTick(function () {
      parse.call(scope);
    });
  }

• example usage

  n/a

function xml-stream.finite_automata ()

• description and source-code

  function FiniteAutomata() {
    this._symbols = {};
    this._states = {};
    this._deterministic = true;
    this._state = {};
    this._callbacks = {
      enter: {},
      leave: {},
      state: {},
      flag: {}
    };
    this._stack = [];
    this._stackPtr = -1;
  }

• example usage

  n/a

function xml-stream.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

function xml-stream.xml_stream (stream, encoding)

• description and source-code

  function XmlStream(stream, encoding) {
    events.EventEmitter.call(this);
    this._stream = stream;
    this._fa = new FiniteAutomata();
    this._lastState = 0;
    this._startState = {};
    this._finalStates = {};
    this._emitData = false;
    this._bufferLevel = 0;
    this._preserveLevel = 0;
    this._preserveWhitespace = 0;
    this._preserveAll = false;
    this._collect = false;
    this._parser = undefined;
  
    // Set input stream encoding and create an iconv instance,
    // if conversion is required. Default working encoding is UTF-8,
    // so iconv is used when input is anything else, but UTF-8.
    this._encoding = encoding || null;
    this._encoder = makeEncoder(this._encoding);
  
    var scope = this;
  
    // Start parsing.
    process.nextTick(function () {
      parse.call(scope);
    });
  }

• example usage

  n/a

module xml-stream.finite_automata

function xml-stream.finite_automata ()

• description and source-code

  function FiniteAutomata() {
    this._symbols = {};
    this._states = {};
    this._deterministic = true;
    this._state = {};
    this._callbacks = {
      enter: {},
      leave: {},
      state: {},
      flag: {}
    };
    this._stack = [];
    this._stackPtr = -1;
  }

• example usage

  n/a

module xml-stream.finite_automata.prototype

function xml-stream.finite_automata.prototype.enter (symbol, args)

• description and source-code

  enter = function (symbol, args) {
    if (args == null) {
      args = [];
    }
    var next = this.nextState(symbol);
    this._stack[++this._stackPtr] = next;
    this._state = next;
    run.call(this, 'flag');
    run.call(this, 'enter', args);
    return this;
  }

• example usage

  n/a

function xml-stream.finite_automata.prototype.go (symbol, args)

• description and source-code

  go = function (symbol, args) {
    var next = this.nextState(symbol)
    this.setState(next, args);
    return this;
  }

• example usage

  n/a

function xml-stream.finite_automata.prototype.isDeterministic ()

• description and source-code

  isDeterministic = function () {
    return this._deterministic;
  }

• example usage

  n/a

function xml-stream.finite_automata.prototype.leave (args)

• description and source-code

  leave = function (args) {
    this._stack[this._stackPtr] = undefined;
    run.call(this, 'leave', args);
    this._state = this._stack[--this._stackPtr];
    return this;
  }

• example usage

  n/a

function xml-stream.finite_automata.prototype.nextState (symbol)

• description and source-code

  nextState = function (symbol) {
    var newState = {};
    for (var st in this._state) if (__own.call(this._state, st)) {
      if (__own.call(this._states, st)) {
        var next = this._states[st];
        if (__own.call(next, symbol)) {
          extend(newState, next[symbol]);
        }
        if (__own.call(next, '')) {
          extend(newState, (next['']));
        }
      }
    }
    return newState;
  }

• example usage

  ...
      }
    }
  }
  return newState;
  };
  
  FiniteAutomata.prototype.go = function(symbol, args) {
  var next = this.nextState(symbol)
  this.setState(next, args);
  return this;
  };
  
  FiniteAutomata.prototype.leave = function(args) {
  this._stack[this._stackPtr] = undefined;
  run.call(this, 'leave', args);
  ...

function xml-stream.finite_automata.prototype.on (type, state, cb)

• description and source-code

  on = function (type, state, cb) {
    if (!__own.call(this._callbacks, type)) {
      this._callbacks[type] = {};
    }
    var typeCbs = this._callbacks[type];
    if (!__own.call(typeCbs, state)) {
      typeCbs[state] = [];
    }
    typeCbs[state].push(cb);
    return this;
  }

• example usage

  ...
  
  By default, parsed element node contains children as properties. In the case
  of several children with same names, the last one would overwrite others.
  To collect all of *subitem* elements in an array use **collect**:
  
  ```javascript
  xml.collect('subitem');
  xml.on('endElement: item', function(item) {
    console.log(item);
  })
  ```
  
  # Preserving Elements and Text
  
  By default, element text is returned as one concatenated string. In this XML:
  ...

function xml-stream.finite_automata.prototype.run (state, args)

• description and source-code

  run = function (state, args) {
    run.call(this, state, args);
  }

• example usage

  n/a

function xml-stream.finite_automata.prototype.setState (state, args)

• description and source-code

  setState = function (state, args) {
    this._state = state;
    run.call(this, 'enter', args);
    run.call(this, 'state', args);
    return this;
  }

• example usage

  ...
    }
  }
  return newState;
  };
  
  FiniteAutomata.prototype.go = function(symbol, args) {
  var next = this.nextState(symbol)
  this.setState(next, args);
  return this;
  };
  
  FiniteAutomata.prototype.leave = function(args) {
  this._stack[this._stackPtr] = undefined;
  run.call(this, 'leave', args);
  this._state = this._stack[--this._stackPtr];
  ...

function xml-stream.finite_automata.prototype.transition (stateFrom, symbol, stateTo)

• description and source-code

  transition = function (stateFrom, symbol, stateTo) {
    this._symbols[symbol] = true;
    var s;
    if (__own.call(this._states, stateFrom)) {
      s = this._states[stateFrom];
    } else {
      s = this._states[stateFrom] = {};
    }
    var exists = __own.call(s, symbol);
    if (exists) {
      s = s[symbol];
    } else {
      s = s[symbol] = {};
    }
    if (!__own.call(s, stateTo)) {
      s[stateTo] = true;
      this._deterministic &= !exists;
    }
    return this;
  }

• example usage

  n/a

module xml-stream.xml_stream

function xml-stream.xml_stream (stream, encoding)

• description and source-code

  function XmlStream(stream, encoding) {
    events.EventEmitter.call(this);
    this._stream = stream;
    this._fa = new FiniteAutomata();
    this._lastState = 0;
    this._startState = {};
    this._finalStates = {};
    this._emitData = false;
    this._bufferLevel = 0;
    this._preserveLevel = 0;
    this._preserveWhitespace = 0;
    this._preserveAll = false;
    this._collect = false;
    this._parser = undefined;
  
    // Set input stream encoding and create an iconv instance,
    // if conversion is required. Default working encoding is UTF-8,
    // so iconv is used when input is anything else, but UTF-8.
    this._encoding = encoding || null;
    this._encoder = makeEncoder(this._encoding);
  
    var scope = this;
  
    // Start parsing.
    process.nextTick(function () {
      parse.call(scope);
    });
  }

• example usage

  n/a

function xml-stream.xml_stream.super_ ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

module xml-stream.xml_stream.prototype

function xml-stream.xml_stream.prototype.collect (selector)

• description and source-code

  collect = function (selector) {
    selector = normalizeSelector(selector);
    var finalState = getFinalState.call(this, selector);
    var self = this;
    this._fa.on('flag', finalState, function() {
      self._collect = true;
    });
  }

• example usage

  ...
  ```
  
  By default, parsed element node contains children as properties. In the case
  of several children with same names, the last one would overwrite others.
  To collect all of *subitem* elements in an array use **collect**:
  
  ```javascript
  xml.collect('subitem');
  xml.on('endElement: item', function(item) {
    console.log(item);
  })
  ```
  
  # Preserving Elements and Text
  ...

function xml-stream.xml_stream.prototype.on (eventName, listener)

• description and source-code

  on = function (eventName, listener) {
    var event = parseEvent(eventName);
    if (event !== null) {
      // If we're dealing with a selector event,
      // continue with selector-specific processing logic.
      XmlStream.super_.prototype.on.call(this, event.name, listener);
      var finalState = getFinalState.call(this, event.selector);
      var self = this;
      if (event.type === 'updateElement') {
        this._fa.on('enter', finalState, function() {
          self._bufferLevel++;
        });
        this._fa.on('leave', finalState, function(element, context, trace) {
          self.emit(event.name, element, context, trace);
          if (!--self._bufferLevel && self._emitData) {
             emitElement.call(self, element, self._name, true);
          }
        });
      } else {
        var fn = function(element, context, trace) {
          self.emit(event.name, element, context, trace);
        };
        this._fa.on(faModes[event.type], finalState, fn);
      }
    } else {
      // Otherwise, we're dealing with a non-selector event.
      if (eventName === 'data') {
        this._emitData = true;
      }
      XmlStream.super_.prototype.on.call(this, eventName, listener);
    }
  }

• example usage

  ...
  
  By default, parsed element node contains children as properties. In the case
  of several children with same names, the last one would overwrite others.
  To collect all of *subitem* elements in an array use **collect**:
  
  ```javascript
  xml.collect('subitem');
  xml.on('endElement: item', function(item) {
    console.log(item);
  })
  ```
  
  # Preserving Elements and Text
  
  By default, element text is returned as one concatenated string. In this XML:
  ...

function xml-stream.xml_stream.prototype.pause ()

• description and source-code

  pause = function () {
    this._stream.pause();
    this._suspended = true;
    if( !this._parser.pause() ) {
        throw(new Error("Cannot pause parser: "+this._parser.getError()));
    }
  }

• example usage

  ...
  ```
  
  # Pause and resume parsing
  
  If you want parsing to pause (for example, until some asynchronous operation
  of yours is finished), you can pause and resume XML parsing:
  ```javascript
  xml.pause();
  myAsyncFunction( function() {
    xml.resume();
  });
  ```
  Beware that resume() **must not** be called from within a handler callback.
  ...

function xml-stream.xml_stream.prototype.preserve (selector, whitespace)

• description and source-code

  preserve = function (selector, whitespace) {
    selector = normalizeSelector(selector);
    var finalState = getFinalState.call(this, selector);
    var self = this;
    this._fa.on('enter', finalState, function() {
      self._preserveLevel++;
      if (whitespace) {
        self._preserveWhitespace++;
      }
    });
    this._fa.on('leave', finalState, function() {
      self._preserveLevel--;
      if (whitespace) {
        self._preserveWhitespace--;
      }
    });
  }

• example usage

  ...
  ```
  
  The value of **$text** for *item* would be: `one 1 two 2` without any
  indication of the order of element *a*, element *b*, and text parts.
  To preserve this order:
  
  ```javascript
  xml.preserve('item');
  xml.on('endElement: item', function(item) {
    console.log(item);
  })
  ```
  
  # Pause and resume parsing
  ...

function xml-stream.xml_stream.prototype.resume ()

• description and source-code

  resume = function () {
    this._suspended = false;
  
    if( !this._parser.resume() ) {
      throw(new Error("Cannot resume parser: "+this._parser.getError()));
    }
  
    // resume stream only if parser hasn't been paused again
    if( !this._suspended ) {
      this._stream.resume();
    }
  }

• example usage

  ...
  # Pause and resume parsing
  
  If you want parsing to pause (for example, until some asynchronous operation
  of yours is finished), you can pause and resume XML parsing:
  ```javascript
  xml.pause();
  myAsyncFunction( function() {
    xml.resume();
  });
  ```
  Beware that resume() **must not** be called from within a handler callback.
  ...