GEO/GEO_Vertex.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:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      The vertex class. As opposed to GEO_Points, all vertices are unique.
 *
 * WARNING: Try to avoid using the assignment operator '=' because it is
 *          shallow in the attribute component!
 *
 */

#ifndef __GEO_Vertex_H__
#define __GEO_Vertex_H__

#include "GEO_API.h"
#include <GB/GB_Vertex.h>
#include <GB/GB_Attribute.h>
#include "GEO_Point.h"

class GEO_Detail;

class GEO_API GEO_Vertex : public GB_Vertex, public GB_AttributeElem
{
public:
    explicit GEO_Vertex(              GEO_Point *p=0) : GB_Vertex(p) {}
    explicit GEO_Vertex(GEO_Detail *d,GEO_Point *p=0) : GB_Vertex(p)
    { initAttributeData(d); }

    virtual ~GEO_Vertex() { }

    // Avoid using this c-tor because it's dangerously shallow!
    GEO_Vertex(const GEO_Vertex &vtx)
        : GB_Vertex(vtx.getBasePt()), GB_AttributeElem(vtx) {}

    void                 initAttributeData(GEO_Detail *d);
    void                 copyAttributeData(const GEO_Vertex *src, int size);

    GEO_Point           *getPt(void) const { return (GEO_Point*)getBasePt(); }

          UT_Vector4    &getPos()
                         {
                             return ((GEO_Point*)getBasePt())->getPos();
                         }
    const UT_Vector4    &getPos() const
                         {
                             return ((const GEO_Point*)getBasePt())->getPos();
                         }

    void                 steal(GEO_Vertex &src)
                         {
                                GB_Vertex::steal(src);
                                getAttrib().steal(src.getAttrib());
                         }

    void                 copyVertex(const GEO_Vertex *src, GEO_Point *pt,
                                    int avsize)
                         {
                             setPt(pt);
                             copyAttributeData(src, avsize);
                         }
    void                 copyVertex(const GEO_Vertex *src, int avsize)
                         {
                             setPt(src->getBasePt());
                             copyAttributeData(src, avsize); 
                         }

    // Avoid using operator=() because it's dangerously shallow!
    GEO_Vertex          &operator=(const GEO_Vertex &vtx)
                         {
                             if (this != &vtx)
                             {
                                 setPt(vtx.getBasePt());
                                 getAttrib() = vtx.getAttrib(); // shallow!
                             }
                             return *this;

                         }
    int                  operator==(const GEO_Vertex &vtx) const
                         {
                             // Trivial check to make it simple. Do not change.
                             return this == &vtx;
                         }

private:
    // Nothing.
};

#endif

---