windows-xp/Source/XPSP1/NT/base/fs/hsm/fsa/fsaprem.cpp

/*++

� 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);
}