1523 lines
31 KiB
C++
1523 lines
31 KiB
C++
/*++
|
||
|
||
© 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;
|
||
}
|