UT/UT_Pointers.h

Go to the documentation of this file.

#ifndef __UT_Pointers__
#define __UT_Pointers__

#include "UT_API.h"
/*
 *  A UT_Pointers is a utility class which maintains a collection
 *  of pointers to anything. You can add and remove pointers from the
 *  collection without having to deal with memory management using
 *  either the addMember/removeMember methods or the [] operator.
 */

#include "UT_Assert.h"
#include "UT_Iterator.h"
#include "UT_Notifier.h"

typedef void    *UT_ThingP;

class UT_API UT_Pointers {

public:
             UT_Pointers() { list = (UT_ThingP *)0; nentries = size = 0; }
    virtual ~UT_Pointers();

    int         index(UT_ThingP thing) const;
    int         addMember(UT_ThingP thing);     // Returns index
    int         removeMember(UT_ThingP thing);  // Returns old index
    UT_ThingP   removeMember(int idx);  // Returns old pointer
    int         removeMembers(int from, int to);// Returns # removed
    void        insertMember(UT_ThingP thing, int idx);

    typedef UT_Iterator<UT_ThingP, UT_Pointers> Iterator;

    Iterator iterator(int idx = 0)
    {
        return UT_Iterator<UT_ThingP, UT_Pointers>(*this, &myNotifier, idx);
    }

    Iterator iteratorReverse(int idx = 0)
    {
        return UT_Iterator<UT_ThingP, UT_Pointers>(*this, &myNotifier, idx,
                                                   true);
    }

    int          entries()  const { return nentries; }
    
    // for backwards compatability
    int          count()    const { return entries(); } 
    int          getSize()  const { return size; }
    void         grow(int newsize);

    // empty() just sets nentries to 0. clear() actually frees all our memory.
    void         empty();
    void         clear();

    UT_ThingP   &operator[](int idx);
    UT_ThingP    operator()(int idx) const
                 {
                    UT_ASSERT_P(idx >= 0 && (unsigned)idx < nentries);
                    if( ((unsigned)idx) >= nentries  || idx<0 ) return 0;

                    return *(list + idx);
                 }


    void           sortPointers(int (*compare)(const void *, const void *));
    int          searchPointers(int (*compare)(const void *, const void *),
                                const void *key) const;

    void                reverse();

    const UT_ThingP &null() const { return theNullPointer; }

private:

    UT_NotifierImpl<UT_IteratorEvent &> myNotifier;

    // NOTE: The ranges include both endpoints.
    void notifyAdd(int lo, int hi)
    {
        UT_IteratorEvent event(UT_IteratorEvent::ADD, lo, hi);
        myNotifier.notifyObservers(event);
    }
    void notifyAdd(int idx) { notifyAdd(idx, idx); }
    void notifyRemove(int lo, int hi)
    {
        UT_IteratorEvent event(UT_IteratorEvent::REMOVE, lo, hi);
        myNotifier.notifyObservers(event);
    } 
    void notifyRemove(int idx) { notifyRemove(idx, idx); }
    void notifyInvalid() {
        UT_IteratorEvent event(UT_IteratorEvent::INVALID, 0, 0);
        myNotifier.notifyObservers(event);
    }
    
    UT_ThingP    *list;
    unsigned int size;
    unsigned int nentries;

    static UT_ThingP theNullPointer;
};

#endif

---