C++ CIMParamValue类代码示例

void
CIMParamValueToXML(CIMParamValue const& pv, std::ostream& ostr)
{
	ostr << "<PARAMVALUE NAME=\"" << pv.getName() << "\"";
	if (pv.getValue())
	{
		String type = pv.getValue().getCIMDataType().toString();
		if (type == "REF")
		{
			type = "reference";
		}
		ostr << " PARAMTYPE=\"" << type << "\"";
		
		if (pv.getValue().getCIMDataType().isEmbeddedObjectType())
		{
			ostr << " EmbeddedObject=\"object\"";
		}

		ostr << ">";
		CIMtoXML(pv.getValue(), ostr);
	}
	else
	{
		ostr << '>';
	}
	ostr << "</PARAMVALUE>";
}

void UNIX_BGPEndpointStatisticsProvider::invokeMethod(
	const OperationContext& context,
	const CIMObjectPath& objectReference,
	const CIMName& methodName,
	const Array<CIMParamValue>& inParameters,
	MethodResultResponseHandler& handler)
{
	if (!objectReference.getClassName().equal("UNIX_BGPEndpointStatistics") && !objectReference.getClassName().equal("CIM_BGPEndpointStatistics")) {
		String classMessage;
		classMessage.append("UNIX_BGPEndpointStatistics Provider");
		classMessage.append (" does not support class ");
		classMessage.append (objectReference.getClassName().getString());
		throw CIMNotSupportedException(classMessage);
	}


	handler.processing();
	// Make cimom handle invokeMethod request with input parameters.
	CIMObjectPath localReference = CIMObjectPath(
		String(""),
		CIMNamespaceName("root/cimv2"),
		objectReference.getClassName(),
		objectReference.getKeyBindings());
	
	if (methodName.equal("ResetSelectedStats")) {

		if (inParameters.size() != 1)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking ResetSelectedStats method.
		Uint32 invokeResetSelectedStatsReturnValue;

		Array<String> inSelectedStatistics;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "SelectedStatistics"))
			{
				p.getValue().get(inSelectedStatistics);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeResetSelectedStatsReturnValue = _p.invokeResetSelectedStats(

			inSelectedStatistics
		);
		_p.finalize();
		handler.deliver(invokeResetSelectedStatsReturnValue);

	}
	else {
		String message;
		message.append("UNIX_BGPEndpointStatistics");
		message.append (" does not support invokeMethod");
		throw CIMNotSupportedException(message);
	}
}

void testUninitializedObject()
{
    CIMParamValue uninitializedParamValue;
    String name("name");
    CIMValue value(String("value"));

    PEGASUS_TEST_ASSERT(uninitializedParamValue.isUninitialized());

    // Copy constructor allows an uninitialized object
    {
        CIMParamValue initializedParamValue(uninitializedParamValue);
    }

    // Assignment operator allows an uninitialized object
    {
        CIMParamValue initializedParamValue(name, value);
        initializedParamValue = uninitializedParamValue;
    }

    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.getParameterName());
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.getValue());
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.isTyped());
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.setParameterName(name));
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.setValue(value));
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.setIsTyped(true));
    TEST_UNINITIALIZED_OBJECT_EXCEPTION(
        uninitializedParamValue.clone());
}

CIMInstance CIMHelper::extractInstanceParameter(const Array<CIMParamValue>& inParameters, String name)
{
    for(Uint32 i = 0; i < inParameters.size(); i++)
    {
    	CIMParamValue paramValue = inParameters[i];
    	CIMName paramName = paramValue.getParameterName();
    	if (paramName.equal(name))
    	{
    		CIMInstance value;
    		paramValue.getValue().get(value);
    		return value;
    	}
    }
    return CIMInstance();
}

String CIMHelper::extractStringParameter(const Array<CIMParamValue>& inParameters, String name)
{
    for(Uint32 i = 0; i < inParameters.size(); i++)
    {
    	CIMParamValue paramValue = inParameters[i];
    	CIMName paramName = paramValue.getParameterName();
    	if (paramName.equal(name))
    	{
    		String s;
    		paramValue.getValue().get(s);
    		return s;
    	}
    }
    return CIMHelper::EmptyString;
}

void InvokeMethodResponseHandler::deliverParamValue(const CIMParamValue & cimParamValue)
{
    if(cimParamValue.isUninitialized())
    {
        MessageLoaderParms message(
            "Common.Exception.UNINITIALIZED_OBJECT_EXCEPTION",
            "The object is not initialized.");

        throw CIMException(CIM_ERR_FAILED, message);
    }

    SimpleMethodResultResponseHandler::deliverParamValue(cimParamValue);
}

void UNIX_AutonomousSystemProvider::invokeMethod(
	const OperationContext& context,
	const CIMObjectPath& objectReference,
	const CIMName& methodName,
	const Array<CIMParamValue>& inParameters,
	MethodResultResponseHandler& handler)
{
	if (!objectReference.getClassName().equal("UNIX_AutonomousSystem") && !objectReference.getClassName().equal("CIM_AutonomousSystem")) {
		String classMessage;
		classMessage.append("UNIX_AutonomousSystem Provider");
		classMessage.append (" does not support class ");
		classMessage.append (objectReference.getClassName().getString());
		throw CIMNotSupportedException(classMessage);
	}


	handler.processing();
	// Make cimom handle invokeMethod request with input parameters.
	CIMObjectPath localReference = CIMObjectPath(
		String(""),
		CIMNamespaceName("root/cimv2"),
		objectReference.getClassName(),
		objectReference.getKeyBindings());
	
	if (methodName.equal("RequestStateChange")) {

		if (inParameters.size() != 3)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking RequestStateChange method.
		Uint32 invokeRequestStateChangeReturnValue;

		Uint16 inRequestedState;
		CIMInstance inJob;
		CIMDateTime inTimeoutPeriod;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "RequestedState"))
			{
				p.getValue().get(inRequestedState);
			}
			if (String::equalNoCase(p.getParameterName(), "Job"))
			{
				p.getValue().get(inJob);
			}
			if (String::equalNoCase(p.getParameterName(), "TimeoutPeriod"))
			{
				p.getValue().get(inTimeoutPeriod);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeRequestStateChangeReturnValue = _p.invokeRequestStateChange(

			inRequestedState,
			inJob,
			inTimeoutPeriod
		);
		_p.finalize();
		handler.deliver(invokeRequestStateChangeReturnValue);

	}
	else {
		String message;
		message.append("UNIX_AutonomousSystem");
		message.append (" does not support invokeMethod");
		throw CIMNotSupportedException(message);
	}
}

void UNIX_CPUDiagnosticTestProvider::invokeMethod(
	const OperationContext& context,
	const CIMObjectPath& objectReference,
	const CIMName& methodName,
	const Array<CIMParamValue>& inParameters,
	MethodResultResponseHandler& handler)
{
	if (!objectReference.getClassName().equal("UNIX_CPUDiagnosticTest") && !objectReference.getClassName().equal("CIM_CPUDiagnosticTest")) {
		String classMessage;
		classMessage.append("UNIX_CPUDiagnosticTest Provider");
		classMessage.append (" does not support class ");
		classMessage.append (objectReference.getClassName().getString());
		throw CIMNotSupportedException(classMessage);
	}


	handler.processing();
	// Make cimom handle invokeMethod request with input parameters.
	CIMObjectPath localReference = CIMObjectPath(
		String(""),
		CIMNamespaceName("root/cimv2"),
		objectReference.getClassName(),
		objectReference.getKeyBindings());
	
	if (methodName.equal("RunTest")) {

		if (inParameters.size() != 3)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking RunTest method.
		Uint32 invokeRunTestReturnValue;

		CIMInstance inSystemElement;
		CIMInstance inSetting;
		CIMInstance inResult;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "SystemElement"))
			{
				p.getValue().get(inSystemElement);
			}
			if (String::equalNoCase(p.getParameterName(), "Setting"))
			{
				p.getValue().get(inSetting);
			}
			if (String::equalNoCase(p.getParameterName(), "Result"))
			{
				p.getValue().get(inResult);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeRunTestReturnValue = _p.invokeRunTest(

			inSystemElement,
			inSetting,
			inResult
		);
		_p.finalize();
		handler.deliver(invokeRunTestReturnValue);

	}
	else if (methodName.equal("ClearResults")) {

		if (inParameters.size() != 2)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking ClearResults method.
		Uint32 invokeClearResultsReturnValue;

		CIMInstance inSystemElement;
		Array<String> inResultsNotCleared;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "SystemElement"))
			{
				p.getValue().get(inSystemElement);
			}
			if (String::equalNoCase(p.getParameterName(), "ResultsNotCleared"))
			{
				p.getValue().get(inResultsNotCleared);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeClearResultsReturnValue = _p.invokeClearResults(

			inSystemElement,
			inResultsNotCleared
		);
		_p.finalize();
		handler.deliver(invokeClearResultsReturnValue);

	}
//.........这里部分代码省略.........

void UNIX_AggregatePSExtentProvider::invokeMethod(
	const OperationContext& context,
	const CIMObjectPath& objectReference,
	const CIMName& methodName,
	const Array<CIMParamValue>& inParameters,
	MethodResultResponseHandler& handler)
{
	if (!objectReference.getClassName().equal("UNIX_AggregatePSExtent") && !objectReference.getClassName().equal("CIM_AggregatePSExtent")) {
		String classMessage;
		classMessage.append("UNIX_AggregatePSExtent Provider");
		classMessage.append (" does not support class ");
		classMessage.append (objectReference.getClassName().getString());
		throw CIMNotSupportedException(classMessage);
	}


	handler.processing();
	// Make cimom handle invokeMethod request with input parameters.
	CIMObjectPath localReference = CIMObjectPath(
		String(""),
		CIMNamespaceName("root/cimv2"),
		objectReference.getClassName(),
		objectReference.getKeyBindings());
	
	if (methodName.equal("SetPowerState")) {

		if (inParameters.size() != 2)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking SetPowerState method.
		Uint32 invokeSetPowerStateReturnValue;

		Uint16 inPowerState;
		CIMDateTime inTime;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "PowerState"))
			{
				p.getValue().get(inPowerState);
			}
			if (String::equalNoCase(p.getParameterName(), "Time"))
			{
				p.getValue().get(inTime);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeSetPowerStateReturnValue = _p.invokeSetPowerState(

			inPowerState,
			inTime
		);
		_p.finalize();
		handler.deliver(invokeSetPowerStateReturnValue);

	}
	else if (methodName.equal("Reset")) {

		if (inParameters.size() != 0)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking Reset method.
		Uint32 invokeResetReturnValue;

		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeResetReturnValue = _p.invokeReset();
		_p.finalize();
		handler.deliver(invokeResetReturnValue);

	}
	else if (methodName.equal("EnableDevice")) {

		if (inParameters.size() != 1)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking EnableDevice method.
		Uint32 invokeEnableDeviceReturnValue;

		Boolean inEnabled;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "Enabled"))
			{
				p.getValue().get(inEnabled);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeEnableDeviceReturnValue = _p.invokeEnableDevice(

			inEnabled
//.........这里部分代码省略.........

void test01()
{
    CIMParamValue pv;
    PEGASUS_TEST_ASSERT(pv.isUninitialized());

    String p1("message");
    CIMValue v1(String("argument_Test"));
    CIMParamValue a1(p1, v1);

//  Test call to CIMParamValue::setValue(CIMValue& value)
//  this test uses the above values for a1, p1 and v1.
    CIMParamValue a7(p1, v1);
    CIMValue v7(String("argument_Test7"));
    a7.setValue( v7);
    PEGASUS_TEST_ASSERT(a1.getValue().toString() != a7.getValue().toString());
    PEGASUS_TEST_ASSERT(a1.getParameterName() == a7.getParameterName());

//  Test call to CIMParamValue::setParameterName(String& parameterName)
//  this test uses the above values for a1, p1 and v1.
    CIMParamValue a8(p1, v1);
    String p8("message8");
    a8.setParameterName( p8);
    PEGASUS_TEST_ASSERT(a1.getValue().toString() == a8.getValue().toString());
    PEGASUS_TEST_ASSERT(a1.getParameterName() != a8.getParameterName());
    PEGASUS_TEST_ASSERT(a8.isTyped());
    a8.setIsTyped(false);
    PEGASUS_TEST_ASSERT(!a8.isTyped());

    String p2("message2");
    CIMValue v2(String("argument_Test2"));
    CIMParamValue a2(p2, v2);

    String p3("message3");
    CIMValue v3(String("argument_Test3"));
    CIMParamValue a3(p3, v3);

    String p4("message4");
    CIMValue v4(String("argument_Test4"));
    CIMParamValue a4(p4, v4);
    CIMParamValue a5 = a4;

    String p6("message6");
    CIMValue v6(String("argument_Test6"));
    CIMParamValue a6(p6, v6);

    Array<CIMParamValue> aa;
    aa.append(a1);
    aa.append(a2);

    aa.append(CIMParamValue("message3", CIMValue(200000)));

    aa.append(CIMParamValue("message4", CIMValue(String("test4"))));
    
    //
    // clone
    //
    CIMParamValue a4clone = a4.clone();
    aa.append(a4clone);

    if (verbose)
    {
        for (Uint32 i=0; i< aa.size(); i++)
        {
            XmlWriter::printParamValueElement(aa[i], cout);
        }
    }

    //
    // toXml
    //
    Buffer xmlOut;
    XmlWriter::appendParamValueElement(xmlOut, a4clone);
}

void UNIX_BatchJobProvider::invokeMethod(
	const OperationContext& context,
	const CIMObjectPath& objectReference,
	const CIMName& methodName,
	const Array<CIMParamValue>& inParameters,
	MethodResultResponseHandler& handler)
{
	if (!objectReference.getClassName().equal("UNIX_BatchJob") && !objectReference.getClassName().equal("CIM_BatchJob")) {
		String classMessage;
		classMessage.append("UNIX_BatchJob Provider");
		classMessage.append (" does not support class ");
		classMessage.append (objectReference.getClassName().getString());
		throw CIMNotSupportedException(classMessage);
	}


	handler.processing();
	// Make cimom handle invokeMethod request with input parameters.
	CIMObjectPath localReference = CIMObjectPath(
		String(""),
		CIMNamespaceName("root/cimv2"),
		objectReference.getClassName(),
		objectReference.getKeyBindings());
	
	if (methodName.equal("RequestStateChange")) {

		if (inParameters.size() != 0)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking RequestStateChange method.
		Uint32 invokeRequestStateChangeReturnValue;

		Uint16 inRequestedState;
		CIMDateTime inTimeoutPeriod;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "RequestedState"))
			{
				p.getValue().get(inRequestedState);
			}
			if (String::equalNoCase(p.getParameterName(), "TimeoutPeriod"))
			{
				p.getValue().get(inTimeoutPeriod);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeRequestStateChangeReturnValue = _p.invokeRequestStateChange(

			inRequestedState,
			inTimeoutPeriod
		);
		_p.finalize();
		handler.deliver(invokeRequestStateChangeReturnValue);

	}
	else if (methodName.equal("GetError")) {

		if (inParameters.size() != 0)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking GetError method.
		Uint32 invokeGetErrorReturnValue;

		String inError;
		
		for(Uint32 pi = 0; pi < inParameters.size(); pi++) {
			CIMParamValue p = inParameters[pi];
			if (String::equalNoCase(p.getParameterName(), "Error"))
			{
				p.getValue().get(inError);
			}
		}
		_p.initialize();
		_p.find(localReference.getKeyBindings());
		invokeGetErrorReturnValue = _p.invokeGetError(

			inError
		);
		_p.finalize();
		handler.deliver(invokeGetErrorReturnValue);

	}
	else if (methodName.equal("GetErrors")) {

		if (inParameters.size() != 0)
		{
			throw new CIMOperationFailedException("Incorrect in parameters");
		}
		
		//Invoking GetErrors method.
		Uint32 invokeGetErrorsReturnValue;

		Array<String> inErrors;
		
//.........这里部分代码省略.........

/**
    When the "PropagateError" method is invoked, this function
    will read a CIM_Error embedded instance from the inParameters and use
    that instance to create an InstMethodIndication populating the Error[]
    property with the CIM_Error parameter and errorInstance stored in this
    class (if it's been created already). The output parameter of this method
    will contain the embedded instance received as input, and the newly
    created InstMethodIndication will be sent by the provider to any
    registered listeners.
*/
void EmbeddedInstanceProvider::invokeMethod(
        const OperationContext& context,
        const CIMObjectPath& objectReference,
        const CIMName& methodName,
        const Array<CIMParamValue>& inParameters,
        MethodResultResponseHandler& handler)
{
    // This should start sending indications with the stored Job instance
    // embedded in the InstMethodIndication
    handler.processing();
    if (!methodName.equal(CIMName("PropagateError")))
        throw CIMException(CIM_ERR_METHOD_NOT_AVAILABLE);

    if (inParameters.size() != 1)
    {
        throw CIMException(
            CIM_ERR_INVALID_PARAMETER, "Did not receive exactly 1 parameter");
    }

    CIMParamValue errorParam = inParameters[0];
    if (!String::equal(errorParam.getParameterName(), String("error")))
    {
        throw CIMException(
            CIM_ERR_INVALID_PARAMETER, "Did not find \"error\" parameter");
    }

    CIMInstance errorParamInst;
    errorParam.getValue().get(errorParamInst);
    if (errorParamInst.getPath().getClassName() != "PG_EmbeddedError")
    {
        throw CIMException(CIM_ERR_INVALID_PARAMETER);
    }
    errorParamInst.setPath(errorInstance->getPath());
    Array<CIMName> propList;
    for (unsigned int i = 0, n = errorParamInst.getPropertyCount(); i < n; i++)
    {
        propList.append(errorParamInst.getProperty(i).getName());
    }
    CIMInstance tmpErrorInstance(errorInstance->clone());
    if (!tmpErrorInstance.identical(errorParamInst))
    {
        throw Exception("Did not receive expected ErrorInstance");
    }

    // Build new indication instance
    CIMObjectPath indicationPath(System::getHostName(),
        CIMNamespaceName("test/EmbeddedInstance/Dynamic"),
        CIMName("PG_InstMethodIndication"));
    indicationInstance.reset(new CIMInstance("PG_InstMethodIndication"));
    indicationInstance->setPath(indicationPath);
    indicationInstance->addProperty(CIMProperty("MethodName",
        CIMValue(String("PropagateError"))));
    indicationInstance->addProperty(CIMProperty("PreCall",
        CIMValue(Boolean(false))));
    indicationInstance->addProperty(CIMProperty("SourceInstance",
        CIMValue(CIMObject(*errorInstance))));
    Array<CIMInstance> errorInstances;
    errorInstances.append(*errorInstance);
    errorInstances.append(*errorInstance);
    indicationInstance->addProperty(CIMProperty("Error",
        CIMValue(errorInstances)));

    handler.deliverParamValue(CIMParamValue(String("sameError"),
        CIMValue(errorParamInst)));
    handler.deliver(CIMValue(Uint32(1)));
    handler.complete();

    indicationHandler->deliver(*indicationInstance);
}