RWDiskPageHeap (deprecated)

Module:  Essential Tools Module   Group:  File System Classes

RWDiskPageHeapRWBufferedPageHeapRWVirtualPageHeap

• Local Index
• Synopsis
• Description
• Persistence
• Example
• Public Constructor
• Public Destructor
• Public Member Functions

Members

allocate() deallocate()

dirty() isValid()

lock() RWDiskPageHeap()

unlock() ~RWDiskPageHeap()

#include <rw/diskpage.h>
unsigned nbufs;
unsigned pagesize;
RWDiskPageHeap heap("filename", nbufs, pagesize) ;

Class RWDiskPageHeap is a specializing type of buffered page heap. It swaps its pages to disk as necessary.

---

NOTE -- RWDiskPageHeap is deprecated.

---

None

In this example, 100 nodes of a linked list are created and strung together. The list is then walked, confirming that it contains 100 nodes. Each node is a single page. The "pointer" to the next node is actually the handle for the next page.

#include <iostream>
#include <iomanip>
#include <rw/diskpage.h>
#include <rw/rstream.h>

struct Node 
{
    int   key;
    RWHandle      next;
};

RWHandle head = 0;
const int N = 100;      // Exercise 100 Nodes

int main() 
{
    // Construct a disk-based page heap with page size equal
    // to the size of Node and with 10 buffers:
    RWDiskPageHeap heap(0, 10, sizeof(Node));

    if (!heap.isValid()) {
        std::cerr << "Unable to open temporary swap file.\n";
        std::cerr << "Do you have write privileges?\n" << std::flush;
        return 0;
    }

    // Build the linked list:
    for (int i=0; i<N; i++) {
        RWHandle h = RWHandle(heap.allocate());
        Node* newNode = (Node*)heap.lock(h);
        newNode->key  = i;
        newNode->next = head;
        head = h;
        heap.dirty(h);
        heap.unlock(h);
    }

    // Now walk the list:
    unsigned count = 0;
    RWHandle nodeHandle = head;
    while (nodeHandle) {
        Node* node = (Node*)heap.lock(nodeHandle);
        RWHandle nextHandle = node->next;
        heap.unlock(nodeHandle);
        heap.deallocate(nodeHandle);
        nodeHandle = nextHandle;
        count++;
    }

    std::cout << "List with " << count << " nodes walked.\n";

    // The following line should not be necessary, 
    // but a bug in Sun C++ requires it:
    std::cout << std::flush;

    return 0;
}

Program output:

List with 100 nodes walked.

RWDiskPageHeap(const char* filename = 0,
               unsigned nbufs       = 10,
               unsigned pgsize      = 512);

Constructs a new disk-based page heap. The heap will use a file with filename filename, otherwise it will negotiate with the operating system for a temporary filename. The number of buffers, each the size of the page size, will be nbufs. No more than this many pages can be locked at any one time. The size of each page is given by pgsize. To see whether a valid RWDiskPageHeap has been constructed, call member function isValid(). Note that Windows users may be required to call AnsiToOEM on a Windows character constant for the filename in this constructor, because we use a C function call that may resolve to a DOS system call. In that case, DOS might not be able to recognize Windows character sets.

virtual 
~RWDiskPageHeap();

Returns any resources used by the disk page heap back to the operating system. All pages should have been deallocated before the destructor is called.

virtual RWHandle
allocate();

Redefined from class RWVirtualPageHeap. Allocates a page off the disk page heap and returns a handle for it. If there is no more space (for example, the disk is full), the function returns 1.

virtual void
deallocate(RWHandle h);

Redefined from class RWBufferedPageHeap. Deallocate the page associated with handle h. It is not an error to deallocate a zero handle.

virtual void
dirty(RWHandle h);

Inherited from RWBufferedPageHeap.

bool
isValid() const;

Returns true if this is a valid RWDiskPageHeap.

virtual void*
lock(RWHandle h);

Inherited from RWBufferedPageHeap.

virtual void
unlock(RWHandle h);

Inherited from RWBufferedPageHeap.

© Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.