📄 typefact.cpp

📁 Windows CE 6.0 Server 源码
💻 CPP
📖 第 1 页 / 共 4 页
字号:
        CHK_BOOL(m_ppCustomMapperInfo[m_lNextMapperID], E_OUTOFMEMORY);        

        // make sure that the mapper ID starts with EndOfBuildin + 1
    	CHK(m_ppCustomMapperInfo[m_lNextMapperID]->Init(bstrTypeName, bstrTypeNameSpace, bstrProgID, bstrIID, enXSDUndefined, bIsType));
    	m_lNextMapperID++;

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




/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CTypeMapperFactory::getMapper( enXSDType xsdType, IXMLDOMNode *pSchemaNode, ISoapTypeMapper **ppSoapTypeMapper)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTypeMapperFactory::getMapper(
				enXSDType xsdType,
				IXMLDOMNode *pSchemaNode,
				ISoapTypeMapper **ppSoapTypeMapper
				)
{
    HRESULT hr;
    CHK(createBuildInMapper(ppSoapTypeMapper, pSchemaNode, xsdType));    
Cleanup:
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////







/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT  CTypeMapperFactory::createBuildInMapper(ISoapTypeMapper **ppSoapTypeMapper, IXMLDOMNode *pSchemaNode, long lXSDType)
//
//  parameters:
//
//  description:
//
//  returns: 
//      S_OK
//      E_OUTOFMEMORY
//      E_FAIL
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT  CTypeMapperFactory::createBuildInMapper(ISoapTypeMapper **ppSoapTypeMapper, IXMLDOMNode *pSchemaNode, long lXSDType)
{
    HRESULT hr = S_OK;
    CAutoRefc<ISoapTypeMapper> pNewMapper; 

    CHK_BOOL((lXSDType < enXSDEndOfBuildin), E_INVALIDARG);
	switch (lXSDType)
	{
		case enXSDDOM:
			pNewMapper = new CSoapObject<CDOMMapper>(INITIAL_REFERENCE);
			break;

        case enXSDcdata:
		case enXSDncname:
		case enXSDname:
		case enXSDnmtoken:
		case enXSDnmtokens:
		case enXSDlanguage:
		case enXSDtoken:
		case enXSDstring:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;


		case enXSDboolean:
			pNewMapper = new CSoapObject<CBoolMapper>(INITIAL_REFERENCE);
			break;

		case enXSDfloat:
		case enXSDDouble:
			pNewMapper = new CSoapObject<CDoubleMapper>(INITIAL_REFERENCE);
			break;

		case enXSDdecimal:		    
		case enXSDlong:
		case enXSDnonNegativeInteger:
		case enXSDnegativeInteger:
		case enXSDnonpositiveInteger:
		case enXSDinteger:
		case enXSDint:
		case enXSDshort:
		case enXSDbyte:
		case enXSDunsignedLong:
		case enXSDunsignedInt:
		case enXSDunsignedShort:
		case enXSDunsignedByte:
		case enXSDpositiveInteger:
			pNewMapper = new CSoapObject<CDecimalMapper>(INITIAL_REFERENCE);
			break;

		case enXSDbinary:
			// not valid as a direct datatype, the init function checks that...
            pNewMapper = new CSoapObject<CBinaryMapper>(INITIAL_REFERENCE);
			break;
            
		case enXSDmonth:
		case enXSDyear:
		case enXSDcentury:
		case enXSDrecurringDate:
		case enXSDrecurringDay:
		case enXSDtimePeriod:
		case enXSDrecurringDuration:		    
		case enXSDtimeDuration:		    
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDdate:
		case enXSDtime:		    
		case enXSDtimeInstant:		    
			pNewMapper = new CSoapObject<CTimeMapper>(INITIAL_REFERENCE);
			break;
   		case enXSDuriReference:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDid:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDidRef:
		case enXSDidRefs:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDentity:
		case enXSDentities:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDQName:
		case enXSDnotation:
			pNewMapper = new CSoapObject<CStringMapper>(INITIAL_REFERENCE);
			break;
		case enXSDarray:
			pNewMapper = new CSoapObject<CSafearrayMapper>(INITIAL_REFERENCE);
			break;
		case enXSDanyType:
			pNewMapper = new CSoapObject<CAnyTypeMapper>(INITIAL_REFERENCE);
			break;
		case enTKempty:
			pNewMapper = new CSoapObject<CEmptyTypeMapper>(INITIAL_REFERENCE);
			break;
        default:
            ASSERT(0);
            // this would be the custom mapper
            break;
	}


    if (!pNewMapper)
    {
        hr = E_OUTOFMEMORY;
        goto Cleanup;
    }

    CHK(pNewMapper->init(this , pSchemaNode, (enXSDType) lXSDType));
    assign(ppSoapTypeMapper, (ISoapTypeMapper*)pNewMapper);
        

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





/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CTypeMapperFactory::findRegisteredTypeMapper(BSTR bstrTypeName,   BSTR bstrTypeNameSpace,  bool bIsType,  IXMLDOMNode *pSchemaNode,  ISoapTypeMapper **ppSoapTypeMapper)
//
//  parameters:
//
//  description:
//      searches the type/namespace combo in our internal cache
//  returns: 
//      S_OK        -> known mapper
//      S_FAILSE     -> unknown mapper
//      E_FAIL       -> real problem
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTypeMapperFactory::findRegisteredTypeMapper(BSTR bstrTypeName, 
                                                 BSTR bstrTypeNameSpace, 
                                                 bool bIsType, 
                                                 IXMLDOMNode *pSchemaNode,
                                                 ISoapTypeMapper **ppSoapTypeMapper)
{
    HRESULT hr;
    long     lMapperIndex; 

    if (_XSDIsPublicSchema(bstrTypeNameSpace))
    {
        // the type should be a PUBLIC type
        hr = xsdVerifyenXSDType(m_enRevision, bstrTypeName, (enXSDType*)&lMapperIndex);
        if (SUCCEEDED(hr))
        {
            CHK(createBuildInMapper(ppSoapTypeMapper, pSchemaNode, lMapperIndex));
        }    
        else
            hr = S_FALSE;
    }
    else
    {
        // try to find type/namespace combo in our custom mapper list
        lMapperIndex= _findCustomMapper(bstrTypeName, bstrTypeNameSpace, bIsType);
        if (lMapperIndex!= (long) enXSDUndefined)
        {
            CHK(m_ppCustomMapperInfo[lMapperIndex]->GetCustomMapper(ppSoapTypeMapper));
            CHK((*ppSoapTypeMapper)->init(this , pSchemaNode, enXSDUndefined));
        }
        else
        {
            hr = S_FALSE;
        }
    }


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



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function:long CTypeMapperFactory::_findCustomMapper(BSTR bstrTypeName, BSTR bstrTypeNameSpace, bool bIsType)
//
//  parameters:
//
//  description:
//      searches the custom mapper list
//  returns: 
//      dwMapperID -> enXSDUndefined or a valid entry
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
long CTypeMapperFactory::_findCustomMapper(BSTR bstrTypeName, BSTR bstrTypeNameSpace, bool bIsType)
{
    long lRet = (DWORD) enXSDUndefined;
    long lIteration;

    if (m_lCacheSize > 0)
    {
        for (lIteration= 0; lIteration< m_lNextMapperID; lIteration++)
        {
            if (m_ppCustomMapperInfo[lIteration]->isMatch(bstrTypeName, bstrTypeNameSpace, bIsType))
            {
                lRet = lIteration;
                break;
            }
        }
    }
    
    return (lRet);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function:HRESULT CTypeMapperFactory::checkForXSDSubclassing(ISoapTypeMapper **ppSoapTypeMapper, IXMLDOMNode * pschemaNode)
//
//  parameters:
//
//  description:
//      takes a current schema node and checks for an inline restriction base subclass
//  returns: 
//      S_OK -> found a valid mapper
//      E_FAIL -> not an understandable node for us
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTypeMapperFactory::checkForXSDSubclassing(ISoapTypeMapper **ppSoapTypeMapper, IXMLDOMNode * pschemaNode)
{
    HRESULT hr;
    CAutoRefc<IXMLDOMNode> pNode;
    CAutoBSTR               bstrTypeBase;
    long                    lMapperIndex; 

    showNode(pschemaNode);
    CHK(pschemaNode->selectSingleNode(_T("descendant-or-self::schema:simpleType/schema:restriction"), &pNode));

    if (pNode)
    {
        CHK(_WSDLUtilFindAttribute(pNode, _T("base"), &bstrTypeBase));

        // so we found a base type. If this is a VALID and UNDERSTOOD basetype, we can use this guy
    // first verify if there is a buildin/custom one for this
        CHK(xsdVerifyenXSDType(m_enRevision, bstrTypeBase, (enXSDType*)&lMapperIndex));
        CHK(createBuildInMapper(ppSoapTypeMapper, pschemaNode, lMapperIndex));
    }
    else
    {
        CHK(createBuildInMapper(ppSoapTypeMapper, pschemaNode, enXSDDOM));        
    }

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






/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapperInfo::Init(BSTR bstrTypeName, BSTR bstrNameSpace, BSTR bstrProgID, long lMapperID, bool bIsType)
//
//  parameters:
//
//  description:
//      just stores the passed in info from addType
//  returns: 
//      S_OK
//      E_OUTOFMEMORY
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapperInfo::Init(BSTR bstrTypeName, BSTR bstrNameSpace, BSTR bstrProgID, BSTR bstrIID, 
            long lMapperID, bool bIsType)
{
    HRESULT hr = E_OUTOFMEMORY;
    
    CHK(m_bstrNameSpace.Assign(bstrNameSpace));
    CHK(m_bstrTypeName.Assign(bstrTypeName));
    CHK(m_bstrProgID.Assign(bstrProgID));
    CHK(m_bstrIID.Assign(bstrIID));

    m_bIsType = bIsType;

    // if we hold an interface currently, release it.

    m_typeMapper.Clear();

Cleanup:
    ASSERT(hr==S_OK);
    return hr; 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CCustomMapperInfo::GetCustomMapper(CCustomMapper **ppCustomMapper)
//
//  parameters:
//
//  description:
//      retrieves the interface pointer, takes caching into account.
//  returns: 
//      S_OK
//      E_OUTOFMEMORY
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CCustomMapperInfo::GetCustomMapper(ISoapTypeMapper **ppCustomMapper)
{
    HRESULT hr;
    CAutoRefc<CCustomMapper> pMapper;

    pMapper = new CSoapObject<CCustomMapper>(INITIAL_REFERENCE);
    CHK_BOOL(pMapper, E_OUTOFMEMORY);
    CHK(pMapper->privateInit(m_bstrProgID, m_bstrIID));

    // caller takes ownership of addrefed object
    *ppCustomMapper = pMapper.PvReturn();
        
Cleanup:
    return hr;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////





/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function:  bool CCustomMapperInfo::isMatch(BSTR bstrTypeName, BSTR bstrTypeNameSpace, bool  bIsType)
//
//  parameters:
//
//  description:
//      compares the type and namespace
//  returns: 
//      true -> correct guy
//      false -> not
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
bool CCustomMapperInfo::isMatch(BSTR bstrTypeName, BSTR bstrTypeNameSpace, bool bIsType)
{
    int iRet=1; 

    // first they both have to be type or element
    if (bIsType == m_bIsType)
    {
        if (bstrTypeName && m_bstrTypeName)
        {
            iRet = _tcscmp(bstrTypeName, m_bstrTypeName);
        }
        if (iRet == 0 && bstrTypeNameSpace && m_bstrNameSpace)
        {
            iRet = _tcscmp(bstrTypeNameSpace, m_bstrNameSpace);
        }
    }    
    return (iRet==0 ? true : false); 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////






/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: CCustomMapper::CCustomMapper()
//
//  parameters:
//
//  description:
//      constructor
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
CCustomMapper::CCustomMapper()
{
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -