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

#ifndef __GT_ElementSetMap__
#define __GT_ElementSetMap__

#include "GT_API.h"

#include <UT/UT_StringMap.h>
#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Set.h>
#include "GT_ElementSet.h"

class UT_JSONWriter;
class GT_ElementSetMap;

using GT_ElementSetMapPtr = UT_IntrusivePtr<GT_ElementSetMap>;

/// Class to store sets of faces / points / etc on GT mesh primitives
class GT_API GT_ElementSetMap : public UT_IntrusiveRefCounter<GT_ElementSetMap>
{
public:
    using MapType = UT_StringMap<GT_ElementSetPtr>;

    GT_ElementSetMap();
    ~GT_ElementSetMap();

    UT_NON_COPYABLE(GT_ElementSetMap);

    /// @{
    /// Map access.  These methods are @b not thread-safe
    GT_ElementSetPtr    find(const UT_StringRef &name) const;
    GT_ElementSetPtr    add(const UT_StringHolder &name,
                                const GT_ElementSetPtr &set,
                                bool replace_existing=true);
    GT_Size             entries() const { return myMap.size(); }
    /// @}

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

    class GT_API iterator
    {
    public:
        using MapIterator = GT_ElementSetMap::MapType::const_iterator;
        iterator() = default;

        const UT_StringHolder   &name() const { return myIt->first; }
        const GT_ElementSetPtr  &subset() const { return myIt->second; }
        /// Alias for backwards compatibility with GT_FaceSet.
        const GT_ElementSetPtr  &faceSet() const { return myIt->second; }

        iterator        &operator++() { ++myIt; return *this; }
        iterator        &operator=(const iterator &src)
                        {
                            myIt = src.myIt;
                            myEnd = src.myEnd;
                            return *this;
                        }
        bool            operator==(const iterator &cmp) const
                            { return myIt == cmp.myIt; }
        bool            operator!=(const iterator &cmp) const
                            { return myIt != cmp.myIt; }
        bool            atEnd() const   { return myIt == myEnd; }
        void            advance()       { ++myIt; }
    private:
        iterator(const MapIterator &it, const MapIterator &end)
            : myIt(it)
            , myEnd(end)
        {
        }
        MapIterator     myIt;
        MapIterator     myEnd;
        friend class GT_ElementSetMap;
    };
    iterator    begin() const   { return iterator(myMap.begin(), myMap.end()); }
    iterator    end() const     { return iterator(myMap.end(), myMap.end()); }

    /// Delete elements from the sets.  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_ElementSetMapPtr deleteElements(const UT_Set<int> &elements,
                                       const GT_Int32Array &mapping) const;

    /// 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_FaceSetMapPtr    deleteFaces(const UT_Set<int> &faces,
                                const GT_Int32Array &mapping) const
                            { return deleteElements(faces, mapping); }


    exint       getMemoryUsage() const;

private:
    MapType             myMap;
};

#endif