2593 lines
62 KiB
C++
2593 lines
62 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997 - 2000.
|
|
//
|
|
// File: CatAdm.cxx
|
|
//
|
|
// Contents: CI Catalog Administration Interface methods
|
|
//
|
|
// Classes: CCatAdm
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include "stdafx.h"
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::InterfaceSupportsErrorInfo, public
|
|
//
|
|
// Arguments: [riid] -- interface iid
|
|
//
|
|
// Returns: TRUE if interface supports IErrorInfo
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::InterfaceSupportsErrorInfo(REFIID riid)
|
|
{
|
|
|
|
return ( riid == IID_ICatAdm );
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::SetErrorInfo, public
|
|
//
|
|
// Synopsis: Creates & sets the error object
|
|
//
|
|
// Arguments: [hRes] -- HRESULT error code to set
|
|
// [pwszDesc] -- error description
|
|
//
|
|
// Returns: none
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatAdm::SetErrorInfo( HRESULT hRes )
|
|
{
|
|
CiodmError err(hRes);
|
|
|
|
AtlSetErrorInfo(CLSID_CatAdm, err.GetErrorMessage(), 0 , 0, IID_ICatAdm, hRes, 0 );
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::CCatAdm, public
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CCatAdm::CCatAdm()
|
|
:_eCurrentState(CIODM_NOT_INITIALIZED),
|
|
_cMinRefCountToDestroy(1),
|
|
_cEnumIndex(0),
|
|
_pIMacAdm(0),
|
|
_dwTickCount(0)
|
|
{
|
|
//
|
|
// empty
|
|
//
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::Initialize, public
|
|
//
|
|
// Synopsis: Initializes CCatAdm object, populates scopes list
|
|
//
|
|
// Arguments: [xCatAdmin] -- contained catAdmin
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatAdm::Initialize( XPtr<CCatalogAdmin> & xCatAdmin )
|
|
{
|
|
Win4Assert( 0 == _aIScopeAdmin.Count() );
|
|
Win4Assert( !xCatAdmin.IsNull() );
|
|
|
|
CTranslateSystemExceptions xlate;
|
|
|
|
TRY
|
|
{
|
|
_xCatAdmin.Set( xCatAdmin.Acquire() );
|
|
|
|
XPtr<CScopeEnum> xScopeEnum(_xCatAdmin->QueryScopeEnum());
|
|
|
|
for ( ; xScopeEnum->Next(); )
|
|
{
|
|
XPtr<CScopeAdmin> xScopeAdmin( xScopeEnum->QueryScopeAdmin() );
|
|
|
|
XInterface<ScopeAdmObject> xIScopeAdm;
|
|
|
|
GetScopeAutomationObject( xScopeAdmin, xIScopeAdm );
|
|
|
|
_aIScopeAdmin.Add ( xIScopeAdm.GetPointer() , _aIScopeAdmin.Count() );
|
|
|
|
xIScopeAdm.Acquire();
|
|
|
|
}
|
|
|
|
_eCurrentState = CIODM_INITIALIZED;
|
|
}
|
|
CATCH( CException,e )
|
|
{
|
|
_eCurrentState = CIODM_NOT_INITIALIZED;
|
|
|
|
_cEnumIndex = 0;
|
|
|
|
_xCatAdmin.Free();
|
|
|
|
_aIScopeAdmin.Free();
|
|
|
|
RETHROW();
|
|
}
|
|
END_CATCH
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::InternalAddRef, public
|
|
//
|
|
// Synopsis: overrides CComObjectRootEx<Base>::InternalAddRef, to AddRef parent too
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG CCatAdm::InternalAddRef()
|
|
{
|
|
CLock lock(_mtx);
|
|
|
|
//
|
|
// AddRef self
|
|
//
|
|
unsigned cRef = CComObjectRootEx<CComMultiThreadModel>::InternalAddRef();
|
|
|
|
odmDebugOut(( DEB_TRACE,"CCatAdm(%ws) AddRef returned: %d\n",
|
|
_xCatAdmin.IsNull() ? L"" : _xCatAdmin->GetName(), cRef ));
|
|
|
|
//
|
|
// AddRef parent if it exists (it won't if catadmin was created in bogus context)
|
|
//
|
|
|
|
if ( 0 != _pIMacAdm )
|
|
_pIMacAdm->AddRef();
|
|
|
|
odmDebugOut(( DEB_TRACE,"=========================== CCatAdm(%ws) object count: %d\n",
|
|
_xCatAdmin.IsNull() ? L"" : _xCatAdmin->GetName(), _cMinRefCountToDestroy ));
|
|
|
|
return cRef;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::InternalRelease, public
|
|
//
|
|
// Synopsis: overrides CComObjectRootEx<Base>::InternalRelease, to release parent too.
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ULONG CCatAdm::InternalRelease()
|
|
{
|
|
CLock lock(_mtx);
|
|
|
|
//
|
|
// Delete contained objects if we're being destoryed.
|
|
// m_dwRef is an internal ATL public refcount member.
|
|
//
|
|
|
|
if ( _eCurrentState != CIODM_DESTROY && m_dwRef == _cMinRefCountToDestroy )
|
|
{
|
|
_eCurrentState = CIODM_DESTROY;
|
|
|
|
_aIScopeAdmin.Free();
|
|
|
|
//
|
|
// Assert we're the only object left to be destroyed.
|
|
//
|
|
Win4Assert( 1 == m_dwRef );
|
|
|
|
Win4Assert( _cMinRefCountToDestroy == 1 );
|
|
|
|
if ( 0 != _pIMacAdm )
|
|
_pIMacAdm->DecObjectCount();
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( 1 < m_dwRef );
|
|
|
|
Win4Assert( 1 <= _cMinRefCountToDestroy );
|
|
}
|
|
|
|
//
|
|
// Release parent
|
|
//
|
|
|
|
unsigned cRef = CComObjectRootEx<CComMultiThreadModel>::InternalRelease();
|
|
|
|
odmDebugOut(( DEB_TRACE,"CCatAdm(%ws) Release returned: %d\n",
|
|
_xCatAdmin.IsNull() ? L"" : _xCatAdmin->GetName(), cRef ));
|
|
|
|
if ( 0 != _pIMacAdm )
|
|
_pIMacAdm->Release();
|
|
|
|
return cRef;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::GetScopeAutomationObject, public
|
|
//
|
|
// Synopsis: Wraps a CScopeAdmin pointer in an IDispatch interface.
|
|
//
|
|
// Arguments: [xScopeAdmin] -- Scope admin object
|
|
// [xIScopeAdm] -- xInterface to contain created ScopeAdmObject
|
|
//
|
|
// Returns: none, throws upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatAdm::GetScopeAutomationObject( XPtr<CScopeAdmin> & xScopeAdmin,
|
|
XInterface<ScopeAdmObject> & xIScopeAdm )
|
|
|
|
{
|
|
Win4Assert( !xScopeAdmin.IsNull() );
|
|
|
|
SCODE sc = ScopeAdmObject::CreateInstance( xIScopeAdm.GetPPointer() );
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "CoCreateInstance(CLSID_ScopeAdm) Failed: %x\n",sc ));
|
|
|
|
THROW(CException(sc) );
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( !xIScopeAdm.IsNull() );
|
|
|
|
xIScopeAdm->SetParent( (CComObject<CCatAdm> *)this );
|
|
|
|
xIScopeAdm->AddRef();
|
|
|
|
IncObjectCount(); // inc. internal object count
|
|
}
|
|
|
|
//
|
|
// Initialize the new object
|
|
//
|
|
xIScopeAdm->Initialize( xScopeAdmin );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::GetIDisp, public
|
|
//
|
|
// Synopsis: QI for IDispatch on CScopeAdm object given by the passed in index.
|
|
//
|
|
// Arguments: [cPosition] -- index of CScopeAdm object
|
|
//
|
|
// Returns: [IDispatch *] -- pointer to IDispatch on CScopeAdm, throws upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
IDispatch * CCatAdm::GetIDisp( unsigned cPosition )
|
|
{
|
|
IDispatch * pTmpIDisp = 0;
|
|
|
|
SCODE sc = _aIScopeAdmin[cPosition]->QueryInterface(IID_IDispatch, (void **) &pTmpIDisp);
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "QueryInterface() Failed: %x\n", sc ));
|
|
|
|
THROW(CException(sc));
|
|
}
|
|
|
|
Win4Assert( pTmpIDisp );
|
|
|
|
return pTmpIDisp;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::ForceMasterMerge, public
|
|
//
|
|
// Synopsis: Starts a master merge
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::ForceMasterMerge(void)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
sc = ::ForceMasterMerge ( L"\\",
|
|
_xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName() );
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "ForceMasterMerge Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::AddScope, public
|
|
//
|
|
// Synopsis: Adds a scope to current catalog, logon & password should only
|
|
// be passed in if path is UNC.
|
|
//
|
|
// Arguments: [bstrScopeName] - in param, scope to Add
|
|
// [fExclude] - in param, Exclude flag to set
|
|
// [vtLogon] - in param, logon name
|
|
// [vtPassword] - in param,
|
|
// [pIDisp] - out param, IDispatch for new scope.
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::AddScope(BSTR bstrScopeName,
|
|
VARIANT_BOOL fExclude,
|
|
VARIANT vtLogon,
|
|
VARIANT vtPassword,
|
|
IDispatch * * pIDisp)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
ValidateInputParam( bstrScopeName );
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
sc = IsScopeValid( bstrScopeName, SysStringLen(bstrScopeName), _xCatAdmin->IsLocal() );
|
|
|
|
if ( SUCCEEDED(sc) )
|
|
{
|
|
WCHAR const * pwszLogon = GetWCHARFromVariant(vtLogon);
|
|
WCHAR const * pwszPassword = GetWCHARFromVariant(vtPassword);
|
|
|
|
if ( (( pwszLogon && *pwszLogon && pwszPassword ) && ( bstrScopeName[0] == L'\\' || bstrScopeName[1] == L'\\')) ||
|
|
(( !pwszLogon && !pwszPassword ) && ( bstrScopeName[1] == L':' )) )
|
|
{
|
|
|
|
if ( ScopeExists( bstrScopeName ) )
|
|
{
|
|
sc = HRESULT_FROM_WIN32( ERROR_ALREADY_EXISTS );
|
|
}
|
|
else
|
|
{
|
|
_xCatAdmin->AddScope(bstrScopeName, NULL, fExclude, pwszLogon, pwszPassword);
|
|
|
|
XPtr<CScopeAdmin> xScopeAdmin( _xCatAdmin->QueryScopeAdmin(bstrScopeName) );
|
|
|
|
unsigned cPosition = _aIScopeAdmin.Count();
|
|
|
|
XInterface<ScopeAdmObject> xIScopeAdm;
|
|
|
|
GetScopeAutomationObject( xScopeAdmin, xIScopeAdm );
|
|
|
|
_aIScopeAdmin.Add ( xIScopeAdm.GetPointer() , cPosition );
|
|
|
|
xIScopeAdm.Acquire();
|
|
|
|
*pIDisp = GetIDisp(cPosition);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
odmDebugOut(( DEB_ERROR,"Invalid Scope params: UNC scope name require Logon & passwd, local drive doesn't\n"));
|
|
sc = E_INVALIDARG;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "AddScope Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// member: CCatAdm::ScopeExists, public
|
|
//
|
|
// Synopsis: determines if a scope exists on this catalog.
|
|
//
|
|
// Arguments: [pScopePath] -- scope path
|
|
//
|
|
// Returns: TRUE if scope already exists, false otherwise.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CCatAdm::ScopeExists(WCHAR const * pScopePath)
|
|
{
|
|
Win4Assert( pScopePath );
|
|
|
|
unsigned cPosition = _aIScopeAdmin.Count();
|
|
|
|
for ( DWORD i = 0; i < cPosition; i++ )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[i] );
|
|
|
|
CScopeAdmin * pScopeAdmin = _aIScopeAdmin[i]->GetScopeAdmin();
|
|
|
|
Win4Assert( pScopeAdmin );
|
|
|
|
if ( !_wcsicmp( pScopePath, pScopeAdmin->GetPath() ) )
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetWCHARFromVariant
|
|
//
|
|
// Synopsis: returns a pointer to WCHAR within a variant
|
|
//
|
|
// Arguments: [Var] - variant containing a bstr
|
|
//
|
|
// Returns: valid WCHAR * to the bstr in the variant
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
WCHAR const * GetWCHARFromVariant( VARIANT & Var )
|
|
{
|
|
|
|
switch ( Var.vt )
|
|
{
|
|
case VT_BSTR:
|
|
if ( 0 == Var.bstrVal )
|
|
{
|
|
THROW(CException(E_INVALIDARG));
|
|
}
|
|
|
|
return Var.bstrVal;
|
|
|
|
break;
|
|
|
|
case VT_BSTR|VT_BYREF:
|
|
|
|
if ( 0 == Var.pbstrVal || 0 == *Var.pbstrVal )
|
|
{
|
|
THROW(CException(E_INVALIDARG));
|
|
}
|
|
|
|
return *Var.pbstrVal;
|
|
|
|
break;
|
|
|
|
case VT_BYREF|VT_VARIANT:
|
|
|
|
|
|
if ( 0 == Var.pvarVal )
|
|
{
|
|
THROW( CException(E_INVALIDARG) );
|
|
}
|
|
|
|
return GetWCHARFromVariant(*Var.pvarVal);
|
|
|
|
break;
|
|
|
|
|
|
case VT_ERROR: // set if optional param is not set.
|
|
case VT_EMPTY:
|
|
|
|
//
|
|
// do nothing
|
|
//
|
|
break;
|
|
|
|
default:
|
|
odmDebugOut(( DEB_ERROR, "Unexpected Variant type: %x\n", Var.vt ));
|
|
|
|
THROW( CException(E_INVALIDARG) );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::RemoveScope, public
|
|
//
|
|
// Synopsis: deletes a scope
|
|
//
|
|
// Arguments: [bstrScopePath] - in param, scope to delete
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::RemoveScope(BSTR bstrScopePath)
|
|
{
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
ValidateInputParam( bstrScopePath );
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
unsigned cPosition = _aIScopeAdmin.Count();
|
|
|
|
for ( DWORD i = 0; i < cPosition; i++ )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[i] );
|
|
|
|
CScopeAdmin * pScopeAdmin = _aIScopeAdmin[i]->GetScopeAdmin();
|
|
|
|
Win4Assert( pScopeAdmin );
|
|
|
|
if ( !_wcsicmp( bstrScopePath, pScopeAdmin->GetPath() ) )
|
|
{
|
|
//
|
|
// Remove scope from local list, move last element to empty spot,
|
|
// Release corresponding IDispatch
|
|
//
|
|
|
|
ScopeAdmObject * pIScopeAdm = _aIScopeAdmin.AcquireAndShrink(i);
|
|
|
|
Win4Assert( pIScopeAdm );
|
|
|
|
pIScopeAdm->SetInvalid();
|
|
|
|
pIScopeAdm->Release();
|
|
|
|
//
|
|
// Remove from CI
|
|
//
|
|
|
|
_xCatAdmin->RemoveScope(bstrScopePath);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( i == cPosition )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "RemoveScope Failed, Scope(%ws) not found\n", bstrScopePath ));
|
|
|
|
sc = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
|
|
}
|
|
}
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "RemoveScope Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::GetScopeByPath, public
|
|
//
|
|
// Synopsis: Searches for scopes on this catalog by Path
|
|
//
|
|
// Arguments: [bstrPath] -- Path to search for.
|
|
// [pIDisp] -- out param, IDispatch for CScopeAdmin if Path matches
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::GetScopeByPath(BSTR bstrPath, IDispatch * * pIDisp)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
ValidateInputParam( bstrPath );
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
unsigned cMaxScopes = _aIScopeAdmin.Count();
|
|
|
|
for ( DWORD i = 0; i < cMaxScopes; i++ )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[i] );
|
|
|
|
CScopeAdmin *pScopeAdmin = _aIScopeAdmin[i]->GetScopeAdmin();
|
|
|
|
Win4Assert( pScopeAdmin );
|
|
|
|
if ( !_wcsicmp( pScopeAdmin->GetPath(), bstrPath ) )
|
|
{
|
|
*pIDisp = GetIDisp(i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Scope not found
|
|
//
|
|
if ( i == cMaxScopes )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "GetScopeByPath(%ws) Failed: Scope Not found\n",bstrPath ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_NOT_FOUND );
|
|
}
|
|
}
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "GetScopeByPath Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::FindFirstScope, public
|
|
//
|
|
// Synopsis: Scope enumerator. Resets scan to start of list.
|
|
//
|
|
// Arguments: [pfFound] -- out param, True --> Found at least one scope
|
|
//
|
|
// Returns: SO_OK upon success, other values upon faillure
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::FindFirstScope(VARIANT_BOOL * pfFound)
|
|
{
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
_cEnumIndex = 0;
|
|
|
|
if ( _aIScopeAdmin.Count() > 0 )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[0] );
|
|
|
|
*pfFound = VARIANT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pfFound = VARIANT_FALSE;
|
|
}
|
|
}
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "FindFirstScope Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::FindNextScope, public
|
|
//
|
|
// Synopsis: Scope enumerator. Scans for next scope in the list
|
|
//
|
|
// Arguments: [pfFound] -- out param, True --> Found next scope
|
|
//
|
|
// Returns: SO_OK upon success, other values upon faillure
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::FindNextScope(VARIANT_BOOL * pfFound)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
_cEnumIndex++;
|
|
|
|
if ( _cEnumIndex < _aIScopeAdmin.Count() )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[0] );
|
|
|
|
*pfFound = VARIANT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pfFound = VARIANT_FALSE;
|
|
}
|
|
}
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "FindNextScope Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::GetScope, public
|
|
//
|
|
// Synopsis: Scope enumerator. Returns IDispatch to current scope
|
|
//
|
|
// Arguments: [pIDisp] -- out param, IDispatch to current scope
|
|
//
|
|
// Returns: SO_OK upon success, other values upon faillure
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::GetScope(IDispatch * * pIDisp)
|
|
{
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
if ( _cEnumIndex >= _aIScopeAdmin.Count() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "No More Scopes, Index: %d\n", _cEnumIndex ));
|
|
|
|
sc = HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS);
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( _aIScopeAdmin[_cEnumIndex] );
|
|
|
|
*pIDisp = GetIDisp(_cEnumIndex);
|
|
}
|
|
}
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "GetScope Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_CatalogName, public
|
|
//
|
|
// Synopsis: Gets the CatalogName Property
|
|
//
|
|
// Arguments: [pVal] -- out param, buffer containing catalog name
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_CatalogName(BSTR * pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog: %ws\n", _xCatAdmin->GetName() ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
WCHAR const * pwszName = _xCatAdmin->GetName();
|
|
|
|
*pVal = SysAllocString(pwszName);
|
|
|
|
if ( !*pVal )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_CatalogName Failed: Out of memory\n" ));
|
|
|
|
sc = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_CatalogName Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_CatalogLocation, public
|
|
//
|
|
// Synopsis: Gets the CatalogLocation property
|
|
//
|
|
// Arguments: [pVal] -- out param, buffer containing catalog location
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_CatalogLocation(BSTR * pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
|
|
SafeForScripting();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
|
|
WCHAR const * pwszLocation = _xCatAdmin->GetLocation();
|
|
|
|
*pVal = SysAllocString(pwszLocation);
|
|
|
|
if ( !*pVal )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_CatalogLocation Failed: Out of memory\n"));
|
|
|
|
sc = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_CatalogLocation Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::GetScopeByAlias, public
|
|
//
|
|
// Synopsis: Searches for scopes on this catalog by Alias
|
|
//
|
|
// Arguments: [bstrAlias] -- Alias to search for.
|
|
// [pIDisp] -- out param, IDispatch for CScopeAdmin if Alias matches
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 12-10-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::GetScopeByAlias(BSTR bstrAlias, IDispatch * * pIDisp)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
|
|
SafeForScripting();
|
|
|
|
ValidateInputParam( bstrAlias );
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog: %ws\n", _xCatAdmin->GetName() ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else
|
|
{
|
|
unsigned cMaxScopes = _aIScopeAdmin.Count();
|
|
|
|
for ( DWORD i = 0; i < cMaxScopes; i++ )
|
|
{
|
|
Win4Assert( _aIScopeAdmin[i] );
|
|
|
|
CScopeAdmin * pScopeAdmin = _aIScopeAdmin[i]->GetScopeAdmin();
|
|
|
|
Win4Assert( pScopeAdmin );
|
|
|
|
if ( !_wcsicmp( pScopeAdmin->GetAlias(), bstrAlias ) )
|
|
{
|
|
*pIDisp = GetIDisp(i);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Scope not found
|
|
//
|
|
if ( i == cMaxScopes )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "GetScopeByAlias(%ws) Failed: Alias not found\n", bstrAlias ));
|
|
|
|
sc = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
|
|
}
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "GetScopeByAlias Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_WordListCount, public property
|
|
//
|
|
// Synopsis: returns catalog's WordListCount property
|
|
//
|
|
// Arguments: [pVal] -- out param
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_WordListCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetWordListCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_WordListCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_PersistentIndexCount, public property
|
|
//
|
|
// Synopsis: returns catalog's PersistentIndexCount property
|
|
//
|
|
// Arguments: [pVal] -- out param
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_PersistentIndexCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetPersistentIndexCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_PersistentIndexCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_QueryCount, public property
|
|
//
|
|
// Synopsis: returns catalog's QueryCount property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_QueryCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetQueryCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_QueryCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_DocumentsToFilter, public property
|
|
//
|
|
// Synopsis: returns catalog's DocumentsToFilter property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_DocumentsToFilter(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetDocumentsToFilter();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_DocumentsToFilter Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_FreshTestCount, public property
|
|
//
|
|
// Synopsis: returns catalog's FreshTestCount
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_FreshTestCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetFreshTestCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_FreshTestCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_PctMergeComplete, public property
|
|
//
|
|
// Synopsis: returns catalog's PctMergeComplete property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_PctMergeComplete(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.PctMergeComplete();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_PctMergeComplete Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_FilteredDocumentCount, public property
|
|
//
|
|
// Synopsis: returns catalog's FilteredDocumentCount property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_FilteredDocumentCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetFilteredDocumentCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_FilteredDocumentCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_TotalDocumentCount, public property
|
|
//
|
|
// Synopsis: returns catalog's TotalDocumentCount property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_TotalDocumentCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetTotalDocumentCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_TotalDocumentCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_PendingScanCount, public property
|
|
//
|
|
// Synopsis: returns catalog's PendingDocumentCount property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_PendingScanCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetPendingScanCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_PendingScanCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_IndexSize, public property
|
|
//
|
|
// Synopsis: returns catalog's IndexSize property
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_IndexSize(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetIndexSize();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_IndexSize Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_UniqueKeyCount, public property
|
|
//
|
|
// Synopsis: returns catalog's UniqueKeyCount
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned value, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_UniqueKeyCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetUniqueKeyCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_UniqueKeyCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_StateInfo, public property
|
|
//
|
|
// Synopsis: returns catalog's StateInformation
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: Property value is an unsigned value, though it is being
|
|
// passed in as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_StateInfo(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetStateInfo();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_StateInfo Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_IsUpToDate, public property
|
|
//
|
|
// Synopsis: property is TRUE if catalog is up to date.
|
|
//
|
|
// Arguments: [pVal] -- out param,
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// History: 4-6-97 mohamedn created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_IsUpToDate(VARIANT_BOOL *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
DWORD currentState = state.GetStateInfo();
|
|
|
|
if ( 0 != state.GetDocumentsToFilter() ||
|
|
currentState & CI_STATE_CONTENT_SCAN_REQUIRED ||
|
|
currentState & CI_STATE_SCANNING ||
|
|
currentState & CI_STATE_RECOVERING ||
|
|
currentState & CI_STATE_READING_USNS ||
|
|
currentState & CI_STATE_STARTING )
|
|
{
|
|
*pVal = VARIANT_FALSE;
|
|
}
|
|
else
|
|
{
|
|
*pVal = VARIANT_TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_IsUpToDate Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::get_DelayedFilterCount, public property
|
|
//
|
|
// Synopsis: returns catalog's DelayedFilterCount property
|
|
//
|
|
// Arguments: [pVal] -- out param
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Notes: out value is an unsigned value, though it is being
|
|
// passed as a signed LONG for compatiblity with automation
|
|
// clients (VB5, VB6 don't support unsigned long).
|
|
//
|
|
// History: 4-14-98 vikasman created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::get_DelayedFilterCount(LONG *pVal)
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
CCatStateInfo & state = _xCatAdmin->State();
|
|
|
|
if ( !IsCurrentObjectValid() )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "Invalid catalog\n" ));
|
|
|
|
sc = HRESULT_FROM_WIN32( ERROR_INVALID_STATE );
|
|
}
|
|
else if ( GetTickCount() > _dwTickCount + UpdateInterval )
|
|
{
|
|
state.LokUpdate();
|
|
|
|
_dwTickCount = GetTickCount();
|
|
}
|
|
|
|
if ( state.IsValid() )
|
|
{
|
|
*pVal = state.GetDelayedFilterCount();
|
|
}
|
|
else
|
|
{
|
|
sc = state.GetErrorCode();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "get_DelayedFilterCount Failed: %x\n",sc ));
|
|
|
|
SetErrorInfo( sc );
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::PauseCatalog, public
|
|
//
|
|
// Synopsis: Pauses the catalog
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pdwOldState] -- out param, DWORD indicating the previous
|
|
// state of the catalog
|
|
//
|
|
// History: 08-03-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::PauseCatalog( CatalogStateType * pdwOldState )
|
|
{
|
|
Win4Assert( CICAT_STOPPED == csStopped );
|
|
Win4Assert( CICAT_READONLY == csReadOnly );
|
|
Win4Assert( CICAT_WRITABLE == csWritable );
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_READONLY,
|
|
&dwOldState );
|
|
|
|
// mask off the no_query bit
|
|
*pdwOldState = (CatalogStateType)(dwOldState & (~CICAT_NO_QUERY));
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "PauseCatalog Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::StartCatalog, public
|
|
//
|
|
// Synopsis: Starts the catalog
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pdwOldState] -- out param, DWORD indicating the previous
|
|
// state of the catalog
|
|
//
|
|
// History: 08-05-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::StartCatalog( CatalogStateType * pdwOldState )
|
|
{
|
|
Win4Assert( CICAT_STOPPED == csStopped );
|
|
Win4Assert( CICAT_READONLY == csReadOnly );
|
|
Win4Assert( CICAT_WRITABLE == csWritable );
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_WRITABLE,
|
|
&dwOldState );
|
|
|
|
// mask off the no_query bit
|
|
*pdwOldState = (CatalogStateType)(dwOldState & (~CICAT_NO_QUERY));
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "StartCatalog Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::StopCatalog, public
|
|
//
|
|
// Synopsis: Stops the catalog
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pdwOldState] -- out param, DWORD indicating the previous
|
|
// state of the catalog
|
|
//
|
|
// History: 08-05-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::StopCatalog( CatalogStateType * pdwOldState )
|
|
{
|
|
Win4Assert( CICAT_STOPPED == csStopped );
|
|
Win4Assert( CICAT_READONLY == csReadOnly );
|
|
Win4Assert( CICAT_WRITABLE == csWritable );
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_STOPPED,
|
|
&dwOldState );
|
|
|
|
// mask off the no_query bit
|
|
*pdwOldState = (CatalogStateType)(dwOldState & (~CICAT_NO_QUERY));
|
|
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "StopCatalog Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::ContinueCatalog, public
|
|
//
|
|
// Synopsis: Continues the catalog
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pdwOldState] -- out param, DWORD indicating the previous
|
|
// state of the catalog
|
|
//
|
|
// History: 09-08-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::ContinueCatalog( CatalogStateType * pdwOldState )
|
|
{
|
|
Win4Assert( CICAT_STOPPED == csStopped );
|
|
Win4Assert( CICAT_READONLY == csReadOnly );
|
|
Win4Assert( CICAT_WRITABLE == csWritable );
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_WRITABLE,
|
|
&dwOldState );
|
|
|
|
// mask off the no_query bit
|
|
*pdwOldState = (CatalogStateType)(dwOldState & (~CICAT_NO_QUERY));
|
|
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "ContinueCatalog Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::IsCatalogRunning, public
|
|
//
|
|
// Synopsis: check if the catalog is in R/W mode
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pfIsRunning] -- out param
|
|
//
|
|
// History: 08-10-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::IsCatalogRunning( VARIANT_BOOL *pfIsRunning )
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_GET_STATE,
|
|
&dwOldState );
|
|
|
|
*pfIsRunning = ( ( CICAT_WRITABLE & dwOldState ) &&
|
|
!( CICAT_NO_QUERY & dwOldState) ) ? VARIANT_TRUE : VARIANT_FALSE;
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "IsCatalogRunning Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::IsCatalogPaused, public
|
|
//
|
|
// Synopsis: check if the catalog is paused (read-only)
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pfIsPaused] -- out param
|
|
//
|
|
// History: 08-10-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::IsCatalogPaused( VARIANT_BOOL *pfIsPaused )
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_GET_STATE,
|
|
&dwOldState );
|
|
|
|
*pfIsPaused = (CICAT_READONLY & dwOldState) ? VARIANT_TRUE : VARIANT_FALSE;
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "IsCatalogPaused Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatAdm::IsCatalogStopped, public
|
|
//
|
|
// Synopsis: check if the catalog is stopped
|
|
//
|
|
// Returns: S_OK upon success, other values upon failure.
|
|
//
|
|
// Arguments: [pfIsStopped] -- out param
|
|
//
|
|
// History: 08-10-98 kitmanh created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDMETHODIMP CCatAdm::IsCatalogStopped( VARIANT_BOOL *pfIsStopped )
|
|
{
|
|
SCODE sc = S_OK;
|
|
|
|
CLock lock(_mtx);
|
|
|
|
TRANSLATE_EXCEPTIONS;
|
|
|
|
TRY
|
|
{
|
|
SafeForScripting();
|
|
|
|
DWORD dwOldState;
|
|
|
|
sc = SetCatalogState ( _xCatAdmin->GetName(),
|
|
_xCatAdmin->GetMachName(),
|
|
CICAT_GET_STATE,
|
|
&dwOldState );
|
|
|
|
*pfIsStopped = (CICAT_STOPPED & dwOldState) ? VARIANT_TRUE : VARIANT_FALSE;
|
|
|
|
}
|
|
CATCH ( CException,e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
}
|
|
END_CATCH
|
|
|
|
UNTRANSLATE_EXCEPTIONS;
|
|
|
|
if ( FAILED(sc) )
|
|
{
|
|
odmDebugOut(( DEB_ERROR, "IsCatalogStopped Failed: %x\n",sc ));
|
|
SetErrorInfo(sc);
|
|
}
|
|
|
|
return sc;
|
|
}
|
|
|