|
|
/*++
� 1998 Seagate Software, Inc. All rights reserved.
Module Name:
fsaprem.cpp
Abstract:
Defines the functions for the premigrated list classes.
Author:
Ron White [ronw] 18-Feb-1997
Revision History:
--*/
#include "stdafx.h"
#include "wsb.h"
#include "fsaprem.h"
#define WSB_TRACE_IS WSB_TRACE_BIT_FSA
static USHORT iCountPrem = 0; // Count of existing objects
HRESULT CFsaPremigratedDb::FinalConstruct( void ) /*++
Implements:
CComObjectRoot::FinalConstruct().
--*/ { HRESULT hr = S_OK;
try { WsbAssertHr(CWsbDb::FinalConstruct()); m_version = 1; } WsbCatch(hr);
return(hr); }
HRESULT CFsaPremigratedDb::FinalRelease( void ) /*++
Implements:
CComObjectRoot::FinalRelease
--*/ { HRESULT hr = S_OK;
CWsbDb::FinalRelease(); return(hr); }
HRESULT CFsaPremigratedDb::GetClassID( OUT CLSID* pClsid )
/*++
Implements:
IPersist::GetClassID().
--*/ { HRESULT hr = S_OK;
try { WsbAssert(0 != pClsid, E_POINTER); *pClsid = CLSID_CFsaPremigratedDb; } WsbCatch(hr); return(hr); }
HRESULT CFsaPremigratedDb::Init( IN OLECHAR* path, IN IWsbDbSys* pDbSys, OUT BOOL* pCreated )
/*++
Implements:
IFsaPremigrated::Init
--*/ { BOOL created = FALSE; HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedDb::Init"),OLESTR("")); try { int i = 0;
m_pWsbDbSys = pDbSys; WsbAffirmPointer(m_pWsbDbSys);
// Attempt to find the DB
hr = Locate(path);
if (S_OK != hr) { WsbTrace(OLESTR("CFsaPremigratedDb::Init: db Locate failed\n")); if (STG_E_FILENOTFOUND != hr) { // Got some error; try deleting the DB and recreating it
WsbTrace(OLESTR("CFsaPremigratedDb::Init: deleting DB\n")); WsbAffirmHr(Delete(path)); hr = STG_E_FILENOTFOUND; } }
if (STG_E_FILENOTFOUND == hr){ ULONG memSize;
hr = S_OK; m_nRecTypes = 2;
memSize = m_nRecTypes * sizeof(IDB_REC_INFO); m_RecInfo = (IDB_REC_INFO*)WsbAlloc(memSize); WsbAffirm(0 != m_RecInfo, E_FAIL); ZeroMemory(m_RecInfo, memSize);
// Premigrated file record type
m_RecInfo[0].Type = PREMIGRATED_REC_TYPE; m_RecInfo[0].EntityClassId = CLSID_CFsaPremigratedRec; m_RecInfo[0].Flags = IDB_REC_FLAG_VARIABLE; m_RecInfo[0].MinSize = (2 * WsbPersistSizeOf(FILETIME)) + (5 * WsbPersistSizeOf(LONGLONG)) + WsbPersistSizeOf(GUID) + 4 + WsbPersistSizeOf(BOOL); m_RecInfo[0].MaxSize = m_RecInfo[0].MinSize + PREMIGRATED_MAX_PATH_SIZE;
m_RecInfo[0].nKeys = 3;
memSize = m_RecInfo[0].nKeys * sizeof(IDB_KEY_INFO); m_RecInfo[0].Key = (IDB_KEY_INFO*)WsbAlloc(memSize); WsbAffirm(0 != m_RecInfo[0].Key, E_FAIL); ZeroMemory(m_RecInfo[0].Key, memSize);
// This is the default key used after a GetEntity call
m_RecInfo[0].Key[0].Type = PREMIGRATED_ACCESS_TIME_KEY_TYPE; m_RecInfo[0].Key[0].Size = WSB_BYTE_SIZE_BOOL + WSB_BYTE_SIZE_FILETIME + WSB_BYTE_SIZE_LONGLONG + WSB_BYTE_SIZE_GUID; m_RecInfo[0].Key[0].Flags = IDB_KEY_FLAG_DUP_ALLOWED;
// This is the primary key, which controls how the records are
// arranged in the DB
m_RecInfo[0].Key[1].Type = PREMIGRATED_BAGID_OFFSETS_KEY_TYPE; m_RecInfo[0].Key[1].Size = WSB_BYTE_SIZE_BOOL + 2 * WSB_BYTE_SIZE_LONGLONG + WSB_BYTE_SIZE_GUID; m_RecInfo[0].Key[1].Flags = IDB_KEY_FLAG_PRIMARY;
m_RecInfo[0].Key[2].Type = PREMIGRATED_SIZE_KEY_TYPE; m_RecInfo[0].Key[2].Size = WSB_BYTE_SIZE_BOOL + WSB_BYTE_SIZE_LONGLONG + WSB_BYTE_SIZE_LONGLONG + WSB_BYTE_SIZE_GUID; m_RecInfo[0].Key[2].Flags = IDB_KEY_FLAG_DUP_ALLOWED;
WsbAffirm(m_RecInfo[0].nKeys <= IDB_MAX_KEYS_PER_REC, E_FAIL);
// Recovery record type
m_RecInfo[1].Type = RECOVERY_REC_TYPE; m_RecInfo[1].EntityClassId = CLSID_CFsaRecoveryRec; m_RecInfo[1].Flags = IDB_REC_FLAG_VARIABLE; m_RecInfo[1].MinSize = 4 * WsbPersistSizeOf(LONGLONG) + WsbPersistSizeOf(LONG) + WsbPersistSizeOf(ULONG) + WsbPersistSizeOf(GUID) + 4; m_RecInfo[1].MaxSize = m_RecInfo[1].MinSize + PREMIGRATED_MAX_PATH_SIZE;
m_RecInfo[1].nKeys = 1;
memSize = m_RecInfo[1].nKeys * sizeof(IDB_KEY_INFO); m_RecInfo[1].Key = (IDB_KEY_INFO*)WsbAlloc(memSize); WsbAffirm(0 != m_RecInfo[1].Key, E_FAIL); ZeroMemory(m_RecInfo[1].Key, memSize);
// This is the default and primary key
m_RecInfo[1].Key[0].Type = RECOVERY_KEY_TYPE; m_RecInfo[1].Key[0].Size = RECOVERY_KEY_SIZE; m_RecInfo[1].Key[0].Flags = IDB_KEY_FLAG_PRIMARY;
// Attempt to create the DB
WsbAssertHr(Create(path)); created = TRUE; } else { WsbAffirmHr(hr); } } WsbCatch(hr);
if (pCreated) { *pCreated = created; } WsbTraceOut(OLESTR("CFsaPremigratedDb::Init"), OLESTR("hr = <%ls>, Created = %ls"), WsbHrAsString(hr), WsbBoolAsString(created)); return(hr); }
HRESULT CFsaPremigratedDb::Load( IN IStream* pStream )
/*++
Implements:
IPersistStream::Load().
--*/ { HRESULT hr = S_OK;
hr = CWsbDb::Load(pStream);
if (S_OK != hr && STG_E_FILENOTFOUND != hr) { // Got some error; delete the DB (we'll recreate it later if
// we need it
WsbTrace(OLESTR("CFsaPremigratedDb::Load: deleting DB\n")); if (S_OK == Delete(NULL)) { hr = STG_E_FILENOTFOUND; } }
return(hr); }
HRESULT CFsaPremigratedDb::Save( IN IStream* pStream, IN BOOL clearDirty )
/*++
Implements:
IPersistStream::Save().
--*/ { HRESULT hr = S_OK;
try { WsbAffirmHr(CWsbDb::Save(pStream, clearDirty)); } WsbCatch(hr);
return(hr); }
HRESULT CFsaPremigratedRec::GetAccessTime( OUT FILETIME* pAccessTime ) /*++
Implements:
IFsaPremigratedRec::GetAccessTime
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetAccessTime"),OLESTR(""));
try { WsbAssert(0 != pAccessTime, E_POINTER); *pAccessTime = m_AccessTime; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetAccessTime"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::GetBagId( OUT GUID* pId ) /*++
Implements:
IFsaPremigratedRec::GetBagId
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetBagId"),OLESTR(""));
try { WsbAssert(0 != pId, E_POINTER);
*pId = m_BagId; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetBagId"), OLESTR("hr = <%ls> Id = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pId));
return(hr); }
HRESULT CFsaPremigratedRec::GetBagOffset( OUT LONGLONG* pOffset ) /*++
Implements:
IFsaPremigratedRec::GetBagOffset
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetBagOffset"),OLESTR(""));
try { WsbAssert(0 != pOffset, E_POINTER); *pOffset = m_BagOffset; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetBagOffset"), OLESTR("hr = <%ls> Offset = <%ls>"), WsbHrAsString(hr), WsbLonglongAsString(*pOffset));
return(hr); }
HRESULT CFsaPremigratedRec::GetFileId( OUT LONGLONG* pFileId ) /*++
Implements:
IFsaPremigratedRec::GetFileId
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetFileId"),OLESTR(""));
try { WsbAssert(0 != pFileId, E_POINTER); *pFileId = m_FileId; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetFileId"), OLESTR("hr = <%ls> FileId = <%ls>"), WsbHrAsString( hr ), WsbLonglongAsString( *pFileId ) );
return(hr); }
HRESULT CFsaPremigratedRec::GetFileUSN( OUT LONGLONG* pFileUSN ) /*++
Implements:
IFsaPremigratedRec::GetFileUSN
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetFileUSN"),OLESTR(""));
try { WsbAssert(0 != pFileUSN, E_POINTER); *pFileUSN = m_FileUSN; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetFileUSN"), OLESTR("hr = <%ls> File USN = <%ls>"), WsbHrAsString( hr ), WsbLonglongAsString( *pFileUSN ) );
return(hr); }
HRESULT CFsaPremigratedRec::GetOffset( OUT LONGLONG* pOffset ) /*++
Implements:
IFsaPremigratedRec::GetOffset
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetOffset"),OLESTR(""));
try { WsbAssert(0 != pOffset, E_POINTER); *pOffset = m_Offset; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetOffset"), OLESTR("hr = <%ls> Offset = <%ls>"), WsbHrAsString( hr ), WsbLonglongAsString( *pOffset ) );
return(hr); }
HRESULT CFsaPremigratedRec::GetPath( OUT OLECHAR** ppPath, IN ULONG bufferSize ) /*++
Implements:
IFsaPremigratedRec::GetPath
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetPath"),OLESTR(""));
try { WsbAssert(0 != ppPath, E_POINTER); WsbAffirmHr(m_Path.CopyTo(ppPath, bufferSize)); WsbTrace( OLESTR("CFsaPremigratedRec::GetPath path = <%ls>\n"), *ppPath ); } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetPath"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::GetRecallTime( OUT FILETIME* pTime ) /*++
Implements:
IFsaPremigratedRec::GetRecallTime
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetRecallTime"),OLESTR(""));
try { WsbAssert(0 != pTime, E_POINTER); *pTime = m_RecallTime; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetRecallTime"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::GetSize( OUT LONGLONG* pSize ) /*++
Implements:
IFsaPremigratedRec::GetSize
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetSize"),OLESTR(""));
try { WsbAssert(0 != pSize, E_POINTER); *pSize = m_Size; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetSize"), OLESTR("hr = <%ls> Size = <%ls>"), WsbHrAsString( hr ), WsbLonglongAsString( *pSize ) );
return(hr); }
HRESULT CFsaPremigratedRec::FinalConstruct( void ) /*++
Implements:
CComObjectRoot::FinalConstruct().
--*/ { HRESULT hr = S_OK;
try {
WsbAssertHr(CWsbDbEntity::FinalConstruct());
m_AccessTime.dwLowDateTime = 0; m_AccessTime.dwHighDateTime = 0; m_BagOffset = 0; m_BagId = GUID_NULL; m_FileId = 0; m_IsWaitingForClose = FALSE; m_Size = 0; m_Offset = 0; m_FileUSN = 0;
} WsbCatch(hr);
iCountPrem++;
return(hr); }
HRESULT CFsaPremigratedRec::FinalRelease( void ) /*++
Implements:
CComObjectRoot::FinalRelease
--*/ { HRESULT hr = S_OK;
CWsbDbEntity::FinalRelease();
iCountPrem--;
return(hr); }
HRESULT CFsaPremigratedRec::GetClassID ( OUT LPCLSID pclsid ) /*++
Implements:
IPerist::GetClassID
--*/
{ HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetClassID"), OLESTR(""));
try { WsbAssert(0 != pclsid, E_POINTER); *pclsid = CLSID_CFsaPremigratedRec;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CSecRec::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pclsid)); return(hr); }
HRESULT CFsaPremigratedRec::GetSizeMax ( OUT ULARGE_INTEGER* pcbSize ) /*++
Routine Description:
See IPersistStream::GetSizeMax().
Arguments:
See IPersistStream::GetSizeMax().
Return Value:
See IPersistStream::GetSizeMax().
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::GetSizeMax"), OLESTR(""));
try { WsbAssert(0 != pcbSize, E_POINTER);
pcbSize->QuadPart = WsbPersistSizeOf(FILETIME) + WsbPersistSizeOf(BOOL) + WsbPersistSizeOf(GUID) + 4 * WsbPersistSizeOf(LONGLONG) + WsbPersistSize((wcslen(m_Path) + 1) * sizeof(OLECHAR));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pcbSize));
return(hr); }
HRESULT CFsaPremigratedRec::IsWaitingForClose( void ) /*++
Implements:
IFsaPremigratedRec::IsWaitingForClose
--*/ { HRESULT hr = S_FALSE;
WsbTraceIn(OLESTR("CFsaPremigratedRec::IsWaitingForClose"),OLESTR(""));
if (m_IsWaitingForClose) { hr = S_OK; }
WsbTraceOut(OLESTR("CFsaPremigratedRec::IsWaitingForClose"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::Load ( IN IStream* pStream ) /*++
Implements:
IPersistStream::Load
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::Load"), OLESTR(""));
try { WsbAssert(0 != pStream, E_POINTER); WsbAssertHr(WsbLoadFromStream(pStream, &m_AccessTime)); WsbAssertHr(WsbLoadFromStream(pStream, &m_BagId)); WsbAssertHr(WsbLoadFromStream(pStream, &m_BagOffset)); WsbAssertHr(WsbLoadFromStream(pStream, &m_FileId)); WsbAssertHr(WsbLoadFromStream(pStream, &m_IsWaitingForClose)); WsbAssertHr(WsbLoadFromStream(pStream, &m_Offset)); WsbAssertHr(WsbLoadFromStream(pStream, &m_Path, 0)); WsbAssertHr(WsbLoadFromStream(pStream, &m_Size)); WsbAssertHr(WsbLoadFromStream(pStream, &m_RecallTime)); WsbAssertHr(WsbLoadFromStream(pStream, &m_FileUSN));
} WsbCatch(hr); WsbTraceOut(OLESTR("CFsaPremigratedRec::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::Print ( IN IStream* pStream ) /*++
Implements:
IWsbDbEntity::Print
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::Print"), OLESTR(""));
try { WsbAssert(0 != pStream, E_POINTER); CWsbStringPtr strGuid; WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" AccessTime = %ls"), WsbFiletimeAsString(FALSE, m_AccessTime))); WsbAffirmHr(WsbSafeGuidAsString(m_BagId, strGuid)); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" BagId = %ls"), (WCHAR *)strGuid)); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", BagOffset = %ls"), WsbLonglongAsString(m_BagOffset))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", FileId = %ls"), WsbLonglongAsString(m_FileId))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" Waiting for close = %ls"), WsbBoolAsString(m_IsWaitingForClose))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", Offset = %ls"), WsbLonglongAsString(m_Offset))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", Path = %ls"), static_cast<OLECHAR*>(m_Path))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", Size = %ls"), WsbLonglongAsString(m_Size))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" RecallTime = %ls"), WsbFiletimeAsString(FALSE, m_RecallTime))); WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(", File USN = %ls"), WsbLonglongAsString(m_FileUSN))); WsbAffirmHr(CWsbDbEntity::Print(pStream));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::Print"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::Save ( IN IStream* pStream, IN BOOL clearDirty ) /*++
Implements:
IPersistStream::Save
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
try { WsbAssert(0 != pStream, E_POINTER); WsbAssertHr(WsbSaveToStream(pStream, m_AccessTime)); WsbAssertHr(WsbSaveToStream(pStream, m_BagId)); WsbAssertHr(WsbSaveToStream(pStream, m_BagOffset)); WsbAssertHr(WsbSaveToStream(pStream, m_FileId)); WsbAssertHr(WsbSaveToStream(pStream, m_IsWaitingForClose)); WsbAssertHr(WsbSaveToStream(pStream, m_Offset)); WsbAssertHr(WsbSaveToStream(pStream, m_Path)); WsbAssertHr(WsbSaveToStream(pStream, m_Size)); WsbAssertHr(WsbSaveToStream(pStream, m_RecallTime)); WsbAssertHr(WsbSaveToStream(pStream, m_FileUSN));
// If we got it saved and we were asked to clear the dirty bit, then
// do so now.
if (clearDirty) { m_isDirty = FALSE; } } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetAccessTime( IN FILETIME AccessTime ) /*++
Implements:
IFsaPremigratedRec::SetAccessTime
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetAccessTime"),OLESTR(""));
try { m_AccessTime = AccessTime; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetAccessTime"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetFromScanItem( IN IFsaScanItem* pScanItem, IN LONGLONG offset, IN LONGLONG size, IN BOOL isWaitingForClose ) /*++
Implements:
IFsaPremigratedRec::SetFromScanItem
--*/ { HRESULT hr = S_OK; FSA_PLACEHOLDER placeholder;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetFromScanItem"),OLESTR(""));
try { WsbAssert(0 != pScanItem, E_POINTER);
// Get the name of the file
WsbAffirmHr(pScanItem->GetPathAndName(0, &m_Path, 0)); WsbTrace(OLESTR("CFsaPremigratedRec::SetFromScanItem: path = %ls\n"), static_cast<WCHAR*>(m_Path));
// Get the file id.
WsbAffirmHr(pScanItem->GetFileId(&m_FileId));
// Get the access time, offset, and size.
WsbAffirmHr(pScanItem->GetAccessTime(&m_AccessTime)); WsbTrace(OLESTR("CFsaPremigratedRec::SetFromScanItem: access time = %ls\n"), WsbFiletimeAsString(FALSE, m_AccessTime)); m_Offset = offset; m_Size = size; m_IsWaitingForClose = isWaitingForClose;
// Get the bag id and offset.
WsbAffirmHr(pScanItem->GetPlaceholder(offset, size, &placeholder)); m_BagId = placeholder.bagId; m_BagOffset = placeholder.fileStart; m_RecallTime = placeholder.recallTime; WsbTrace(OLESTR("CFsaPremigratedRec::SetFromScanItem: recall time = %ls\n"), WsbFiletimeAsString(FALSE, m_RecallTime));
} WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetFromScanItem"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetBagId( IN GUID BagId ) /*++
Implements:
IFsaPremigratedRec::SetBagId
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetBagId"),OLESTR(""));
m_BagId = BagId;
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetBagId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetBagOffset( IN LONGLONG BagOffset ) /*++
Implements:
IFsaPremigratedRec::SetBagOffset
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetBagOffset"),OLESTR(""));
m_BagOffset = BagOffset;
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetBagOffset"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetFileId( IN LONGLONG FileId ) /*++
Implements:
IFsaPremigratedRec::SetFileId
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetFileId"),OLESTR("FileId = %ls"), WsbLonglongAsString(FileId));
try { m_FileId = FileId; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetFileId"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetFileUSN( IN LONGLONG FileUSN ) /*++
Implements:
IFsaPremigratedRec::SetFileUSN
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetFileUSN"),OLESTR("File USN = %ls"), WsbLonglongAsString(FileUSN));
try { m_FileUSN = FileUSN; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetFileUSN"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetIsWaitingForClose( IN BOOL isWaiting ) /*++
Implements:
IFsaPremigratedRec::SetIsWaitingForClose
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetIsWaitingForClose"),OLESTR(""));
m_IsWaitingForClose = isWaiting;
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetIsWaitingForClose"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetOffset( IN LONGLONG Offset ) /*++
Implements:
IFsaPremigratedRec::SetOffset
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetOffset"),OLESTR(""));
try { m_Offset = Offset; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetOffset"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetPath( IN OLECHAR* Path ) /*++
Implements:
IFsaPremigratedRec::SetPath
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetPath"),OLESTR(""));
try { m_Path = Path; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetPath"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetRecallTime( IN FILETIME time ) /*++
Implements:
IFsaPremigratedRec::SetRecallTime
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetRecallTime"),OLESTR(""));
try { m_RecallTime = time; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetRecallTime"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::SetSize( IN LONGLONG Size ) /*++
Implements:
IFsaPremigratedRec::SetSize
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CFsaPremigratedRec::SetSize"),OLESTR(""));
try { m_Size = Size; } WsbCatch(hr);
WsbTraceOut(OLESTR("CFsaPremigratedRec::SetSize"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
HRESULT CFsaPremigratedRec::UpdateKey( IWsbDbKey *pKey ) /*++
Implements:
IWsbDbEntity::UpdateKey
--*/ { HRESULT hr = S_OK;
try { ULONG KeyType;
WsbAffirmHr(pKey->GetType(&KeyType)); switch (KeyType) { case PREMIGRATED_ACCESS_TIME_KEY_TYPE: WsbAffirmHr(pKey->SetToBool(m_IsWaitingForClose)); WsbAffirmHr(pKey->AppendFiletime(m_AccessTime)); WsbAffirmHr(pKey->AppendGuid(m_BagId)); WsbAffirmHr(pKey->AppendLonglong(m_BagOffset)); break;
case PREMIGRATED_BAGID_OFFSETS_KEY_TYPE: WsbAffirmHr(pKey->SetToGuid(m_BagId)); WsbAffirmHr(pKey->AppendLonglong(m_BagOffset)); WsbAffirmHr(pKey->AppendLonglong(m_Offset)); break;
case PREMIGRATED_SIZE_KEY_TYPE: WsbAffirmHr(pKey->SetToBool(m_IsWaitingForClose)); WsbAffirmHr(pKey->AppendLonglong(m_Size)); WsbAffirmHr(pKey->AppendGuid(m_BagId)); WsbAffirmHr(pKey->AppendLonglong(m_BagOffset)); break; } } WsbCatch(hr);
return(hr); }
|