GT_ElementSet.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.
 *
 * NAME:        GT_ElementSet.h (GT Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GT_ElementSet__
#define __GT_ElementSet__

#include "GT_API.h"

#include "GT_DANumeric.h"
#include "GT_Handles.h"
#include "GT_Types.h"
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Lock.h>
#include <UT/UT_Set.h>
#include <SYS/SYS_Deprecated.h>

class UT_JSONWriter;
class GT_ElementSet;

using GT_ElementSetPtr = UT_IntrusivePtr<GT_ElementSet>;

/// A set of element indices in a GT_Primitive, e.g. points / faces / tets
class GT_API GT_ElementSet : public UT_IntrusiveRefCounter<GT_ElementSet>
{
public:
    class SetType
    {
    public:
        // Thread-safety semantics
        // Only one thread can write to the set at a time
        // No other threads can read during creation
        // After creation, multiple threads should be able to access (search,
        // iterate)
        using ArrayType = UT_Array<GT_Offset>;

        SetType() = default;

        exint   getMemoryUsage() const
        {
            return sizeof(*this) + myOffsets.getMemoryUsage();
        }

        void    insert(GT_Offset offset)
        {
            if (myOffsets.entries() && myOffsets.last() >= offset)
            {
                if (myOffsets.last() == offset)
                    return;     // No duplicates, so we can just return
                myDirty = true; // Flag as un-ordered
            }
            myOffsets.append(offset);
        }
        template <typename T>
        void    multipleInsert(const T *list, exint size)
        {
            if (size < 2)
            {
                if (size == 1)
                    insert(list[0]);    // Don't automatically mark as dirty
                return;
            }
            // Instead of keeping track of whether the inserts are ordered or
            // not, just mark the list as dirty.
            myDirty = true;
            exint       start = myOffsets.entries();
            exint       end = start + size;
            myOffsets.setCapacity(end);
            myOffsets.entries(end);
            for (exint i = start; i < end; ++i, ++list)
                myOffsets(i) = list[0];
        }
        exint   size() const    { return myOffsets.entries(); }
        int     count(GT_Offset idx) const
        {
            return findOffset(idx) >= 0 ? 1 : 0;
        }
        void    erase(GT_Offset item)
        {
            exint       idx = findOffset(item);
            if (idx >= 0)
                myOffsets.removeIndex(idx);
        }
        using const_iterator = ArrayType::const_iterator;
        const_iterator  begin() const
        {
            // If we begin iteration, and another thread does a find, we need
            // to be sorted.
            ensureSorted();
            return myOffsets.begin();
        }
        const_iterator  end() const     { return myOffsets.end(); }

        // Methods not on std::set
        template <typename T> void
        fillOrderedArray(T *list) const
        {
            ensureSorted();
            for (exint i = 0; i < myOffsets.entries(); ++i)
                list[i] = myOffsets(i);
        }

    private:
        inline void     ensureSorted() const
        {
            if (myDirty)
                SYSconst_cast(this)->sortOffsets();
        }
        void    sortOffsets()
        {
            // TODO: Fence this?
            UT_AutoLock lock(myLock);
            myOffsets.sort();
            myOffsets.sortedRemoveDuplicates();
            myDirty = false;
        }
        exint   findOffset(GT_Offset item) const
        {
            ensureSorted();
            return myOffsets.uniqueSortedFind(item, std::less<exint>());
        }
        ArrayType       myOffsets;
        UT_Lock         myLock;
        bool            myDirty = false;
    };

    GT_ElementSet() = default;
    GT_ElementSet(const GT_DataArrayHandle &members);
    ~GT_ElementSet();

    UT_NON_COPYABLE(GT_ElementSet);

    /// @{
    /// Number of elements in the set
    GT_Size     entries() const { return myMembers.size(); }
    GT_Size     size() const    { return myMembers.size(); }
    exint       getMemoryUsage() const;
    /// @}

    /// Test whether an element is in the set
    bool        contains(GT_Offset element) const
                    { return myMembers.count(element) > 0; }

    /// Add an element to the set
    void        addElement(GT_Offset element);

    /// @{
    /// Add a list of elements
    void        addElements(const int32 *indices, exint count);
    void        addElements(const int64 *indices, exint count);
    /// @}

    /// Remove an element from the set
    void        removeElement(GT_Offset element);

    /// Extract the member list as a sorted array of integers
    GT_DataArrayHandle  extractMembers() const;

    /// Save sets to a JSON stream
    bool        save(UT_JSONWriter &w) const;

    SetType::const_iterator     begin() const   { return myMembers.begin(); }
    SetType::const_iterator     end() const     { return myMembers.end(); }

    /// Check whether any of the elements in this set are in the list of
    /// elements to be deleted.
    bool                anyIntersect(const UT_Set<int> &elements) const;

    /// Delete elements from the set.  The second argument is an array
    /// mapping the old element numbers to the new element numbers.  For example,
    /// deleting polygon 2 from a set of [0,1,2,3] would expect a remapping
    /// array of [0,1,x,2] (the value of 2 doesn't actually matter)
    GT_ElementSetPtr    deleteElements(const UT_Set<int> &elements,
                                       const GT_Int32Array &mapping) const;

    // Old Methods for backwards compatibility with GT_FaceSet.

    /// Add a face to the set
    SYS_DEPRECATED_REPLACE(20.5, "addElement")
    void        addFace(GT_Offset face_index)
                    { addElement(face_index); }

    /// @{
    /// Add a list of faces
    SYS_DEPRECATED_REPLACE(20.5, "addElements")
    void        addFaces(const int32 *indices, exint count)
                    { addElements(indices, count); }
    SYS_DEPRECATED_REPLACE(20.5, "addElements")
    void        addFaces(const int64 *indices, exint count)
                    { addElements(indices, count); }
    /// @}

    /// Remove a face from the set
    SYS_DEPRECATED_REPLACE(20.5, "removeElement")
    void        removeFace(GT_Offset face_index)
                    { removeElement(face_index); }

    /// Delete polygons from the face set.  The second argument is an array
    /// mapping the old face numbers to the new face numbers.  For example,
    /// deleting polygon 2 from a set of [0,1,2,3] would expect a remapping
    /// array of [0,1,x,2] (the value of 2 doesn't actually matter)
    SYS_DEPRECATED_REPLACE(20.5, "deleteElements")
    GT_ElementSetPtr    deleteFaces(const UT_Set<int> &faces,
                                const GT_Int32Array &mapping) const
                    { return deleteElements(faces, mapping); }

protected:
    SetType             myMembers;
    bool                my64bit = false;
};

#endif