GB/GB_EdgeHash.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GB_EdgeHash.h ( GU Library, C++)
 *
 * COMMENTS:    This has a hash object useful for holding unordered
 *              and directed edges.  It is designed to be used with the
 *              UT_HashTable class.
 */

#ifndef __GB_EdgeHash__
#define __GB_EdgeHash__

#include "GB_API.h"
#include <UT/UT_Hash.h>

#include "GB_Element.h"

// The hash key for unordered edges:
class GB_API GB_EdgeHash : public UT_Hash
{
public:
    virtual ~GB_EdgeHash()      {}

    int                 myA, myB;

    GB_EdgeHash(int a, int b) : myA(a), myB(b) { orderKey(); }
    GB_EdgeHash(const GB_Element *a, const GB_Element *b) : 
                myA(a->getNum()), myB(b->getNum()) { orderKey(); }
    GB_EdgeHash(GB_EdgeHash const &h) : UT_Hash(), myA(h.myA), myB(h.myB)
                        { orderKey(); }

    int                 compare(const UT_Hash &a) const
                        {
                            return !(myA==((const GB_EdgeHash &)a).myA &&
                                     myB==((const GB_EdgeHash &)a).myB);
                        }
    void                copy(const UT_Hash &a)
                        {
                            myA = static_cast<const GB_EdgeHash &>(a).myA;
                            myB = static_cast<const GB_EdgeHash &>(a).myB;
                        }
    unsigned            hash() const
                        {
                            return myA * 47 + myB * 53;
                        }

    UT_Hash            *copy() const
                        {
                            return new GB_EdgeHash(myA, myB);
                        }
    
protected:
    void                orderKey()
                        {
                            int t;
                            if (myA > myB)
                            {
                                t = myA;        myA = myB;      myB = t;
                            }
                        }
};

// The hash key for directed edges:
class GB_API GB_DEdgeHash : public UT_Hash
{
public:
    virtual ~GB_DEdgeHash()     {}

    int                 myA, myB;

    GB_DEdgeHash(int a, int b) : myA(a), myB(b) { }
    GB_DEdgeHash(GB_Element *a, GB_Element *b) : 
                        myA(a->getNum()), myB(b->getNum()) {}
    GB_DEdgeHash(GB_DEdgeHash const &h) : UT_Hash(), myA(h.myA), myB(h.myB) { }

    int                 compare(const UT_Hash &a) const
                        {
                            return !(myA==((const GB_DEdgeHash &)a).myA &&
                                     myB==((const GB_DEdgeHash &)a).myB);
                        }
    void                copy(const UT_Hash &a)
                        {
                            myA = static_cast<const GB_DEdgeHash &>(a).myA;
                            myB = static_cast<const GB_DEdgeHash &>(a).myB;
                        }
    unsigned            hash() const
                        {
                            return myA * 47 + myB * 53;
                        }

    UT_Hash            *copy() const
                        {
                            return new GB_DEdgeHash(myA, myB);
                        }
};

#endif

---