---------------------------------------------------------------------
  CLASS: PagedSpaceBitmapMap     --GKG
  PUBLIC METHODS:
    PagedSpaceBitmapMap()   - Constructor which requires a
                            SpaceBitmapDesc, the block number where
                            it is located in the partition, and the
                            block size of the medium.
    pageSize()              - Returns the size (in bytes) of the pages
                            into which the bitmap has been segmented.
                            The actual size of the last page may be
                            smaller than this value as it contains
                            the residue. This value is always an even
                            muliple of the logical blocks size.
    numPages()              - Returns the number of pages into which
                            the bitmap has been segmented.
    blocksPerPage()         - Returns the number of logical blocks that
                            fill the page size.
    pageStartBlock()        - Returns the logical block number of the
                            first block in the specified page.
    pageAbsToRel()          - Converts a logical block number to a
                            block offset relative to the start of the
                            page.
    pageRelToAbs()          - Converts a block number relative to the
                            start of the page to an absolute logical
                            block number.
    pageStartByteOffset()   - Returns the offset (in bytes) to the
                            beginning of the bitmap data withing the
                            specified page. This value should be zero
                            except when specifing page zero.
    pageNum()               - Returns the page number of the page
                            containing the specified bit address.
    pageBitOffset()         - Returns the residule bit offset within a
                            page of a specified bit address.
    pageBitAddr()           - Returns the bit address of a specified
                            bit offset within a specified page.
    pageBitSize()           - Returns the size of the specified page in
                            bits. The value is the same for all pages
                            except possibly the last page (which may
                            be smaller than the others).
    pageByteSize()          - Returns the size of the specified page in
                            bytes. The value except possibly the last
                            page.
    pageBlockSize()         - Returns the size of the specified page in
                            logical blocks.  The value is the same
                            for all pages except possibly the last
                            page.
    pageBitResidue()        - Returns the number of residule bits in
                            the last byte of the specified page (can
                            only be non-zero for the last page).
    pageNumBits()           - Returns the number of bits in the
                            specified page representing bitmap data.
                            Excludes space used by the header
                            (differentiating  it from pageBitSize() ).
    pageOffsetToBufferPos() - Converts a bit address within a page into
                            a bit offset within the page memory
                            buffer.
    bufferPosToPageOffset() - Converts a bit offset within the page
                            memory buffer to a bit address within the
                            page.
    bufferBlockOffset()     - Returns the block offset within the page
                            memory buffer of a given bit offset
                            within a given page within a specified
                            block.
 
  USAGE NOTES:
 
   This is to be used AFTER using the SpaceBitmapDesc, in order to
   access individual bits in the SpaceBitmap. It merely provides
   information about where bits are located, and leaves the task of
   reading and writing individual pages of the bitmap up to the user.
 
   It supports arbitrary-sized paging of bitmaps, by supporting an
   optional BlockNum in the byteOffset() method.
 
   Once it is constructed, the SpaceBitmapDesc passed in may be
   destroyed, since this object contains neither a pointer nor a
   reference to it, but rather extracts all the information it needs
   at that time.
 
   NOTE that the first block of the SpaceBitmap contains the
   SpaceBitmapDesc (at its beginning). Also NOTE that this class
   takes that descriptor's presence into account, so that it will
   NEVER return values allowing the SpaceBitmapDesc to be
   modified. Therefore, if only the addresses returned by this class
   are used for modifying bits, the first block in the bitmap area
   may be read/modified/written with no risk to the SpaceBitmapDesc
   becoming corrupted. Thus, the user may view this as presenting the
   entire SpaceBitmap area as ONLY a bitmap which may be easily paged
   in and out to disk.
 
 ----------------------------------------------------------------------