C++ AnalyzeXML::Analyze方法代码示例

// Execute the command line by building up an XML message and submitting it to our regular command processor.
bool RhsListener::ExecuteCommandLine(AgentSML* pAgent, char const* pFunctionName, char const* pArgument, int maxLengthReturnValue, char* pReturnValue)
{
	KernelSML* pKernel = m_pKernelSML ;

	// We'll pretend this came from the local (embedded) connection.
	Connection* pConnection = pKernel->GetEmbeddedConnection() ;

	// Build up a single command line from our functionName + argument combination
	std::stringstream commandLine;
	commandLine << pFunctionName;

	if (pArgument)
	{
		commandLine << " " ;
		commandLine << pArgument ;
	}

	// Build up a message to execute the command line
	bool rawOutput = true ;
	soarxml::ElementXML* pMsg = pConnection->CreateSMLCommand(sml_Names::kCommand_CommandLine, rawOutput) ;
	pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamAgent, pAgent->GetName());
	pConnection->AddParameterToSMLCommand(pMsg, sml_Names::kParamLine, commandLine.str().c_str()) ;

	AnalyzeXML incoming ;
	incoming.Analyze(pMsg) ;

	// Create a response object which the command line can fill in
	soarxml::ElementXML* pResponse = pConnection->CreateSMLResponse(pMsg) ;

	// Execute the command line
	bool ok = pKernel->ProcessCommand(sml_Names::kCommand_CommandLine, pConnection, &incoming, pResponse) ;

	if (ok)
	{
		// Take the result from executing the command line and fill it in to our "pReturnValue" array.
		AnalyzeXML response ;
		response.Analyze(pResponse) ;

		char const* pResult = response.GetResultString() ;

		if (pResult)
		{
			strncpy(pReturnValue, pResult, maxLengthReturnValue) ;
			pReturnValue[maxLengthReturnValue-1] = 0 ;
		}
	}

	// Clean up
	delete pMsg ;
	delete pResponse ;

	return ok ;
}

/*************************************************************
* @brief	Takes an incoming SML message and responds with
*			an appropriate response message.
*
* @param pConnection	The connection this message came in on.
* @param pIncoming		The incoming message
*************************************************************/
soarxml::ElementXML* KernelSML::ProcessIncomingSML(Connection* pConnection, soarxml::ElementXML* pIncomingMsg)
{
	if (!pIncomingMsg || !pConnection)
		return NULL ;

	// Make sure only one thread is executing commands in the kernel at a time.
	// This is really just an insurance policy as I don't think we'll ever execute
	// commands on different threads within kernelSML because we
	// only allow one embedded connection to the kernel, but it's nice to be sure.
	soar_thread::Lock lock(m_pKernelMutex) ;

#ifdef DEBUG
	// For debugging, it's helpful to be able to look at the incoming message as an XML string
	char* pIncomingXML = pIncomingMsg->GenerateXMLString(true) ;
#endif

	soarxml::ElementXML* pResponse = pConnection->CreateSMLResponse(pIncomingMsg) ;

	// Fatal error creating the response
	if (!pResponse)
		return NULL ;

	// Analyze the message and find important tags
	AnalyzeXML msg ;
	msg.Analyze(pIncomingMsg) ;

	// Get the "name" attribute from the <command> tag
	char const* pCommandName = msg.GetCommandName() ;

	if (pCommandName)
	{
		ProcessCommand(pCommandName, pConnection, &msg, pResponse) ;
	}
	else
	{
		// The message wasn't something we recognize.
		if (!msg.GetCommandTag())
			AddErrorMsg(pConnection, pResponse, "Incoming message did not contain a <command> tag") ;
		else
			AddErrorMsg(pConnection, pResponse, "Incoming message did not contain a name attribute in the <command> tag") ;
	}

#ifdef DEBUG
	// For debugging, it's helpful to be able to look at the response as XML
	char* pResponseXML = pResponse->GenerateXMLString(true) ;

	// Set a break point on this next line if you wish to see the incoming
	// and outgoing as XML before they get deleted.
	soarxml::ElementXML::DeleteString(pIncomingXML) ;
	soarxml::ElementXML::DeleteString(pResponseXML) ;
#endif

	return pResponse ;
}

void InputListener::ProcessPendingInput(AgentSML* pAgentSML, int )
{
	PendingInputList* pPending = pAgentSML->GetPendingInputList() ;

	bool ok = true ;

	for (PendingInputListIter iter = pPending->begin() ; iter != pPending->end() ; iter = pPending->erase(iter)) {
		soarxml::ElementXML* pInputMsg = *iter ;

		// Analyze the message and find important tags
		AnalyzeXML msg ;
		msg.Analyze(pInputMsg) ;

		// Get the "name" attribute from the <command> tag
		char const* pCommandName = msg.GetCommandName() ;

		// Only input commands should be stored in the pending input list
		(void)pCommandName; // silences warning in release mode
		assert(!strcmp(pCommandName, "input")) ;

		soarxml::ElementXML const* pCommand = msg.GetCommandTag() ;

		int nChildren = pCommand->GetNumberChildren() ;

		soarxml::ElementXML wmeXML(NULL) ;
		soarxml::ElementXML* pWmeXML = &wmeXML ;

		if (kDebugInput)
			PrintDebugFormat("--------- %s starting input ----------", pAgentSML->GetName()) ;

		for (int i = 0 ; i < nChildren ; i++)
		{
			pCommand->GetChild(&wmeXML, i) ;

			// Ignore tags that aren't wmes.
			if (!pWmeXML->IsTag(sml_Names::kTagWME))
				continue ;

			// Find out if this is an add or a remove
			char const* pAction = pWmeXML->GetAttribute(sml_Names::kWME_Action) ;

			if (!pAction)
				continue ;

			bool add = IsStringEqual(pAction, sml_Names::kValueAdd) ;
			bool remove = IsStringEqual(pAction, sml_Names::kValueRemove) ;

			if (add)
			{
				char const* pID			= pWmeXML->GetAttribute(sml_Names::kWME_Id) ;	// May be a client side id value (e.g. "o3" not "O3")
				char const* pAttribute  = pWmeXML->GetAttribute(sml_Names::kWME_Attribute) ;
				char const* pValue		= pWmeXML->GetAttribute(sml_Names::kWME_Value) ;
				char const* pType		= pWmeXML->GetAttribute(sml_Names::kWME_ValueType) ;	// Can be NULL (=> string)
				char const* pTimeTag	= pWmeXML->GetAttribute(sml_Names::kWME_TimeTag) ;	// May be a client side time tag (e.g. -3 not +3)

				// Set the default value
				if (!pType)
					pType = sml_Names::kTypeString ;

				// Check we got everything we need
				if (!pID || !pAttribute || !pValue || !pTimeTag)
					continue ;

				if (kDebugInput)
				{
					PrintDebugFormat("%s Add %s ^%s %s (type %s tag %s)", pAgentSML->GetName(), pID, pAttribute, pValue, pType, pTimeTag) ;
				}

				// Add the wme
				ok = pAgentSML->AddInputWME( pID, pAttribute, pValue, pType, pTimeTag) && ok ;
			}
			else if (remove)
			{
				char const* pTimeTag = pWmeXML->GetAttribute(sml_Names::kWME_TimeTag) ;	// May be (will be?) a client side time tag (e.g. -3 not +3)

				if (kDebugInput)
				{
					PrintDebugFormat("%s Remove tag %s", pAgentSML->GetName(), pTimeTag) ;
				}

				// Remove the wme
				ok = pAgentSML->RemoveInputWME(pTimeTag) && ok ;
			}
		}

		delete pInputMsg ;
	}

	std::list<DirectInputDelta>* pBufferedDirect = pAgentSML->GetBufferedDirectList();
	for (std::list<DirectInputDelta>::iterator iter = pBufferedDirect->begin() ; iter != pBufferedDirect->end() ; iter = pBufferedDirect->erase(iter)) 
	{
		DirectInputDelta& delta = *iter;
		switch (delta.type)
		{
		case DirectInputDelta::kRemove:
			pAgentSML->RemoveInputWME(delta.clientTimeTag);
			break;
		case DirectInputDelta::kAddString:
			pAgentSML->AddStringInputWME(delta.id.c_str(), delta.attribute.c_str(), delta.svalue.c_str(), delta.clientTimeTag);
			break;
//.........这里部分代码省略.........