BucketType.h

Go to the documentation of this file.

// -*- C++ -*-

#ifndef _included_BucketType_h
#define _included_BucketType_h

/*
*************************************************************************
* If a bucket is filled completely with records, insertrec() and        *
* addrec() copy the WHOLE list to a NEW bucket. The old list is deleted.*
* All references to the old list become invalid during insertrec() and  *
* addrec(). The data is simply copied bevore insertrec() and addrec().  *
*************************************************************************
*/

#include <list>
#include <cstring>
#include <cstdlib>

/* Assemble elements of type "Type" in a consecutive memory block.
 * The dynamic list for type "Type" is implemented using std::list.
 * Various list-manipulation routines are supplied. 
 * @author Manish Parashar, Ralf Deiterding (minor corrections)
 * Julian Cummings (modified to use std::list)
 */

template <class Type>
class Bucket
{
private:
    typedef std::list<Type> list_type;
    list_type theList;
    typename list_type::iterator cur;
public:
    typedef typename list_type::iterator iterator;

    // constructors
    inline Bucket() { cur = theList.end(); }

    // Make one-argument constructors explicit to avoid unwanted conversions
    // ignore maxnum argument, since there is no pre-allocation with std::list
    explicit Bucket(const unsigned int) { cur = theList.end(); }

    inline Bucket(const void *package, const unsigned int size, const int n)
    {
        unsigned int cnt;
        for (int i=0; i<n; ++i) {
            const char* hdr = reinterpret_cast<const char*>(package)+i*size;
            std::memcpy(reinterpret_cast<char*>(&cnt), hdr, 
                        sizeof(unsigned int));
            if (cnt) {
                const Type* beg = 
                    reinterpret_cast<const Type*>(hdr+sizeof(unsigned int));
                const Type* end = beg + cnt;
                theList.insert(theList.end(), beg, end);
            }
        }
        cur = theList.end(); 
    }

    inline Bucket(const Bucket<Type> &other)
        : theList(other.theList) { cur = theList.end(); }

    // query function
    inline int number() const { return theList.size(); }
    inline bool isempty() const { return theList.empty(); }

    // current record accessors
    inline Type* first(void)
    {
        if (!theList.empty()) {
            cur = theList.begin();
            return &(*cur);
        }
        else {
            return NULL;
        }
    }

    inline Type* last(void) 
    {
        if (!theList.empty()) {
            cur = --theList.end();
            return &(*cur);
        }
        else {
            return NULL;
        }
    }

    inline Type* current(void)
    {
        if (cur != theList.end())
            return &(*cur);
        else
            return NULL;
    }

    inline Type* prev(void)
    {
        if (cur != theList.begin()) {
            --cur;
            return &(*cur);
        }
        else {
            cur = theList.end();
            return NULL;
        }
    }

    inline Type* next(void)
    {
        if (cur == theList.end()) 
            return first();
        ++cur;
        if (cur != theList.end())
            return &(*cur);
        else
            return NULL;
    }

   inline iterator currec(void) { return cur; }

   inline void setcurrec(iterator c) { cur = c; }

    // list manipulators
    // add item to end of list
    inline Type* add(void)
    { 
        theList.push_back(Type()); 
        cur = --theList.end();
        return &(*cur); 
    }
    inline Type* add(const Type &t)
    { 
        theList.push_back(t); 
        cur = --theList.end();
        return &(*cur); 
    }

    // insert item after current position
    inline Type* insert(void)
    {
        if (cur == --theList.end() || theList.empty()) return add();
        cur = theList.insert(++cur,Type()); 
        return &(*cur); 
    }
    inline Type* insert(const Type &t)
    {
        if (cur == --theList.end() || theList.empty()) return add(t);
        cur = theList.insert(++cur,t); 
        return &(*cur); 
    }

    // remove current item and set pointer to previous item
    inline Type* remove(void)
    { 
        if (!theList.empty()) { 
            if (cur == theList.begin()) {
                theList.erase(cur);
                cur = theList.end();
            }
            else {
                iterator r = cur--;
                theList.erase(r);
            }
        }
        return current();
    }

    // clear all items from the list
    inline void empty(void)
    { 
        theList.clear(); 
        cur = theList.end(); 
    }

    // swap storage with another bucket
    inline void swap(Bucket<Type>& bkt)
    { 
        iterator bktcur = bkt.cur;
        theList.swap(bkt.theList); 
        bkt.cur = cur;
        cur = bktcur;
    }

    // split the list at the current item
    inline void split(Bucket<Type>& bkt)
    {
        if (!theList.empty()) { 
            if (cur == theList.begin()) {
                bkt.theList.splice(bkt.theList.end(), theList);
                bkt.cur = bkt.theList.end();
                cur = theList.end();
            }
            else {
                iterator r = cur--;
                bkt.theList.splice(bkt.theList.end(), theList,
                    r, theList.end());
                bkt.cur = bkt.theList.end();
            }
        }
    }

    // utility routines
    // These routines copy items from std::list into a contiguous buffer.
    // The new buffer should be deleted after it is used.
    void *pack(int &size)
    {
        const unsigned int cnt = theList.size();
        size = cnt * sizeof(Type) + sizeof(unsigned int);
        char* pkg = new char[size];
        std::memcpy(pkg, reinterpret_cast<const char*>(&cnt), 
                    sizeof(unsigned int));
        if (cnt) {
            Type* t = reinterpret_cast<Type*>(pkg + sizeof(unsigned int));
            iterator it, iend = theList.end();
            for (it = theList.begin(); it != iend; ++it, ++t)
                std::memcpy(reinterpret_cast<char*>(t),
                            reinterpret_cast<char*>(&(*it)), sizeof(Type));
        }
        return pkg;
    }
    void pack(void *&package, int &size)
    {
        const unsigned int cnt = theList.size();
        size = cnt * sizeof(Type) + sizeof(unsigned int);
        char* pkg = new char[size];
        std::memcpy(pkg, reinterpret_cast<const char*>(&cnt), 
                    sizeof(unsigned int));
        if (cnt) {
            Type* t = reinterpret_cast<Type*>(pkg + sizeof(unsigned int));
            iterator it, iend = theList.end();
            for (it = theList.begin(); it != iend; ++it, ++t)
                std::memcpy(reinterpret_cast<char*>(t),
                            reinterpret_cast<char*>(&(*it)), sizeof(Type));
        }
        package = pkg;
        return;
    }
};

#endif

---