//*****************************************************************************
// Save the data to a stream. A TiggerStorage sub-allocates streams within
// the stream.
//*****************************************************************************
__checkReturn
HRESULT CLiteWeightStgdbRW::SaveToStream(
IStream *pIStream,
MetaDataReorderingOptions reorderingOptions,
CorProfileData *pProfileData)
{
HRESULT hr = S_OK; // A result.
StgIO *pStgIO = 0;
TiggerStorage *pStorage = 0;
// Allocate a storage subsystem and backing store.
IfNullGo(pStgIO = new (nothrow) StgIO);
IfNullGo(pStorage = new (nothrow) TiggerStorage);
// Open around this stream for write.
IfFailGo(pStgIO->Open(W(""),
DBPROP_TMODEF_DFTWRITEMASK,
0, 0, // pbData, cbData
pIStream,
0)); // LPSecurityAttributes
OptionValue ov;
IfFailGo(m_MiniMd.GetOption(&ov));
IfFailGo(pStorage->Init(pStgIO, ov.m_RuntimeVersion));
// Save worker will do tables, pools.
IfFailGo(SaveToStorage(pStorage, reorderingOptions, pProfileData));
ErrExit:
if (pStgIO != NULL)
pStgIO->Release();
if (pStorage != NULL)
delete pStorage;
return hr;
} // CLiteWeightStgdbRW::SaveToStream
//*****************************************************************************
// Save the metadata to a file.
//*****************************************************************************
HRESULT CLiteWeightStgdbRW::Save( // S_OK or error.
LPCWSTR szDatabase, // Name of file to which to save.
DWORD dwSaveFlags) // Flags for the save.
{
TiggerStorage *pStorage=0; // IStorage object.
StgIO *pStgIO=0; // Backing storage.
HRESULT hr = S_OK;
if (!*m_rcDatabase)
{
if (!szDatabase)
{
// Make sure that a NULL is not passed in the first time around.
_ASSERTE(!"Not allowed to pass a NULL for filename on the first call to Save.");
return (E_INVALIDARG);
}
else
{
// Save the file name.
wcscpy(m_rcDatabase, szDatabase);
}
}
else if (szDatabase && _wcsicmp(szDatabase, m_rcDatabase) != 0)
{
// Allow for same name, case of multiple saves during session.
// Changing the name on a scope which is already opened is not allowed.
// Save the file name.
wcscpy(m_rcDatabase, szDatabase);
}
// Sanity check the name.
if (lstrlenW(m_rcDatabase) >= _MAX_PATH)
IfFailGo(E_INVALIDARG);
m_eFileType = FILETYPE_CLB;
// Allocate a new storage object.
IfNullGo(pStgIO = new StgIO);
// Create the output file.
IfFailGo(pStgIO->Open(m_rcDatabase, DBPROP_TMODEF_DFTWRITEMASK));
// Allocate an IStorage object to use.
IfNullGo(pStorage = new TiggerStorage);
// Init the storage object on the i/o system.
OptionValue ov;
m_MiniMd.GetOption(&ov);
IfFailGo( pStorage->Init(pStgIO, ov.m_RuntimeVersion) );
// Save the data.
IfFailGo(SaveToStorage(pStorage));
ErrExit:
if (pStgIO)
pStgIO->Release();
if (pStorage)
delete pStorage;
return (hr);
} // HRESULT CLiteWeightStgdbRW::Save()
//*****************************************************************************
// Save the data to a stream. A TiggerStorage sub-allocates streams within
// the stream.
//*****************************************************************************
HRESULT CLiteWeightStgdbRW::SaveToStream(
IStream *pIStream)
{
HRESULT hr = S_OK; // A result.
StgIO *pStgIO = 0;
TiggerStorage *pStorage = 0;
// Allocate a storage subsystem and backing store.
IfNullGo(pStgIO = new StgIO);
IfNullGo(pStorage = new TiggerStorage);
// Open around this stream for write.
IfFailGo(pStgIO->Open(L"", DBPROP_TMODEF_DFTWRITEMASK, 0, 0, pIStream));
OptionValue ov;
m_MiniMd.GetOption(&ov);
IfFailGo( pStorage->Init(pStgIO, ov.m_RuntimeVersion) );
// Save worker will do tables, pools.
IfFailGo(SaveToStorage(pStorage));
ErrExit:
if (pStgIO)
pStgIO->Release();
if (pStorage)
delete pStorage;
return hr;
} // HRESULT CLiteWeightStgdbRW::PersistToStream()
//*****************************************************************************
// Save the metadata to a file.
//*****************************************************************************
__checkReturn
HRESULT CLiteWeightStgdbRW::Save(
LPCWSTR szDatabase, // Name of file to which to save.
DWORD dwSaveFlags) // Flags for the save.
{
TiggerStorage * pStorage = NULL; // IStorage object.
StgIO * pStgIO = NULL; // Backing storage.
HRESULT hr = S_OK;
if (m_wszFileName == NULL)
{
if (szDatabase == NULL)
{
// Make sure that a NULL is not passed in the first time around.
_ASSERTE(!"Not allowed to pass a NULL for filename on the first call to Save.");
return E_INVALIDARG;
}
else
{
// Save the file name.
IfFailGo(SetFileName(szDatabase));
}
}
else if ((szDatabase != NULL) && (SString::_wcsicmp(szDatabase, m_wszFileName) != 0))
{
// Save the file name.
IfFailGo(SetFileName(szDatabase));
}
// Sanity check the name.
if (!IsValidFileNameLength(m_wszFileName))
{
IfFailGo(E_INVALIDARG);
}
m_eFileType = FILETYPE_CLB;
// Allocate a new storage object.
IfNullGo(pStgIO = new (nothrow) StgIO);
// Create the output file.
IfFailGo(pStgIO->Open(m_wszFileName,
DBPROP_TMODEF_DFTWRITEMASK,
0,0, // pbData, cbData
0, // IStream*
0)); // LPSecurityAttributes
// Allocate an IStorage object to use.
IfNullGo(pStorage = new (nothrow) TiggerStorage);
// Init the storage object on the i/o system.
OptionValue ov;
IfFailGo(m_MiniMd.GetOption(&ov));
IfFailGo(pStorage->Init(pStgIO, ov.m_RuntimeVersion));
// Save the data.
IfFailGo(SaveToStorage(pStorage));
ErrExit:
if (pStgIO != NULL)
pStgIO->Release();
if (pStorage != NULL)
delete pStorage;
return hr;
} // CLiteWeightStgdbRW::Save
int CManageGroupChat::Clean()
{
int nRet = 0;
nRet = SaveToStorage();
return nRet;
}
BOOL COleDocument::OnSaveDocument(LPCTSTR lpszPathName)
// lpszPathName must be fully qualified
{
ASSERT(lpszPathName == NULL || AfxIsValidString(lpszPathName));
// use default implementation if 'docfile' not enabled
if (!m_bCompoundFile && m_lpRootStg == NULL)
{
ASSERT(lpszPathName != NULL);
return CDocument::OnSaveDocument(lpszPathName);
}
LPSTORAGE lpOrigStg = NULL;
if (lpszPathName != NULL)
m_bSameAsLoad = AfxComparePath(m_strPathName, lpszPathName);
BOOL bResult = FALSE;
TRY
{
// open new root storage if necessary
if (lpszPathName != NULL && !m_bSameAsLoad)
{
// temporarily detach current storage
lpOrigStg = m_lpRootStg;
m_lpRootStg = NULL;
LPSTORAGE lpStorage;
const CStringW strPathName(lpszPathName);
SCODE sc = ::StgCreateDocfile(strPathName.GetString(),
STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_CREATE,
0, &lpStorage);
if (sc != S_OK)
AfxThrowOleException(sc);
ASSERT(lpStorage != NULL);
m_lpRootStg = lpStorage;
}
ASSERT(m_lpRootStg != NULL);
// use helper to save to root storage
SaveToStorage();
if (lpszPathName != NULL)
{
// commit each of the items
CommitItems(m_bRemember && !m_bSameAsLoad);
// mark document as clean if remembering the storage
if (m_bRemember)
SetModifiedFlag(FALSE);
// remember correct storage or release save copy as storage
if (!m_bSameAsLoad)
{
if (m_bRemember)
{
// Save As case -- m_stgRoot is new storage, forget old storage
lpOrigStg->Release();
}
else
{
// Save Copy As case -- m_stgRoot should hook up to m_stgOrig.
m_lpRootStg->Release();
m_lpRootStg = lpOrigStg;
}
}
}
bResult = TRUE;
}
CATCH_ALL(e)
{
if (lpOrigStg != NULL)
{
// save as failed: abort new storage, and re-attach original
RELEASE(m_lpRootStg);
m_lpRootStg = lpOrigStg;
}
if (lpszPathName == NULL)
{
THROW_LAST();
}
TRY
{
ReportSaveLoadException(lpszPathName, e,
TRUE, AFX_IDP_FAILED_TO_SAVE_DOC);
}
END_TRY
DELETE_EXCEPTION(e);
}
END_CATCH_ALL
// cleanup
m_bSameAsLoad = TRUE;
m_bRemember = TRUE;
return bResult;
}
