able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/hsm/fsa/fsaprem.cpp

1192 lines
24 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
<EFBFBD> 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);
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" AccessTime = %ls"),
WsbFiletimeAsString(FALSE, m_AccessTime)));
WsbAffirmHr(WsbPrintfToStream(pStream, OLESTR(" BagId = %ls"),
WsbGuidAsString(m_BagId)));
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);
}
Reference in a new issue Copy permalink