typefact.cpp

Windows CE 6.0 Server 源码

    m_state = enMapperUndefined; 
    m_bCachable = false;    
    m_bCheckedForCachable = false;
    m_vtType = VT_ERROR;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CCustomMapper::~CCustomMapper()
//
//  parameters:
//
//  description:
//      detructor
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
CCustomMapper::~CCustomMapper()
{
    if (m_state > enMapperUndefined)
    {
        if (m_bCachable==false)
        {
            m_critSect.Delete();
        }
        m_gipTypeMapper.Unglobalize();    
    }    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::_verifyState(enCustomMapperState stateToCheck)
//
//  parameters:
//
//  description:
//      verifies that the custom mapper is in properstate
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::_verifyState(enCustomMapperState stateToCheck)
{
    HRESULT hr = S_OK;
    CHK_BOOL(m_state >= stateToCheck, E_UNEXPECTED);

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




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::init(ISoapTypeMapperFactory *ptypeFactory, IXMLDOMNode * pSchema, enXSDType xsdType)
//
//  parameters:
//
//  description:
//      ISoapMapper::Init()
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::init(ISoapTypeMapperFactory *ptypeFactory, IXMLDOMNode * pSchema, enXSDType xsdType)
{
    HRESULT hr = E_INVALIDARG;
    CAutoRefc<ISoapTypeMapper> pMapper; 

    if (!ptypeFactory || !pSchema)
    {
        goto Cleanup;
    }
    CHK(_verifyState(enMapperPrivInit));
    m_typeFactory.Clear();
    m_pSchemaNode.Clear();

    assign(&m_typeFactory, ptypeFactory);
    assign(&m_pSchemaNode, pSchema);

    m_enXSDType = xsdType;

#ifndef CE_NO_EXCEPTIONS
    try 
    {
#endif 
        if (!m_bCachable)
        {
            CAutoRefc<ISoapTypeMapper> pTypeMapper;
            CAutoRefc<ISoapTypeMapper2> pT2; 
            CCritSectWrapper csw(&m_critSect);

            CHK(csw.Enter());
            
            CHK(GetTypeMapperInterface(&pTypeMapper));
            CHK(pTypeMapper->varType(&m_vtType));
            if (pTypeMapper->QueryInterface(IID_ISoapTypeMapper2, (void**)&pT2)== S_OK)
            {
                m_bstrIID.Clear(); 
                CHK(pT2->iid(&m_bstrIID)); 
            }
        }
        else
        {
            // use the GIT entry
            LIP(ISoapTypeMapper) pTypeMapper(m_gipTypeMapper, hr);
            CHK(hr);
            CHK(pTypeMapper->init(ptypeFactory, pSchema, xsdType));
            CHK(pTypeMapper->varType(&m_vtType));
        }
#ifndef CE_NO_EXCEPTIONS
    }    
    catch(...)
    {
        hr = E_UNEXPECTED;
        goto Cleanup;
    }
#endif 

    m_state = enMapperWorking;

Cleanup:
    if (FAILED(hr))
        globalAddErrorFromErrorInfo(0, hr);
    return hr;
    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::read(IXMLDOMNode * pNode, BSTR bstrEncoding, enEncodingStyle enStyle, LONG lFlags, VARIANT * pvar)
//
//  parameters:
//
//  description:
//      ISoapMapper::Read()
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::read(IXMLDOMNode * pNode, BSTR bstrEncoding, enEncodingStyle enStyle, LONG lFlags, VARIANT * pvar)
{
    HRESULT hr;
    CAutoRefc<ISoapTypeMapper> pMapper; 

    CHK(_verifyState(enMapperWorking));
#ifndef UNDER_CE
    try 
    {
#endif 
        if (!m_bCachable)
        {
            CAutoRefc<ISoapTypeMapper> pTypeMapper;
            CCritSectWrapper csw(&m_critSect);
            
            CHK( csw.Enter() );
            
            CHK(GetTypeMapperInterface(&pTypeMapper));            
            CHK(pTypeMapper->read(pNode, bstrEncoding, enStyle, 0, pvar));
        }
        else
        {
            // use the GIT entry
            LIP(ISoapTypeMapper) pTypeMapper(m_gipTypeMapper, hr);
            CHK(hr);
            CHK(pTypeMapper->read(pNode, bstrEncoding, enStyle, 0, pvar));            
        }    
#ifndef UNDER_CE
    }    
    catch(...)
    {
        hr = E_UNEXPECTED;
    }
#endif 

Cleanup:
    if (FAILED(hr))
        globalAddErrorFromErrorInfo(0, hr);

    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, LONG lFlags, VARIANT * pvar)
//
//  parameters:
//
//  description:
//      ISoapMapper::write()
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, LONG lFlags, VARIANT * pvar)
{
    HRESULT hr;
    CAutoRefc<ISoapTypeMapper> pMapper; 

    CHK(_verifyState(enMapperWorking));
#ifndef CE_NO_EXCEPTIONS
    try 
    {
#endif 
        if (!m_bCachable)
        {
            CAutoRefc<ISoapTypeMapper> pTypeMapper;
            CCritSectWrapper csw(&m_critSect);
            
            CHK( csw.Enter());
            
            CHK(GetTypeMapperInterface(&pTypeMapper));            
            CHK(pTypeMapper->write(pSoapSerializer, bstrEncoding, enStyle, 0, pvar));
        }    
        else
        {
            LIP(ISoapTypeMapper) pTypeMapper(m_gipTypeMapper, hr);
            CHK(hr);
            CHK(pTypeMapper->write(pSoapSerializer, bstrEncoding, enStyle, 0, pvar));
        }
#ifndef CE_NO_EXCEPTIONS
    }    
    catch(...)
    {
        hr = E_UNEXPECTED;
    }
#endif 

Cleanup:
    if (FAILED(hr))
        globalAddErrorFromErrorInfo(0, hr);
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::varType(long *pvtType)
//
//  parameters:
//
//  description:
//      ISoapMapper::varType()
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::varType(long *pvtType)
{
    HRESULT hr;
    CHK(_verifyState(enMapperWorking));    
    *pvtType = m_vtType;
Cleanup:    
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::iid(BSTR *pbstrIID)
//
//  parameters:
//
//  description:
//      ISoapMapper2::iid()
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::iid(BSTR *pbstrIID)
{
    HRESULT hr; 
    CHK(_verifyState(enMapperWorking));        
    CHK(_WSDLUtilReturnAutomationBSTR(pbstrIID, m_bstrIID));
Cleanup:
    return hr; 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::privateInit(BSTR bstrProgID)
//
//  parameters:
//
//  description:
//      privateInit(BSTR bstrProgID) -> set's up the progid for creation of the real thing
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::privateInit(BSTR bstrProgID, BSTR bstrIID)
{
    HRESULT hr;
#ifndef CE_NO_EXCEPTIONS
    try 
    {
#endif 
        CHK(m_bstrProgID.Assign(bstrProgID));
        CHK(m_bstrIID.Assign(bstrIID));
        CHK(_checkForCachable());
        if (m_bCachable==false)
        {
            CHK(m_critSect.Initialize());
        }
        m_state = enMapperPrivInit;
#ifndef CE_NO_EXCEPTIONS
    }
    catch(...)
    {
        hr = E_UNEXPECTED;
    }
#endif 
Cleanup:    
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::_checkForCachable(void)
//
//  parameters:
//
//  description:
//      checks if the typemapper is cachable
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::_checkForCachable(void)
{
    HRESULT hr;
    LPOLESTR    p=0; 
    DWORD       dwType;
    DWORD       dwSize=_MAX_BUFFER_SIZE;
#ifndef UNDER_CE
    TCHAR       achBuffer[_MAX_BUFFER_SIZE+1]; 
#else //moving to heap since CE only has a 4k guard page
    TCHAR       *achBuffer= new TCHAR[_MAX_BUFFER_SIZE+1]; 
    CHK_MEM(achBuffer);
#endif 

	CHK(CLSIDFromProgID(m_bstrProgID, &m_clsid));

	if (!m_bCheckedForCachable)
	{
	    CHkey        hKey; 

        // now as this is the first time, check if the component is boththreaded or freethreaded...
        CHK(StringFromCLSID(m_clsid, &p)); 
        wcscpy(achBuffer, _T("CLSID\\")); 
        wcscat(achBuffer, p); 
        wcscat(achBuffer, _T("\\InProcServer32")); 
        if (RegOpenKeyEx(HKEY_CLASSES_ROOT, achBuffer, 0, KEY_READ, &hKey.hkey)==ERROR_SUCCESS)
        {
            if (RegQueryValueEx(
                  hKey.hkey,            // handle to key
                  _T("ThreadingModel"),  // value name
                  0,   // reserved
                  &dwType,       // type buffer
                  (LPBYTE)achBuffer,        // data buffer
                  &dwSize      // size of data buffer
                )==ERROR_SUCCESS)
                {
                    if (dwSize > 0)
                    {
                        if (wcscmp(achBuffer, _T("Free"))==0)
                        {
                            hr = E_UNEXPECTED;
                            globalAddError(WSDL_IDS_CUSTOMMAPPERFREETHREADED, WSDL_IDS_MAPPER, hr, m_bstrProgID);
                            CHK(hr);
                        }
                        if (wcscmp(achBuffer, _T("Both"))==0 || 
                           wcscmp(achBuffer, _T("Neutral"))==0)
                        {
                            m_bCachable = true;                            
                        }
                    }
                }
                            
        }
        // verify the flag.
        m_bCheckedForCachable = true; 

        // if the guy is cachable, we want to put him in the GIT
        if (m_bCachable)
        {
            CAutoRefc<ISoapTypeMapper> pTypeMapper;
            CHK(GetTypeMapperInterface(&pTypeMapper));
            CHK(m_gipTypeMapper.Globalize(pTypeMapper));
        }    
	}
	
Cleanup:
    if (p)
    {
        CoTaskMemFree(p);
    }
    
#ifdef UNDER_CE
    if(achBuffer)
        delete [] achBuffer;
#endif 
    return(hr);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapper::GetTypeMapperInterface(ISoapTypeMapper **ppTypeMapper)
//
//  parameters:
//
//  description:
//      GetTypeMapperInterface(void) - creates the real thing if needed and calls INIT on it
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapper::GetTypeMapperInterface(ISoapTypeMapper **ppTypeMapper)
{
    HRESULT hr = S_OK;
	CHK(CoCreateInstance(m_clsid, 0, CLSCTX_ALL, IID_ISoapTypeMapper, (void**)ppTypeMapper));
	if (m_pSchemaNode)
	{
        showNode(m_pSchemaNode);    	
        CHK((*ppTypeMapper)->init(m_typeFactory, m_pSchemaNode, m_enXSDType));
	}    
Cleanup:
	return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////