dojo._xdResourceLoaded({
depends: [["provide", "dojox.dtl.tag.logic"],
["require", "dojox.dtl._base"]],
defineResource: function(dojo){if(!dojo._hasResource["dojox.dtl.tag.logic"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.dtl.tag.logic"] = true;
dojo.provide("dojox.dtl.tag.logic");

dojo.require("dojox.dtl._base");

dojox.dtl.tag.logic.IfNode = function(bools, trues, falses, type){
	this.bools = bools;
	this.trues = trues;
	this.falses = falses;
	this.type = type;
}
dojo.extend(dojox.dtl.tag.logic.IfNode, {
	render: function(context, buffer){
		if(this.type == "or"){
			for(var i = 0, bool; bool = this.bools[i]; i++){
				var ifnot = bool[0];
				var filter = bool[1];
				var value = filter.resolve(context);
				if((value && !ifnot) || (ifnot && !value)){
					if(this.falses){
						buffer = this.falses.unrender(context, buffer);
					}
					return this.trues.render(context, buffer, this);
				}
				buffer = this.trues.unrender(context, buffer);
				if(this.falses)	return this.falses.render(context, buffer, this);
			}
		}else{
			for(var i = 0, bool; bool = this.bools[i]; i++){
				var ifnot = bool[0];
				var filter = bool[1];
				var value = filter.resolve(context);
				if(!((value && !ifnot) || (ifnot && !value))){
					if(this.trues){
						buffer = this.trues.unrender(context, buffer);
					}
					return this.falses.render(context, buffer, this);
				}
				buffer = this.falses.unrender(context, buffer);
				if(this.falses)	return this.trues.render(context, buffer, this);
			}
		}
		return buffer;
	},
	unrender: function(context, buffer){
		if(this.trues) buffer = this.trues.unrender(context, buffer);
		if(this.falses) buffer = this.falses.unrender(context, buffer);
		return buffer;
	},
	clone: function(buffer){
		var trues = this.trues;
		var falses = this.falses;
		if(trues){
			trues = trues.clone(buffer);
		}
		if(falses){
			falses = falses.clone(buffer);
		}
		return new this.constructor(this.bools, trues, falses, this.type);
	},
	toString: function(){ return "dojox.dtl.tag.logic.IfNode"; }
});

dojox.dtl.tag.logic.ForNode = function(assign, loop, reversed, nodelist){
	this.assign = assign;
	this.loop = loop;
	this.reversed = reversed;
	this.nodelist = nodelist;
	this.pool = [];
}
dojo.extend(dojox.dtl.tag.logic.ForNode, {
	render: function(context, buffer){
		var parentloop = {};
		if(context.forloop){
			parentloop = context.forloop;
		}
		var items = dojox.dtl.resolveVariable(this.loop, context);
		context.push();
		for(var i = items.length; i < this.pool.length; i++){
			this.pool[i].unrender(context, buffer);
		}
		if(this.reversed){
			items = items.reversed();
		}
		var j = 0;
		for(var i in items){
			var item = items[i];
			context.forloop = {
				key: i,
				counter0: j,
				counter: j + 1,
				revcounter0: items.length - j - 1,
				revcounter: items.length - j,
				first: j == 0,
				parentloop: parentloop
			};
			context[this.assign] = item;
			if(j + 1 > this.pool.length){
				this.pool.push(this.nodelist.clone(buffer));
		 	}
			buffer = this.pool[j].render(context, buffer, this);
			++j;
		}
		context.pop();
		return buffer;
	},
	unrender: function(context, buffer){
		for(var i = 0, pool; pool = this.pool[i]; i++){
			buffer = pool.unrender(context, buffer);
		}
		return buffer;
	},
	clone: function(buffer){
		return new this.constructor(this.assign, this.loop, this.reversed, this.nodelist.clone(buffer));
	},
	toString: function(){ return "dojox.dtl.tag.logic.ForNode"; }
});

dojox.dtl.tag.logic.if_ = function(parser, text){
	var parts = text.split(/\s+/g);
	var type;
	var bools = [];
	parts.shift();
	text = parts.join(" ");
	parts = text.split(" and ");
	if(parts.length == 1){
		type = "or";
		parts = text.split(" or ");
	}else{
		type = "and";
		for(var i = 0; i < parts.length; i++){
			if(parts[i] == "or"){
				throw new Error("'if' tags can't mix 'and' and 'or'");
			}
		}
	}
	for(var i = 0, part; part = parts[i]; i++){
		var not = false;
		if(part.indexOf("not ") == 0){
			part = part.substring(4);
			not = true;
		}
		bools.push([not, new dojox.dtl.Filter(part)]);
	}
	var trues = parser.parse(["else", "endif"]);
	var falses = false;
	var token = parser.next();
	if(token.text == "else"){
		var falses = parser.parse(["endif"]);
		parser.next();
	}
	return new dojox.dtl.tag.logic.IfNode(bools, trues, falses, type);
}

dojox.dtl.tag.logic.for_ = function(parser, text){
	var parts = text.split(/\s+/g);
	var reversed = parts.length == 5;
	var nodelist = parser.parse(["endfor"]);
	parser.next();
	return new dojox.dtl.tag.logic.ForNode(parts[1], parts[3], reversed, nodelist);
}

}

}});