mungedb-aggregate/lib/pipeline/expressions/NaryExpression.js

"use strict";

/**
 * The base class for all n-ary `Expression`s
 * @class NaryExpression
 * @namespace mungedb-aggregate.pipeline.expressions
 * @module mungedb-aggregate
 * @extends mungedb-aggregate.pipeline.expressions.Expression
 * @constructor
 **/
var Expression = require("./Expression");

var NaryExpression = module.exports = function NaryExpression(){
	if (arguments.length !== 0) throw new Error("Zero args expected");
	this.operands = [];
	base.call(this);
}, klass = NaryExpression, base = Expression, proto = klass.prototype = Object.create(base.prototype, {constructor:{value:klass}});

klass.parse = function(SubClass) {
	return function parse(expr, vps) {
		var outExpr = new SubClass(),
			args = NaryExpression.parseArguments(expr, vps);
		outExpr.validateArguments(args);
		outExpr.operands = args;
		return outExpr;
	};
};

klass.parseArguments = function(exprElement, vps) {
	var out = [];
	if(exprElement instanceof Array) {
		for(var ii = 0; ii < exprElement.length; ii++) {
			out.push(Expression.parseOperand(exprElement[ii], vps));
		}
	} else {
		out.push(Expression.parseOperand(exprElement, vps));
	}
	return out;
};


function partitionBy(fn, coll) {
	var ret = {pass:[],
			   fail:[]};
	coll.forEach(function(x) {
		if(fn(x)) {
			ret.pass.push(x);
		} else {
			ret.fail.push(x);
		}
	});
	return ret;
}
// DEPENDENCIES
var ConstantExpression = require("./ConstantExpression");

// PROTOTYPE MEMBERS
proto.evaluate = undefined; // evaluate(doc){ ... defined by inheritor ... }

proto.getOpName = function getOpName(doc){
	throw new Error("NOT IMPLEMENTED BY INHERITOR");
};

proto.optimize = function optimize(){
	var n = this.operands.length,
		constantCount = 0;

	for(var ii = 0; ii < n; ii++) {
		if(this.operands[ii] instanceof ConstantExpression) {
			constantCount++;
		} else {
			this.operands[ii] = this.operands[ii].optimize();
						}
					}

	if(constantCount === n) {
		return new ConstantExpression(this.evaluateInternal({}));
				}

	if(!this.isAssociativeAndCommutative) {
		return this;
	}

	// Flatten and inline nested operations of the same type

	var similar = partitionBy(function(x){ return x.getOpName() === this.getOpName();}, this.operands);

	this.operands = similar.fail;
	similar.pass.forEach(function(x){
		this.operands.concat(x.operands);
	});

	// Partial constant folding

	var constantOperands = partitionBy(function(x) {return x instanceof ConstantExpression;}, this.operands);

	this.operands = constantOperands.pass;
	this.operands = [new ConstantExpression(this.evaluateInternal({}))].concat(constantOperands.fail);

	return this;
};

proto.addDependencies = function addDependencies(deps){
	for(var i = 0, l = this.operands.length; i < l; ++i)
		this.operands[i].addDependencies(deps);
};

/**
 * Add an operand to the n-ary expression.
 * @method addOperand
 * @param pExpression the expression to add
 **/
proto.addOperand = function addOperand(expr) {
	this.operands.push(expr);
};

proto.serialize = function serialize() {
	var ret = {}, subret = [];
	for(var ii = 0; ii < this.operands.length; ii++) {
		subret.push(this.operands[ii].serialize());
	}
	ret[this.getOpName()] = subret;
	return ret;
};

proto.fixedArity = function(nargs) {
	this.nargs = nargs;
};

proto.validateArguments = function(args) {
	if(this.nargs !== args.length) {
		throw new Error("Expression " + this.getOpName() + " takes exactly " + this.nargs + " arguments. " + args.length + " were passed in.");
	}
};