490 lines
13 KiB
C++
490 lines
13 KiB
C++
// wwuperst.cpp: Implementation of wordwheel update persistance interface
|
|
#include <mvopsys.h>
|
|
|
|
#ifdef _DEBUG
|
|
static char s_aszModule[] = __FILE__; /* For error report */
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
#include <iterror.h>
|
|
#include <atlinc.h>
|
|
#include <itpropl.h>
|
|
#include <ccfiles.h>
|
|
#include <itsortid.h>
|
|
#include "wwumain.h"
|
|
|
|
|
|
// Type Definitions ***********************************************************
|
|
typedef struct
|
|
{
|
|
DWORD cKeys;
|
|
DWORD ilOffset;
|
|
} RECKW, FAR * PRECKW;
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::Save(IStorage *pStgSave, BOOL fSameAsLoad)
|
|
{
|
|
if (FALSE == m_fInitialized || NULL == m_piitskSortKey)
|
|
return SetErrReturn(E_NOTINIT);
|
|
|
|
// Create the permanent header stream
|
|
HRESULT hr;
|
|
IStream *pHeaderStream;
|
|
if (FAILED(hr = pStgSave->CreateStream
|
|
(SZ_BTREE_HEADER, STGM_WRITE, 0, 0, &pHeaderStream)))
|
|
return hr;
|
|
|
|
ResolveGlobalProperties (pHeaderStream);
|
|
|
|
// Handle occurence/term data
|
|
DWORD dwSize = GetFileSize(m_hTempFile, NULL);
|
|
CloseHandle(m_hTempFile);
|
|
m_hTempFile = NULL;
|
|
if (dwSize)
|
|
{
|
|
if (FAILED(hr = BuildPermanentFiles(pStgSave, pHeaderStream)))
|
|
{
|
|
pHeaderStream->Release();
|
|
return hr;
|
|
}
|
|
}
|
|
DeleteFile(m_szTempFile);
|
|
|
|
pHeaderStream->Release();
|
|
return S_OK;
|
|
} /* Save */
|
|
|
|
|
|
/***************************************************************
|
|
* @doc INTERNAL
|
|
*
|
|
* @api HRESULT FAR PASCAL | BuildKeywordFiles | This routine is called
|
|
* at the end of compilation to generate the appropriate
|
|
* .MVB subfiles to support runtime keyword stuff.
|
|
*
|
|
****************************************************************/
|
|
|
|
HRESULT WINAPI CITWordWheelUpdate::BuildPermanentFiles
|
|
(IStorage *pIStorage, IStream *pHeaderStream)
|
|
{
|
|
RECKW reckw;
|
|
HBT hbt;
|
|
IStream *pDataStream = NULL;
|
|
HRESULT hr; // Return code
|
|
|
|
LKW kwCur, kwNext;
|
|
LPSTR pCur, pEnd;
|
|
char fEOF;
|
|
DWORD dwWritten, dwTemp;
|
|
LPSTR pInput; // Input buffer
|
|
void * pvNewKey; // Used to resolve duplicate keys
|
|
DWORD dwBufferSize = CBMAX_KWENTRY; // Used to resolve duplicate keys
|
|
|
|
LPBYTE pKeyDataBuffer = NULL, pOccDataBuffer = NULL;
|
|
|
|
// Allocate temp buffers
|
|
pvNewKey = (void *)new BYTE[dwBufferSize];
|
|
if(NULL == pvNewKey)
|
|
return SetErrReturn(E_OUTOFMEMORY);
|
|
|
|
pKeyDataBuffer = new BYTE[m_cbMaxKeyData];
|
|
if (pKeyDataBuffer == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exit0;
|
|
}
|
|
|
|
pOccDataBuffer = new BYTE[m_cbMaxOccData];
|
|
if (pOccDataBuffer == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto exit0;
|
|
}
|
|
|
|
// Sort the input file using our own sort function
|
|
if (S_OK !=(hr = FileSort(NULL,(LPB)m_szTempFile,
|
|
NULL, NULL, 0, CompareKeys, m_piitskSortKey, ScanTempFile, NULL)))
|
|
{
|
|
exit0:
|
|
delete pvNewKey;
|
|
if(pKeyDataBuffer)
|
|
delete pKeyDataBuffer;
|
|
if(pOccDataBuffer)
|
|
delete pOccDataBuffer;
|
|
|
|
return hr;
|
|
}
|
|
|
|
m_btParams.hfs = pIStorage;
|
|
|
|
// *****************************
|
|
// Map the input file to memory
|
|
// *****************************
|
|
pInput = MapSequentialReadFile(m_szTempFile, &dwTemp);
|
|
if (!pInput)
|
|
{
|
|
SetErrCode(&hr, E_FAIL);
|
|
goto exit0;
|
|
}
|
|
pCur = pInput;
|
|
pEnd = pInput + dwTemp;
|
|
|
|
hbt = HbtInitFill(SZ_BTREE_BTREE_A, &m_btParams, &hr);
|
|
if (hbt == hNil)
|
|
{
|
|
exit2:
|
|
UnmapViewOfFile(pInput);
|
|
goto exit0;
|
|
}
|
|
|
|
BtreeSetExtSort(hbt, m_piitskSortKey);
|
|
|
|
// **************************************
|
|
// CREATE KEYWORD FILE IN MVB FILE SYSTEM
|
|
// **************************************
|
|
|
|
if (FAILED(hr = pIStorage->CreateStream
|
|
(SZ_BTREE_DATA, STGM_WRITE, 0, 0, &pDataStream)))
|
|
{
|
|
exit4:
|
|
if (pDataStream)
|
|
pDataStream->Release();
|
|
RcAbandonHbt(hbt);
|
|
goto exit2;
|
|
}
|
|
|
|
// Process keywords until we get to the next set
|
|
reckw.ilOffset = dwWritten = 0;
|
|
fEOF = 0;
|
|
pCur = ParseKeywordLine(pCur, &kwCur); // Load first record
|
|
|
|
// Process occurence information
|
|
while (!fEOF)
|
|
{
|
|
LARGE_INTEGER liNull = {0};
|
|
DWORD cbKeyProp; // Size of the Key data block
|
|
|
|
reckw.cKeys = 1;
|
|
dwWritten = 0;
|
|
|
|
// Handle properties for the key
|
|
BOOL fNotDup = TRUE;
|
|
cbKeyProp = 0;
|
|
while (!fEOF && kwCur.bPropDest == C_PROPDEST_KEY)
|
|
{
|
|
if (fNotDup)
|
|
{
|
|
hr = FWriteData
|
|
(pDataStream, &kwCur, &cbKeyProp, pKeyDataBuffer);
|
|
if (FAILED(hr))
|
|
goto exit4;
|
|
fNotDup = FALSE;
|
|
}
|
|
if (pCur == pEnd)
|
|
fEOF = TRUE;
|
|
else
|
|
pCur = ParseKeywordLine(pCur, &kwCur);
|
|
}
|
|
// cbKeyProp is an accumulated total for all previous writes
|
|
// if we didin't write anything we must at least write a
|
|
// record size of zero to the stream.
|
|
if (0 == cbKeyProp)
|
|
{
|
|
dwTemp = 0;
|
|
pDataStream->Write (&dwTemp, sizeof (DWORD), &cbKeyProp);
|
|
}
|
|
|
|
// You must have occurrence information -- not just key data
|
|
if (fEOF)
|
|
{
|
|
SetErrCode(&hr, E_FAIL);
|
|
goto exit4;
|
|
}
|
|
|
|
if (FAILED(hr = FWriteData
|
|
(pDataStream, &kwCur, &dwWritten, pOccDataBuffer)))
|
|
goto exit4;
|
|
|
|
if (pEnd != pCur)
|
|
pCur = ParseKeywordLine(pCur, &kwNext);
|
|
else
|
|
fEOF = 1;
|
|
|
|
// ********************************************************
|
|
// ********* PROCESS ALL IDENTICAL ENTRIES **********
|
|
// ********************************************************
|
|
while (!fEOF)
|
|
{
|
|
LONG lResult;
|
|
hr = m_piitskSortKey->Compare(kwCur.szKeyword + sizeof(DWORD),
|
|
kwNext.szKeyword + sizeof(DWORD), &lResult, NULL);
|
|
ITASSERT(SUCCEEDED(hr));
|
|
if(lResult)
|
|
break;
|
|
|
|
// These keys are identical, but the user may want to calapse
|
|
// them for some reason. Maybe he has custom data embedded in
|
|
// the keys.
|
|
hr = m_piitskSortKey->ResolveDuplicates(
|
|
kwCur.szKeyword + sizeof(DWORD),
|
|
kwNext.szKeyword + sizeof(DWORD),
|
|
pvNewKey, &dwBufferSize);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
// Verify that the user didn't alter the sort order!
|
|
hr = m_piitskSortKey->Compare(
|
|
kwCur.szKeyword + sizeof(DWORD),
|
|
pvNewKey, &lResult, NULL);
|
|
ITASSERT(SUCCEEDED(hr));
|
|
if(lResult)
|
|
{
|
|
ITASSERT(FALSE);
|
|
SetErrCode(&hr, E_UNEXPECTED);
|
|
goto exit4;
|
|
}
|
|
|
|
// Copy the key to our local buffer
|
|
MEMCPY(kwCur.szKeyword
|
|
+ sizeof(DWORD), pvNewKey, CBMAX_KWENTRY);
|
|
}
|
|
else if(hr != E_NOTIMPL)
|
|
{
|
|
ITASSERT(FALSE);
|
|
goto exit4;
|
|
}
|
|
if (FAILED(hr = FWriteData
|
|
(pDataStream, &kwNext, &dwWritten, pOccDataBuffer)))
|
|
goto exit4;
|
|
|
|
if (pEnd == pCur)
|
|
fEOF = 1;
|
|
else
|
|
pCur = ParseKeywordLine(pCur, &kwNext);
|
|
reckw.cKeys++;
|
|
}
|
|
|
|
// Add record into B-Tree
|
|
if (FAILED (hr = RcFillHbt(hbt,
|
|
(KEY)kwCur.szKeyword + sizeof(DWORD),(QV)&reckw)))
|
|
goto exit4;
|
|
|
|
reckw.ilOffset += dwWritten + cbKeyProp;
|
|
|
|
LKW kwTemp = kwCur;
|
|
kwCur = kwNext;
|
|
kwNext = kwTemp;
|
|
}
|
|
|
|
// ***********************************************
|
|
// CLOSE THE BTREE FOR THIS KEYWORD SET, CLOSE THE
|
|
// .MVB SUBFILE, AND DISPOSE OF THE TEMPORARY FILE
|
|
// ***********************************************
|
|
pDataStream->Release();
|
|
pDataStream = NULL;
|
|
|
|
hr = RcFiniFillHbt(hbt);
|
|
if (FAILED(hr))
|
|
goto exit4;
|
|
|
|
// ***********************************************
|
|
// NOW, BUILD THE APPROPRIATE MAP FILE FOR EACH
|
|
// KEYWORD SET USED BY THE THUMB ON THE SCROLL BOX
|
|
// ***********************************************
|
|
if (FAILED (hr = RcCreateBTMapHfs(pIStorage, hbt, SZ_WORDWHEEL_MAP_A)))
|
|
goto exit4;
|
|
|
|
if (FAILED (hr = RcCloseBtreeHbt(hbt)))
|
|
goto exit4;
|
|
|
|
// Write PROPERTY file (contains property headers)
|
|
DWORD dwSize;
|
|
if (m_lpbKeyHeader)
|
|
{
|
|
pHeaderStream->Write (&m_cbKeyHeader, sizeof (DWORD), &dwWritten);
|
|
pHeaderStream->Write (m_lpbKeyHeader, m_cbKeyHeader, &dwWritten);
|
|
}
|
|
else
|
|
{
|
|
dwSize = 0;
|
|
pHeaderStream->Write (&dwSize, sizeof (DWORD), &dwWritten);
|
|
}
|
|
// For now, we have no default data
|
|
dwSize = 0;
|
|
pHeaderStream->Write (&dwSize, sizeof (DWORD), &dwWritten);
|
|
|
|
if (m_lpbOccHeader)
|
|
{
|
|
pHeaderStream->Write (&m_cbOccHeader, sizeof (DWORD), &dwWritten);
|
|
pHeaderStream->Write (m_lpbOccHeader, m_cbOccHeader, &dwWritten);
|
|
}
|
|
else
|
|
{
|
|
dwSize = 0;
|
|
pHeaderStream->Write (&dwSize, sizeof (DWORD), &dwWritten);
|
|
}
|
|
// For now, we have no default data
|
|
dwSize = 0;
|
|
pHeaderStream->Write (&dwSize, sizeof (DWORD), &dwWritten);
|
|
|
|
// *****************
|
|
// TIDY UP AND LEAVE
|
|
// *****************
|
|
hr = S_OK;
|
|
goto exit2;
|
|
} /* BuildPermanentFiles */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::ResolveGlobalProperties
|
|
(IStream *pHeaderStream)
|
|
{
|
|
DWORD dwSize, dwWritten;
|
|
|
|
CloseHandle(m_hGlobalPropTempFile);
|
|
m_hGlobalPropTempFile = NULL;
|
|
if (!m_dwGlobalPropSize)
|
|
{
|
|
dwSize = 0;
|
|
pHeaderStream->Write (&dwSize, sizeof (DWORD), &dwWritten);
|
|
|
|
DeleteFile(m_szGlobalPropTempFile);
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT hr;
|
|
IITPropList *plTemp = NULL;
|
|
LPSTR pInput = NULL;
|
|
ULARGE_INTEGER ulSize;
|
|
|
|
// Map the temp file to memory
|
|
pInput = MapSequentialReadFile(m_szGlobalPropTempFile, &dwSize);
|
|
if (NULL == pInput)
|
|
{
|
|
SetErrCode(&hr, E_FAIL);
|
|
GlobalExit0:
|
|
if (plTemp)
|
|
plTemp->Release();
|
|
if (pInput)
|
|
UnmapViewOfFile (pInput);
|
|
return hr;
|
|
}
|
|
|
|
// Create property list
|
|
hr = CoCreateInstance(CLSID_IITPropList, NULL,
|
|
CLSCTX_INPROC_SERVER, IID_IITPropList,(LPVOID *)&plTemp);
|
|
if (FAILED(hr))
|
|
goto GlobalExit0;
|
|
|
|
// Load list from temp file
|
|
if (FAILED (hr = plTemp->LoadFromMem (pInput, dwSize)))
|
|
goto GlobalExit0;
|
|
|
|
// Get list size
|
|
plTemp->GetSizeMax(&ulSize);
|
|
|
|
// Write the property list size
|
|
hr = pHeaderStream->Write
|
|
(&ulSize.LowPart, sizeof(ulSize.LowPart), &dwSize);
|
|
if (FAILED(hr))
|
|
goto GlobalExit0;
|
|
|
|
// Write the property list
|
|
if (FAILED(hr = plTemp->Save(pHeaderStream, TRUE)))
|
|
goto GlobalExit0;
|
|
|
|
plTemp->Release();
|
|
UnmapViewOfFile (pInput);
|
|
|
|
DeleteFile(m_szGlobalPropTempFile);
|
|
return S_OK;
|
|
} /* ResolveGlobalProperties */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::GetClassID(CLSID *pClsID)
|
|
{
|
|
if (NULL == pClsID
|
|
|| IsBadWritePtr(pClsID, sizeof(CLSID)))
|
|
return SetErrReturn(E_INVALIDARG);
|
|
|
|
*pClsID = CLSID_IITWordWheelUpdate;
|
|
return S_OK;
|
|
} /* GetClassID */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::IsDirty(void)
|
|
{
|
|
if (m_fIsDirty)
|
|
return S_OK;
|
|
return S_FALSE;
|
|
} /* IsDirty */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::Load(IStorage *pStg)
|
|
{
|
|
return SetErrReturn(E_NOTIMPL);
|
|
} /* Load */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::InitNew(IStorage *pStg)
|
|
{
|
|
if (m_pStorage)
|
|
return SetErrReturn(CO_E_ALREADYINITIALIZED);
|
|
|
|
if (NULL == pStg)
|
|
return SetErrReturn(E_INVALIDARG);
|
|
|
|
m_pStorage = pStg;
|
|
pStg->AddRef();
|
|
|
|
m_fIsDirty = FALSE;
|
|
|
|
// Create a temp file
|
|
char szTempPath [_MAX_PATH + 1];
|
|
if (0 == GetTempPath(_MAX_PATH, szTempPath))
|
|
return SetErrReturn(E_FILECREATE);
|
|
if (0 == GetTempFileName(szTempPath, "WWU", 0, m_szTempFile))
|
|
return SetErrReturn(E_FILECREATE);
|
|
m_hTempFile = CreateFile
|
|
(m_szTempFile, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_hTempFile)
|
|
return SetErrReturn(E_FILECREATE);
|
|
|
|
if (0 == GetTempFileName(szTempPath, "WWU", 0, m_szGlobalPropTempFile))
|
|
return SetErrReturn(E_FILECREATE);
|
|
m_hGlobalPropTempFile = CreateFile(m_szGlobalPropTempFile,
|
|
GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_hGlobalPropTempFile)
|
|
return SetErrReturn(E_FILECREATE);
|
|
|
|
// Reset member variables
|
|
m_dwEntryCount = 0;
|
|
m_dwGlobalPropSize = 0;
|
|
|
|
m_lpbKeyHeader = m_lpbOccHeader = NULL;
|
|
m_cbMaxKeyData = m_cbMaxOccData = 0;
|
|
|
|
m_fInitialized = TRUE;
|
|
|
|
return S_OK;
|
|
} /* InitNew */
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::SaveCompleted(IStorage *pStgNew)
|
|
{
|
|
if (pStgNew)
|
|
{
|
|
if (!m_pStorage)
|
|
return SetErrReturn(E_UNEXPECTED);
|
|
m_pStorage->Release();
|
|
(m_pStorage = pStgNew)->AddRef();
|
|
}
|
|
m_fIsDirty = FALSE;
|
|
return S_OK;
|
|
} /* SaveCompleted */
|
|
|
|
|
|
STDMETHODIMP CITWordWheelUpdate::HandsOffStorage(void)
|
|
{
|
|
return S_OK;
|
|
} /* HandsOffStorage */
|