rm_Drive Class Reference
[Resource Manager Database Library]

#include <rmdb.h>

Collaboration diagram for rm_Drive:

Collaboration graph
[legend]

List of all members.

Detailed Description

Definition at line 192 of file rmdb.h.


Public Attributes

Int32_t driveKey
Int32_t libraryKey
rm_String driveName
Int32_t status
rm_String driveIndex
Int32_t mediaFamily
Int32_t capabilities
Int32_t dataThroughput
Int32_t loadTime
Int32_t unloadTime
Int32_t aveSeekTime
Int32_t rewindTime
Int32_t usageCount
Int32_t cleanNr
rm_TimeStamp lastClean
Int32_t options
rm_String vendorID
rm_String productID
rm_String serialNo
rm_String firmwareRev
rm_String scsiID

Private Member Functions

void Insert ()
void Update ()
void Remove (Int32_t a_driveKey)
void Select (Int32_t a_driveKey)
void SelectByName (rm_String a_name)
void SelectByAddr (int a_libraryKey, rm_String &a_addr)
vector< rm_Drive > SelectByStatus (const UInt32_t &a_status)
vector< rm_Drive > SelectForOperation (UInt32_t a_libraryKey, UInt32_t a_mediumFamily, UInt32_t a_requiredCapability, bool a_select_in_use)
vector< rm_Drive > SelectAll ()
void StartSelectAll ()
void EndSelectAll ()
rm_Drive & Next ()
 rm_Drive ()
 rm_Drive (Int32_t a_driveKey)
bool operator== (const rm_Drive &dr2) const

Private Attributes

 log_CLASSID_m

Friends

class rm_Operator
class rm_Medium

Constructor & Destructor Documentation

rm_Drive::rm_Drive (  )  [private]

Definition at line 803 of file librmdb.exx.

00804     :   driveName(rmdb_MAX_DRIVENAME),
00805         driveIndex(rmdb_MAX_DRIVEIDX),
00806         vendorID(rmdb_MAX_VENDORID),
00807         productID(rmdb_MAX_PRODUCTID),
00808         serialNo(rmdb_MAX_SERIALNO),
00809         firmwareRev(rmdb_MAX_FIRMWAREREV),
00810         scsiID(rmdb_MAX_SCSIID)    {
00811 }

rm_Drive::rm_Drive ( Int32_t  a_driveKey  )  [private]

Definition at line 814 of file librmdb.exx.

References Select().

00814                                :
00815         driveName(rmdb_MAX_DRIVENAME),
00816         driveIndex(rmdb_MAX_DRIVEIDX),
00817         vendorID(rmdb_MAX_VENDORID),
00818         productID(rmdb_MAX_PRODUCTID),
00819         serialNo(rmdb_MAX_SERIALNO),
00820         firmwareRev(rmdb_MAX_FIRMWAREREV),
00821         scsiID(rmdb_MAX_SCSIID) {
00822     Select(a_key);
00823 }

Here is the call graph for this function:

Member Function Documentation

void rm_Drive::Insert (  )  [private]

Definition at line 827 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, rm_String::cvalue_p, dataThroughput, dbg_NORM, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_m, rm_TimeStamp::m_iscTime, MAX, mediaFamily, NAME, options, productID, rewindTime, serialNo, SQL_CHECK_M, SQL_NOERROR, SQL_UNIQUEVIOLATION, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::Add().

00827                       {
00828 
00829     log_FUNC_m(Insert);
00830 
00831     if (libraryKey < 1) {
00832         bi1 = -1;
00833     }
00834     else {
00835         bi1 = 0;
00836     }
00837 
00838     EXEC SQL
00839         SET TRANSACTION NAME readWriteTrans;
00840 
00841     Int32_t k(0);
00842     if ( driveKey == 0 ) {
00843         EXEC SQL
00844             SELECT TRANSACTION readWriteTrans
00845             MAX(driveKey) INTO :k FROM Drive;
00846 
00847         driveKey = ++k;
00848         log_DBG_m(dbg_NORM,"New drivekey generated: " << driveKey);
00849     }
00850     else {
00851         EXEC SQL SELECT TRANSACTION readWriteTrans
00852             driveKey INTO :k FROM DRIVE
00853                     WHERE driveKey = :driveKey;
00854         if (SQLCODE == SQL_NOERROR) {
00855                 log_DBG_m(dbg_NORM,"key exists");
00856                 throw ivd_DBException( SQL_UNIQUEVIOLATION ,"Drive Key already exists");
00857         }
00858     }
00859 
00860 
00861     EXEC SQL
00862         INSERT TRANSACTION readWriteTrans INTO
00863             DRIVE VALUES(
00864                     :driveKey,
00865                     :libraryKey INDICATOR :bi1,
00866                     :driveName.cvalue_p,
00867                     :status,
00868                     :driveIndex.cvalue_p,
00869                     :mediaFamily,
00870                     :capabilities,
00871                     :dataThroughput,
00872                     :loadTime,
00873                     :unloadTime,
00874                     :aveSeekTime,
00875                     :rewindTime,
00876                     :usageCount,
00877                     :cleanNr,
00878                     :lastClean.m_iscTime,
00879                     :options,
00880                     :vendorID.cvalue_p,
00881                     :productID.cvalue_p,
00882                     :serialNo.cvalue_p,
00883                     :serialNo.cvalue_p,
00884                     :firmwareRev.cvalue_p
00885                  );
00886 
00887     string sqlErrDesc = errorDesc(SQLCODE,"Insert record into Drive", driveKey);
00888     SQL_CHECK_M( sqlErrDesc );
00889 }// rm_Drive::Insert()

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::Update (  )  [private]

Definition at line 911 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, rm_String::cvalue_p, dataThroughput, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, scsiID, serialNo, SQL_CHECK_M, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), rm_Operator::InventoryUpdate(), rm_Operator::ReleaseResources(), and rm_Operator::Update().

00911                       {
00912     log_FUNC_m(Update);
00913 
00914 
00915     if (libraryKey < 1) {
00916         bi1 = -1;
00917     }
00918     else {
00919         bi1 = 0;
00920     }
00921 
00922     EXEC SQL
00923         SET TRANSACTION NAME readWriteTrans;
00924 
00925     EXEC SQL
00926         UPDATE TRANSACTION readWriteTrans
00927         DRIVE SET
00928                     LIBRARYKEY =    :libraryKey INDICATOR :bi1,
00929                     DRIVENAME =     :driveName.cvalue_p,
00930                     STATUS =        :status,
00931                     DRIVEINDEX =    :driveIndex.cvalue_p,
00932                     MEDIAFAMILY =   :mediaFamily,
00933                     CAPABILITIES =  :capabilities,
00934                     DATATHROUGHPUT = :dataThroughput,
00935                     LOADTIME =      :loadTime,
00936                     UNLOADTIME =    :unloadTime,
00937                     AVESEEKTIME =   :aveSeekTime,
00938                     REWINDTIME =    :rewindTime,
00939                     USAGECOUNT =     :usageCount,
00940                     CLEANNR =       :cleanNr,
00941                     LASTCLEAN =     :lastClean.m_iscTime,
00942                     OPTIONS =       :options,
00943                     VENDORID =      :vendorID.cvalue_p,
00944                     PRODUCTID =     :productID.cvalue_p,
00945                     SERIALNO =      :serialNo.cvalue_p,
00946                     FIRMWAREREV =   :firmwareRev.cvalue_p,
00947                     SCSIID =        :scsiID.cvalue_p
00948                 WHERE DRIVEKEY = :driveKey;
00949     string sqlErrDesc = errorDesc(SQLCODE,"Update Drive record", driveKey);
00950     SQL_CHECK_M( sqlErrDesc );
00951 
00952 }// rm_update_Drive

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::Remove ( Int32_t  a_driveKey  )  [private]

Definition at line 893 of file librmdb.exx.

References errorDesc(), log_FUNC_m, NAME, and SQL_CHECK_M.

Referenced by rm_Operator::RemoveDrive().

00893                                         {
00894     log_FUNC_m(Remove);
00895 
00896     EXEC SQL
00897         SET TRANSACTION NAME readWriteTrans;
00898 
00899     EXEC SQL
00900         DELETE TRANSACTION readWriteTrans
00901         FROM DRIVE WHERE DRIVEKEY = :a_driveKey;
00902 
00903     string sqlErrDesc = errorDesc(SQLCODE,"Remove drive record", a_driveKey);
00904     SQL_CHECK_M( sqlErrDesc );
00905 
00906 } // rm_Drive::Remove

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::Select ( Int32_t  a_driveKey  )  [private]

Definition at line 957 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, dataThroughput, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::AllocateAdmin(), rm_Drive(), rm_Operator::SelectDrive(), and rm_Operator::SelectDriveForMig().

00957                                         {
00958     log_FUNC_m(Select);
00959 
00960 
00961     char driveNameVal[rmdb_MAX_DRIVENAME];
00962     char driveIndexVal[rmdb_MAX_DRIVEIDX];
00963     char vendorIDVal[rmdb_MAX_VENDORID];
00964     char productIDVal[rmdb_MAX_PRODUCTID];
00965     char serialNoVal[rmdb_MAX_SERIALNO];
00966     char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
00967     char scsiIDVal[rmdb_MAX_SCSIID];
00968 
00969     EXEC SQL
00970         SET TRANSACTION NAME readTrans
00971             READ ONLY
00972             ISOLATION LEVEL READ COMMITTED;
00973 
00974     EXEC SQL
00975         SELECT TRANSACTION readTrans
00976         * INTO
00977                 :driveKey,
00978                 :libraryKey,
00979                 :driveNameVal,
00980                 :status,
00981                 :driveIndexVal,
00982                 :mediaFamily,
00983                 :capabilities,
00984                 :dataThroughput,
00985                 :loadTime,
00986                 :unloadTime,
00987                 :aveSeekTime,
00988                 :rewindTime,
00989                 :usageCount,
00990                 :cleanNr,
00991                 :lastClean.m_iscTime,
00992                 :options,
00993                 :vendorIDVal,
00994                 :productIDVal,
00995                 :serialNoVal,
00996                 :firmwareRevVal,
00997                 :scsiIDVal
00998        FROM DRIVE WHERE DRIVEKEY = :a_driveKey;
00999 
01000     if ( SQLCODE == SQL_NOERROR ) {
01001         driveName   = driveNameVal;
01002         driveIndex  = driveIndexVal;
01003         vendorID    = vendorIDVal;
01004         productID   = productIDVal;
01005         serialNo    = serialNoVal;
01006         lastClean   = lastClean.m_iscTime;
01007         firmwareRev     = firmwareRevVal;
01008         scsiID          = scsiIDVal;
01009     }
01010 
01011     string sqlErrDesc = errorDesc(SQLCODE,"Select record from Drive", a_driveKey);
01012     SQL_CHECKREAD_M( sqlErrDesc );
01013 
01014 }// rm_Drive::Select

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::SelectByName ( rm_String  a_name  )  [private]

Definition at line 1017 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, rm_String::cvalue_p, dataThroughput, dbg_DETAIL, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_PRODUCTID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::Add(), rm_Operator::RemoveDrive(), rm_Operator::RemoveDriveHost(), rm_Operator::SelectDrive(), rm_Operator::SelectDriveHost(), rm_Operator::SelectMediumByDrive(), and rm_Operator::Update().

01017                                             {
01018     log_FUNC_m(SelectByName);
01019 
01020 
01021     char driveNameVal[rmdb_MAX_DRIVENAME];
01022     char driveIndexVal[rmdb_MAX_DRIVEIDX];
01023     char vendorIDVal[rmdb_MAX_VENDORID];
01024     char productIDVal[rmdb_MAX_PRODUCTID];
01025     char serialNoVal[rmdb_MAX_SERIALNO];
01026     char firmwareRevVal[rmdb_MAX_PRODUCTID];
01027     char scsiIDVal[rmdb_MAX_SERIALNO];
01028 
01029     EXEC SQL
01030         SET TRANSACTION NAME readTrans
01031             READ ONLY
01032             ISOLATION LEVEL READ COMMITTED;
01033 
01034     EXEC SQL
01035         SELECT TRANSACTION readTrans
01036         * INTO
01037                         :driveKey,
01038                         :libraryKey,
01039                         :driveNameVal,
01040                         :status,
01041                         :driveIndexVal,
01042                           :mediaFamily,
01043                         :capabilities,
01044                         :dataThroughput,
01045                         :loadTime,
01046                         :unloadTime,
01047                         :aveSeekTime,
01048                         :rewindTime,
01049                         :usageCount,
01050                         :cleanNr,
01051                         :lastClean.m_iscTime,
01052                         :options,
01053                         :vendorIDVal,
01054                         :productIDVal,
01055                         :serialNoVal,
01056                         :firmwareRevVal,
01057                         :scsiIDVal
01058                FROM DRIVE WHERE DRIVENAME = :a_name.cvalue_p;
01059 
01060     if ( SQLCODE == SQL_NOERROR ) {
01061         driveName       = driveNameVal;
01062         driveIndex      = driveIndexVal;
01063         vendorID        = vendorIDVal;
01064         productID       = productIDVal;
01065         serialNo        = serialNoVal;
01066         firmwareRev     = firmwareRevVal;
01067         scsiID          = scsiIDVal;
01068         log_DBG_m(dbg_DETAIL, "successfully selected drive: ");
01069     }
01070     string sqlErrDesc = errorDesc(SQLCODE, "Selecting Drive record by Name");
01071     SQL_CHECKREAD_M( sqlErrDesc );
01072 
01073 }// rm_Drive::SelectByName

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::SelectByAddr ( int  a_libraryKey,
rm_String &  a_addr 
) [private]

Definition at line 1077 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, rm_String::cvalue_p, dataThroughput, dbg_DETAIL, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::Add(), rm_Operator::InventoryUpdate(), rm_Operator::MediumLoaded(), and rm_Operator::Update().

01077                                                                {
01078     log_FUNC_m(SelectByAddr);
01079 
01080 
01081     char driveNameVal[rmdb_MAX_DRIVENAME];
01082     char driveIndexVal[rmdb_MAX_DRIVEIDX];
01083     char vendorIDVal[rmdb_MAX_VENDORID];
01084     char productIDVal[rmdb_MAX_PRODUCTID];
01085     char serialNoVal[rmdb_MAX_SERIALNO];
01086     char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
01087     char scsiIDVal[rmdb_MAX_SCSIID];
01088 
01089     EXEC SQL
01090         SET TRANSACTION NAME readTrans
01091             READ ONLY
01092             ISOLATION LEVEL READ COMMITTED;
01093 
01094     EXEC SQL
01095         SELECT TRANSACTION readTrans
01096         * INTO
01097                         :driveKey,
01098                         :libraryKey,
01099                         :driveNameVal,
01100                         :status,
01101                         :driveIndexVal,
01102                         :mediaFamily,
01103                         :capabilities,
01104                         :dataThroughput,
01105                         :loadTime,
01106                         :unloadTime,
01107                         :aveSeekTime,
01108                         :rewindTime,
01109                         :usageCount,
01110                         :cleanNr,
01111                         :lastClean.m_iscTime,
01112                         :options,
01113                         :vendorIDVal,
01114                         :productIDVal,
01115                         :serialNoVal,
01116                         :firmwareRevVal,
01117                         :scsiIDVal
01118                         FROM DRIVE WHERE
01119                             LIBRARYKEY = :a_libraryKey AND
01120                             DRIVEINDEX = :a_addr.cvalue_p;
01121 
01122     if ( SQLCODE == SQL_NOERROR ) {
01123         driveName   = driveNameVal;
01124         driveIndex  = driveIndexVal;
01125         lastClean   = lastClean.m_iscTime;
01126         vendorID    = vendorIDVal;
01127         productID   = productIDVal;
01128         serialNo    = serialNoVal;
01129         firmwareRev = firmwareRevVal;
01130         scsiID      = scsiIDVal;
01131         log_DBG_m(dbg_DETAIL, "successfully selected drive: " << driveName);
01132     }
01133     string sqlErrDesc = errorDesc(SQLCODE, "Selecting Drive record by Addr");
01134     SQL_CHECKREAD_M( sqlErrDesc );
01135 
01136 
01137 
01138 }// rm_Drive::SelectByAddr

Here is the call graph for this function:

Here is the caller graph for this function:

vector< rm_Drive > rm_Drive::SelectByStatus ( const UInt32_t &  a_status  )  [private]

Definition at line 1234 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, cmn_Num2Str(), dataThroughput, dbg_DETAIL, dbg_NORM, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, ie_NO_RESOURCE_FOUND, ie_RMDB_ERROR, ivd_Error, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, SQL_NOTFOUND, status, unloadTime, usageCount, and vendorID.

01234                                                                  {
01235     log_FUNC_m(SelectByStatus);
01236     vector<rm_Drive> selDrive;
01237 
01238     EXEC SQL
01239         SET TRANSACTION NAME readTrans
01240             READ ONLY
01241             ISOLATION LEVEL READ COMMITTED;
01242 
01243 
01244     EXEC SQL
01245         DECLARE SELECT_DRIVE_BY_STATUS CURSOR FOR
01246         SELECT * FROM DRIVE
01247             WHERE
01248             bin_and(DRIVE.STATUS, :a_status) = 0;
01249 
01250     log_DBG_m(dbg_DETAIL, "declare cursor SELECT_DRIVE_BY_STATUS returned sqlcode:" << SQLCODE);
01251 
01252 
01253     if ( SQLCODE != SQL_NOERROR ) {
01254         throw ivd_Error(ie_RMDB_ERROR," Could not declare cursor SELECT_DRIVE_BY_STATUS");
01255     }
01256 
01257 
01258     EXEC SQL
01259         OPEN TRANSACTION readTrans
01260         SELECT_DRIVE_BY_STATUS;
01261 
01262     if ( SQLCODE != SQL_NOERROR ) {
01263         throw ivd_Error(ie_RMDB_ERROR," Could not open cursor SELECT_DRIVE_BY_STATUS");
01264     }
01265     log_DBG_m(dbg_DETAIL, "open cursor SELECT_DRIVE_BY_STATUS returned sqlcode:" << SQLCODE);
01266 
01267     bool endOfCursor = false;
01268 
01269     do {
01270         char driveNameVal[rmdb_MAX_DRIVENAME];
01271         char driveIndexVal[rmdb_MAX_DRIVEIDX];
01272         char vendorIDVal[rmdb_MAX_VENDORID];
01273         char productIDVal[rmdb_MAX_PRODUCTID];
01274         char serialNoVal[rmdb_MAX_SERIALNO];
01275         char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
01276         char scsiIDVal[rmdb_MAX_SCSIID];
01277 
01278         EXEC SQL
01279             FETCH SELECT_DRIVE_BY_STATUS
01280                         INTO
01281                             :driveKey,
01282                             :libraryKey,
01283                             :driveNameVal,
01284                             :status,
01285                             :driveIndexVal,
01286                             :mediaFamily,
01287                             :capabilities,
01288                             :dataThroughput,
01289                             :loadTime,
01290                             :unloadTime,
01291                             :aveSeekTime,
01292                             :rewindTime,
01293                             :usageCount,
01294                             :cleanNr,
01295                             :lastClean.m_iscTime,
01296                             :options,
01297                             :vendorIDVal,
01298                             :productIDVal,
01299                             :serialNoVal,
01300                             :firmwareRevVal,
01301                             :scsiIDVal;
01302 
01303 
01304         if (SQLCODE == SQL_NOERROR) {
01305             driveName   = driveNameVal;
01306             driveIndex  = driveIndexVal;
01307             lastClean   = lastClean.m_iscTime;
01308             vendorID    = vendorIDVal;
01309             productID   = productIDVal;
01310             serialNo    = serialNoVal;
01311             firmwareRev = firmwareRevVal;
01312             scsiID      = scsiIDVal;
01313 
01314             selDrive.push_back(*this);
01315 
01316         }
01317         else if (SQLCODE == SQL_NOTFOUND) {
01318             log_DBG_m(dbg_NORM,"reached end of cursor");
01319             endOfCursor = true;
01320         }
01321         else {
01322             log_DBG_m(dbg_NORM,"Fatal Drive Allocation error sqlcode:" << SQLCODE);
01323             throw ivd_Error (
01324                     ie_NO_RESOURCE_FOUND,
01325                     "Fatal DriveAllocation error sqlcode:" +
01326                     cmn_Num2Str((Int32_t)SQLCODE), true);
01327         };
01328 
01329     } while (endOfCursor == false);
01330     EXEC SQL
01331         CLOSE SELECT_DRIVE_BY_STATUS;
01332     string sqlErrDesc = errorDesc(SQLCODE,"CLOSE SELECT_DRIVE_BY_STATUS");
01333     SQL_CHECKREAD_M(sqlErrDesc);
01334     return selDrive;
01335 } //end_of_Select_by_status

Here is the call graph for this function:

vector< rm_Drive > rm_Drive::SelectForOperation ( UInt32_t  a_libraryKey,
UInt32_t  a_mediumFamily,
UInt32_t  a_requiredCapability,
bool  a_select_in_use 
) [private]

Definition at line 1339 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, cmn_Num2Str(), dataThroughput, dbg_DETAIL, dbg_NORM, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, ie_NO_RESOURCE_FOUND, ie_RMDB_ERROR, ivd_Error, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_A_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_DRIVE_DISABLED, rmdb_DRIVE_ERROR, rmdb_DRIVE_IN_USE, rmdb_LIBRARY_DISABLED, rmdb_LIBRARY_ERROR, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, SQL_NOTFOUND, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), rm_Operator::CheckForAnyResourceForMig(), and rm_Operator::SelectDriveForMig().

01343                                                      {
01344 
01345     log_FUNC_A_m(SelectForOperation, "a_libraryKey:" << a_libraryKey <<
01346                                      " a_mediaFamily:" << a_mediaFamily <<
01347                                      " a_reqCap:" << a_reqCap <<
01348                                      boolalpha << " a_select_in_use:" << a_select_in_use );
01349 
01350     vector<rm_Drive> selDrive;
01351 
01352     EXEC SQL
01353         SET TRANSACTION NAME readTrans
01354             READ ONLY
01355             ISOLATION LEVEL READ COMMITTED;
01356 
01357     UInt32_t opStatus = rmdb_DRIVE_DISABLED | rmdb_DRIVE_ERROR;
01358     if (!a_select_in_use) {
01359         opStatus = opStatus | rmdb_DRIVE_IN_USE;
01360     }
01361     UInt32_t opLibStatus = rmdb_LIBRARY_DISABLED | rmdb_LIBRARY_ERROR;
01362 
01363 
01364     EXEC SQL
01365         DECLARE SELECT_DRIVE_FOR_OPERATION CURSOR FOR
01366         SELECT DRIVE.* FROM DRIVE, LIBRARY
01367             WHERE
01368                 LIBRARY.LIBRARYKEY = :a_libraryKey          AND
01369                 DRIVE.LIBRARYKEY = LIBRARY.LIBRARYKEY       AND
01370                 bin_and(DRIVE.STATUS, :opStatus ) = 0       AND
01371                 bin_and(LIBRARY.STATUS, :opLibStatus ) = 0  AND
01372                 DRIVE.MEDIAFAMILY = :a_mediaFamily
01373             ORDER BY USAGECOUNT ASCENDING;
01374 
01375     log_DBG_m(dbg_DETAIL,   "declare cursor SELECT_DRIVE_FOR_OPERATION " <<
01376                             "returned sqlcode:" << SQLCODE);
01377 
01378 
01379     if ( SQLCODE != SQL_NOERROR ) {
01380         throw ivd_Error(ie_RMDB_ERROR," Could not declare cursor SELECT_DRIVE_FOR_OPERATION");
01381     }
01382 
01383 
01384     EXEC SQL
01385         OPEN TRANSACTION readTrans
01386         SELECT_DRIVE_FOR_OPERATION;
01387 
01388     if ( SQLCODE != SQL_NOERROR ) {
01389         throw ivd_Error(ie_RMDB_ERROR," Could not open cursor SELECT_DRIVE_FOR_OPERATION");
01390     }
01391     log_DBG_m(dbg_DETAIL, "open cursor SELECT_DRIVE_FOR_OPERATION returned sqlcode:" << SQLCODE);
01392 
01393     bool endOfCursor = false;
01394 
01395     do {
01396         char driveNameVal[rmdb_MAX_DRIVENAME];
01397         char driveIndexVal[rmdb_MAX_DRIVEIDX];
01398         char vendorIDVal[rmdb_MAX_VENDORID];
01399         char productIDVal[rmdb_MAX_PRODUCTID];
01400         char serialNoVal[rmdb_MAX_SERIALNO];
01401         char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
01402         char scsiIDVal[rmdb_MAX_SCSIID];
01403 
01404         EXEC SQL
01405             FETCH SELECT_DRIVE_FOR_OPERATION
01406                         INTO
01407                             :driveKey,
01408                             :libraryKey,
01409                             :driveNameVal,
01410                             :status,
01411                             :driveIndexVal,
01412                             :mediaFamily,
01413                             :capabilities,
01414                             :dataThroughput,
01415                             :loadTime,
01416                             :unloadTime,
01417                             :aveSeekTime,
01418                             :rewindTime,
01419                             :usageCount,
01420                             :cleanNr,
01421                             :lastClean.m_iscTime,
01422                             :options,
01423                             :vendorIDVal,
01424                             :productIDVal,
01425                             :serialNoVal,
01426                             :firmwareRevVal,
01427                             :scsiIDVal;
01428 
01429         log_DBG_m(dbg_DETAIL,"Fetch returned SQLCODE" << SQLCODE);
01430 
01431         if (SQLCODE == SQL_NOERROR) {
01432             driveName   = driveNameVal;
01433             driveIndex  = driveIndexVal;
01434             lastClean   = lastClean.m_iscTime;
01435             vendorID    = vendorIDVal;
01436             productID   = productIDVal;
01437             serialNo    = serialNoVal;
01438             firmwareRev = firmwareRevVal;
01439             scsiID      = scsiIDVal;
01440             if ( (a_reqCap & this->capabilities) == a_reqCap) {
01441                 log_DBG_m(dbg_DETAIL,"Selected drive: " << this->driveKey << " for operation");
01442                 selDrive.push_back(*this);
01443             }
01444             else {
01445                 log_DBG_m(dbg_DETAIL,"Drive " << this->driveKey <<
01446                                      " does not match capabilities ");
01447             }
01448 
01449 
01450         }
01451         else if (SQLCODE == SQL_NOTFOUND) {
01452             log_DBG_m(dbg_NORM,"reached end of cursor");
01453             endOfCursor = true;
01454         }
01455         else {
01456             log_DBG_m(dbg_NORM,"Fatal Drive Allocation error sqlcode:" << SQLCODE);
01457             throw ivd_Error (
01458                         ie_NO_RESOURCE_FOUND,
01459                         "Fatal DriveAllocation error sqlcode:" +
01460                         cmn_Num2Str((Int32_t)SQLCODE),
01461                         true);
01462         };
01463 
01464     } while (endOfCursor == false);
01465 
01466     EXEC SQL
01467         CLOSE SELECT_DRIVE_FOR_OPERATION;
01468     string sqlErrDesc = errorDesc(SQLCODE,"CLOSE SELECT_DRIVE_FOR_OPERATION");
01469     SQL_CHECKREAD_M(sqlErrDesc);
01470 
01471     return selDrive;
01472 } //end_of_Select_by_status

Here is the call graph for this function:

Here is the caller graph for this function:

vector< rm_Drive > rm_Drive::SelectAll (  )  [private]

Definition at line 1475 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, cmn_Num2Str(), dataThroughput, dbg_DETAIL, dbg_LOW, dbg_NORM, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, ie_NO_RESOURCE_FOUND, ie_RMDB_ERROR, ivd_Error, lastClean, libraryKey, loadTime, log_DBG_m, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, NAME, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, SQL_NOTFOUND, status, unloadTime, usageCount, and vendorID.

Referenced by rm_Operator::SelectAllDrives().

01475                                     {
01476     log_FUNC_m(SelectAll);
01477     cmn_MutexLock l(g_driveCursor_x);
01478 
01479     vector<rm_Drive> selDrive;
01480 
01481     EXEC SQL
01482         SET TRANSACTION NAME readTrans
01483             READ ONLY
01484             ISOLATION LEVEL READ COMMITTED;
01485 
01486 
01487     if ( SQLCODE != SQL_NOERROR ) {
01488         log_DBG_m(dbg_LOW, "SQLERROR: " << SQLCODE);
01489         throw ivd_Error(ie_RMDB_ERROR," Could not declare cursor SELECT_DRIVE_ALL");
01490     }
01491     log_DBG_m(dbg_DETAIL, "declare cursor SELECT_DRIVE_ALL returned sqlcode:" << SQLCODE);
01492 
01493     EXEC SQL
01494         OPEN TRANSACTION readTrans
01495         SELECT_ALL_DRIVE;
01496 
01497     if ( SQLCODE != SQL_NOERROR ) {
01498         throw ivd_Error(ie_RMDB_ERROR," Could not open cursor SELECT_DRIVE_ALL");
01499     }
01500     log_DBG_m(dbg_DETAIL, "open cursor SELECT_DRIVE_ALL returned sqlcode:" << SQLCODE);
01501 
01502     bool endOfCursor = false;
01503 
01504     do {
01505         char driveNameVal[rmdb_MAX_DRIVENAME];
01506         char driveIndexVal[rmdb_MAX_DRIVEIDX];
01507         char vendorIDVal[rmdb_MAX_VENDORID];
01508         char productIDVal[rmdb_MAX_PRODUCTID];
01509         char serialNoVal[rmdb_MAX_SERIALNO];
01510         char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
01511         char scsiIDVal[rmdb_MAX_SCSIID];
01512 
01513         EXEC SQL
01514             FETCH SELECT_ALL_DRIVE
01515                         INTO
01516                             :driveKey,
01517                             :libraryKey,
01518                             :driveNameVal,
01519                             :status,
01520                             :driveIndexVal,
01521                             :mediaFamily,
01522                             :capabilities,
01523                             :dataThroughput,
01524                             :loadTime,
01525                             :unloadTime,
01526                             :aveSeekTime,
01527                             :rewindTime,
01528                             :usageCount,
01529                             :cleanNr,
01530                             :lastClean.m_iscTime,
01531                             :options,
01532                             :vendorIDVal,
01533                             :productIDVal,
01534                             :serialNoVal,
01535                             :firmwareRevVal,
01536                             :scsiIDVal;
01537 
01538         if (SQLCODE == SQL_NOERROR) {
01539             driveName  = driveNameVal;
01540             driveIndex  = driveIndexVal;
01541             lastClean   = lastClean.m_iscTime;
01542             vendorID  = vendorIDVal;
01543             productID  = productIDVal;
01544             serialNo = serialNoVal;
01545             firmwareRev = firmwareRevVal;
01546             scsiID      = scsiIDVal;
01547             selDrive.push_back(*this);
01548         }
01549         else if (SQLCODE == SQL_NOTFOUND) {
01550             log_DBG_m(dbg_NORM,"reached end of cursor");
01551             endOfCursor = true;
01552         }
01553         else {
01554             log_DBG_m(dbg_NORM,"Fatal Drive Allocation error sqlcode:" << SQLCODE);
01555             throw ivd_Error (
01556                 ie_NO_RESOURCE_FOUND,
01557                 "Fatal DriveAllocation error sqlcode:" +
01558                 cmn_Num2Str((Int32_t)SQLCODE),
01559                 true);
01560         };
01561 
01562     } while (endOfCursor == false);
01563     EXEC SQL
01564         CLOSE SELECT_ALL_DRIVE;
01565     string sqlErrDesc = errorDesc(SQLCODE,"CLOSE SELECT_ALL_DRIVE");
01566     SQL_CHECKREAD_M(sqlErrDesc);
01567 
01568 
01569     return selDrive;
01570 } //end_of_Select_by_status

Here is the call graph for this function:

Here is the caller graph for this function:

void rm_Drive::StartSelectAll (  )  [private]

Definition at line 1141 of file librmdb.exx.

References errorDesc(), cmn_Mutex::Lock(), log_ERR_m, log_FUNC_m, NAME, and cmn_Mutex::Unlock().

01141                              {
01142 
01143     log_FUNC_m(StartSelectAll);
01144 
01145     g_driveCursor_x.Lock();
01146 
01147     EXEC SQL
01148         SET TRANSACTION NAME readTrans
01149             READ ONLY
01150             ISOLATION LEVEL READ COMMITTED;
01151 
01152     EXEC SQL
01153         OPEN TRANSACTION readTrans SELECT_ALL_DRIVE;
01154 
01155     if ( SQLCODE != 0 ) {
01156         string sqlErrDesc = errorDesc(SQLCODE, "Opening SELECT_ALL_DRIVE Cursor failed");
01157         log_ERR_m(sqlErrDesc);
01158         g_driveCursor_x.Unlock();
01159         throw ivd_DBException( SQLCODE ,sqlErrDesc, true);
01160     }
01161 }// rm_Drive:: StartSelectAll

Here is the call graph for this function:

void rm_Drive::EndSelectAll (  )  [private]

Definition at line 1163 of file librmdb.exx.

References errorDesc(), log_FUNC_m, SQL_CHECKREAD_M, and cmn_Mutex::Unlock().

01163                            {
01164     log_FUNC_m(EndSelectAll);
01165 
01166     EXEC SQL
01167         CLOSE SELECT_ALL_DRIVE;
01168 
01169     g_driveCursor_x.Unlock();
01170     string sqlErrDesc = errorDesc(SQLCODE,"EXEC SQL CLOSE SELECT_ALL_LIB");
01171     SQL_CHECKREAD_M(sqlErrDesc);
01172 
01173 }// rm_Drive:: EndSelectAll

Here is the call graph for this function:

rm_Drive & rm_Drive::Next (  )  [private]

Definition at line 1175 of file librmdb.exx.

References aveSeekTime, capabilities, cleanNr, dataThroughput, driveIndex, driveKey, driveName, errorDesc(), firmwareRev, lastClean, libraryKey, loadTime, log_FUNC_m, rm_TimeStamp::m_iscTime, mediaFamily, options, productID, rewindTime, rmdb_MAX_DRIVEIDX, rmdb_MAX_DRIVENAME, rmdb_MAX_FIRMWAREREV, rmdb_MAX_PRODUCTID, rmdb_MAX_SCSIID, rmdb_MAX_SERIALNO, rmdb_MAX_VENDORID, scsiID, serialNo, SQL_CHECKREAD_M, SQL_NOERROR, status, unloadTime, cmn_Mutex::Unlock(), usageCount, and vendorID.

01175                          {
01176     log_FUNC_m(Next);
01177 
01178     char driveNameVal[rmdb_MAX_DRIVENAME];
01179     char driveIndexVal[rmdb_MAX_DRIVEIDX];
01180     char vendorIDVal[rmdb_MAX_VENDORID];
01181     char productIDVal[rmdb_MAX_PRODUCTID];
01182     char serialNoVal[rmdb_MAX_SERIALNO];
01183     char firmwareRevVal[rmdb_MAX_FIRMWAREREV];
01184     char scsiIDVal[rmdb_MAX_SCSIID];
01185 
01186     EXEC SQL
01187         FETCH SELECT_ALL_DRIVE
01188                     INTO
01189                         :driveKey,
01190                         :libraryKey,
01191                         :driveNameVal,
01192                         :status,
01193                         :driveIndexVal,
01194                         :mediaFamily,
01195                         :capabilities,
01196                         :dataThroughput,
01197                         :loadTime,
01198                         :unloadTime,
01199                         :aveSeekTime,
01200                         :rewindTime,
01201                         :usageCount,
01202                         :cleanNr,
01203                         :lastClean.m_iscTime,
01204                         :options,
01205                         :vendorIDVal,
01206                         :productIDVal,
01207                         :serialNoVal,
01208                         :firmwareRevVal,
01209                         :scsiIDVal;
01210 
01211     if (SQLCODE == SQL_NOERROR) {
01212         driveName   = driveNameVal;
01213         driveIndex  = driveIndexVal;
01214         lastClean   = lastClean.m_iscTime;
01215         vendorID    = vendorIDVal;
01216         productID   = productIDVal;
01217         serialNo    = serialNoVal;
01218         firmwareRev = firmwareRevVal;
01219         scsiID      = scsiIDVal;
01220     }
01221     else {
01222         int fetchCode = SQLCODE;
01223         EXEC SQL
01224             CLOSE SELECT_ALL_DRIVE;
01225         g_driveCursor_x.Unlock();
01226         SQLCODE = fetchCode;
01227         string sqlErrDesc = errorDesc(fetchCode,"reached end of SELECT_ALL_DRIVE cursor");
01228         SQL_CHECKREAD_M(sqlErrDesc);
01229     };
01230 
01231     return *this;
01232 }

Here is the call graph for this function:

bool rm_Drive::operator== ( const rm_Drive &  dr2  )  const [inline, private]

Definition at line 276 of file rmdb.h.

References capabilities, driveKey, driveName, mediaFamily, productID, serialNo, and vendorID.

00276                                                {
00277         return (    ( driveKey == dr2.driveKey          )   &&
00278                     ( mediaFamily == dr2.mediaFamily    )   &&
00279                     ( capabilities == dr2.capabilities  )   &&
00280                     ( driveName == dr2.driveName        )   &&
00281                     ( vendorID == dr2.vendorID          )   &&
00282                     ( productID == dr2.productID        )   &&
00283                     ( serialNo == dr2.serialNo          )   );
00284     };

Friends And Related Function Documentation

friend class rm_Operator [friend]

Definition at line 194 of file rmdb.h.

friend class rm_Medium [friend]

Definition at line 195 of file rmdb.h.

Member Data Documentation

Int32_t rm_Drive::driveKey

Definition at line 199 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), Insert(), rm_Operator::InventoryUpdate(), rm_Operator::MediumLoaded(), Next(), operator==(), rm_Operator::RemoveDrive(), rm_Operator::RemoveDriveHost(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), rm_Operator::SelectDriveForMig(), rm_Operator::SelectDriveHost(), SelectForOperation(), rm_Operator::SelectMediumByDrive(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::libraryKey

Definition at line 200 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::driveName

Definition at line 201 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AllocateAdmin(), rm_Operator::AutoDetect(), rm_Medium::Convert2Corba(), rm_Operator::GetBestCopy(), rm_Operator::GetHost(), Insert(), rm_Operator::InventoryUpdate(), Next(), operator==(), Select(), SelectAll(), rm_Operator::SelectAllDriveHosts(), rm_Operator::SelectAllMediaByPart(), rm_Operator::SelectAllMedium(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), rm_Operator::SelectDriveForMig(), rm_Operator::SelectDriveHost(), SelectForOperation(), rm_Operator::SelectMedium(), rm_Operator::SelectMediumByDrive(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::status

Definition at line 202 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), rm_Operator::AutoDetect(), rm_Operator::GetBestCopy(), Insert(), rm_Operator::InventoryUpdate(), Next(), rm_Operator::ReleaseResources(), rm_Operator::RemoveDrive(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), rm_Operator::SelectDriveForMig(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::driveIndex

Definition at line 203 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AllocateAdmin(), rm_Operator::AllocateRecall(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), rm_Operator::SelectDriveForMig(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::mediaFamily

Definition at line 204 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), Next(), operator==(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::capabilities

Definition at line 205 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), rm_Operator::IsDriveWORM(), Next(), operator==(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::dataThroughput

Definition at line 206 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::loadTime

Definition at line 207 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::unloadTime

Definition at line 208 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::aveSeekTime

Definition at line 209 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::rewindTime

Definition at line 210 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::usageCount

Definition at line 211 of file rmdb.h.

Referenced by rm_Operator::Add(), rm_Operator::AutoDetect(), Insert(), Next(), rm_Operator::ReleaseResources(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::cleanNr

Definition at line 212 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_TimeStamp rm_Drive::lastClean

Definition at line 213 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

Int32_t rm_Drive::options

Definition at line 214 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::vendorID

Definition at line 215 of file rmdb.h.

Referenced by Insert(), Next(), operator==(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::productID

Definition at line 216 of file rmdb.h.

Referenced by Insert(), Next(), operator==(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::serialNo

Definition at line 217 of file rmdb.h.

Referenced by Insert(), Next(), operator==(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::firmwareRev

Definition at line 218 of file rmdb.h.

Referenced by rm_Operator::Add(), Insert(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_String rm_Drive::scsiID

Definition at line 219 of file rmdb.h.

Referenced by rm_Operator::Add(), Next(), Select(), SelectAll(), SelectByAddr(), SelectByName(), SelectByStatus(), rm_Operator::SelectDrive(), SelectForOperation(), rm_Operator::Update(), and Update().

rm_Drive::log_CLASSID_m [private]

Definition at line 284 of file rmdb.h.

The documentation for this class was generated from the following files:
Generated on Mon Feb 27 19:46:34 2012 for OPENARCHIVE by  doxygen 1.5.6