C++ IPersistStream::Load方法代码示例

HRESULT LoadPropertyStoreFromStream(IStream *pstm, REFIID riid, void **ppv)
{
    *ppv = NULL;

    STATSTG stat;
    HRESULT hr = pstm->Stat(&stat, STATFLAG_NONAME);
    if (SUCCEEDED(hr))
    {
        IPersistStream *pps;
        hr = PSCreateMemoryPropertyStore(IID_PPV_ARGS(&pps));
        if (SUCCEEDED(hr))
        {
            if (stat.cbSize.QuadPart == 0)
            {
                hr = S_OK; // empty stream => empty property store
            }
            else if (stat.cbSize.QuadPart > (128 * 1024))
            {
                hr = STG_E_MEDIUMFULL; // can't be that large
            }
            else
            {
                hr = pps->Load(pstm);
            }

            if (SUCCEEDED(hr))
            {
                hr = pps->QueryInterface(riid, ppv);
            }
            pps->Release();
        }
    }
    return hr;
}

HRESULT CDShowCtrl::LoadGraphFile(IGraphBuilder *pGraph, const WCHAR* wszName)
{
    IStorage *pStorage = 0;
    if (S_OK != StgIsStorageFile(wszName))
    {
        return E_FAIL;
    }
    HRESULT hr = StgOpenStorage(wszName, 0, 
        STGM_TRANSACTED | STGM_READ | STGM_SHARE_DENY_WRITE, 
        0, 0, &pStorage);
    if (FAILED(hr))
    {
        return hr;
    }
    IPersistStream *pPersistStream = 0;
    hr = pGraph->QueryInterface(IID_IPersistStream,
             reinterpret_cast<void**>(&pPersistStream));
    if (SUCCEEDED(hr))
    {
        IStream *pStream = 0;
        hr = pStorage->OpenStream(L"ActiveMovieGraph", 0, 
            STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
        if(SUCCEEDED(hr))
        {
            hr = pPersistStream->Load(pStream);
            pStream->Release();
        }
        pPersistStream->Release();
    }
    pStorage->Release();
    return hr;
}

// @pymethod |PyIPersistStream|Load|Initializes an object from the stream where it was previously saved.
PyObject *PyIPersistStream::Load(PyObject *self, PyObject *args)
{
		IPersistStream *pMy = GetI(self);
	if (pMy==NULL) return NULL;

	PyObject *obStream;
	// @pyparm <o PyIStream>|stream||Stream object to load from.
	if (!PyArg_ParseTuple(args, "O:Load", &obStream))
		return NULL;

	IStream *pStream;
	if (!PyCom_InterfaceFromPyInstanceOrObject(obStream, IID_IStream, (void **)&pStream, FALSE /*bNoneOK*/))
		return NULL;

	PY_INTERFACE_PRECALL;
	HRESULT hr = pMy->Load(pStream);
	pStream->Release();
	PY_INTERFACE_POSTCALL;
	if (FAILED(hr))
		return PyCom_BuildPyException(hr, pMy, IID_IPersistStream);
	Py_INCREF(Py_None);
	return Py_None;
	// @comm This method loads an object from its associated stream. The seek pointer is set as it was in the most recent <om PyIPersistStream.Save> method. This method can seek and read from the stream, but cannot write to it.
	// @comm On exit, the seek pointer must be in the same position it was in on entry, immediately past the end of the data.
}

HRESULT CLTDMLoader::LoadFromFile(LPDMUS_OBJECTDESC pDesc,IDirectMusicObject8 ** ppIObject)

{
	HRESULT hr;
    
	hr = CoCreateInstance(pDesc->guidClass,
		NULL,CLSCTX_INPROC_SERVER,IID_IDirectMusicObject8,
		(void **) ppIObject);
	if (SUCCEEDED(hr))
	{
		WCHAR wzFullPath[DMUS_MAX_FILENAME];
		ZeroMemory( wzFullPath, sizeof(WCHAR) * DMUS_MAX_FILENAME );
		CLTDMFileStream *pStream = new CLTDMFileStream ( this );
		if (pStream)
		{
			if (pDesc->dwValidData & DMUS_OBJ_FULLPATH)
			{
				wcscpy(wzFullPath,pDesc->wszFileName);
			}
			else
			{
				// find the directory that matches this class and copy it to the path
				CLoadDirByClassItem* pItem = m_pLoadDirByClassList->Find(pDesc->guidClass);
				if (pItem != NULL) wcscpy(wzFullPath, pItem->GetPath());

				// check if slash was on end of string if not add it
				if ((wzFullPath[wcslen(wzFullPath)-1] != m_wszBackSlash[0]) && 
					(wzFullPath[wcslen(wzFullPath)-1] != m_wszForwardSlash[0]))
				{
					wcscat(wzFullPath, m_wszBackSlash);
				}

				// add filename to string
				wcscat(wzFullPath, pDesc->wszFileName);
			}
			hr = pStream->Open(wzFullPath,GENERIC_READ);
			if (SUCCEEDED(hr))
			{
				IPersistStream* pIPS;
				hr = (*ppIObject)->QueryInterface( IID_IPersistStream, (void**)&pIPS );
				if (SUCCEEDED(hr))
				{
                    // Now that we have the IPersistStream interface from the object, we can ask it to load from our stream!
					hr = pIPS->Load( pStream );
					pIPS->Release();
				}
			}
			pStream->Release();
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
        if (FAILED(hr))
        {
       		(*ppIObject)->Release();
        }
	}
	return hr;
}

HRESULT CPkcs7::SaveIntoJavaClassFile(FILEHANDLE hFile,LPCOLESTR wszFileName,BOOL fClearDirty)
// Save this signed data (presumably already signed) into the right place in the class file
	{
	HRESULT hr = S_OK;
	CFileStream stm;
	if (stm.OpenFileForWriting(hFile, wszFileName, FALSE))
		{
		IPersistStream* pPerStream;
		hr = CJavaClassFile::CreateInstance(NULL, IID_IPersistStream, (LPVOID*)&pPerStream);
		if (hr == S_OK)
			{
			hr = pPerStream->Load(&stm);						// load the class file
			if (hr == S_OK)
				{
				BLOB b;
				hr = CPersistMemoryHelper2::Save(&b, FALSE);	// get our bits
				if (hr == S_OK)
					{
					IInsertSig* pSig;
					hr = pPerStream->QueryInterface(IID_IInsertSig, (LPVOID*)&pSig);
					if (hr == S_OK)
						{
						hr = pSig->SaveSig(&b);					// stuff our bits in
						pSig->Release();
						}
					FreeTaskMem(b);
					}
				if (hr == S_OK)
					{
					stm.Reset();
					stm.Truncate();
					hr = pPerStream->Save(&stm, FALSE);			// save the class file
					}
				}
			pPerStream->Release();
			}
		}
	else
		hr = HError();

	if (hr == S_OK && fClearDirty)
		m_isDirty = FALSE;

	return hr;
	}

HRESULT CLTDMLoader::LoadFromMemory(LPDMUS_OBJECTDESC pDesc,IDirectMusicObject8 ** ppIObject)

{
	HRESULT hr;
	hr = CoCreateInstance(pDesc->guidClass,
		NULL,CLSCTX_INPROC_SERVER,IID_IDirectMusicObject8,
		(void **) ppIObject);
	if (SUCCEEDED(hr))
	{
		CLTDMMemStream *pStream = new CLTDMMemStream ( this );
		if (pStream)
		{
			hr = pStream->Open(pDesc->pbMemData,pDesc->llMemLength);
			if (SUCCEEDED(hr))
			{
				IPersistStream* pIPS;
				hr = (*ppIObject)->QueryInterface( IID_IPersistStream, (void**)&pIPS );
				if (SUCCEEDED(hr))
				{
                    // Now that we have the IPersistStream interface from the object, we can ask it to load from our stream!
					hr = pIPS->Load( pStream );
					pIPS->Release();
				}
			}
			pStream->Release();
		}
		else
		{
			hr = E_OUTOFMEMORY;
		}
        if (FAILED(hr))
        {
       		(*ppIObject)->Release();
        }
	}
	return hr;
}