PDG_AttributeSplit.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.
 *
 * COMMENTS:
 */

#ifndef __PDG_ATTRIBUTE_SPLIT_H__
#define __PDG_ATTRIBUTE_SPLIT_H__

#include "PDG_API.h"

#include "PDG_AttributeMap.h"
#include "PDG_Types.h"
#include "PDG_WorkItem.h"

#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>

/**
 * Utility class for splitting a list of work items by an attribute value,
 * into a map to subsets of the original work item list.
 */
class PDG_API PDG_AttributeSplit
{
public:
    /// Value -> work item list map, used when splitting a list of work
    /// items into multiple list by an attribute value.
    template <typename Value>
    using SplitMap          = UT_ArrayMap<Value, PDG_WorkItemArray>;

    /// String value -> work item list map, used when splitting a list of
    /// work items without specifying a specific attribute type.
    using StringSplitMap    = UT_ArrayStringMap<PDG_WorkItemArray>;

    /// Integer value -> work item list map, used when splitting a list of
    /// work items into batches.
    using BatchSplitArray   = UT_Array<PDG_WorkItemArray>;

public:
    /// Batches work items by frame. Iterates over a list of work items and
    /// attempts to extract N contiguous lists that span an increasing frame
    /// range.
    static void                 batchWorkItemsByFrame(
                                    BatchSplitArray& batches,
                                    PDG_WorkItemArray& missing_items,
                                    const PDG_WorkItemArray& work_items,
                                    const PDG_NodeArray* input_nodes,
                                    bool save_missing = true);

    /// Splits a list of input work items into a split map by the specified
    /// attribute value. Work items that are missing the attribute are
    /// returned in a second output list. The list of unique attribute values
    /// is also returned as a third output.
    ///
    /// This variation of the function is templated on a specific type of
    /// attribute, and uses that type natively for the map key and when
    /// accessing attribute values. An alternative version exists below that
    /// is not templated on the type and simply uses the common, string
    /// represenation of the attribute value instead.
    template <typename Attribute>
    static bool                 splitWorkItems(
                                    SplitMap<typename Attribute::Data>& split,
                                    PDG_WorkItemArray& missing_items,
                                    typename Attribute::Array& unique_values,
                                    const PDG_WorkItemArray& work_items,
                                    const UT_StringHolder& attrib_name,
                                    bool save_missing = true)
    {
        bool conflict = false;
        for (auto&& work_item : work_items)
        {
            auto&& ref = work_item->attributes().refRO<Attribute>(attrib_name);
            if (!ref || !ref->valid(0))
            {
                if (ref.error() == PDG_AttributeRef::eErrorTypeConflict)
                    conflict = true;
                if (save_missing)
                    missing_items.append(work_item);
                continue;
            }

            typename Attribute::Data value = ref->value(0);
            auto&& iter = split.find(value);
            if (iter == split.end())
            {
                unique_values.append(value);
                split[value].append(work_item);
                continue;
            }

            iter->second.append(work_item);
        }

        unique_values.sort();
        return conflict;
    }

    /// Same as above, but values are converted to strings and accessed without
    /// any type information. The attribute name string can contain multiple
    /// attrib names, separated by spaces
    static bool                 splitWorkItems(
                                    StringSplitMap& split,
                                    PDG_WorkItemArray& missing_items,
                                    UT_StringArray& unique_values,
                                    const PDG_WorkItemArray& work_items,
                                    const UT_StringHolder& attrib_names,
                                    const UT_StringHolder* default_value,
                                    bool save_missing = true,
                                    bool partial_match = false);
};

#endif