xsdpars.cpp

Windows CE 6.0 Server 源码

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDFindRevision(ISoapSerializer* pSoapSerializer, schemaRevisionNr *pRevision)
//
//  parameters: 
//      
//  description:    
//      finds the currently used revision in the started payload
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDFindRevision(ISoapSerializer* pSoapSerializer, schemaRevisionNr *pRevision)
{
    HRESULT hr=S_OK;
    CAutoBSTR   bstrPrefix; 

    for (int i = 0; i < countof(g_arrSchemaEntries); i++)
    {
        pSoapSerializer->getPrefixForNamespace((BSTR) g_arrSchemaEntries[i].m_schemaNS, &bstrPrefix);
        if (bstrPrefix)
        {
            *pRevision = g_arrSchemaEntries[i].m_enSchemaRevision; 
            goto Cleanup;
        }
        bstrPrefix.Clear(); 
    }
    hr = E_FAIL; 

Cleanup:
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDAddNS(ISoapSerializer* pSoapSerializer, BSTR *pPrefix, WCHAR *pchNS)
//
//  parameters: 
//      
//  description:    
// 
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDAddNS(ISoapSerializer* pSoapSerializer, BSTR *pPrefix, WCHAR *pchNS)
{
    HRESULT hr = S_OK;
    
    // is the first namespace defined
    pSoapSerializer->getPrefixForNamespace((BSTR) pchNS, pPrefix);
    if (!(*pPrefix))
    {
        // ok , not existend, we might want to create one
        CHK(pSoapSerializer->SoapNamespace( (BSTR)g_pwstrEmpty, (BSTR) pchNS));
        CHK(pSoapSerializer->getPrefixForNamespace( (BSTR)pchNS, pPrefix));
     }

Cleanup:
    ASSERT (SUCCEEDED(hr));
    return hr;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDAddTKDataNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
//
//  parameters: 
//      
//  description:    
//      adds the desired schema namespace to the payload
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDAddTKDataNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
{
    HRESULT hr = S_OK;
    WCHAR   *pchNS;

    *pPrefix = NULL;
    CHK_BOOL(revision != enSchemaInvalid, E_FAIL);

    pchNS = (WCHAR *) g_pwstrTKData;
    
    CHK (_XSDAddNS(pSoapSerializer, pPrefix, pchNS));

Cleanup:
    ASSERT (SUCCEEDED(hr));
    return hr;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDAddSchemaNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
//
//  parameters: 
//      
//  description:    
//      adds the desired schema namespace to the payload
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDAddSchemaNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
{
    HRESULT hr = S_OK;
    TCHAR   *pchNS;

    *pPrefix = NULL;
    CHK_BOOL(revision != enSchemaInvalid, E_FAIL);

    pchNS = (TCHAR*) _XSDSchemaNS(revision); 
    // is the first namespace defined
    
    CHK (_XSDAddNS(pSoapSerializer, pPrefix, pchNS));

Cleanup:
    ASSERT (SUCCEEDED(hr));
    return hr;

}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDAddSchemaInstanceNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
//
//  parameters: 
//      DomDocument -> document with schema definitons
//  description:    
//    adds the desired schema Instance namespace to the payload
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDAddSchemaInstanceNS(ISoapSerializer* pSoapSerializer, schemaRevisionNr revision, BSTR *pPrefix)
{
    HRESULT hr = S_OK;
    WCHAR   *pchNS;

    *pPrefix = NULL;
    CHK_BOOL(revision != enSchemaInvalid, E_FAIL);
    pchNS = (WCHAR*) _XSDSchemaInstanceNS(revision);
    
    CHK (_XSDAddNS(pSoapSerializer, pPrefix, pchNS));

Cleanup:
    ASSERT (SUCCEEDED(hr));
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

// simple access methods to get the strings behind the revision numbers


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function:  const TCHAR * _XSDSchemaNS(schemaRevisionNr revision)
//
//  parameters: 
//     
//  description:    
//    
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
const TCHAR * _XSDSchemaNS(schemaRevisionNr revision)
{
    if (revision != enSchemaInvalid)
    {
        ASSERT(g_arrSchemaEntries[revision-1].m_enSchemaRevision == revision);
        return g_arrSchemaEntries[revision-1].m_schemaNS; 
    }
    return (0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: const TCHAR * _XSDSchemaInstanceNS(schemaRevisionNr revision)
//
//  parameters: 
//     
//  description:    
//    
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
const TCHAR * _XSDSchemaInstanceNS(schemaRevisionNr revision)
{
    if (revision != enSchemaInvalid)
    {
        ASSERT(g_arrSchemaEntries[revision-1].m_enSchemaRevision == revision);
        return g_arrSchemaEntries[revision-1].m_schemaInstanceNS; 
    }
    return (0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: const TCHAR * _XSDSchemaInstanceXPATH(schemaRevisionNr revision)
//
//  parameters: 
//     
//  description:    
//    
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
const TCHAR * _XSDSchemaInstanceXPATH(schemaRevisionNr revision)
{
    if (revision != enSchemaInvalid)
    {
        ASSERT(g_arrSchemaEntries[revision-1].m_enSchemaRevision == revision);        
        return g_arrSchemaEntries[revision-1].m_schemaInstanceXPATH; 
    }
    return (0);
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDFindNodeInSchemaNS(const TCHAR *pchQuery, IXMLDOMNode *pStartNode, IXMLDOMNode **ppNode)
//
//  parameters: 
//      
//  description:    
//      finds a node by trying all available schemaNS
//  returns: 
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDFindNodeInSchemaNS(const TCHAR *pchQuery, IXMLDOMNode *pStartNode, IXMLDOMNode **ppNode)
{
    HRESULT hr = S_OK;
    

    for (int i = 0; i < countof(g_arrSchemaEntries); i++)
    {
        {
            XPathState  xp;
            CHK (xp.init(pStartNode));
            // need the XSI namespace
            CHK (xp.addNamespace(g_arrSchemaEntries[i].m_schemaInstanceXPATH));
            CHK (pStartNode->selectSingleNode((BSTR)g_pwstrXpathXSIanyType, ppNode));
            if (*ppNode)
                goto Cleanup;
        }
    }    
    // if we get here, we did not find anything
    hr =E_FAIL;
    
Cleanup:
    return (hr);
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDFindChildElements(IXMLDOMNode *pStartNode, IXMLDOMNodeList **ppResultList, 
//					                                TCHAR * pchElementName, int iIDS, BSTR *pbstrNSUri)
//
//  parameters:
//
//  description:
//      this function is a helper to expand the part=parameters behaviour.
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDFindChildElements(IXMLDOMNode *pStartNode, IXMLDOMNodeList **ppResultList, 
                                TCHAR * pchElementName, int iIDS, BSTR *pbstrNSUri)
{
    HRESULT                 hr = E_FAIL;
    TCHAR		            achPrefix[_MAX_ATTRIBUTE_LEN+1];
    CAutoBSTR               bstrElement;
    CAutoRefc<IXMLDOMNode>  pTargetSchema; 
    CAutoRefc<IXMLDOMNode>  pTargetNode;     
#ifndef UNDER_CE
    long                    lLen;
#endif 
    CAutoFormat             autoFormat;
    

    *ppResultList = 0;     

    achPrefix[0] = 0;
    CHK(_WSDLUtilSplitQName(pchElementName, achPrefix, &bstrElement));
    if (wcslen(achPrefix)>0)
    {
        hr = _XSDFindURIForPrefix(pStartNode, achPrefix, pbstrNSUri);        
        if (FAILED(hr)) 
        {
            globalAddError(WSDL_IDS_URIFORQNAMENF, iIDS, hr, achPrefix, bstrElement);
            goto Cleanup;
        }
    }    
    
    if (_XSDIsPublicSchema(*pbstrNSUri))
    {
        // wrong: an element declaration has to point to a private schema
        hr = E_FAIL;
        globalAddError(WSDL_IDS_MAPPERNOSCHEMA, iIDS, hr, *pbstrNSUri, bstrElement);
        goto Cleanup;
    }
    else
    {
        // user schema, look for the node
        hr = _XSDLFindTargetSchema(*pbstrNSUri, pStartNode, &pTargetSchema);
        if (FAILED(hr)) 
        {
            globalAddError(WSDL_IDS_MAPPERNOSCHEMA, iIDS, hr, *pbstrNSUri, bstrElement);    
            goto Cleanup;
        }
        // now search for the subnode:
        CHK(autoFormat.sprintf(_T(".//schema:element[@name=\"%s\"]"), bstrElement));
        pTargetSchema->selectSingleNode(&autoFormat, &pTargetNode);
        if (pTargetNode)
        {
            // found the root... 
            // now we try to find all subelements of the form
            // element/complexType/sequence/element OR
            // element/complexType/all/element
            // as this is the PID case, we assume that this is .NET, hence we do a very lazy lookup and will treat each
            // empty result as a call with no parts

            CHK(autoFormat.sprintf(_T("(//schema:element[@name=\"%s\"]/schema:complexType/schema:all/schema:element | //schema:element[@name=\"%s\"]/schema:complexType/schema:sequence/schema:element)"), bstrElement, bstrElement));
            CHK(pTargetNode->selectNodes(&autoFormat, ppResultList));
            
        }
        else
        {
            globalAddError(WSDL_IDS_MAPPERNODEFINITION, iIDS, hr, bstrElement);   
            hr = E_FAIL;
            goto Cleanup;
        }
    }    


Cleanup:
    ASSERT(SUCCEEDED(hr));
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT _XSDSetupDefaultXPath(IXMLDOMNode*pNode, schemaRevisionNr enRevision)
//
//  parameters:
//
//  description:
//      set's up our default namespace search
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT _XSDSetupDefaultXPath(IXMLDOMNode*pNode, schemaRevisionNr enRevision)
{
    WCHAR                       *achNameSpaces[] = { _T("def"), _T("soap"), _T("ext"), _T("schema") };
    WCHAR                       *achNameSpaceURIs[4];
    HRESULT                     hr = E_FAIL;


    // set this one up as our search namespace:

    achNameSpaceURIs[0] = (WCHAR*)g_pwstrWSDL;
    achNameSpaceURIs[1] = (WCHAR*)g_pwstrSOAP;
    achNameSpaceURIs[2] = (WCHAR*)g_pwstrMSExtension;
    achNameSpaceURIs[3] = (WCHAR *)_XSDSchemaNS(enRevision);

    CHK(_XPATHUtilPrepareLanguage(pNode, &(achNameSpaces[0]), &(achNameSpaceURIs[0]), 4));

Cleanup:
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////