analytics/webcontent/common/framework/objectModel/parameters.js

/*
 *+------------------------------------------------------------------------+
 *| Licensed Materials - Property of IBM
 *| IBM Cognos Products: Viewer
 *| (C) Copyright IBM Corp. 2001, 2011
 *|
 *| US Government Users Restricted Rights - Use, duplication or
 *| disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 *|
 *+------------------------------------------------------------------------+
 */

function CParameterValueStringOperators(sBetween, sNotBetween, sLessThan, sGreaterThan)
{
	this.m_sBetween = sBetween;
	this.m_sNotBetween = sNotBetween;
	this.m_sLessThan = sLessThan;
	this.m_sGreaterThan = sGreaterThan;
}

function CParameterValues()
{
	this.m_parameterValues = new CDictionary();
}

CParameterValues.prototype.length = function()
{
	var parameterValues = this.m_parameterValues.keys();
	if(typeof parameterValues == "undefined" || parameterValues == null) {
		return 0;
	}

	return parameterValues.length;
};

CParameterValues.prototype.getParameterValue = function(name)
{
	if(typeof name != "string" || name == "") {
		return null;
	}

	if(this.m_parameterValues.exists(name)) {
		return this.m_parameterValues.get(name);
	}
	return null;
};

CParameterValues.prototype.getAt = function(index)
{
	if(index < this.length())
	{
		var parameterValues = this.m_parameterValues.keys();
		if(this.m_parameterValues.exists(parameterValues[index]))
		{
			return this.m_parameterValues.get(parameterValues[index]);
		}
	}

	return null;
};

CParameterValues.prototype.addParameterValue = function(paramName, parmValueItem)
{
	var parameterValue = this.getParameterValue(paramName);
	if(parameterValue == null)
	{
		parameterValue = new CParameterValue();
		parameterValue.setName(paramName);
	}

	parameterValue.addParmValueItem(parmValueItem);
	this.m_parameterValues.add(paramName, parameterValue);
};

CParameterValues.prototype.removeParameterValue = function(name)
{
	return (this.m_parameterValues.remove(name) != null);
};

CParameterValues.prototype.removeSimpleParmValueItem = function(name, useValue)
{
	var parameterValue = this.getParameterValue(name);
	if(parameterValue == null) {
		return false;
	}

	return parameterValue.removeSimpleParmValueItem(useValue);
};

CParameterValues.prototype.addSimpleParmValueItem = function(name, useValue, displayValue, inclusiveValue)
{
	// validate the parameter name (must be a string, and it must contain something)
	if(typeof name != "string" || name == "") {
		return null;
	}

	// validate the use value (must be a string, and it must contain something)
	if(typeof useValue != "string" || useValue == "") {
		return null;
	}

	// validate the display value (must be a string, we won't enforce it to contain a value)
	if(typeof displayValue != "string") {
		return null;
	}

	// the inclusive value must be either true or false (as a string)
	if(typeof inclusiveValue != "string" || (inclusiveValue != "false" && inclusiveValue != "true")) {
		return null;
	}

	var parameterValue = null;
	if(this.m_parameterValues.exists(name) == false)
	{
		parameterValue = new CParameterValue(name);
		this.m_parameterValues.add(name, parameterValue);
	}

	parameterValue = this.m_parameterValues.get(name);
	if(typeof parameterValue == "undefined" || parameterValue == null) {
		return null;
	}

	// check for duplicate use values
	var parmValueItems = parameterValue.getParmValueItems();
	for(var index = 0; index < parmValueItems.length; ++index)
	{
		var simpleParmValueItem = parmValueItems[index];
		if(simpleParmValueItem.getDisplayValue() == displayValue && simpleParmValueItem.getUseValue() == useValue)
		{
			return;
		}
	}

	return parameterValue.addSimpleParmValueItem(useValue, displayValue, inclusiveValue);

};

CParameterValues.prototype.getSimpleParmValueItem = function(name, useValue)
{
	var parameterValue = this.getParameterValue(name);
	if(parameterValue != null)
	{
		return parameterValue.getSimpleParmValueItem(useValue);
	}

	return null;

};

CParameterValues.prototype.load = function(parameterValuesNode)
{
	return this.loadWithOptions(parameterValuesNode, /*credentials*/true);
};

CParameterValues.prototype.loadWithOptions = function(parameterValuesNode, includeCredentials)
{
	try
	{
		var parameterValueNodes = parameterValuesNode.childNodes;
		for(var param_value_idx = 0; param_value_idx < parameterValueNodes.length; ++param_value_idx)
		{
			var parameterValueNode = parameterValueNodes[param_value_idx];
			if(parameterValueNode.nodeType == 3) // skip over text nodes
			{
				continue;
			}
			var parameterValue = new CParameterValue();
			if(parameterValue.load(parameterValueNode))
			{
				var paramName = parameterValue.name();
				if(paramName != "")
				{
					if (includeCredentials==true || paramName.indexOf("credential:") != 0)
					{
						this.m_parameterValues.add(paramName, parameterValue);
					}
				}
			}
			else
			{
				delete parameterValue;
			}
		}
	}
	catch(e)
	{
		return false;
	}

	return true;
};

CParameterValues.prototype.buildXML = function(xmlBuilder, rootNode, sTag)
{
	var parameterValuesElement = rootNode.createElement(sTag);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "xmlns:xs", "http://www.w3.org/2001/XMLSchema");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "xmlns:bus", "http://developer.cognos.com/schemas/bibus/3/");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "SOAP-ENC:arrayType", "bus:parameterValue[]", "http://schemas.xmlsoap.org/soap/encoding/");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValuesElement, "xsi:type", "SOAP-ENC:Array", "http://www.w3.org/2001/XMLSchema-instance");
	rootNode.documentElement.appendChild(parameterValuesElement);

	var parameterValues = this.m_parameterValues.keys();
	for(var parameterValueIdx = 0; parameterValueIdx < parameterValues.length; ++parameterValueIdx)
	{
		if(this.m_parameterValues.exists(parameterValues[parameterValueIdx]))
		{
			var parameterValue = this.m_parameterValues.get(parameterValues[parameterValueIdx]);
			parameterValue.generateXML(xmlBuilder, parameterValuesElement);
		}
	}

	return parameterValuesElement;
};

CParameterValues.prototype.generateXML = function(xmlBuilder, rootNode, sTag)
{
	var sNodeName = "parameterValues";
	if(typeof sTag != "undefined" && sTag != null)
	{
		sNodeName = sTag;
	}

	XMLBuilderSerializeNode(this.buildXML(xmlBuilder, rootNode, sNodeName));

	return XMLBuilderSerializeNode(rootNode);
};

function CParameterValue(name)
{
	this.m_name = name;
	this.m_parmValueItems = [];
}

CParameterValue.prototype.name = function()
{
	return this.m_name;
};

CParameterValue.prototype.setName = function(name)
{
	this.m_name = name;
};

CParameterValue.prototype.getParmValueItems = function()
{
	return this.m_parmValueItems;
};

CParameterValue.prototype.length = function()
{
	return this.m_parmValueItems.length;
};

CParameterValue.prototype.addParmValueItem = function(parmValueItem)
{
	this.m_parmValueItems.push(parmValueItem);
};

CParameterValue.prototype.addSimpleParmValueItem = function(useValue, displayValue, inclusiveValue)
{
	// validate the use value (must be a string, and it must contain something)
	if(typeof useValue != "string" || useValue == "") {
		return null;
	}

	// validate the display value (must be a string, we won't enforce it to contain a value)
	if(typeof displayValue != "string") {
		return null;
	}

	// the inclusive value must be either true or false (as a string)
	if(typeof inclusiveValue != "string" || (inclusiveValue != "false" && inclusiveValue != "true")) {
		return null;
	}

	var simpleParmValueItem = new CSimpleParmValueItem(useValue, displayValue, inclusiveValue);
	this.m_parmValueItems.push(simpleParmValueItem);
	return simpleParmValueItem;
};

CParameterValue.prototype.removeSimpleParmValueItem = function(useValue)
{
	if(typeof useValue != "string" || useValue == "") {
		return false;
	}

	var arrayPlaceHolder = [];
	var bItemRemoved = false;

	for(var parm_value_idx = 0; parm_value_idx < this.length(); ++parm_value_idx)
	{
		var parmValueItem = this.m_parmValueItems[parm_value_idx];
		if(parmValueItem instanceof CSimpleParmValueItem)
		{
			if(parmValueItem.getUseValue() == useValue)
			{
				bItemRemoved = true;
				continue;
			}
		}

		arrayPlaceHolder.push(parmValueItem);
	}

	this.m_parmValueItems = arrayPlaceHolder;

	return bItemRemoved;
};

CParameterValue.prototype.getSimpleParmValueItem = function(useValue)
{
	if(typeof useValue != "string" || useValue == "") {
		return null;
	}

	for(var parm_value_idx = 0; parm_value_idx < this.length(); ++parm_value_idx)
	{
		var parmValueItem = this.m_parmValueItems[parm_value_idx];
		if(parmValueItem instanceof CSimpleParmValueItem)
		{
			if(parmValueItem.getUseValue() == useValue)
			{
				return parmValueItem;
			}
		}
	}

	return null;
};

CParameterValue.prototype.load = function(parameterValueNode)
{
	var parameterValueAttrType = parameterValueNode.getAttributeNode("xsi:type");
	// make sure the type is a parameterValue
	if(parameterValueAttrType == null || parameterValueAttrType.nodeValue != "bus:parameterValue") {
		return false;
	}

	var nameNode = XMLHelper_FindChildByTagName(parameterValueNode, "name", false);
	if(nameNode == null) {
		return false;
	}

	this.m_name = XMLHelper_GetText(nameNode);
	if(this.m_name == "") {
		return false;
	}

	var valueNode = XMLHelper_FindChildByTagName(parameterValueNode, "value", false);
	if(valueNode == null) {
		return false;
	}

	var valueAttrType = valueNode.getAttributeNode("xsi:type");
	if(valueAttrType == null || valueAttrType.nodeValue != "SOAP-ENC:Array") {
		return false;
	}

	var arrayType = valueNode.getAttributeNode("SOAP-ENC:arrayType");
	if(arrayType == null || arrayType.nodeValue.indexOf("bus:parmValueItem[") == -1) {
		return false;
	}

	var parmValueItemNodes = valueNode.childNodes;
	for(var parm_value_item_idx = 0; parm_value_item_idx < parmValueItemNodes.length; ++parm_value_item_idx)
	{
		var parmValueItemNode = parmValueItemNodes[parm_value_item_idx];
		if(parmValueItemNode.nodeType == 3) // skip over text nodes
		{
			continue;
		}

		var parmValueItemAttrType = parmValueItemNode.getAttributeNode("xsi:type");
		if(parmValueItemAttrType != null)
		{
			var parmValueItem;
			var bSuccess;
			switch(parmValueItemAttrType.nodeValue)
			{
				case "bus:simpleParmValueItem" :
					parmValueItem = new CSimpleParmValueItem("","","");
					break;
				case "bus:boundRangeParmValueItem" :
					parmValueItem = new CBoundRangeParmValueItem();
					break;
				case "bus:unboundedEndRangeParmValueItem" :
					parmValueItem = new CUnboundedEndRangeParmValueItem();
					break;
				case "bus:unboundedStartRangeParmValueItem" :
					parmValueItem = new CUnboundedStartRangeParmValueItem();
					break;
				case "bus:hierarchicalParmValueItem" :
					parmValueItem = new CHierarchicalParmValueItem();
					break;
				default:
					return false;
			}

			bSuccess = parmValueItem.load(parmValueItemNode);

			if(bSuccess)
			{
				this.m_parmValueItems.push(parmValueItem);
			}
			else
			{
				delete parmValueItem;
			}
		}
	}

	return true;
};

CParameterValue.prototype.generateXML = function(xmlBuilder, parameterValuesElement)
{
	var rootNode = parameterValuesElement.ownerDocument;

	var parameterValueElement = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(parameterValueElement, "xsi:type", "bus:parameterValue", "http://www.w3.org/2001/XMLSchema-instance");
	parameterValuesElement.appendChild(parameterValueElement);

	var busNameElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:name", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(busNameElement, "xsi:type", "xs:string", "http://www.w3.org/2001/XMLSchema-instance");
	busNameElement.appendChild(rootNode.createTextNode(this.m_name));
	parameterValueElement.appendChild(busNameElement);

	var busValueElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:value", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(busValueElement, "SOAP-ENC:arrayType", "bus:parmValueItem[]", "http://schemas.xmlsoap.org/soap/encoding/");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(busValueElement, "xsi:type", "SOAP-ENC:Array", "http://www.w3.org/2001/XMLSchema-instance");
	parameterValueElement.appendChild(busValueElement);

	for(var parmValueItemIdx = 0; parmValueItemIdx < this.m_parmValueItems.length; ++parmValueItemIdx)
	{
		if(typeof this.m_parmValueItems[parmValueItemIdx].generateXML != "undefined") {
			this.m_parmValueItems[parmValueItemIdx].generateXML(xmlBuilder, busValueElement);
		}
	}
};

CParameterValue.prototype.toString = function(parameterValueStringOperators)
{
	var result = "";
	for(var parmValueItemIdx = 0; parmValueItemIdx < this.m_parmValueItems.length; ++parmValueItemIdx)
	{
		if(result != "")
		{
			result += ", ";
		}

		if(typeof this.m_parmValueItems[parmValueItemIdx].toString != "undefined")
		{
			result += this.m_parmValueItems[parmValueItemIdx].toString(parameterValueStringOperators);
		}
	}

	return result;
};

// This is an abstract base class, do not instantiate directly
function CParmValueItem()
{
	this.initialize("true");
}

CParmValueItem.prototype.getInclusiveValue = function()
{
	return this.m_inclusiveValue;
};

CParmValueItem.prototype.setInclusiveValue = function(inclusiveValue)
{
	this.m_inclusiveValue = inclusiveValue;
};

CParmValueItem.prototype.initialize = function(inclusiveValue)
{
	this.m_inclusiveValue = inclusiveValue;
};

CParmValueItem.prototype.load = function(simpleParmValueItemNode)
{
	// default to true incase the xml does not specify the inclusive value
	this.m_inclusiveValue = "true";

	var inclusiveValueNode = XMLHelper_FindChildByTagName(simpleParmValueItemNode, "inclusive", false);
	if(inclusiveValueNode != null)
	{
		var text = XMLHelper_GetText(inclusiveValueNode);
		if(text == "true" || text== "false") {
			this.m_inclusiveValue = text;
		}
	}
};

CParmValueItem.prototype.generateXML = function(xmlBuilder, parmValueItem)
{
	var rootNode = parmValueItem.ownerDocument;
	var businclusiveElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:inclusive", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(businclusiveElement, "xsi:type", "xs:boolean", "http://www.w3.org/2001/XMLSchema-instance");
	businclusiveElement.appendChild(rootNode.createTextNode(this.m_inclusiveValue));
	parmValueItem.appendChild(businclusiveElement);
};

function CSimpleParmValueItem(useValue, displayValue, inclusiveValue)
{
	// initialize the base class
	CSimpleParmValueItem.baseclass.initialize.call(this, inclusiveValue);

	// The use value should be considered a constant, once it's set, it can never be changed
	this.m_useValue = useValue;
	this.m_displayValue = displayValue;
}

// set up the base class
CSimpleParmValueItem.prototype = new CParmValueItem();
CSimpleParmValueItem.prototype.constructor = CSimpleParmValueItem;
CSimpleParmValueItem.baseclass = CParmValueItem.prototype;

CSimpleParmValueItem.prototype.getUseValue = function()
{
	return this.m_useValue;
};

CSimpleParmValueItem.prototype.getDisplayValue = function()
{
	return this.m_displayValue;
};

CSimpleParmValueItem.prototype.getParmValueItem = function()
{
	return this.m_parmValueItem;
};

CSimpleParmValueItem.prototype.setDisplayValue = function(displayValue)
{
	this.m_displayValue = displayValue;
};

CSimpleParmValueItem.prototype.setUseValue = function(useValue)
{
	this.m_useValue = useValue;
};

CSimpleParmValueItem.prototype.toString = function(parameterValueStringOperators)
{
	return this.getDisplayValue();
};

CSimpleParmValueItem.prototype.load = function (simpleParmValueItemNode)
{
	// call the base class
	CSimpleParmValueItem.baseclass.load.call(this, simpleParmValueItemNode);

	var useValueNode = XMLHelper_FindChildByTagName(simpleParmValueItemNode, "use", false);
	if(useValueNode == null) {
		return false;
	}

	var useValueText = XMLHelper_GetText(useValueNode);
	if(useValueText == "") {
		return false;
	}

	this.m_useValue = useValueText;

	var displayValueNode = XMLHelper_FindChildByTagName(simpleParmValueItemNode, "display", false);
	if(displayValueNode != null)
	{
		this.m_displayValue = XMLHelper_GetText(displayValueNode);
	}

	return true;
};

CSimpleParmValueItem.prototype.generateXML = function(xmlBuilder, busValueElement)
{
	var rootNode = busValueElement.ownerDocument;

	var simpleParmValueItem = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(simpleParmValueItem, "xsi:type", "bus:simpleParmValueItem", "http://www.w3.org/2001/XMLSchema-instance");
	busValueElement.appendChild(simpleParmValueItem);

	// call the base class
	CSimpleParmValueItem.baseclass.generateXML.call(this, xmlBuilder, simpleParmValueItem);

	var busUseElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:use", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(busUseElement, "xsi:type", "xs:string", "http://www.w3.org/2001/XMLSchema-instance");
	busUseElement.appendChild(rootNode.createTextNode(this.m_useValue));
	simpleParmValueItem.appendChild(busUseElement);

	var busDisplayElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:display", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(busDisplayElement, "xsi:type", "xs:string", "http://www.w3.org/2001/XMLSchema-instance");
	busDisplayElement.appendChild(rootNode.createTextNode(this.m_displayValue));
	simpleParmValueItem.appendChild(busDisplayElement);
};


function CBoundRangeParmValueItem()
{
	// initialize the base class
	CBoundRangeParmValueItem.baseclass.initialize.call(this, "true");
	this.m_start = null;
	this.m_end = null;
}

CBoundRangeParmValueItem.prototype = new CParmValueItem();
CBoundRangeParmValueItem.prototype.constructor = CBoundRangeParmValueItem;
CBoundRangeParmValueItem.baseclass = CParmValueItem.prototype;

CBoundRangeParmValueItem.prototype.setStart = function(start)
{
	this.m_start = start;
};

CBoundRangeParmValueItem.prototype.getStart = function()
{
	return this.m_start;
};

CBoundRangeParmValueItem.prototype.setEnd = function(end)
{
	this.m_end = end;
};

CBoundRangeParmValueItem.prototype.getEnd = function()
{
	return this.m_end;
};

CBoundRangeParmValueItem.prototype.toString = function(parameterValueStringOperators)
{
	return CViewerCommon.getMessage(parameterValueStringOperators.m_sBetween, [this.m_start.getDisplayValue(), this.m_end.getDisplayValue()]);
};

CBoundRangeParmValueItem.prototype.load = function (boundRangeParmValueItemNode)
{
	// call the base class
	CBoundRangeParmValueItem.baseclass.load.call(this, boundRangeParmValueItemNode);

	this.m_start = new CSimpleParmValueItem("", "", "");
	this.m_start.load(XMLHelper_FindChildByTagName(boundRangeParmValueItemNode, "start", false));

	this.m_end = new CSimpleParmValueItem("","","");
	this.m_end.load(XMLHelper_FindChildByTagName(boundRangeParmValueItemNode, "end", false));

	return true;
};

CBoundRangeParmValueItem.prototype.generateXML = function(xmlBuilder, busValueElement)
{
	var rootNode = busValueElement.ownerDocument;

	var boundRangeParmValueItem = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(boundRangeParmValueItem, "xsi:type", "bus:boundRangeParmValueItem", "http://www.w3.org/2001/XMLSchema-instance");
	busValueElement.appendChild(boundRangeParmValueItem);

	// call the base class
	CBoundRangeParmValueItem.baseclass.generateXML.call(this, xmlBuilder, boundRangeParmValueItem);

	var busStartElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:start", rootNode);
	boundRangeParmValueItem.appendChild(busStartElement);
	this.m_start.generateXML(xmlBuilder, busStartElement);

	var busEndElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:end", rootNode);
	boundRangeParmValueItem.appendChild(busEndElement);
	this.m_end.generateXML(xmlBuilder, busEndElement);
};

function CUnboundedStartRangeParmValueItem()
{
	// initialize the base class
	CUnboundedStartRangeParmValueItem.baseclass.initialize.call(this, "true");
	this.m_end = null;
}

CUnboundedStartRangeParmValueItem.prototype = new CParmValueItem();
CUnboundedStartRangeParmValueItem.prototype.constructor = CUnboundedStartRangeParmValueItem;
CUnboundedStartRangeParmValueItem.baseclass = CParmValueItem.prototype;

CUnboundedStartRangeParmValueItem.prototype.setEnd = function(end)
{
	this.m_end = end;
};

CUnboundedStartRangeParmValueItem.prototype.getEnd = function()
{
	return this.m_end;
};


CUnboundedStartRangeParmValueItem.prototype.load = function (unboundedStartRangeParmValueItemNode)
{
	// call the base class
	CUnboundedStartRangeParmValueItem.baseclass.load.call(this, unboundedStartRangeParmValueItemNode);

	this.m_end = new CSimpleParmValueItem("","","");
	this.m_end.load(XMLHelper_FindChildByTagName(unboundedStartRangeParmValueItemNode, "end", false));

	return true;
};

CUnboundedStartRangeParmValueItem.prototype.generateXML = function(xmlBuilder, busValueElement)
{
	var rootNode = busValueElement.ownerDocument;

	var unboundedStartRangeParmValueItem = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(unboundedStartRangeParmValueItem, "xsi:type", "bus:unboundedStartRangeParmValueItem", "http://www.w3.org/2001/XMLSchema-instance");
	busValueElement.appendChild(unboundedStartRangeParmValueItem);

	// call the base class
	CUnboundedStartRangeParmValueItem.baseclass.generateXML.call(this, xmlBuilder, unboundedStartRangeParmValueItem);

	var busEndElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:end", rootNode);
	unboundedStartRangeParmValueItem.appendChild(busEndElement);
	this.m_end.generateXML(xmlBuilder, busEndElement);
};

CUnboundedStartRangeParmValueItem.prototype.toString = function(parameterValueStringOperators)
{
	return parameterValueStringOperators.m_sLessThan + " " + this.m_end.getDisplayValue();
};

function CUnboundedEndRangeParmValueItem()
{
	// initialize the base class
	CUnboundedEndRangeParmValueItem.baseclass.initialize.call(this, "true");
	this.m_start = null;
}

CUnboundedEndRangeParmValueItem.prototype = new CParmValueItem();
CUnboundedEndRangeParmValueItem.prototype.constructor = CUnboundedEndRangeParmValueItem;
CUnboundedEndRangeParmValueItem.baseclass = CParmValueItem.prototype;

CUnboundedEndRangeParmValueItem.prototype.setStart = function(start)
{
	this.m_start = start;
};

CUnboundedEndRangeParmValueItem.prototype.getStart = function()
{
	return this.m_start;
};

CUnboundedEndRangeParmValueItem.prototype.load = function (unboundedEndRangeParmValueItemNode)
{
	// call the base class
	CUnboundedEndRangeParmValueItem.baseclass.load.call(this, unboundedEndRangeParmValueItemNode);

	this.m_start = new CSimpleParmValueItem("","","");
	this.m_start.load(XMLHelper_FindChildByTagName(unboundedEndRangeParmValueItemNode, "start", false));

	return true;
};

CUnboundedEndRangeParmValueItem.prototype.generateXML = function(xmlBuilder, busValueElement)
{
	var rootNode = busValueElement.ownerDocument;

	var unboundedEndRangeParmValueItem = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(unboundedEndRangeParmValueItem, "xsi:type", "bus:unboundedEndRangeParmValueItem", "http://www.w3.org/2001/XMLSchema-instance");
	busValueElement.appendChild(unboundedEndRangeParmValueItem);

	// call the base class
	CUnboundedEndRangeParmValueItem.baseclass.generateXML.call(this, xmlBuilder, unboundedEndRangeParmValueItem);

	var busStartElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:start", rootNode);
	unboundedEndRangeParmValueItem.appendChild(busStartElement);
	this.m_start.generateXML(xmlBuilder, busStartElement);
};

CUnboundedEndRangeParmValueItem.prototype.toString = function(parameterValueStringOperators)
{
	return parameterValueStringOperators.m_sGreaterThan + " " + this.m_start.getDisplayValue();
};

function CHierarchicalParmValueItem()
{
	// initialize the base class
	CHierarchicalParmValueItem.baseclass.initialize.call(this, "true");
	this.m_value = null;
	this.m_subNodes = [];
}

CHierarchicalParmValueItem.prototype = new CParmValueItem();
CHierarchicalParmValueItem.prototype.constructor = CHierarchicalParmValueItem;
CHierarchicalParmValueItem.baseclass = CParmValueItem.prototype;

CHierarchicalParmValueItem.prototype.getValue = function()
{
	return this.m_value;
};

CHierarchicalParmValueItem.prototype.getSubNodes = function()
{
	return this.m_subNodes;
};

CHierarchicalParmValueItem.prototype.setValue = function(value)
{
	this.m_value = value;
};

CHierarchicalParmValueItem.prototype.setSubNodes = function(subNodes)
{
	this.m_subNodes = subNodes;
};

CHierarchicalParmValueItem.prototype.load = function (hierarchicalParmValueItemNode)
{
	// call the base class
	CHierarchicalParmValueItem.baseclass.load.call(this, hierarchicalParmValueItemNode);

	this.m_value = new CSimpleParmValueItem("","","");
	this.m_value.load(XMLHelper_FindChildByTagName(hierarchicalParmValueItemNode, "value", false));

	var subNodes = XMLHelper_FindChildByTagName(hierarchicalParmValueItemNode, "subNodes", false);
	if(subNodes == null) {
		return false;
	}

	var valueAttrType = subNodes.getAttributeNode("xsi:type");
	if(valueAttrType == null || valueAttrType.nodeValue != "SOAP-ENC:Array") {
		return false;
	}

	var arrayType = subNodes.getAttributeNode("SOAP-ENC:arrayType");
	if(arrayType == null || arrayType.nodeValue != "bus:hierarchicalParmValueItem[]") {
		return false;
	}

	var hierarchicalParmValueItemNodes = subNodes.childNodes;
	for(var index = 0; index < hierarchicalParmValueItemNodes.length; ++index)
	{
		var hierarchicalParmValueItem = new CHierarchicalParmValueItem();
		hierarchicalParmValueItem.load(hierarchicalParmValueItemNodes[index]);
		this.m_subNodes.push(hierarchicalParmValueItem);
	}

	return true;
};

CHierarchicalParmValueItem.prototype.generateXML = function(xmlBuilder, busValueElement)
{
	var rootNode = busValueElement.ownerDocument;

	var hierarchicalParmValueItem = rootNode.createElement("item");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(hierarchicalParmValueItem, "xsi:type", "bus:hierarchicalParmValueItem", "http://www.w3.org/2001/XMLSchema-instance");
	busValueElement.appendChild(hierarchicalParmValueItem);

	// call the base class
	CHierarchicalParmValueItem.baseclass.generateXML.call(this, xmlBuilder, hierarchicalParmValueItem);

	var valueElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:value", rootNode);
	hierarchicalParmValueItem.appendChild(valueElement);
	this.m_value.generateXML(xmlBuilder, valueElement);

	var subNodesElement = xmlBuilder.XMLBuilderCreateElementNS("http://developer.cognos.com/schemas/bibus/3/", "bus:subNodes", rootNode);
	xmlBuilder.XMLBuilderSetAttributeNodeNS(subNodesElement, "SOAP-ENC:arrayType", "bus:hierarchicalParmValueItem[]", "http://schemas.xmlsoap.org/soap/encoding/");
	xmlBuilder.XMLBuilderSetAttributeNodeNS(subNodesElement, "xsi:type", "SOAP-ENC:Array", "http://www.w3.org/2001/XMLSchema-instance");
	hierarchicalParmValueItem.appendChild(subNodesElement);

	for(var index = 0; index < this.m_subNodes.length; ++index)
	{
		this.m_subNodes[index].generateXML(xmlBuilder, subNodesElement);
	}
};

CHierarchicalParmValueItem.prototype.toString = function()
{
	//TODO Get string for hierarchial values (may be too complex to present in the info bar
	return "";
};