able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/query/ciodm/catadm.cxx

2593 lines
60 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// 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;
}
Reference in a new issue Copy permalink