Esempio n. 1
0
//--------------------------------------------------------------------------
VeChar8 VeFileIStream::Peek() noexcept
{
	if (m_stPointer >= m_stFileSize)
	{
		m_bError = true;
		return -1;
	}
	if (!Cached())
	{
		CacheReload();
	}
	return *((VeChar8*)m_pbyCache + m_stPointer - m_stCachePointer);
}
Esempio n. 2
0
//--------------------------------------------------------------------------
VeSizeT VeFileIStream::Read(void* pvBuffer, VeSizeT stBytes) noexcept
{
	if (stBytes && pvBuffer)
	{
		VeSizeT stCached = Cached();
		VeSizeT stRes(0);
		{
			VeSizeT stSpace = m_stPointer < m_stFileSize ?
				m_stFileSize - m_stPointer : 0;
			stBytes = (stSpace >= stBytes) ? stBytes : stSpace;
		}
		while (stBytes)
		{
			if (!stCached)
			{
				CacheReload();
				stCached = m_stCacheUse;
			}
			if (stBytes <= stCached)
			{
				VeCrazyCopy((VeChar8*)pvBuffer + stRes,
					(VeChar8*)m_pbyCache + m_stPointer - m_stCachePointer,
					stBytes);
				stRes += stBytes;
				m_stPointer += stBytes;
				stBytes = 0;
				break;
			}
			else
			{
				VeCrazyCopy((VeChar8*)pvBuffer + stRes,
					(VeChar8*)m_pbyCache + m_stPointer - m_stCachePointer,
					stCached);
				stRes += stCached;
				m_stPointer += stCached;
				stBytes -= stCached;
				stCached = 0;
			}
		}
		return stRes;
	}
	else
	{
		return 0;
	}
}
Esempio n. 3
0
HRESULT
CFileResourceCache::WriteResource(
    _In_ IXpsDocumentConsumer*  pXpsConsumer,
    _In_ IFixedPage*            pFixedPage,
    _In_ IResWriter*            pResWriter
    )
{
    HRESULT hr = S_OK;

    if (SUCCEEDED(hr = CHECK_POINTER(pXpsConsumer, E_POINTER)) &&
        SUCCEEDED(hr = CHECK_POINTER(pFixedPage, E_POINTER)) &&
        SUCCEEDED(hr = CHECK_POINTER(pResWriter, E_POINTER)))
    {
        CComBSTR bstrKeyName;
        CComBSTR bstrURI;

        //
        // Check if the resource has already been written
        //
        if (SUCCEEDED(hr = pResWriter->GetKeyName(&bstrKeyName)) &&
            SUCCEEDED(hr = pResWriter->GetResURI(&bstrURI)))
        {
            if (!Cached(bstrKeyName))
            {
                //
                // The resource is not cached:
                //    1. Create the resource part
                //    2. Write data to part
                //    3. Cache URI and new part against the resource name
                //
                CComPtr<_T> pRes(NULL);
                CComPtr<IPrintWriteStream> pWrite(NULL);

                if (SUCCEEDED(hr = pXpsConsumer->GetNewEmptyPart(bstrURI,
                                                                 __uuidof(_T),
                                                                 reinterpret_cast<VOID**>(&pRes),
                                                                 &pWrite)))
                {
                    hr = pResWriter->WriteData(pRes, pWrite);

                    pWrite->Close();

                    try
                    {
                        CComPtr<IPartBase> pPartBase(NULL);
                        if (SUCCEEDED(hr) &&
                            SUCCEEDED(hr = pRes.QueryInterface(&pPartBase)))
                        {
                            m_resMap[CComBSTR(bstrKeyName)].first = bstrURI;
                            m_resMap[CComBSTR(bstrKeyName)].second = pPartBase;
                        }
                    }
                    catch (exception& DBG_ONLY(e))
                    {
                        ERR(e.what());
                        hr = E_FAIL;
                    }
                }
            }

            //
            // Set the resource so relationships are updated
            //
            try
            {
                if (SUCCEEDED(hr))
                {
                    hr = pFixedPage->SetPagePart(m_resMap[CComBSTR(bstrKeyName)].second);
                }
            }
            catch (exception& DBG_ONLY(e))
            {
                ERR(e.what());
                hr = E_FAIL;
            }
        }
    }

    ERR_ON_HR(hr);
    return hr;
}