tmapr.cpp

Windows CE 6.0 Server 源码

        {
            bTimeZonePlus = false;
        }
        else
        {
            pchTemp = wcsrchr(pchTime, _T('+'));
        }
    }
    else
    {
        // as a date is stored in ccyy-mm-dd
        // we need to skip past the days and then check if there is anything behind it...
        // the timezone has to look like hh:mm , so look for a : first
        pchTemp = wcsrchr(pchDate, _T(':'));
        while (pchTemp && *pchTemp)
        {
            if (*pchTemp == _T('-') || *pchTemp == _T('+'))
                break;
            pchTemp--;
        }
        if (pchTemp)
        {
            if (*pchTemp == _T('-'))
            {
                bTimeZonePlus = false;
            }
            else if (*pchTemp != _T('+'))
            {
                hr = E_INVALIDARG;
                goto Cleanup;
            }
        }
    }
    if (pchTemp)
    {
        *pchTemp = 0;
        pchTemp++;
        // here is where the timezone should start
        CHK(VarDateFromStr(pchTemp, LCID_TOUSE , 0, &timeDiff));
        fLocalConversion = true;
    }

    if (m_enXSDType == enXSDtime)
    {
        // in this case, the pchDate SHOULD be a time. Verify the timestring
       CHK(verifyTimeString(pchDate));
    }

    CHK(VarDateFromStr(pchDate, LCID_TOUSE , 0, &dateOut));

    if (m_enXSDType == enXSDtimeInstant)
    {
        CHK_BOOL(pchTime, E_INVALIDARG);
        CHK(verifyTimeString(pchTime));
        CHK(VarDateFromStr(pchTime, LCID_TOUSE , 0, &timeOut));        
        dateOut += (dateOut > 0) ? timeOut : timeOut * -1;
    }

    
    if (timeDiff != 0)
    {
        double dSeconds;
        long   lSeconds; 
        
        dSeconds = (timeDiff - floor(timeDiff)) * c_secondsInDay; 
        lSeconds = (long) (floor(dSeconds + 0.5)); 
        if (bTimeZonePlus)
        {
            lSeconds *= -1;
        }
        CHK(adjustTime(&dateOut, lSeconds));
        
    }

    if (fLocalConversion)
    {
        CHK(adjustTimeZone(&dateOut, false));
    }

    if (m_enXSDType == enXSDtime)
    {
        double d  = (dateOut < 0) ? dateOut * -1.0 : dateOut;
        dateOut = d - (floor(d));
    }
    
    V_VT(pvar) = VT_DATE;
    V_DATE(pvar) = dateOut;

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



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CTimeMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
//
//  parameters:
//
//  description:
//      mapping a string into a soap message
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTimeMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
{
    HRESULT hr = E_FAIL;
    double pTheDate = 0;

#ifndef UNDER_CE
    TCHAR   achBuffer[_MAX_BUFFER_SIZE+1];   
    TCHAR   achNum[_MAX_ATTRIBUTE_LEN+1];
#else //putting on heap since our stack guard page is only 4k
    TCHAR    *achBuffer = new TCHAR[_MAX_BUFFER_SIZE+1];    
    TCHAR    *achNum = new TCHAR[_MAX_ATTRIBUTE_LEN+1];
    CHK_MEM(achBuffer); 
    CHK_MEM(achNum); 
#endif 
   
    SYSTEMTIME systemTime;
    
    CHK_BOOL(V_VT(pvar) & VT_DATE, E_INVALIDARG);
    if (V_VT(pvar) == VT_DATE)
        pTheDate = V_DATE(pvar);
    else 
        pTheDate = *(V_DATEREF(pvar));

    memset(achBuffer, 0, _MAX_BUFFER_SIZE+1);

    if (m_enXSDType != enXSDdate)
    {
        CHK(adjustTimeZone(&pTheDate, true));
    }

    CHK_BOOL (::VariantTimeToSystemTime(pTheDate, &systemTime), E_INVALIDARG);

    if (m_enXSDType != enXSDtime)
    {
        // if we are just xsdTime, do NOT persist the date
        swprintf(achNum, _T("%04d-%02d-%02d"), systemTime.wYear, systemTime.wMonth, systemTime.wDay);
        wcscat(achBuffer, achNum);        
    }
    
    if (m_enXSDType != enXSDdate)
    {
        // if we are just a date, do NOT persist the time
        if (m_enXSDType == enXSDtimeInstant)
        {
            // the T seperator for Time is only needed for timeinstant
            wcscat(achBuffer, _T("T"));        
        }    
        swprintf(achNum, _T("%02d:%02d:%02dZ"), systemTime.wHour, systemTime.wMinute, systemTime.wSecond);                   
        wcscat(achBuffer, achNum);
    }

    CHK( pSoapSerializer->writeString((BSTR)achBuffer));


Cleanup:
    ASSERT(SUCCEEDED(hr));
    
#ifdef UNDER_CE
    if(achBuffer)
        delete [] achBuffer;
    if(achNum)
        delete [] achNum;
#endif 
        
    return (hr);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CTimeMapper::verifyTimeString(TCHAR *pchTimeString)
//
//  parameters:
//
//  description:
//      ole only supports hh:mm:ss
//          
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTimeMapper::verifyTimeString(TCHAR *pchTimeString)
{
    HRESULT hr = S_OK;

    while (pchTimeString && *pchTimeString)
    {
        if (*pchTimeString==_T('.'))
        {
            *pchTimeString = 0; 
            goto Cleanup;
        }
        pchTimeString++;
    }

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

/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function:  HRESULT CTimeMapper::adjustTimeZone(DOUBLE *pdblDate)
//
//  parameters:
//
//  description:
//      takes date, calls gettimezoneinfo and uses that to call adjust time
//          
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CTimeMapper::adjustTimeZone(DOUBLE *pdblDate, bool fToUTC)
{
    HRESULT hr=S_OK;
    double dblResult;

    if (fToUTC)
    {
        CHK(VariantTimeToUTCTime(*pdblDate, &dblResult));
    }
    else
    {
        CHK(UTCTimeToVariantTime(*pdblDate, &dblResult));
    }
    *pdblDate = dblResult;
    
Cleanup:
    return hr; 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDOMMapper::read(IXMLDOMNode *_pNodeOfMapper, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
//
//  parameters:
//
//  description:
//      reading a string out of a soap message
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDOMMapper::read(IXMLDOMNode *_pNodeOfMapper, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
{
    HRESULT hr = S_OK;
    CAutoRefc<IXMLDOMNodeList> pChildren(NULL);
    CAutoRefc<IXMLDOMNode> pNode(NULL);
    CAutoRefc<IXMLDOMNode> pNodeOfMapper(_pNodeOfMapper);

    // make sure we got a node
    CHK_BOOL(pNodeOfMapper, E_INVALIDARG);
    // and create an additional refcount, since we are handling it in a CAutoRefc
    pNodeOfMapper->AddRef();

    // follow the Href if necessary
    CHK (FollowHref(&pNodeOfMapper));
    
    CHK (pNodeOfMapper->get_childNodes(&pChildren));    
    
    V_VT(pvar) = VT_DISPATCH;
    V_DISPATCH(pvar) = pChildren;    // now let's put this guy into our comobject
    pChildren.PvReturn();             // the variant took ownership of the object

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



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDOMMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
//
//  parameters:
//
//  description:
//      mapping a string into a soap message
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDOMMapper::write(ISoapSerializer* pSoapSerializer, BSTR bstrEncoding, enEncodingStyle enStyle, long lFlags,  VARIANT * pvar)
{
    HRESULT hr=S_OK;
    CAutoRefc<IXMLDOMNodeList> pNodeList(NULL); 

    CHK_BOOL ((V_VT(pvar) == VT_DISPATCH) ||(V_VT(pvar) == VT_UNKNOWN), E_INVALIDARG);

    CHK ( V_DISPATCH(pvar)->QueryInterface(IID_IXMLDOMNodeList, (void**)&pNodeList));
    
    
    // this might be complex.....
    CHK ( saveList(pSoapSerializer, pNodeList) );


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



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDOMMapper::iid(BSTR *pbstrIID)
//
//  parameters:
//
//  description:
//      returning the IID for IXMLDOMNodeList
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT STDMETHODCALLTYPE CDOMMapper::iid(BSTR *pbstrIID)
{
    #define GUIDBUFFER  64
    HRESULT hr = S_OK;
    WCHAR acBuffer[GUIDBUFFER +1];

    CHK_BOOL(pbstrIID, E_INVALIDARG);

    *pbstrIID = NULL;
    
#ifndef UNDER_CE
    CHK_BOOL(::StringFromGUID2((REFGUID)IID_IXMLDOMNodeList, (LPOLESTR) &acBuffer, GUIDBUFFER), E_FAIL);
#else
    CHK_BOOL(::StringFromGUID2((REFGUID)IID_IXMLDOMNodeList, (LPOLESTR) acBuffer, GUIDBUFFER), E_FAIL);
#endif 

    *pbstrIID = ::SysAllocString(acBuffer);
    CHK_MEM(*pbstrIID);
    
Cleanup:
    return hr;
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDOMMapper::saveNode(ISoapSerializer *pISoapSerializer, IXMLDOMNode *pNode)
//
//  parameters:
//
//  description:
//        recursive method to save nodes and childnodes...
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDOMMapper::saveNode(ISoapSerializer *pISoapSerializer, IXMLDOMNode *pNode)
{
    HRESULT hr = S_OK;

    CAutoBSTR   bstrXML;
    long         ulLen;

    if (!pNode)
    {
        goto Cleanup;
    }

    hr = pNode->get_xml(&bstrXML);
    if (FAILED(hr) || bstrXML==0) 
    {
        goto Cleanup;
    }
    ulLen = ::SysStringLen(bstrXML);    
    if (ulLen > 0)
    {
        CHK(pISoapSerializer->writeXML(bstrXML));
    }    

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



/////////////////////////////////////////////////////////////////////////////////////////////////////////
//  function: HRESULT CDOMMapper::processChildren(ISoapSerializer *pISoapSerializer, IXMLDOMNode *pNode)
//
//  parameters:
//
//  description:
//
//  returns: 
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////
HRESULT CDOMMapper::processChildren(ISoapSerializer *pISoapSerializer, IXMLDOMNode *pNode)
{
    CAutoRefc<IXMLDOMNodeList> pChildren=0;
    CAutoRefc<IXMLDOMNode> pChild=0;
    HRESULT hr = S_OK;

    // now process all children....
    hr = pNode->get_childNodes(&pChildren);
    if (FAILED(hr)) 
    {