"associatorInstances requires keys for the instance to be populated");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE, "Associators");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pObjectName);
		Element iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "ObjectName");
		Element instancenameE = CIMXMLBuilderImpl.createINSTANCENAME(pDoc, iparamvalueE, className);
		for (int i = 0; i < keysA.length; i++) {
			CIMProperty<?> prop = keysA[i];
			String propName = prop.getName();
			String propTypeStr = prop.getDataType().toString();
			String propValueStr = valueStr(prop);

			Element keybindingE = CIMXMLBuilderImpl.createKEYBINDING(pDoc, instancenameE, propName);
			CIMXMLBuilderImpl.createKEYVALUE(pDoc, keybindingE, propTypeStr, propValueStr);
		}
		if (pAssocClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "AssocClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pAssocClass);
		}
		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}
		if (pResultRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultRole");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");

}

		private boolean setUInt64(String pValue) {
			try {
				this.iValue = new UnsignedInteger64(pValue);
			} catch (NumberFormatException e) {
				return false;
			}
			this.iType = CIMDataType.UINT64_T;
			return true;
		}

		private boolean setSInt64(String pValue) {
			try {
				this.iValue = new Long(pValue);
			} catch (NumberFormatException e) {
				return false;
			}
			this.iType = CIMDataType.SINT64_T;
			return true;
		}

		private boolean setReal64(String pValue) {
			try {
				if (WBEMConfiguration.getGlobalConfiguration().verifyJavaLangDoubleStrings()) {
					if (Util.isBadDoubleString(pValue)) return false;
				}
				this.iValue = new Double(pValue);
			} catch (NumberFormatException e) {
				return false;
			}
			this.iType = CIMDataType.REAL64_T;
			return true;
		}

		private boolean setBoolean(String pValue) {
			this.iValue = Boolean.valueOf(pValue);
			this.iType = CIMDataType.BOOLEAN_T;
			return true;
		}

		private boolean setDTAbsolute(String pValue) {
			try {
				this.iValue = new CIMDateTimeAbsolute(pValue);
			} catch (IllegalArgumentException e) {
				return false;
			}
			this.iType = CIMDataType.DATETIME_T;
			return true;
		}

		private boolean setDTInterval(String pValue) {
			try {
				this.iValue = new CIMDateTimeInterval(pValue);
			} catch (IllegalArgumentException e) {
				return false;
			}
			this.iType = CIMDataType.DATETIME_T;
			return true;
		}
	}

CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}
		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, INCLUDE_CLASS_ORIGIN);
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, PROPERTY_LIST);
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++)
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
		}
		if (pFilterQueryLanguage != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
					FILTER_QUERY_LANGUAGE);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pFilterQueryLanguage);
		}
		if (pFilterQuery != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, FILTER_QUERY);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pFilterQuery);
		}
		if (pOperationTimeout != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
					OPERATION_TIMEOUT);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pOperationTimeout);
		}

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, CONTINUE_ON_ERROR);
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pContinueOnError);

		if (pMaxObjectCount != null) {
			iparamvalueE = CIMXMLBuilderImpl
					.createIPARAMVALUE(pDoc, imethodcallE, MAX_OBJECT_COUNT);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pMaxObjectCount);
		}

		return simplereqE;
	}

	/**
	 * OpenEnumerateInstancePaths_request
	 * 
	 * @param pDoc
	 * @param pPath
	 * @param pFilterQueryLanguage
	 * @param pFilterQuery
	 * @param pOperationTimeout
	 * @param pContinueOnError
	 * @param pMaxObjectCount
	 * @return Element
	 * @throws WBEMException
	 */
	public Element OpenEnumerateInstancePaths_request(Document pDoc, CIMObjectPath pPath,

if (pAssocClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "AssocClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pAssocClass);
		}
		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}
		if (pResultRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultRole");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}
		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associators_request
	 * 
	 * @param pDoc
	 * @param pObjectName
	 * @param pAssocClass
	 * @param pResultClass
	 * @param pRole
	 * @param pResultRole
	 * @param pIncludeQualifiers
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @return Element
	 * @throws WBEMException
	 */
	public Element associators_request(Document pDoc, CIMObjectPath pObjectName,

Element iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "ObjectName");
		// createOBJECTNAME will internally call createINSTANCENAME but as there
		// are no keys Element containing keys will not be populated
		CIMXMLBuilderImpl.createOBJECTNAME(pDoc, iparamvalueE, pPath);

		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}
		return simplereqE;
	}

	/**
	 * referenceInstances_request
	 * 
	 * @param pDoc
	 * @param pPath
	 * @param pResultClass
	 * @param pRole
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @return Element
	 * @throws WBEMException
	 */
	public Element referenceInstances_request(Document pDoc, CIMObjectPath pPath,

public static Element createIRETURNVALUE_ASSOCIATORS(Document pDoc, Element pParentE,
			Object[] pResultSet, String pNameSpace) throws Exception {
		Element ireturnvalueE = pDoc.createElement("IRETURNVALUE");
		if (pResultSet != null) {
			for (int i = 0; i < pResultSet.length; i++) {
				Object obj = pResultSet[i];
				CIMObjectPath op = null;
				if (obj instanceof CIMClass) {
					op = ((CIMClass) obj).getObjectPath();
				} else if (obj instanceof CIMInstance) {
					op = ((CIMInstance) obj).getObjectPath();
				} else {
					throw new WBEMException(WBEMException.CIM_ERR_FAILED,
							"object in result set neither class nor instance!");
				}
				if (op.getHost() == null || "".equals(op.getHost())) {
					createVALUEOBJECTWITHLOCALPATH(pDoc, ireturnvalueE, obj, pNameSpace);
				} else {
					createVALUEOBJECTWITHPATH(pDoc, ireturnvalueE, obj, pNameSpace);
				}
			}
		}
		pParentE.appendChild(ireturnvalueE);
		return ireturnvalueE;
	}

	/**
	 * createIRETURNVALUE_ENUMERATE_INSTANCENAME
	 * 
	 * @param pDoc
	 * @param pParentE
	 * @param pResultSet
	 * @param pNameSpace
	 * @return Element
	 * @throws Exception
	 */
	public static Element createIRETURNVALUE_ENUMERATE_INSTANCENAME(Document pDoc,

if (this.iPathNodeNameEnum == LOCALCLASSPATH) illegalChildNodePair(LOCALCLASSPATH,
					INSTANCE);
		} else throw new SAXException(getNodeName() + " node cannot have " + pNodeNameEnum
				+ " child!");
	}

	@Override
	public void childParsed(Node pChild) throws SAXException {
		if (pChild instanceof AbstractObjectPathNode) {
			this.iPathNodeNameEnum = pChild.getNodeName();
			this.iObjPath = ((AbstractObjectPathNode) pChild).getCIMObjectPath();
		} else { // ClassNode or InstanceNode, iObjPath must be available
			// here
			this.iObjNodeNameEnum = pChild.getNodeName();
			if (this.iPathNodeNameEnum == null) throw new SAXException(getNodeName()
					+ " first child should contain an object path!");
			if (pChild instanceof ClassNode) {
				this.iCIMObj = ((ClassNode) pChild).getCIMClass(this.iObjPath);
			} else {
				this.iCIMObj = ((InstanceNode) pChild).getCIMInstance(this.iObjPath);
			}
		}
	}

	@Override
	public void testCompletness() throws SAXException {
		if (this.iPathNodeNameEnum == null) throw new SAXException(getNodeName()
				+ " node must have a LOCALCLASSPATH or a LOCALINSTANCEPATH child node!");

doc, pObjectName, pAssocClass, pResultClass, pRole, pResultRole,
					pIncludeClassOrigin, pPropertyList, pFilterQueryLanguage, pFilterQuery,
					pTimeout, pContinueOnError, pMaxObjects));

			InputStreamReader is = transmitRequest(operation, hh, doc);

			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void closeEnumeration(CIMObjectPath pObjectName, String pEnumerationContext)

return new CIMArgument<Object>(name, type, op);
		}

		// CLASS
		Element classA[] = searchNodes(pParamValueE, "CLASS", 0, 1, false);
		if (classA != null) {
			CIMClass cl = parseCLASS(classA[0]);
			return new CIMArgument<Object>(name, CIMDataType.CLASS_T, cl);
		}

		// INSTANCE
		Element instanceA[] = searchNodes(pParamValueE, "INSTANCE", 0, 1, false);
		if (instanceA != null) {
			CIMInstance inst = parseINSTANCE(instanceA[0]);
			return new CIMArgument<Object>(name, CIMDataType.OBJECT_T, inst);
		}

		// VALUE.NAMEDINSTANCE
		Element valuenamedisntanceA[] = searchNodes(pParamValueE, "VALUE.NAMEDINSTANCE", 0, 1,
				false);
		if (valuenamedisntanceA != null) {
			CIMInstance inst = parseVALUENAMEDINSTANCE(valuenamedisntanceA[0]);
			return new CIMArgument<Object>(name, CIMDataType.OBJECT_T, inst);
		}
		checkOtherNodes(pParamValueE, nodesPARAMVALUE);

"OpenAssociatorInstancePaths");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
				INSTANCE_NAME);
		CIMXMLBuilderImpl.createINSTANCENAME(pDoc, iparamvalueE, pPath);

		if (pAssocClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, ASSOC_CLASS);
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pAssocClass);
		}
		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, RESULT_CLASS);
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, ROLE);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}
		if (pResultRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, RESULT_ROLE);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}

this.iXmlHelper.createCIMMessage(doc, this.iXmlHelper.PullInstances_request(doc,
					pObjectName, pContext, pMaxObjects));

			InputStreamReader is = transmitRequest(operation, hh, doc);
			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMInstance> getInstancesWithPath(CIMObjectPath pObjectName,

InputStreamReader is = transmitRequest("DeleteClass", hh, doc);

			CloseableIterator<?> iter = getIterator(is, pPath);
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

			return;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void deleteInstance(CIMObjectPath pPath) throws WBEMException {

pTimeout, pContinueOnError, pMaxObjects));

			InputStreamReader is = transmitRequest(operation, hh, doc);

			EnumerateResponse<CIMObjectPath> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMInstance> associators(CIMObjectPath pObjectName,

if (pFilterQueryLanguage != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
					FILTER_QUERY_LANGUAGE);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pFilterQueryLanguage);
		}
		if (pFilterQuery != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, FILTER_QUERY);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pFilterQuery);
		}
		if (pOperationTimeout != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
					OPERATION_TIMEOUT);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pOperationTimeout);
		}

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, CONTINUE_ON_ERROR);
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pContinueOnError);

		if (pMaxObjectCount != null) {
			iparamvalueE = CIMXMLBuilderImpl
					.createIPARAMVALUE(pDoc, imethodcallE, MAX_OBJECT_COUNT);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pMaxObjectCount);
		}

		return simplereqE;
	}

	/**
	 * OpenAssociatorInstances_request
	 * 
	 * @param pDoc
	 * @param pPath
	 * @param pAssocClass
	 * @param pResultClass
	 * @param pRole
	 * @param pResultRole
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @param pFilterQueryLanguage
	 * @param pFilterQuery
	 * @param pOperationTimeout
	 * @param pContinueOnError
	 * @param pMaxObjectCount
	 * @return Element OpenAssociatorInstances_request
	 * @throws WBEMException
	 */
	public Element OpenAssociatorInstances_request(Document pDoc, CIMObjectPath pPath,

pTimeout, pContinueOnError, pMaxObjects, pQueryResultClass));

			InputStreamReader is = transmitRequest(operation, hh, doc);
			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMObjectPath> getInstancePaths(CIMObjectPath pObjectName,

pTimeout, pContinueOnError, pMaxObjects));

			InputStreamReader is = transmitRequest(operation, hh, doc);

			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void closeEnumeration(CIMObjectPath pObjectName, String pEnumerationContext)

pTimeout, pContinueOnError, pMaxObjects, pQueryResultClass));

			InputStreamReader is = transmitRequest(operation, hh, doc);
			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMObjectPath> getInstancePaths(CIMObjectPath pObjectName,

isPropagated(), pIncludeClassOrigin ? getOriginClass() : null);
	}

	/**
	 * Get a qualifier by index.
	 * 
	 * @param pIndex
	 *            The index of the qualifier to retrieve.
	 * @return The qualifier at the specified index.
	 * @throws ArrayIndexOutOfBoundsException
	 */
	public CIMQualifier<?> getQualifier(int pIndex) throws ArrayIndexOutOfBoundsException {
		return this.iQualiImpl.getQualifier(pIndex);
	}

	/**
	 * Gets a qualifier by name.
	 * 
	 * @param pName
	 *            The name of the qualifier to get.
	 * @return The qualifier requested or <code>null</code> if the qualifier
	 *         does not exist.
	 */
	public CIMQualifier<?> getQualifier(String pName) {
		return this.iQualiImpl.getQualifier(pName);
	}

	/**
	 * Get the number of qualifiers defined for this property.
	 * 
	 * @return The number of qualifiers defined for this property.
	 */
	public int getQualifierCount() {
		return this.iQualiImpl.getQualifierCount();
	}

	/**
	 * Returns the list of qualifiers for this property.
	 * 
	 * @return Qualifiers for this property.
	 */
	public CIMQualifier<?>[] getQualifiers() {
		return this.iQualiImpl.getQualifiers();
	}

	/**
	 * Gets a qualifier value by name.
	 * 
	 * @param pName
	 *            The name of the qualifier to get.
	 * @return <code>null</code> if the qualifier does not exist or value is
	 *         <code>null</code>, otherwise returns the reference to the
	 *         qualifier.
	 */
	public Object getQualifierValue(String pName) {
		return this.iQualiImpl.getQualifierValue(pName);
	}

	/**
	 * Checks whether the specified qualifier is one of the qualifiers defined
	 * for this property.
	 * 
	 * @param pName
	 *            The name of the qualifier.
	 * @return <code>true</code> if the qualifier exists in this property,
	 *         otherwise <code>false</code>.
	 */
	public boolean hasQualifier(String pName) {
		return this.iQualiImpl.hasQualifier(pName);
	}

	/**
	 * Checks whether the specified qualifier is one of the qualifiers defined
	 * for this property with the specified value. This method will return
	 * <code>false</code> if the qualifier is not applied or if the value does
	 * not match.
	 * 
	 * @param pName
	 *            The name of the qualifier.
	 * @param pValue
	 *            The value to be tested.
	 * @return <code>true</code> if the qualifier exists in this property,
	 *         otherwise <code>false</code>.
	 */
	public boolean hasQualifierValue(String pName, Object pValue) {
		return this.iQualiImpl.hasQualifierValue(pName, pValue);
	}

pObjectName, pResultClass, pRole, pIncludeQualifiers, pIncludeClassOrigin,
					pPropertyList));

			InputStreamReader is = transmitRequest("References", hh, doc);

			return getIterator(is, pObjectName);

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMInstance> referenceInstances(CIMObjectPath pObjectName,

pTimeout, pContinueOnError, pMaxObjects, pQueryResultClass));

			InputStreamReader is = transmitRequest(operation, hh, doc);
			EnumerateResponse<CIMInstance> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

CloseableIterator<?> iter = getIterator(is, pClass.getObjectPath());
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

			return;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void modifyInstance(CIMInstance pInst, String[] pPropertyList) throws WBEMException {

InputStreamReader is = transmitRequest("EnumerateClassNames", hh, doc);

			CloseableIterator<CIMObjectPath> iter = getIterator(is, pPath);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> enumerateClasses(CIMObjectPath pPath, boolean pDeep,

CloseableIterator<?> iter = getIterator(is, pPath);
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

			return;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMObjectPath> enumerateClassNames(CIMObjectPath pPath, boolean pDeep)

InputStreamReader is = transmitRequest("AssociatorNames", hh, doc);

			CloseableIterator<CIMObjectPath> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

CloseableIterator<?> iter = getIterator(is, pPath);
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

			return;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void deleteInstance(CIMObjectPath pPath) throws WBEMException {

CloseableIterator<?> iter = getIterator(is, pPath);
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

			return;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMObjectPath> enumerateClassNames(CIMObjectPath pPath, boolean pDeep)

InputStreamReader is = transmitRequest("EnumerateInstances", hh, doc);

			CloseableIterator<CIMInstance> iter = getIterator(is, pPath);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

CloseableIterator<?> iter = getIterator(is, pClass.getObjectPath());
			try {
				iter.hasNext();
			} finally {
				iter.close();
			}

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CIMObjectPath createInstance(CIMInstance pInstance) throws WBEMException {

CIMXMLBuilderImpl.createINSTANCENAME(pDoc, iparamvalueE, pName);

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "LocalOnly");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pLocalOnly);

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * deleteInstance_request
	 * 
	 * @param pDoc
	 * @param pName
	 * @return Element
	 * @throws WBEMException
	 */
	public Element deleteInstance_request(Document pDoc, CIMObjectPath pName) throws WBEMException {

CloseableIterator<CIMObjectPath> iter = getIterator(is, pPath);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMInstance> enumerateInstances(CIMObjectPath pPath, boolean pDeep,

if (pAssocClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "AssocClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pAssocClass);
		}
		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}
		if (pResultRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultRole");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");

CloseableIterator<CIMObjectPath> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

if (iter.hasNext()) { return (CIMObjectPath) iter.next(); }
			} finally {
				iter.close();
			}

			return null;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void deleteClass(CIMObjectPath pPath) throws WBEMException {

CloseableIterator<CIMObjectPath> iter = getIterator(is, pPath);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> enumerateClasses(CIMObjectPath pPath, boolean pDeep,

EnumerateResponse<CIMObjectPath> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMInstance> associators(CIMObjectPath pObjectName,

CloseableIterator<CIMObjectPath> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

EnumerateResponse<CIMObjectPath> enumResp = getEnumerateResponse(is, pObjectName);
			return enumResp;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMInstance> associators(CIMObjectPath pObjectName,

"Keys should not be populated for referenceClasses");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE, "References");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "ObjectName");
		// createOBJECTNAME will internally call createINSTANCENAME but as there
		// are no keys Element containing keys will not be populated
		CIMXMLBuilderImpl.createOBJECTNAME(pDoc, iparamvalueE, pPath);

		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");

"Output auguments not found during CIM-XML PULL parser"); }

		for (int i = 0; i < pOutArgA.length; i++) {
			if (pOutArgA[i].getName().equals("EnumerationContext")) enumContext = (String) pOutArgA[i]
					.getValue();
			else if (pOutArgA[i].getName().equals("EndOfSequence")) endOfSequence = (Boolean) pOutArgA[i]
					.getValue();
			else throw new IllegalArgumentException(
					"Invalid argument : only EnumerationContext and EndOfSequence are allowed");
		}
		// EndOfSequence can never be null
		if (endOfSequence == null) { throw new IllegalArgumentException(
				"Invalid argument : EndOfSequence can never be null"); }

		// EnumerationContext can't be null if there is more data available
		if ((endOfSequence.booleanValue() == false) && (enumContext == null)) { throw new IllegalArgumentException(
				"Invalid argument : EnumerationContext cannot be null if there is more data available"); }

CloseableIterator<CIMObjectPath> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

CloseableIterator<CIMObjectPath> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

CloseableIterator<CIMClass> iter = getIterator(is, pObjectName);

			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMInstance> associatorInstances(CIMObjectPath pObjectName,

if (pAssocClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "AssocClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pAssocClass);
		}
		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}
		if (pResultRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultRole");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMInstance> associatorInstances(CIMObjectPath pObjectName,

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public EnumerateResponse<CIMInstance> associators(CIMObjectPath pObjectName,

CloseableIterator<CIMInstance> iter = getIterator(is, pObjectName);
			return iter;

		} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public synchronized void close() {

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public void deleteClass(CIMObjectPath pPath) throws WBEMException {

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	public CloseableIterator<CIMClass> associatorClasses(CIMObjectPath pObjectName,

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

	// DSP1033 states that CIMOMs shall include an Interop Namespace and that
	// the name of this Interop Namespace shall be either "interop" (preferred)
	// or "root/interop" while OpenPegasus 2.11 and earlier implemented
	// "root/PG_InterOp" prior to adopting DSP1033.
	private static final String[] InteropNamespaces = { "interop", "root/interop",

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

} catch (WBEMException e) {
			logger.trace(Level.FINE, operation + " request resulted in CIM Error", e);
			throw e;
		} catch (Exception e) {
			if (e.getCause() != null && e.getCause() instanceof WBEMException) {
				logger
						.trace(Level.FINE, operation + " request resulted in CIM Error", e
								.getCause());
				throw (WBEMException) e.getCause();
			}
			logger.trace(Level.FINE, operation + " request failed", e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, null, null, e);
		} finally {
			logger.exit();
		}
	}

iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associators_request
	 * 
	 * @param pDoc
	 * @param pObjectName
	 * @param pAssocClass
	 * @param pResultClass
	 * @param pRole
	 * @param pResultRole
	 * @param pIncludeQualifiers
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @return Element
	 * @throws WBEMException
	 */
	public Element associators_request(Document pDoc, CIMObjectPath pObjectName,

iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList"); // BB
			// fixed
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associators_response
	 * 
	 * @param pDoc
	 * @param pNamedElementA
	 * @return Element
	 */
	public static Element associators_response(Document pDoc,

else if (this.iHasError) ownedNodeName = ERROR;
			else ownedNodeName = null;
			if (ownedNodeName != null) throw new SAXException(pNodeNameEnum
					+ " child node is invalid for " + getNodeName()
					+ " node, since it already has a " + ownedNodeName + " child node!");
		} else if (pNodeNameEnum == PARAMVALUE) {
			if (this.iHasError) throw new SAXException(pNodeNameEnum
					+ " child node is invalid for " + getNodeName()
					+ " node, since it already has an ERROR child node!");
		} else throw new SAXException(getNodeName() + " node cannot have " + pNodeNameEnum
				+ " child node!");
	}

	/**
	 * @param pChild
	 */
	@Override
	public void childParsed(Node pChild) {
		if (pChild instanceof ErrorNode) {
			this.iHasError = true;
			this.iErrorNode = (ErrorNode) pChild;

private static String pad(int pDigits, int pNum) {
		String str = Integer.toString(pNum);
		int len = Math.max(pDigits, str.length());
		char[] cA = new char[len];
		int paddingDigits = pDigits - str.length();
		int dIdx = 0;
		while (dIdx < paddingDigits)
			cA[dIdx++] = '0';
		int sIdx = 0;
		while (dIdx < len)
			cA[dIdx++] = str.charAt(sIdx++);
		return new String(cA);
	}

	/**
	 * formatWorker
	 * 
	 * @param pMillis
	 *            - total milliseconds
	 * @param pIncludeMillis
	 *            - include milliseconds in String
	 * @return formatted date/time String. ( YYYY.MM.DD HH:mm:SS[.sss] )
	 */
	private static String formatWorker(long pMillis, boolean pIncludeMillis) {

private static byte BASE64_ALPHABET[] = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
			78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103,
			104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
			121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47 };

this.iInternalListenerTraceConsole = new TraceListener() {

					public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage) {
						LogRecord record = new LogRecord(pLevel, pMessage);
						record.setSourceMethodName(String.valueOf(pOrigin));
						logger.log(record);
					}

					public void trace(Level pLevel, StackTraceElement pOrigin, String pMessage,
							Throwable pThrown) {
						LogRecord record = new LogRecord(pLevel, pMessage);
						record.setSourceMethodName(String.valueOf(pOrigin));
						record.setThrown(pThrown);
						logger.log(record);
					}
				};
				addTraceListener(this.iInternalListenerTraceConsole);

final LogAndTraceBroker logger = LogAndTraceBroker.getBroker();
		logger.entry();

		checkState();

		try {

			if (pObjectName == null || pObjectName.getNamespace() == null
					|| pObjectName.getObjectName() == null) { throw new WBEMException(
					WBEMException.CIM_ERR_INVALID_PARAMETER, "Invalid object path"); }

			HttpHeader hh = new HttpHeader();
			hh.addField("CIMObject", HttpHeader.encode(pObjectName.getNamespace(), "UTF-8",
					"US-ASCII"));

			Document doc = this.iXmlHelper.newDocument();

			this.iXmlHelper.createCIMMessage(doc, this.iXmlHelper.associatorNames_request(doc,

public Element createQualifierType_request(Document pDoc, CIMObjectPath pPath,
			CIMQualifierType<?> pQt) throws WBEMException {
		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl
				.createIMETHODCALL(pDoc, simplereqE, "SetQualifier");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
				"QualifierDeclaration");
		CIMXMLBuilderImpl.createQUALIFIER_DECLARATION(pDoc, iparamvalueE, pQt);

		return simplereqE;
	}

	/**
	 * deleteClass_request
	 * 
	 * @param pDoc
	 * @param pPath
	 * @return Element
	 * @throws WBEMException
	 */
	public Element deleteClass_request(Document pDoc, CIMObjectPath pPath) throws WBEMException {

}

	/**
	 * Get a qualifier by index.
	 * 
	 * @param pIndex
	 *            The index of the qualifier to retrieve.
	 * @return The qualifier at the specified index.
	 * @throws ArrayIndexOutOfBoundsException
	 */
	public CIMQualifier<?> getQualifier(int pIndex) throws ArrayIndexOutOfBoundsException {
		return this.iQualiImpl.getQualifier(pIndex);
	}

	/**
	 * Gets a qualifier by name.
	 * 
	 * @param pName
	 *            The name of the qualifier to get.
	 * @return The qualifier requested or <code>null</code> if the qualifier
	 *         does not exist.
	 */
	public CIMQualifier<?> getQualifier(String pName) {
		return this.iQualiImpl.getQualifier(pName);
	}

	/**
	 * Get the number of qualifiers defined in this CIM class.
	 * 
	 * @return The number of qualifiers defined in the CIM class.
	 */
	public int getQualifierCount() {
		return this.iQualiImpl.getQualifierCount();
	}

	/**
	 * Returns the list of qualifiers for the CIM class.
	 * 
	 * @return Qualifiers for this class.
	 */
	public CIMQualifier<?>[] getQualifiers() {
		return this.iQualiImpl.getQualifiers();
	}

	/**
	 * Gets a qualifier value by name.
	 * 
	 * @param pName
	 *            The name of the qualifier to get.
	 * @return <code>null</code> if the qualifier does not exist or value is
	 *         <code>null</code>, otherwise returns the reference to the
	 *         qualifier.
	 */
	public Object getQualifierValue(String pName) {
		return this.iQualiImpl.getQualifierValue(pName);
	}

	/**
	 * Gets the name of the parent of this CIM class.
	 * 
	 * @return The name of the parent class.
	 */
	public String getSuperClassName() {

final LogAndTraceBroker logger = LogAndTraceBroker.getBroker();
		logger.entry();

		checkState();

		try {
			if (pPath == null || pPath.getNamespace() == null) { throw new WBEMException(
					WBEMException.CIM_ERR_INVALID_PARAMETER, "Invalid object path"); }

			HttpHeader hh = new HttpHeader();
			hh.addField("CIMObject", HttpHeader.encode(pPath.getNamespace(), "UTF-8", "US-ASCII"));

			Document doc = this.iXmlHelper.newDocument();
			this.iXmlHelper.createCIMMessage(doc, this.iXmlHelper.enumerateClassNames_request(doc,

"OpenReferenceInstancePaths");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
				INSTANCE_NAME);
		CIMXMLBuilderImpl.createINSTANCENAME(pDoc, iparamvalueE, pPath);

		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, RESULT_CLASS);
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, ROLE);
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

.getValue();
			else throw new IllegalArgumentException(
					"Invalid argument : only EnumerationContext and EndOfSequence are allowed");
		}
		// EndOfSequence can never be null
		if (endOfSequence == null) { throw new IllegalArgumentException(
				"Invalid argument : EndOfSequence can never be null"); }

		// EnumerationContext can't be null if there is more data available
		if ((endOfSequence.booleanValue() == false) && (enumContext == null)) { throw new IllegalArgumentException(
				"Invalid argument : EnumerationContext cannot be null if there is more data available"); }

		this.enumResponse = new EnumerateResponse<T>(enumContext, (CloseableIterator<T>) iter,
				endOfSequence.booleanValue());
	}

	/**
	 * Returns enumResponse
	 * 
	 * @return The value of enumResponse.
	 */
	public EnumerateResponse<T> getEnumResponse() {
		return this.enumResponse;
	}

}

Element iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "ObjectName");
		// createOBJECTNAME will internally call createINSTANCENAME to populate
		// Element containing keys
		CIMXMLBuilderImpl.createOBJECTNAME(pDoc, iparamvalueE, pPath);

		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");

CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pResultRole);
		}

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associatorClasses_request
	 * 
	 * @param pDoc
	 * @param pObjectName
	 * @param pAssocClass
	 * @param pResultClass
	 * @param pRole
	 * @param pResultRole
	 * @param pIncludeQualifiers
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @return Element
	 * @throws WBEMException
	 */
	public Element associatorClasses_request(Document pDoc, CIMObjectPath pObjectName,

iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "LocalOnly");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pLocalOnly);

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "DeepInheritance");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pDeepInheritance);

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "IncludeQualifiers");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeQualifiers);

		iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "IncludeClassOrigin");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList");
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associatorClasses_request
	 * 
	 * @param pDoc
	 * @param pObjectName
	 * @param pAssocClass
	 * @param pResultClass
	 * @param pRole
	 * @param pResultRole
	 * @param pIncludeQualifiers
	 * @param pIncludeClassOrigin
	 * @param pPropertyList
	 * @return Element
	 * @throws WBEMException
	 */
	public Element associatorClasses_request(Document pDoc, CIMObjectPath pObjectName,

"EnumerateClasses");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE;
		if (pPath != null && pPath.getObjectName() != null
				&& pPath.getObjectName().trim().length() != 0) {
			String className = pPath.getObjectName();
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ClassName");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, className);
		}
		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "LocalOnly");

Element iparamvalueE = CIMXMLBuilderImpl
				.createIPARAMVALUE(pDoc, imethodcallE, "ObjectName");
		CIMXMLBuilderImpl.createOBJECTNAME(pDoc, iparamvalueE, pPath);

		if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

}

	@Override
	public void testCompletness() {
	// no mandatory child nodes
	}

	public CIMError getCIMError() {
		return this.iErrorNode == null ? null : this.iErrorNode.getCIMError();
	}

	public int getReturnValueCount() {
		return this.iRetValNode == null ? 0 : this.iRetValNode.getReturnValueCount();
	}

	public Object readReturnValue() {
		return this.iRetValNode.readReturnValue();
	}

	/**
	 * getName
	 * 
	 * @return String
	 */
	public String getName() {
		return this.iName;
	}

try {
									this.iPrevAuthInfo = getAuthentication(false,
											this.iPrevAuthInfo, authenticate);
									if (this.iPrevAuthInfo != null) {
										this.iRequestHeaders.addField(this.iPrevAuthInfo
												.getHeaderFieldName(), this.iPrevAuthInfo
												.toString());
									}
								} catch (NoSuchAlgorithmException e) {
									logger.trace(Level.FINER, "Unable to find digest algorithm", e);
								} catch (IllegalArgumentException e) {
									logger
											.trace(
													Level.FINER,

Element[] paramValElementA = searchNodes(pMethodResponseE, "PARAMVALUE", 0,
				Integer.MAX_VALUE, true);
		if (paramValElementA != null) {
			Vector<Object> v = new Vector<Object>();
			for (int i = 0; i < paramValElementA.length; i++) {
				Element paramvalueE = paramValElementA[i];
				CIMArgument<?> arg = parsePARAMVALUE(paramvalueE);
				v.add(arg);
			}
			response.addParamValue(v);
		}

INSTANCENAME, CLASSNAME, QUALIFIER_DECLARATION, CLASS, INSTANCE, VALUE_NAMEDINSTANCE };

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		boolean allowed = false;
		for (int i = 0; i < ALLOWED_CHILDREN.length; i++) {
			if (ALLOWED_CHILDREN[i] == pNodeNameEnum) {
				allowed = true;
				break;
			}
		}
		if (!allowed) throw new SAXException(getNodeName() + " node cannot have " + pNodeNameEnum
				+ " child node!");
		/*
		 * this kind of check is not so strict (ValueNode.getValue() can return
		 * null)
		 */
		if (this.iValue != null) throw new SAXException(getNodeName()

that.getBytes();
			if (this.iBytes != null && that.iBytes != null) {
				for (int i = this.iLength - 1; i >= 0; i--)
					if (this.iBytes[i].byteValue() != that.iBytes[i].byteValue()) return false;
				numCompares++;
			}
		}

		// Octet strings equal if byte arrays equal
		if (numCompares > 0) return true;

		if (this.iBytes == null && that.iBytes != null) {

PROPERTY_REFERENCE, METHOD };

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		for (int i = 0; i < ALLOWED_CHILDREN.length; i++)
			if (ALLOWED_CHILDREN[i] == pNodeNameEnum) return;
		throw new SAXException(getNodeName() + " node cannot have " + pNodeNameEnum
				+ " child node!");
	}

	@Override
	public void childParsed(Node pChild) {
		if (this.iQualiHandler.addQualifierNode(pChild)) return;
		if (pChild instanceof AbstractPropertyNode) {

createCLASSPATH(pDoc, valueobjectwithpathE, clazz.getObjectPath());
			createCLASS(pDoc, valueobjectwithpathE, clazz);
		} else if (pObj instanceof CIMInstance) {
			CIMInstance inst = (CIMInstance) pObj;
			if (inst.getObjectPath().getNamespace() == null
					|| inst.getObjectPath().getNamespace().length() == 0) {
				// ebak: changing the namespace ins inst's objectPath
				// inst.getObjectPath().setNameSpace(pNameSpace);
				inst = changeInstanceNameSpace(inst, pNameSpace);
			}

if (pChild instanceof TypedIf) this.iType = ((TypedIf) pChild).getType();
		else if (pChild instanceof ObjectPathIf) this.iType = CIMDataType
				.getDataType(((ObjectPathIf) pChild).getCIMObjectPath());
		else if (pChild instanceof ValueIf) this.iType = CIMDataType.getDataType(((ValueIf) pChild)
				.getValue());

public LogFormatter() {
		super();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.util.logging.Formatter#format(java.util.logging.LogRecord)
	 */
	@Override
	public String format(LogRecord pRecord) {
		StringBuffer buffer = new StringBuffer();
		buffer.append(TimeStamp.format(pRecord.getMillis()));
		buffer.append(" >");
		buffer.append(String.valueOf(pRecord.getThreadID()));
		buffer.append("< ");
		// buffer.append(iLineSeparator);
		buffer.append(pRecord.getLevel().getName());

String ns = null;

		HttpHeaderParser manOptHeader = null;
		if (man != null && man.length() > 0) manOptHeader = new HttpHeaderParser(man);
		else if (opt != null && opt.length() > 0) manOptHeader = new HttpHeaderParser(opt);
		if (manOptHeader != null) ns = manOptHeader.getValue("ns");

		if (ns != null) {

if (ch1 >= '0' && ch1 <= '9') value = value * 16 + (ch1 - '0');
						else if (ch1 >= 'A' && ch1 <= 'F' || ch1 >= 'a' && ch1 <= 'f') value = value
								* 16 + (Character.toUpperCase(ch1) - 'A' + 10);
						else if (ch1 == ';') break;
						else throw new XMLPullParserException(

|| pClass.getObjectPath().getNamespace() == null) { throw new WBEMException(
					WBEMException.CIM_ERR_INVALID_PARAMETER, "Invalid object path"); }

			HttpHeader hh = new HttpHeader();
			hh.addField("CIMObject", HttpHeader.encode(pClass.getObjectPath().getNamespace(),
					"UTF-8", "US-ASCII"));

			Document doc = this.iXmlHelper.newDocument();
			this.iXmlHelper.createCIMMessage(doc, this.iXmlHelper.createClass_request(doc, pClass

}

	private static final HashMap<String, String> NODENAME_HASH = new HashMap<String, String>();

	private static void initNodeNameHash(String[] pEnumA) {
		for (int i = 0; i < pEnumA.length; i++)
			NODENAME_HASH.put(pEnumA[i], pEnumA[i]);
	}

	static {
		initNodeNameHash(new String[] { "CIM", "DECLARATION", "DECLGROUP", "DECLGROUP.WITHNAME",

final LogAndTraceBroker logger = LogAndTraceBroker.getBroker();
		logger.entry();

		checkState();

		try {
			if (pName == null || pName.getNamespace() == null || pName.getObjectName() == null) { throw new WBEMException(
					WBEMException.CIM_ERR_INVALID_PARAMETER, "Invalid object path"); }

			HttpHeader hh = new HttpHeader();
			hh.addField("CIMObject", HttpHeader.encode(pName.getNamespace(), "UTF-8", "US-ASCII"));

char ch5 = XMLPullParser.this.iBufferChar[startPos + 4];
				if (ch1 == 'a' && ch2 == 'p' && ch3 == 'o' && ch4 == 's' && ch5 == ';') {
					return '\'';
				} else if (ch1 == 'q' && ch2 == 'u' && ch3 == 'o' && ch4 == 't' && ch5 == ';') {
					return '\"';
				} else {
					// TODO return reference
				}
			}
			return -1;
		}

public Element getInstance_request(Document pDoc, CIMObjectPath pName, boolean pLocalOnly,
			boolean pIncludeQualifiers, boolean pIncludeClassOrigin, String[] pPropertyList)
			throws WBEMException {
		// obtain data
		String className = pName.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE, "GetInstance");

this.iRetValNode = null;
		if (this.iCIMArgAL != null) this.iCIMArgAL.clear();
		this.iHasError = false;
		this.iHasRetVal = false;
	}

	/**
	 * @param pData
	 */
	@Override
	public void parseData(String pData) {
	// no data
	}

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		if (pNodeNameEnum == ERROR) {
			String ownedNodeName;
			if (this.iHasRetVal) ownedNodeName = IRETURNVALUE;

} else
		// Values of parameters should be stored in array
		if (pChild instanceof ParamValueNode) {
			if (this.iCIMArgAL == null) this.iCIMArgAL = new ArrayList<CIMArgument<Object>>();
			this.iCIMArgAL.add(((ParamValueNode) pChild).getCIMArgument());
		}
	}

	@Override
	public void testCompletness() {
	// no mandatory child nodes
	}

	public CIMError getCIMError() {
		return this.iErrorNode == null ? null : this.iErrorNode.getCIMError();

CIMObjectPath op = parseCLASSNAME(classnameA[0]);
			if (op != null && op.getNamespace() != null) {
				// LocalPathBuilder includes default namespace in CLASSNAME
				// elements, needs to be stripped
				op = new CIMObjectPath(op.getScheme(), op.getHost(), op.getPort(), null, op
						.getObjectName(), op.getKeys(), op.getXmlSchemaName());
			}
			return op;
		}

else if (this.iHasError) ownedNodeName = ERROR;
			else if (this.iCIMArgAL != null && this.iCIMArgAL.size() > 0) ownedNodeName = PARAMVALUE;
			else ownedNodeName = null;
			if (ownedNodeName != null) throw new SAXException(pNodeNameEnum
					+ " child node is invalid for " + getNodeName()
					+ " node, since it already has a " + ownedNodeName + " child node!");
		} else if (pNodeNameEnum == IRETURNVALUE) {

"VALUE.INSTANCEWITHPATH node must have an INSTANCE child node!");
	}

	/**
	 * @see ValueIf#getValue()
	 * @return CIMInstance
	 */
	public Object getValue() {
		/*
		 * INSTANCENAME contains the key properties only, INSTANCE contains
		 * non-key properties too.
		 */
		if (WBEMConfiguration.getGlobalConfiguration().synchronizeNumericKeyDataTypes()) return CIMHelper
				.CIMInstanceWithSynchonizedNumericKeyDataTypes(this.iCIMInstPath, this.iCIMInstance
						.getProperties());
		return new CIMInstance(this.iCIMInstPath, this.iCIMInstance.getProperties());
	}

	public CIMDataType getType() {
		return CIMDataType.OBJECT_T;
	}

}

CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pIncludeClassOrigin);

		if (pPropertyList != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyList"); // BB
			// fixed
			Element valuearrayE = CIMXMLBuilderImpl.createVALUEARRAY(pDoc, iparamvalueE);
			for (int i = 0; i < pPropertyList.length; i++) {
				CIMXMLBuilderImpl.createVALUE(pDoc, valuearrayE, pPropertyList[i]);
			}
		}

		return simplereqE;
	}

	/**
	 * associators_response
	 * 
	 * @param pDoc
	 * @param pNamedElementA
	 * @return Element
	 */
	public static Element associators_response(Document pDoc,

Vector<String> resStringV = new Vector<String>();
		for (int i = 0; i < nl.getLength(); i++) {
			Node n = nl.item(i);
			if (n instanceof Text && "".equalsIgnoreCase(n.getNodeValue().trim())) continue;
			String name = n.getNodeName();
			if (name.equals("VALUE")) {

Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE, "GetProperty");
		CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE,
				"InstanceName");
		CIMXMLBuilderImpl.createINSTANCENAME(pDoc, iparamvalueE, pPath);

		if (pPropertyName != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "PropertyName");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pPropertyName);
		}

+ "ms of idle time");

							if (this.iSocket != null && !this.iSocket.isClosed()) {
								try {
									this.iSocket.close();
								} catch (IOException e) {
									logger.trace(Level.FINER,
											"Exception caught while closing socket", e);
								}
							}
							this.iSocket = null;
							this.iReset = true;
							this.iResponse = null;

String pAssocClass, String pResultClass, String pRole, String pResultRole,
			String pFilterQueryLanguage, String pFilterQuery, UnsignedInteger32 pOperationTimeout,
			boolean pContinueOnError, UnsignedInteger32 pMaxObjectCount) throws WBEMException {

		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE,

return new CIMArgument<Object>(name, embObjHandler.getType(), embObjHandler.getValue());
		}

		// CLASSNAME
		Element classNameA[] = searchNodes(pParamValueE, "CLASSNAME", 0, 1, false);
		if (classNameA != null) {
			CIMObjectPath op = parseCLASSNAME(classNameA[0]);
			CIMDataType type = new CIMDataType(op.getObjectName());
			return new CIMArgument<Object>(name, type, op);
		}

		// INSTANCENAME
		Element instNameA[] = searchNodes(pParamValueE, "INSTANCENAME", 0, 1, false);

}

		// INSTANCENAME
		Element instNameA[] = searchNodes(pParamValueE, "INSTANCENAME", 0, 1, false);
		if (instNameA != null) {
			CIMObjectPath op = parseINSTANCENAME(instNameA[0]);
			CIMDataType type = new CIMDataType(op.getObjectName());
			return new CIMArgument<Object>(name, type, op);
		}

		// CLASS
		Element classA[] = searchNodes(pParamValueE, "CLASS", 0, 1, false);

super(VALUE_OBJECTWITHLOCALPATH);
	}

	/**
	 * @param pAttribs
	 * @param pSession
	 */
	@Override
	public void init(Attributes pAttribs, SAXSession pSession) {
		this.iPathNodeNameEnum = this.iObjNodeNameEnum = null;
		this.iObjPath = null;
		this.iCIMObj = null;
		// no attributes
	}

	/**
	 * @param pData
	 */
	@Override
	public void parseData(String pData) {
	// no data
	}

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		if (pNodeNameEnum == LOCALCLASSPATH) {

String pAssocClass, String pResultClass, String pRole, String pResultRole)
			throws WBEMException {

		// obtain data
		String className = pObjectName.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");
		CIMProperty<?>[] keysA = pObjectName.getKeys();

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE,

if (pResultClass != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ResultClass");
			CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, pResultClass);
		}
		if (pRole != null) {
			iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "Role");
			CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pRole);
		}

boolean pDeepInheritance, boolean pLocalOnly, boolean pIncludeQualifiers,
			boolean pIncludeClassOrigin, String[] pPropertyList) throws WBEMException {

		// obtain data
		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE,

super(PROPERTY_ARRAY);
	}

	@Override
	protected void specificInit(Attributes pAttribs, SAXSession pSession) throws SAXException {
		this.iHasTypeAttribute = (getCIMType(pAttribs, true) != null);
		this.iEmbObjHandler = EmbObjHandler.init(this.iEmbObjHandler, getNodeName(), pAttribs,
				pSession, this.iQualiHandler, true);
		this.iHasValueArray = false;

this.iMethodCallNode = (ExpMethodCallNode) pChild;
		} else if (pChild instanceof CorrelatorNode) {
			// TODO: return to WBEMClient API if JSR48 changes
		}
	}

	/**
	 * @param pAttribs
	 * @param pSession
	 */
	@Override
	public void init(Attributes pAttribs, SAXSession pSession) {
		this.iMethodCallNode = null;
		// no attributes
	}

	/**
	 * @param pData
	 */
	@Override
	public void parseData(String pData) {
	// no data
	}

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		if (pNodeNameEnum == EXPMETHODCALL) {

public void trace(Level pLevel, String pMessage) {
		try {
			if (isLoggableTrace(pLevel)) {
				final List<TraceListener> traceListeners = getTraceListeners();
				StackTraceElement caller = getCaller();
				for (int i = 0; i < traceListeners.size(); ++i) {
					traceListeners.get(i).trace(pLevel, caller, pMessage);

trace(Level.SEVERE, msg, e);
			throw new WBEMException(WBEMException.CIM_ERR_FAILED, msg, null, e);
		}
		CIMXMLParserImpl.setLocalObjectPath(pLocalPath);
		CIMMessage cimMsg;
		try {
			cimMsg = CIMXMLParserImpl.parseCIM(dom.getDocumentElement());
		} catch (CIMXMLParseException e) {
			String msg = "Exception occurred during parseCIM!";

public Element associatorClasses_request(Document pDoc, CIMObjectPath pObjectName,
			String pAssocClass, String pResultClass, String pRole, String pResultRole,
			boolean pIncludeQualifiers, boolean pIncludeClassOrigin, String[] pPropertyList)
			throws WBEMException {

		String className = pObjectName.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

public Element createClass_request(Document pDoc, CIMObjectPath pPath, CIMClass pClass)
			throws WBEMException {
		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE, "CreateClass");

public Element EnumerationCount_request(Document pDoc, CIMObjectPath pPath,
			String pEnumerationContext) throws WBEMException {

		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

		Element simplereqE = CIMXMLBuilderImpl.createSIMPLEREQ(pDoc);
		Element imethodcallE = CIMXMLBuilderImpl.createIMETHODCALL(pDoc, simplereqE,

byte3 = (short) (pPlain[source++] & 0xFF);

			highBits = (short) (byte1 & 0x03);
			lowBits = (short) (byte2 & 0x0F);

			short val1 = (short) (byte1 >> 2);
			short val2 = (short) (byte2 >> 4);

this.iInternalListenerLogConsole = new LogListener() {

					public void log(Level pLevel, String pMessageKey, String pMessage,
							Object[] pParameters) {
						LogRecord record = new LogRecord(pLevel, pMessageKey + " " + pMessage);
						record.setParameters(pParameters);
						logger.log(record);
					}
				};
				addLogListener(this.iInternalListenerLogConsole);

private void expire(String pDirectory) {
		List<AdvertisementDecorator> advertisementList = this.iCatalogByDirectory.get(pDirectory);
		if (advertisementList == null) { return; }
		Iterator<AdvertisementDecorator> iter = advertisementList.iterator();
		while (iter.hasNext()) {
			AdvertisementDecorator advertisement = iter.next();

CIMXMLBuilderImpl.createLOCALNAMESPACEPATH(pDoc, imethodcallE, pPath);

		Element iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "ClassName");
		CIMXMLBuilderImpl.createCLASSNAME(pDoc, iparamvalueE, className);
		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "LocalOnly");
		CIMXMLBuilderImpl.createVALUE(pDoc, iparamvalueE, pLocalOnly);

		iparamvalueE = CIMXMLBuilderImpl.createIPARAMVALUE(pDoc, imethodcallE, "DeepInheritance");

CloseableIterator<?> iter = new CloseableIteratorDOM(pStream, pPath);

		// check for error and CIMExceptions
		try {
			iter.hasNext();
		} catch (RuntimeException e) {
			iter.close();
			if (e.getCause() != null && e.getCause() instanceof WBEMException) { throw (WBEMException) e
					.getCause(); }
			throw e;
		}

ReliableIndication indication = this.iQueue.removeFirst();
			logMissingQueueEntries(indication.getSequenceNumber());

			this.iDispatcher.dispatchEvent(new CIMEvent(indication.getIndication(), indication
					.getId(), indication.getInetAddress()));

			this.iExpectedSequenceNumber = indication.getSequenceNumber() + 1;

private void convertBytesToHexString() {
		// Start with "0x"
		StringBuilder str = new StringBuilder("0x");

		// Append length
		String len = Integer.toHexString(this.iLength);
		for (int i = 8 - len.length(); i > 0; i--)
			str.append('0');
		str.append(len);

		// Append string
		for (int i = 4; i < this.iLength; i++) {

Element valueobjectwithpathE = pDoc.createElement("VALUE.OBJECTWITHPATH");
		if (pObj instanceof CIMClass) {
			CIMClass clazz = (CIMClass) pObj;

			if (clazz.getObjectPath().getNamespace() == null
					|| clazz.getObjectPath().getNamespace().length() == 0) {
				// ebak: changing the namespace in clazz's objectPath
				// clazz.getObjectPath().setNameSpace(pNameSpace);
				clazz = changeClassNameSpace(clazz, pNameSpace);
			}

if (this.iStrictParsing) {
						/*
						 * In case of strict parsing Object means CIMClass,
						 * Instance means CIMInstance. Pegasus 2.7.0 seems to
						 * handle it this way.
						 */
						this.iType = isEmbeddedInstance() ? CIMDataType.OBJECT_T
								: CIMDataType.CLASS_T;
					} else {
						/*
						 * for valueless EmbeddedObject="object" the type is
						 * undeterminable since Pegasus's CIMObject can contain
						 * both CIMClass and CIMInstance
						 */
						this.iType = isEmbeddedInstance() ? CIMDataType.OBJECT_T
								: CIMDataType.STRING_T;
					}
				} else {
					this.iType = this.iRawType;
				}
				this.iValue = null;
			} else {

private static boolean hasNodes(Element pParentE) {
		NodeList nl = pParentE.getChildNodes();
		if (nl == null || nl.getLength() == 0) return false;
		for (int i = 0; i < nl.getLength(); i++) {
			Node n = nl.item(i);

+ " node must have a LOCALCLASSPATH or a LOCALINSTANCEPATH child node!");
		if (this.iObjNodeNameEnum == null) throw new SAXException(getNodeName()
				+ " node must have a CLASS or INSTANCE child node!");
	}

	/**
	 * @see ValueIf#getValue()
	 * @return CIMClass or CIMInstance
	 */
	public Object getValue() {
		return this.iCIMObj;
	}

	public CIMDataType getType() {
		if (this.iCIMObj instanceof CIMClass) return CIMDataType.CLASS_T;
		return CIMDataType.OBJECT_T;
	}

}

list.add((T) iter.next());
		} catch (RuntimeException e) {
			iter.close();
			if (e.getCause() != null && e.getCause() instanceof WBEMException) { throw (WBEMException) e
					.getCause(); }
			throw e;
		}

		// pOutArgA can never be null
		CIMArgument<?>[] pOutArgA = ((CloseableIteratorPULL) iter).getCIMArguments();

Element[] instElementA = searchNodes(pErrorE, "INSTANCE", 0, Integer.MAX_VALUE, false);
		if (instElementA != null) {
			for (int i = 0; i < instElementA.length; i++) {
				Element instanceE = instElementA[i];
				CIMInstance inst = parseINSTANCE(instanceE);
				rtnV.add(inst);
			}

} catch (ServiceLocationException e) {
			LogAndTraceBroker.getBroker().trace(Level.FINE, "SLP discovery failed with error", e);
		} catch (Exception e) {
			LogAndTraceBroker.getBroker()
					.trace(Level.FINE, "Exception during service discovery", e);
		}
		logger.exit();
		return new LinkedList<WBEMServiceAdvertisement>();

Iterator<Entry<HeaderEntry, String>> iterator = this.iResponseHeaders.iterator();
		while (iterator.hasNext() && --index >= 0) {
			Entry<HeaderEntry, String> entry = iterator.next();
			if (index == 0) return entry.getValue().toString();

super(VALUE_INSTANCEWITHPATH);
	}

	/**
	 * @param pAttribs
	 * @param pSession
	 */
	@Override
	public void init(Attributes pAttribs, SAXSession pSession) {
		// no attribute
		this.iCIMInstPath = null;
		this.iCIMInstance = null;
	}

	/**
	 * @param pData
	 */
	@Override
	public void parseData(String pData) {
	// no data
	}

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		if (pNodeNameEnum == INSTANCEPATH) {

.getValue();
			else throw new IllegalArgumentException(
					"Invalid argument : only EnumerationContext and EndOfSequence are allowed");
		}
		// EndOfSequence can never be null
		if (endOfSequence == null) { throw new IllegalArgumentException(
				"Invalid argument : EndOfSequence can never be null"); }

		// EnumerationContext can't be null if there is more data available
		if ((endOfSequence.booleanValue() == false) && (enumContext == null)) { throw new IllegalArgumentException(
				"Invalid argument : EnumerationContext cannot be null if there is more data available"); }

public Element referenceClasses_request(Document pDoc, CIMObjectPath pPath,
			String pResultClass, String pRole, boolean pIncludeQualifiers,
			boolean pIncludeClassOrigin, String[] pPropertyList) throws WBEMException {

		String className = pPath.getObjectName();
		if (className == null) throw new WBEMException(WBEMException.CIM_ERR_INVALID_PARAMETER,
				"null class name");

this.iChildNode = null;
	}

	/**
	 * @param pData
	 */
	@Override
	public void parseData(String pData) {
	// no data
	}

	@Override
	public void testChild(String pNodeNameEnum) throws SAXException {
		if (this.iChildNode != null) throw new SAXException(getNodeName()
				+ " node can have only one child node!");
		if (pNodeNameEnum != INSTANCE) throw new SAXException(getNodeName() + " node cannot have "

this.iTextOut.newLine();
				if (this.iAutoFlush) this.out.flush();
			}
		} catch (InterruptedIOException x) {
			Thread.currentThread().interrupt();
		} catch (IOException x) {
			this.iTrouble = x;
		}
	}

	@Override
	public void write(byte buf[], int off, int len) {

}

	/**
	 * Required to handle the output XML of some non-standard CIMOMs like SVC
	 * which adds the TYPE attribute to the sub VALUE or VALUE.ARRAY XML
	 * element.
	 * 
	 * @param pTypedIf
	 * @throws SAXException
	 */
	private void setType(TypedIf pTypedIf) throws SAXException {
		if (this.iType != null) return;
		this.iType = pTypedIf.getType();
		if (this.iType == null) throw new SAXException("Unknown type for Qualifier declaration in "
				+ getNodeName() + " node!");
	}

Enumeration<?> serviceEnum = locator.findServices(SLPDefaults.DA_SERVICE_TYPE,
					this.iScopes, "");

			while (serviceEnum != null && serviceEnum.hasMoreElements()) {
				ServiceURL url = (ServiceURL) serviceEnum.nextElement();
				agents.add(url.getHost());
			}

			logger.trace(Level.FINER, "SLP DA discovery completed in local subnet. "

char ch3 = XMLPullParser.this.iBufferChar[startPos + 2];

			if (ch1 == 'l' && ch2 == 't' && ch3 == ';') {
				return '<';
			} else if (ch1 == 'g' && ch2 == 't' && ch3 == ';') {
				return '>';
			} else {
				char ch4 = XMLPullParser.this.iBufferChar[startPos + 3];