pipeline.js

DoWhile

function
DoWhile()

Option name Type Description
confg Object

configuration object

Each time split context for current step and use it in current stage
it is differs from sequential and parallel because it is not combining, stage and not limited to any number of iteration

config as Object

  • stage

      evaluating stage
    
  • split

      function that split existing stage into smalls parts, it needed
    
function DoWhile(config) {

	var self = this;

	if (!(self instanceof DoWhile)) {
		throw new Error('constructor is not a function');
	}

	if (config && config.run instanceof Function) {
		config.stage = new Stage(config.run);
		delete config.run;
	}

	Stage.apply(self, arguments);

	if (!config) {
		config = {};
	}

	if (config instanceof Stage) {
		config = {
			stage: config
		};
	}

stage, split, reachEnd, combine

if (config.stage instanceof Stage) {
	self.stage = config.stage;
} else {
	if (config.stage instanceof Function) {
		self.stage = new Stage(config.stage);
	} else {
		self.stage = new Empty();
	}
}

if (config.split instanceof Function) {
	self.split = config.split;
}

if (config.reachEnd instanceof Function) {
	self.reachEnd = config.reachEnd;
}

self.name = config.name;
}

stage

property
DoWhile.prototype.stage

internal declaration fo stage

DoWhile.prototype.stage = undefined;

split

method
DoWhile.prototype.split()

internal declaration fo split

DoWhile.prototype.split = function(ctx, iter) {
	return ctx;
};

reachEnd

method
DoWhile.prototype.reachEnd()

internal declaration fo reachEnd

DoWhile.prototype.reachEnd = function(err, ctx, iter) {
	return true;
};

reportName

method
DoWhile.prototype.reportName()

override of reportName

DoWhile.prototype.reportName = function() {
	var self = this;
	return "WHI:" + self.name;
};

compile

method
DoWhile.prototype.compile()

override of compile
split context one by one and run each after another

DoWhile.prototype.compile = function() {
	var self = this;
	if (!self.name) {
		self.name = self.stage.reportName();
	}
	var run = function(err, ctx, done) {
		var iter = -1;
		var next = function(err, retCtx) {
			iter++;
			if (self.reachEnd(err, ctx, iter)) {
				done(err);
			} else {
				self.stage.execute(self.split(ctx, iter), next);
			}
		};
		next();
	};
	self.run = run;
};

execute

method
DoWhile.prototype.execute()

Option name Type Description
context Context

evaluating context

[callback] Context

returning callback

override of execute

DoWhile.prototype.execute = function(context, callback) {
	var self = this;
	if (!self.run) {
		self.compile();
	}
	DoWhile.super_.prototype.execute.apply(self, arguments);
};