|
|
/*++
� 1998 Seagate Software, Inc. All rights reserved
Module Name:
RmsLibry.cpp
Abstract:
Implementation of CRmsLibrary
Author:
Brian Dodd [brian] 15-Nov-1996
Revision History:
--*/
#include "stdafx.h"
#include "RmsLibry.h"
#include "RmsServr.h"
//////////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CRmsLibrary::CompareTo( IN IUnknown *pCollectable, OUT SHORT *pResult ) /*++
Implements:
IWsbCollectable::CompareTo
--*/ { HRESULT hr = E_FAIL; SHORT result = 1;
WsbTraceIn( OLESTR("CRmsLibrary::CompareTo"), OLESTR("") );
try {
// Validate arguments - Okay if pResult is NULL
WsbAssertPointer( pCollectable );
// We need the IRmsLibrary interface to get the value of the object.
CComQIPtr<IRmsLibrary, &IID_IRmsLibrary> pLibrary = pCollectable; WsbAssertPointer( pLibrary );
CComQIPtr<IRmsComObject, &IID_IRmsComObject> pObject = pCollectable; WsbAssertPointer( pObject );
switch ( m_findBy ) {
case RmsFindByName: {
CWsbBstrPtr name;
// Get the target device name
pLibrary->GetName( &name );
// Compare the names
result = (SHORT)wcscmp( m_Name, name ); hr = ( 0 == result ) ? S_OK : S_FALSE;
} break;
case RmsFindByMediaSupported: {
RmsMedia mediaSupported;
WsbAffirmHr(pLibrary->GetMediaSupported((LONG*) &mediaSupported));
if( m_mediaSupported == mediaSupported ){
// media types supported match
hr = S_OK; result = 0;
} else{
hr = S_FALSE; result = 1;
}
} break;
case RmsFindByDeviceInfo: {
//
// We're looking for a device in a library.
// The template has one changer device OR one drive device.
//
try {
WsbAssertHr( E_UNEXPECTED ); // Dead code now
if ( m_maxDrives > 0 ) {
CComPtr<IWsbEnum> pEnumDrives;
CComPtr<IWsbIndexedCollection> pFindDrives; CComPtr<IRmsMediumChanger> pFindDrive; CComPtr<IWsbIndexedCollection> pDrives;
WsbAffirmHr( pLibrary->GetDrives( &pDrives ) ); WsbAssertPointer( pDrives );
WsbAffirmHr( m_pDrives->Enum( &pEnumDrives ) ); WsbAssertPointer( pEnumDrives ); WsbAssertHr( pEnumDrives->First( IID_IRmsDrive, (void **)&pFindDrive ) ); WsbAssertPointer( pFindDrive ); hr = pDrives->Contains( pFindDrive ); result = (SHORT) ( ( S_OK == hr ) ? 0 : 1 );
} else if ( m_maxChangers > 0 ) {
CComPtr<IWsbEnum> pEnumChangers;
CComPtr<IWsbIndexedCollection> pFindChangers; CComPtr<IRmsMediumChanger> pFindChanger; CComPtr<IWsbIndexedCollection> pChangers;
WsbAffirmHr( pLibrary->GetChangers( &pChangers ) ); WsbAssertPointer( pChangers );
WsbAffirmHr( m_pChangers->Enum( &pEnumChangers ) ); WsbAssertPointer( pEnumChangers ); WsbAssertHr( pEnumChangers->First( IID_IRmsMediumChanger, (void **)&pFindChanger ) ); WsbAssertPointer( pFindChanger ); hr = pChangers->Contains( pFindChanger ); result = (SHORT)( ( S_OK == hr ) ? 0 : 1 );
} else {
// has to be one or the other
WsbAssertHr( E_UNEXPECTED );
}
} WsbCatch( hr );
} break;
default:
// Do CompareTo for object
hr = CRmsComObject::CompareTo( pCollectable, &result ); break;
}
} WsbCatch( hr );
if ( SUCCEEDED(hr) && (0 != pResult) ){ *pResult = result; }
WsbTraceOut( OLESTR("CRmsLibrary::CompareTo"), OLESTR("hr = <%ls>, result = <%ls>"), WsbHrAsString( hr ), WsbPtrToShortAsString( pResult ) );
return hr; }
HRESULT CRmsLibrary::FinalConstruct( void ) /*++
Implements:
CComObjectRoot::FinalConstruct
--*/ { HRESULT hr = S_OK;
try { WsbAssertHr(CWsbObject::FinalConstruct());
m_mediaSupported = RmsMediaUnknown;
m_maxChangers = 0;
m_maxDrives = 0;
m_maxPorts = 0;
m_maxSlots = 0;
m_NumUsedSlots = 0;
m_NumStagingSlots = 0;
m_NumScratchCarts = 0;
m_NumUnknownCarts = 0;
m_isMagazineSupported = FALSE;
m_maxCleaningMounts = 0;
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pChangers ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pDriveClasses ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pDrives ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pStorageSlots ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pStagingSlots ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pPorts ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pCleaningCartridges ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pScratchCartridges ));
WsbAssertHr(CoCreateInstance( CLSID_CWsbOrderedCollection, 0, CLSCTX_SERVER, IID_IWsbIndexedCollection, (void **)&m_pMediaSets ));
} WsbCatch(hr);
return(hr); }
STDMETHODIMP CRmsLibrary::GetClassID( OUT CLSID* pClsid ) /*++
Implements:
IPersist::GetClassId
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsLibrary::GetClassID"), OLESTR(""));
try {
WsbAssert(0 != pClsid, E_POINTER);
*pClsid = CLSID_CRmsLibrary;
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsLibrary::GetClassID"), OLESTR("hr = <%ls>, CLSID = <%ls>"), WsbHrAsString(hr), WsbGuidAsString(*pClsid));
return(hr); }
STDMETHODIMP CRmsLibrary::GetSizeMax( OUT ULARGE_INTEGER* pcbSize ) /*++
Implements:
IPersistStream::GetSizeMax
--*/ { HRESULT hr = E_NOTIMPL;
// ULONG nameLen;
WsbTraceIn(OLESTR("CRmsLibrary::GetSizeMax"), OLESTR(""));
// try {
// WsbAssert(0 != pcbSize, E_POINTER);
// // Get max size
// nameLen = SysStringByteLen(m_name);
// pcbSize->QuadPart = WsbPersistSizeOf(GUID) + // m_objectId
// WsbPersistSizeOf(LONG) + // m_name length
// nameLen + // m_name data
// WsbPersistSizeOf(LONG) + // m_mediaSupported
// WsbPersistSizeOf(LONG) + // m_maxChangers
// WsbPersistSizeOf(LONG) + // m_maxDrives
// WsbPersistSizeOf(LONG) + // m_maxPorts
// WsbPersistSizeOf(LONG) + // m_maxSlots
// WsbPersistSizeOf(LONG) + // m_NumUsedSlots
// WsbPersistSizeOf(LONG) + // m_NumStagingSlots
// WsbPersistSizeOf(LONG) + // m_NumScratchCarts
// WsbPersistSizeOf(LONG) + // m_NumUnknownCarts
// WsbPersistSizeOf(LONG) + // m_isMagazineSupported
// WsbPersistSizeOf(LONG) + // m_maxCleaningMounts
// WsbPersistSizeOf(LONG); // m_slotSelectionPolicy
// } WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsLibrary::GetSizeMax"), OLESTR("hr = <%ls>, Size = <%ls>"), WsbHrAsString(hr), WsbPtrToUliAsString(pcbSize));
return(hr); }
STDMETHODIMP CRmsLibrary::Load( IN IStream* pStream ) /*++
Implements:
IPersistStream::Load
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsLibrary::Load"), OLESTR(""));
try { CComPtr<IPersistStream> pPersistStream; CComQIPtr<IRmsServer, &IID_IRmsServer> pServer = g_pServer; ULONG temp;
WsbAssert(0 != pStream, E_POINTER);
WsbAffirmHr(CRmsComObject::Load(pStream));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_objectId));
WsbAffirmHr(WsbLoadFromStream(pStream, &temp)); m_mediaSupported = (RmsMedia)temp;
WsbAffirmHr(WsbLoadFromStream(pStream, &m_maxChangers));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_maxDrives));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_maxPorts));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_maxSlots));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumUsedSlots));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumStagingSlots));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumScratchCarts));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_NumUnknownCarts));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_isMagazineSupported));
WsbAffirmHr(WsbLoadFromStream(pStream, &m_maxCleaningMounts));
WsbAffirmHr(WsbLoadFromStream(pStream, &temp)); m_slotSelectionPolicy = (RmsSlotSelect)temp;
WsbAffirmHr(m_pChangers->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pDriveClasses->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pDrives->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pStorageSlots->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pStagingSlots->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pPorts->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pCleaningCartridges->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
WsbAffirmHr(m_pScratchCartridges->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Load(pStream)); pPersistStream = 0;
GUID mediaSetId; CComPtr<IRmsMediaSet> pMediaSet;
WsbAffirmHr( WsbLoadFromStream(pStream, &mediaSetId) );
while ( 0 != memcmp(&GUID_NULL, &mediaSetId, sizeof(GUID))) { hr = pServer->CreateObject( mediaSetId, CLSID_CRmsMediaSet, IID_IRmsMediaSet, RmsOpenExisting, (void **)&pMediaSet ); if (S_OK == hr) {
WsbAffirmHr( m_pMediaSets->Add( pMediaSet ) );
} else if (RMS_E_NOT_FOUND == hr) { WsbThrow(hr); } else { WsbThrow(hr); } WsbAffirmHr( WsbLoadFromStream(pStream, &mediaSetId) ); }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsLibrary::Load"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr; }
STDMETHODIMP CRmsLibrary::Save( IN IStream* pStream, IN BOOL clearDirty ) /*++
Implements:
IPersistStream::Save
--*/ { HRESULT hr = S_OK;
WsbTraceIn(OLESTR("CRmsLibrary::Save"), OLESTR("clearDirty = <%ls>"), WsbBoolAsString(clearDirty));
try { CComPtr<IPersistStream> pPersistStream;
WsbAssertPointer( pStream );
WsbAffirmHr(CRmsComObject::Save(pStream, clearDirty));
WsbAffirmHr(WsbSaveToStream(pStream, m_objectId));
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_mediaSupported));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxChangers));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxDrives));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxPorts));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxSlots));
WsbAffirmHr(WsbSaveToStream(pStream, m_NumUsedSlots));
WsbAffirmHr(WsbSaveToStream(pStream, m_NumStagingSlots));
WsbAffirmHr(WsbSaveToStream(pStream, m_NumScratchCarts));
WsbAffirmHr(WsbSaveToStream(pStream, m_NumUnknownCarts));
WsbAffirmHr(WsbSaveToStream(pStream, m_isMagazineSupported));
WsbAffirmHr(WsbSaveToStream(pStream, m_maxCleaningMounts));
WsbAffirmHr(WsbSaveToStream(pStream, (ULONG) m_slotSelectionPolicy));
WsbAffirmHr(m_pChangers->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pDriveClasses->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pDrives->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pStorageSlots->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pStagingSlots->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pPorts->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pCleaningCartridges->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
WsbAffirmHr(m_pScratchCartridges->QueryInterface(IID_IPersistStream, (void**) &pPersistStream)); WsbAffirmHr(pPersistStream->Save(pStream, clearDirty)); pPersistStream = 0;
// Save the ID (GUID) for the media sets.
GUID objectId; CComPtr<IRmsComObject> pMediaSet; CComPtr<IWsbEnum> pEnum;
WsbAffirmHr( m_pMediaSets->Enum( &pEnum ) );
hr = pEnum->First( IID_IRmsComObject, (void **)&pMediaSet ); while ( S_OK == hr ) {
WsbAffirmHr( pMediaSet->GetObjectId( &objectId ) ); WsbAffirmHr( WsbSaveToStream(pStream, objectId) ); pMediaSet = 0;
hr = pEnum->Next( IID_IRmsComObject, (void **)&pMediaSet ); }
objectId = GUID_NULL; WsbAffirmHr( WsbSaveToStream(pStream, objectId) ); // This marks the last one!
// Do we need to clear the dirty bit?
if (clearDirty) { m_isDirty = FALSE; }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsLibrary::Save"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return hr; }
STDMETHODIMP CRmsLibrary::Test( OUT USHORT *pPassed, OUT USHORT *pFailed ) /*++
Implements:
IWsbTestable::Test
--*/ { HRESULT hr = S_OK;
CComPtr<IRmsLibrary> pLibrary1; CComPtr<IRmsLibrary> pLibrary2; CComPtr<IPersistFile> pFile1; CComPtr<IPersistFile> pFile2;
LONG i;
CWsbBstrPtr bstrVal1 = OLESTR("5A5A5A"); CWsbBstrPtr bstrWork1; CWsbBstrPtr bstrWork2;
LONG longWork1; LONG longWork2;
LONG mediaTable [RMSMAXMEDIATYPES] = { RmsMediaUnknown, RmsMedia8mm, RmsMedia4mm, RmsMediaDLT, RmsMediaOptical, RmsMediaMO35, RmsMediaWORM, RmsMediaCDR, RmsMediaDVD, RmsMediaDisk, RmsMediaFixed, RmsMediaTape };
WsbTraceIn(OLESTR("CRmsLibrary::Test"), OLESTR(""));
try { // Get the Library interface.
hr = S_OK;
try { WsbAssertHr(((IUnknown*) (IRmsLibrary*) this)->QueryInterface(IID_IRmsLibrary, (void**) &pLibrary1));
// Test SetName & GetName interface
bstrWork1 = bstrVal1;
SetName(bstrWork1);
GetName(&bstrWork2);
if (bstrWork1 == bstrWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetMediaSupported & GetMediaSupported
for (i = 0; i < RMSMAXMEDIATYPES; i++){
longWork1 = mediaTable[i];
SetMediaSupported (longWork1);
GetMediaSupported (&longWork2);
if (longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; } }
// Test SetMaxChangers & GetMaxChangers
longWork1 = 99;
SetMaxChangers(longWork1);
GetMaxChangers(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetMaxDrives & GetMaxDrives
longWork1 = 99;
SetMaxDrives(longWork1);
GetMaxDrives(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetMaxPorts & GetMaxPorts
longWork1 = 99;
SetMaxPorts(longWork1);
GetMaxPorts(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetMaxSlots & GetMaxSlots
longWork1 = 99;
SetMaxSlots(longWork1);
GetMaxSlots(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test GetNumUsedSlots
m_NumUsedSlots = 99; longWork1 = m_NumUsedSlots;
GetNumUsedSlots(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetNumStagingSlots & GetNumStagingSlots
longWork1 = 99;
SetNumStagingSlots(longWork1);
GetNumStagingSlots(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetNumScratchCarts & GetNumScratchCarts
longWork1 = 99;
SetNumScratchCarts(longWork1);
GetNumScratchCarts(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetNumUnknownCarts & GetNumUnknownCarts
longWork1 = 99;
SetNumUnknownCarts(longWork1);
GetNumUnknownCarts(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetIsMagazineSupported & IsMagazineSupported to TRUE
hr = S_OK;
try{ WsbAffirmHr(SetIsMagazineSupported (TRUE)); WsbAffirmHr(IsMagazineSupported ()); } WsbCatch (hr);
if (hr == S_OK){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetIsMagazineSupported & IsMagazineSupported to FALSE
hr = S_OK;
try{ WsbAffirmHr(SetIsMagazineSupported (FALSE)); WsbAffirmHr(IsMagazineSupported ()); } WsbCatch (hr);
if (hr == S_OK){ (*pFailed)++; } else { (*pPassed)++; }
// Test SetMaxCleaningMounts & GetMaxCleaningMounts
longWork1 = 99;
SetMaxCleaningMounts(longWork1);
GetMaxCleaningMounts(&longWork2);
if(longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; }
// Test SetSlotSelectionPolicy & GetSlotSelectionPolicy
for (i = RmsSlotSelectUnknown; i < RmsSlotSelectSortLabel; i++){
longWork1 = i;
SetSlotSelectionPolicy (longWork1);
GetSlotSelectionPolicy (&longWork2);
if (longWork1 == longWork2){ (*pPassed)++; } else { (*pFailed)++; } }
} WsbCatch(hr);
// Tally up the results
hr = S_OK; if (*pFailed) { hr = S_FALSE; }
} WsbCatch(hr);
WsbTraceOut(OLESTR("CRmsLibrary::Test"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr); }
////////////////////////////////////////////////////////////////////////////////
//
// IRmsLibrary
//
STDMETHODIMP CRmsLibrary::GetLibraryId( GUID *pLibraryId ) /*++
Implements:
IRmsLibrary::GetLibraryId
--*/ { *pLibraryId = m_objectId; return (S_OK); }
STDMETHODIMP CRmsLibrary::SetLibraryId( GUID objectId ) /*++
Implements:
IRmsLibrary::SetLibraryId
--*/ { m_objectId = objectId; m_isDirty = TRUE; return (S_OK); }
STDMETHODIMP CRmsLibrary::GetName( BSTR *pName ) /*++
Implements:
IRmsLibrary::GetName
--*/ { WsbAssertPointer (pName);
m_Name. CopyToBstr (pName); return S_OK; }
STDMETHODIMP CRmsLibrary::SetName( BSTR name ) /*++
Implements:
IRmsLibrary::SetName
--*/ { m_Name = name; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetMediaSupported( LONG *pType ) /*++
Implements:
IRmsLibrary::GetMediaSupported
--*/ { *pType = m_mediaSupported; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMediaSupported( LONG type ) /*++
Implements:
IRmsLibrary::SetMediaSupported
--*/ { m_mediaSupported = (RmsMedia) type; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetMaxChangers( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetMaxChangers
--*/ { *pNum = m_maxChangers; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMaxChangers( LONG num ) /*++
Implements:
IRmsLibrary::SetMaxChangers
--*/ { m_maxChangers = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetMaxDrives( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetMaxDrives
--*/ { *pNum = m_maxDrives; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMaxDrives( LONG num ) /*++
Implements:
IRmsLibrary::SetMaxDrives
--*/ { m_maxDrives = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetMaxPorts( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetMaxPorts
--*/ { *pNum = m_maxPorts; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMaxPorts( LONG num ) /*++
Implements:
IRmsLibrary::SetMaxPorts
--*/ { m_maxPorts = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetMaxSlots( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetMaxSlots
--*/ { *pNum = m_maxSlots; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMaxSlots( LONG num ) /*++
Implements:
IRmsLibrary::SetMaxSlots
--*/ { m_maxSlots = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetNumUsedSlots( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetNumUsedSlots
--*/ { *pNum = m_NumUsedSlots; return S_OK; }
STDMETHODIMP CRmsLibrary::GetNumStagingSlots( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetNumStagingSlots
--*/ { *pNum = m_NumStagingSlots; return S_OK; }
STDMETHODIMP CRmsLibrary::SetNumStagingSlots( LONG num ) /*++
Implements:
IRmsLibrary::SetNumStagingSlots
--*/ { m_NumStagingSlots = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetNumScratchCarts( LONG *pNum ) /*++
Implements:
IRmsLibrary::SetNumScratchCarts
--*/ { *pNum = m_NumScratchCarts; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::SetNumScratchCarts( LONG num ) /*++
Implements:
IRmsLibrary::SetNumScratchCarts
--*/ { m_NumScratchCarts = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetNumUnknownCarts( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetNumUnknownCarts
--*/ { *pNum = m_NumUnknownCarts; return S_OK; }
STDMETHODIMP CRmsLibrary::SetNumUnknownCarts( LONG num ) /*++
Implements:
IRmsLibrary::SetNumUnknownCarts
--*/ { m_NumUnknownCarts = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::SetIsMagazineSupported( BOOL flag ) /*++
Implements:
IRmsLibrary::SetIsMagazineSupported
--*/ { m_isMagazineSupported = flag; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::IsMagazineSupported( void ) /*++
Implements:
IRmsLibrary::IsMagazineSupported
--*/ { HRESULT hr = S_FALSE;
if (m_isMagazineSupported){ hr = S_OK; }
return (hr); }
STDMETHODIMP CRmsLibrary::GetMaxCleaningMounts( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetMaxCleaningMounts
--*/ { *pNum = m_maxCleaningMounts; return S_OK; }
STDMETHODIMP CRmsLibrary::SetMaxCleaningMounts( LONG num ) /*++
Implements:
IRmsLibrary::SetMaxCleanMounts
--*/ { m_maxCleaningMounts = num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetSlotSelectionPolicy( LONG *pNum ) /*++
Implements:
IRmsLibrary::GetSlotSelectionPolicy
--*/ { *pNum = m_slotSelectionPolicy; return S_OK; }
STDMETHODIMP CRmsLibrary::SetSlotSelectionPolicy( LONG num ) /*++
Implements:
IRmsLibrary::SetSlotSelectionPolicy
--*/ { m_slotSelectionPolicy = (RmsSlotSelect) num; m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::GetChangers( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetChangers
--*/ { *ptr = m_pChangers; m_pChangers->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetDriveClasses( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetDriveClasses
--*/ { *ptr = m_pDriveClasses; m_pDriveClasses->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetDrives( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetDrives
--*/ { *ptr = m_pDrives; m_pDrives->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetStorageSlots( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetStorageSlots
--*/ { *ptr = m_pStorageSlots; m_pStorageSlots->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetStagingSlots( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetStagingSlots
--*/ { *ptr = m_pStagingSlots; m_pStagingSlots->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetPorts( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetPorts
--*/ { *ptr = m_pPorts; m_pPorts->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetCleaningCartridges( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetCleaningCartridges
--*/ { *ptr = m_pCleaningCartridges; m_pCleaningCartridges->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetScratchCartridges( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetScratchCartridges
--*/ { *ptr = m_pScratchCartridges; m_pScratchCartridges->AddRef(); return S_OK; }
STDMETHODIMP CRmsLibrary::GetMediaSets( IWsbIndexedCollection **ptr ) /*++
Implements:
IRmsLibrary::GetMediaSets
--*/ { *ptr = m_pMediaSets; m_pMediaSets->AddRef(); m_isDirty = TRUE; return S_OK; }
STDMETHODIMP CRmsLibrary::Audit( LONG /*start*/, LONG /*count*/, BOOL /*verify*/, BOOL /*unknownOnly*/, BOOL /*mountWait*/, LPOVERLAPPED /*pOverlapped*/, LONG* /*pRequest*/ ) /*++
Implements:
IRmsLibrary::Audit
--*/ { return E_NOTIMPL; }
|