835 lines
19 KiB
C++
835 lines
19 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1996 - 2000.
|
|
//
|
|
// File: FrmUtils.hxx
|
|
//
|
|
// Contents: Framework parameter utility classes
|
|
//
|
|
// History: 14-Jan-1998 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include <ciintf.h>
|
|
#include <driveinf.hxx>
|
|
|
|
class PDeSerStream;
|
|
class PSerStream;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CCiFrameworkParams
|
|
//
|
|
// Purpose: A wrapper around the administrative parameters interface
|
|
// for the frame work.
|
|
//
|
|
// History: 12-05-96 srikants Created
|
|
// 19-10-98 sundara added IS_ENUM_ALLOWED
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CCiFrameworkParams
|
|
{
|
|
public:
|
|
|
|
CCiFrameworkParams( ICiAdminParams * pCiAdminParams = 0 )
|
|
: _pCiAdminParams(pCiAdminParams)
|
|
{
|
|
if ( _pCiAdminParams )
|
|
_pCiAdminParams->AddRef();
|
|
}
|
|
|
|
~CCiFrameworkParams()
|
|
{
|
|
if ( _pCiAdminParams )
|
|
_pCiAdminParams->Release();
|
|
}
|
|
|
|
void Set( ICiAdminParams * pCiAdminParams )
|
|
{
|
|
Win4Assert( 0 != pCiAdminParams );
|
|
Win4Assert( 0 == _pCiAdminParams );
|
|
|
|
pCiAdminParams->AddRef();
|
|
_pCiAdminParams = pCiAdminParams;
|
|
}
|
|
|
|
|
|
const BOOL FilterContents()
|
|
{
|
|
DWORD dwVal = 0;
|
|
_pCiAdminParams->GetValue( CI_AP_FILTER_CONTENTS, &dwVal );
|
|
return 0 != dwVal;
|
|
}
|
|
|
|
const __int64 GetMaxFilesizeFiltered()
|
|
{
|
|
__int64 val;
|
|
_pCiAdminParams->GetInt64Value( CI_AP_MAX_FILESIZE_FILTERED, &val );
|
|
|
|
//
|
|
// Filesize is specified in Kilobytes but used in bytes.
|
|
//
|
|
|
|
val *= 1024;
|
|
|
|
return val;
|
|
}
|
|
|
|
const ULONG GetMasterMergeTime()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue( CI_AP_MASTER_MERGE_TIME, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxFilesizeMultiplier()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_FILESIZE_MULTIPLIER, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const int GetThreadPriorityFilter()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_THREAD_PRIORITY_FILTER, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const int GetThreadClassFilter()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_THREAD_CLASS_FILTER, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetDaemonResponseTimeout()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_DAEMON_RESPONSE_TIMEOUT, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxCharacterization()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_CHARACTERIZATION, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const BOOL GenerateCharacterization()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_GENERATE_CHARACTERIZATION, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return 0 != dwVal;
|
|
}
|
|
|
|
|
|
const BOOL FilterDirectories()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_DIRECTORIES, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return 0 != dwVal;
|
|
}
|
|
|
|
|
|
const BOOL FilterFilesWithUnknownExtensions()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FFILTER_FILES_WITH_UNKNOWN_EXTENSIONS, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return 0 != dwVal;
|
|
}
|
|
|
|
const ULONG GetFilterDelayInterval()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_DELAY_INTERVAL, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetFilterRemainingThreshold()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_REMAINING_THRESHOLD, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxMergeInterval()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MERGE_INTERVAL, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const int GetThreadPriorityMerge()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_THREAD_PRIORITY_MERGE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return (int) dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxUpdates()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_UPDATES, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxWordlists()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_WORDLISTS, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMinSizeMergeWordlist()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_SIZE_MERGE_WORDLISTS, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxWordlistSize()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_WORDLIST_SIZE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMinWordlistMemory()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_WORDLIST_MEMORY, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxWordlistIo()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_WORDLIST_IO, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMinWordlistBattery()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_WORDLIST_BATTERY, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetWordlistUserIdle()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_WORDLIST_USER_IDLE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetWordlistResourceCheckInterval()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_WORDLIST_RESOURCE_CHECK_INTERVAL, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetStartupDelay()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_STARTUP_DELAY, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxFreshDeletes()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_FRESH_DELETES, &dwVal );
|
|
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetLowResourceSleep()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_LOW_RESOURCE_SLEEP, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
|
|
const ULONG GetMaxWordlistMemoryLoad()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_WORDLIST_MEMORY_LOAD, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxFreshCount()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_FRESH_COUNT, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxQueueChunks()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_QUEUE_CHUNKS, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMasterMergeCheckpointInterval()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MASTER_MERGE_CHECKPOINT_INTERVAL, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetFilterBufferSize()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_BUFFER_SIZE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetFilterRetries()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_RETRIES, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetSecQFilterRetries()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_SECQ_FILTER_RETRIES, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetFilterRetryInterval()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_FILTER_RETRY_INTERVAL, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxShadowIndexSize()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_SHADOW_INDEX_SIZE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMinDiskFreeForceMerge()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_DISK_FREE_FORCE_MERGE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxShadowFreeForceMerge()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_SHADOW_FREE_FORCE_MERGE, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxIndexes()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_INDEXES, &dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxIdealIndexes()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_IDEAL_INDEXES,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
|
|
}
|
|
|
|
const ULONG GetMinMergeIdleTime()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_MERGE_IDLE_TIME,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
|
|
}
|
|
|
|
const ULONG GetMaxPendingDocuments()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_PENDING_DOCUMENTS,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
|
|
}
|
|
|
|
const ULONG GetMinIdleQueryThreads()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_IDLE_QUERY_THREADS,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxActiveQueryThreads()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_ACTIVE_QUERY_THREADS,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxQueryTimeslice()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_QUERY_TIMESLICE,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxQueryExecutionTime()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_QUERY_EXECUTION_TIME,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMiscCiFlags()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MISC_FLAGS,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxRestrictionNodes()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_RESTRICTION_NODES,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const ULONG GetMaxDaemonVmUse()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MAX_DAEMON_VM_USE,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
|
|
const BOOL IsEnumAllowed()
|
|
{
|
|
DWORD dwVal=0;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_IS_ENUM_ALLOWED,
|
|
&dwVal);
|
|
Win4Assert( S_OK == sc );
|
|
if(dwVal)
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE ;
|
|
}
|
|
|
|
const ULONG GetMinDiskSpaceToLeave()
|
|
{
|
|
DWORD dwVal;
|
|
|
|
SCODE sc = _pCiAdminParams->GetValue(
|
|
CI_AP_MIN_DISK_SPACE_TO_LEAVE,
|
|
&dwVal );
|
|
Win4Assert( S_OK == sc );
|
|
|
|
return dwVal;
|
|
}
|
|
const BOOL UseOle()
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
const BOOL IsGenerateCharacterization()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
const ULONG GetEventLogFlags()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
|
|
ICiAdminParams * _pCiAdminParams;
|
|
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CCiFrmPerfCounter
|
|
//
|
|
// Purpose: A performance counter using the framework ICiCAdviseStatus
|
|
//
|
|
// History: 12-09-96 srikants Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CCiFrmPerfCounter
|
|
{
|
|
public:
|
|
|
|
CCiFrmPerfCounter( ICiCAdviseStatus * pAdviseStatus = 0,
|
|
CI_PERF_COUNTER_NAME name = CI_PERF_TOTAL_QUERIES )
|
|
: _xAdviseStatus( pAdviseStatus ),
|
|
_name(name)
|
|
{
|
|
if ( 0 != pAdviseStatus )
|
|
_xAdviseStatus->AddRef();
|
|
}
|
|
|
|
~CCiFrmPerfCounter()
|
|
{
|
|
_xAdviseStatus.Free();
|
|
}
|
|
|
|
void SetAdviseStatus( ICiCAdviseStatus * pAdviseStatus )
|
|
{
|
|
_xAdviseStatus.Set( pAdviseStatus );
|
|
_xAdviseStatus->AddRef();
|
|
}
|
|
|
|
void Update( CI_PERF_COUNTER_NAME name, long val )
|
|
{
|
|
_xAdviseStatus->SetPerfCounterValue( name, val );
|
|
}
|
|
|
|
void Update( long val )
|
|
{
|
|
Update( _name, val );
|
|
}
|
|
|
|
long GetCurrValue( CI_PERF_COUNTER_NAME name )
|
|
{
|
|
long val = 0;
|
|
SCODE sc = _xAdviseStatus->GetPerfCounterValue( _name, &val );
|
|
|
|
return S_OK == sc ? val : 0;
|
|
}
|
|
|
|
long GetCurrValue()
|
|
{
|
|
return GetCurrValue( _name );
|
|
}
|
|
|
|
private:
|
|
|
|
XInterface<ICiCAdviseStatus> _xAdviseStatus;
|
|
const CI_PERF_COUNTER_NAME _name;
|
|
};
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CDiskFreeStatus
|
|
//
|
|
// Purpose: A class to monitor free space in a disk.
|
|
//
|
|
// History: 12-09-96 srikants Created
|
|
// 01-Nov-98 KLam Added DiskSpaceToLeave to constructor
|
|
// 20-Nov-98 KLam Added CDriveInfo private member
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CDiskFreeStatus
|
|
{
|
|
public:
|
|
|
|
CDiskFreeStatus( WCHAR const * pwszPath, ULONG cMegToLeaveOnDisk )
|
|
:_fIsLow(FALSE),
|
|
_driveInfo ( pwszPath, cMegToLeaveOnDisk )
|
|
{
|
|
Win4Assert( pwszPath );
|
|
}
|
|
|
|
BOOL IsLow() const
|
|
{
|
|
return _fIsLow;
|
|
}
|
|
|
|
void UpdateDiskLowInfo();
|
|
|
|
ULONG GetDiskSpaceToFree()
|
|
{
|
|
return highDiskWaterMark;
|
|
}
|
|
|
|
private:
|
|
|
|
enum
|
|
{
|
|
lowDiskWaterMark = 3 * 512 * 1024, // 1.5 MB
|
|
highDiskWaterMark = lowDiskWaterMark + 512 * 1024 // 2.0 MB
|
|
};
|
|
|
|
BOOL _fIsLow;
|
|
|
|
CDriveInfo _driveInfo;
|
|
};
|
|
|
|
WCHAR * AllocHeapAndCopy( WCHAR const * pwszSrc, ULONG & cc );
|
|
|
|
inline WCHAR * AllocHeapAndCopy( WCHAR const * pwszSrc )
|
|
{
|
|
ULONG cc;
|
|
return AllocHeapAndCopy( pwszSrc, cc );
|
|
}
|
|
|
|
WCHAR * AllocHeapAndGetWString( PDeSerStream & stm );
|
|
|
|
void PutWString( PSerStream & stm, WCHAR const * pwszStr );
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CFwPerfTime
|
|
//
|
|
// Purpose: A class analogous to CPerfTime but adapted to the framework.
|
|
//
|
|
// History: 1-07-97 srikants Created
|
|
//
|
|
// Notes: We don't AddRef and Release the ICiCAdviseStatus interface
|
|
// here because we know it will not be deleted during the
|
|
// existence of this class.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CFwPerfTime
|
|
{
|
|
|
|
public:
|
|
|
|
CFwPerfTime( ICiCAdviseStatus * pCiCAdviseStatus,
|
|
CI_PERF_COUNTER_NAME name,
|
|
int SizeDivisor=1,
|
|
int TimeMultiplier=1 );
|
|
|
|
~CFwPerfTime() {}
|
|
|
|
void TStart ();
|
|
|
|
void TStop ( DWORD dwValue = 0 );
|
|
|
|
private:
|
|
|
|
LARGE_INTEGER _liStartTime;
|
|
|
|
LONGLONG _llSizeDivisor;
|
|
LONGLONG _llTimeMultiplier;
|
|
|
|
long _counterVal;
|
|
|
|
CI_PERF_COUNTER_NAME _name;
|
|
ICiCAdviseStatus * _pAdviseStatus;
|
|
};
|
|
|
|
|