GB/GB_AttributeRef.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:
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GB_AttributeRef.h ( GB Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GB_AttributeRef__
#define __GB_AttributeRef__

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


/// @brief This class provides a way to lookup attribute data for an element
///
/// Each GB_AttributeElem stores attribute data.  The GB_AttributeRef class
/// stores the information needed to extract the data from the attribute
/// element.
///
/// This class provides an opaque interface to how the element stores the data.
/// @code
///     GB_AttributeRef          Nref;
///     UT_Vector3              *N;
///     Nref = gdp.findNormalAttribute(GEO_POINT_DICT);
///     if (Nref.isValid())
///     {
///         FOR_ALL_GPOINTS(gdp, ppt)
///         {
///             N = ppt->castAttribData<UT_Vector3>(Nref);
///             N->normalize();
///         }
///     }
///
/// @endcode
/// @see GEO_Detail::findPointAttrib()
class GB_API GB_AttributeRef {
public:
    /// Default constructor
    GB_AttributeRef();
    /// Copy constructor
    GB_AttributeRef(const GB_AttributeRef &);
    /// Destructor
    ~GB_AttributeRef();

    /// Assignment operator
    GB_AttributeRef     &operator=(const GB_AttributeRef &src);

    /// Comparison operator
    bool                operator==(const GB_AttributeRef &src) const
                            { return myHandle == src.myHandle; }
    /// Comparison operator
    bool                operator!=(const GB_AttributeRef &src) const
                            { return myHandle != src.myHandle; }

    /// Test to see if the attribute reference refers to a valid attribute
    bool                 isValid() const        { return myHandle >= 0; }

    /// Test to see if the attribute reference refers to a valid attribute
    bool                 isInvalid() const      { return myHandle < 0; }

    /// Method  to clear the handle (so that it is no longer valid)
    void                 clear()                { myHandle = -1; }

#if !defined(HDK_RELAXED_GB)
private:
#endif
    /// Constructor which allows creation of a valid reference (private)
    ///
    /// If you get an error that the constructor is private, that means
    /// that you are trying to assign an integer value to the offset.  If you
    /// need an invalid offset (i.e. -1), this is set in the default
    /// constructor.
    ///
    /// @warning If you are an HDK user, you might want to define
    ///         HDK_RELAXED_GB
    /// When compiling your code.  Be cautioned, however, that you will need to
    /// change your code sooner or later.
#if defined(HDK_RELAXED_GB)
    GB_AttributeRef(int offset);
#else
    explicit GB_AttributeRef(int offset);
#endif

#if defined(HDK_RELAXED_GB)
    operator    int() const     { return myHandle; }
    operator    int&()          { return myHandle; }
private:
#endif

    friend class        GB_AttributeData;
    friend class        GB_AttributeElem;
    friend class        GB_AttributeDict;
    friend class        GB_AttributeDictOffsetIterator;
    friend class        GB_ConstAttributeDictOffsetIterator;
    friend class        GB_AttributeTable;

    friend class        GEO_AttribDict;
    friend class        GEO_AttributeHandleList;
    friend class        GEO_PointAttribDict;
    friend class        GEO_PrimAttribDict;
    friend class        GEO_VertexAttribDict;

    // For float offsets
    friend class        GU_CurveCache;
    friend class        GU_PrimTriBezierCache;
    friend class        GU_TPSurfCache;
    friend class        POP_AttribMap;

    int                 myHandle;
};

/// @{
/// In previous versions of the HDK, the GB_AttributeRef was represented by an
/// integer.  Thus, the methods @c isValid() and @c isInvalid() were not
/// available.  If you need to compile code for earlier baselines with minimal
/// changes, you can use these functions to perform validity checks seamlessly.
static inline bool GBisAttributeRefValid(const GB_AttributeRef &a)
                    { return a.isValid(); }

static inline bool GBisAttributeRefInvalid(const GB_AttributeRef &a)
                    { return a.isInvalid(); }

static inline GB_AttributeRef   GBmakeInvalidAttributeRef()
                    { return GB_AttributeRef(); }

static inline void GBclearAttributeRef(GB_AttributeRef &a)      { a.clear(); }

/// @}

// Explicitly instantiate templated classes using GB_AttributeRef so that
// the generated template code will only be created once in libGB.
#ifndef EXPORT_GB
extern template class GB_API UT_RefArray<GB_AttributeRef>;
#endif

#endif

---