9 #ifndef __PDG_WORKITEM_SORT_H__
10 #define __PDG_WORKITEM_SORT_H__
36 template <
typename T,
bool Reverse,
typename... Args>
37 class Comparator :
public T
40 Comparator() :
T(), myReverse(Reverse), myPriorityItems(
nullptr) {}
42 :
T(std::forward<Args>(
args)...)
43 , myPriorityItems(
nullptr)
47 Comparator(
bool reverse,
50 :
T(std::forward<Args>(
args)...)
51 , myPriorityItems(priority_items)
67 if (prioritize(lhs, rhs, result))
80 if (prioritize(&lhs, &rhs, result))
90 if (!myPriorityItems || myPriorityItems->empty())
96 if (
right == myPriorityItems->end())
98 if (
left == myPriorityItems->end())
104 else if (
left == myPriorityItems->end())
125 class PriorityComparator
131 class IndexComparator
135 : myInputs(input_list) {}
141 class InputComparator
145 : myInputs(input_list) {}
152 class AttributeComparator
156 : myEvaluator(evaluator) {}
163 class FrameComparator
167 : myInputs(input_list) {}
176 template<
bool Reverse=false>
177 using Priority = Comparator<PriorityComparator, Reverse>;
180 template<
bool Reverse=false>
181 using Index = Comparator<IndexComparator, Reverse>;
184 template<
bool Reverse=false>
186 Comparator<IndexComparator, Reverse, const PDG_NodeArray*>;
190 template<
bool Reverse=false>
192 Comparator<InputComparator, Reverse, const PDG_NodeArray*>;
195 template<
bool Reverse=false>
197 Comparator<AttributeComparator, Reverse, const PDG_AttributeEvaluator*>;
200 template<
bool Reverse=false>
201 using Frame = Comparator<FrameComparator, Reverse, const PDG_NodeArray*>;
206 template <
typename Array>
210 sortItems(work_items, default_options,
nullptr,
nullptr);
215 template <
typename Array>
228 work_items, target_node->
sortOptions(), required_items, &inputs);
232 template <
typename Array>
242 sort_options.
myRequired ? required_items :
nullptr;
247 work_items.sort(
IndexInput<>(reverse, priority_items, inputs));
249 work_items.sort(
Index<>(reverse, priority_items));
254 work_items.sort(
Input<>(reverse, priority_items, inputs));
256 work_items.sort(
Index<>(reverse, priority_items));
261 work_items.sort(
Attribute<>(reverse, priority_items, &evaluator));
265 work_items.sort(
Frame<>(reverse, priority_items, inputs));
static void sortItems(Array &work_items, const PDG_Node *target_node, const PDG_WorkItemConstBoolMap *required_items)
bool myRequired
Sort required items to the beginning of the list.
Comparator< IndexComparator, Reverse > Index
Functor for comparing work items for sorting by index.
static void sortItems(Array &work_items)
Sorts the work items based on index, in ascending order.
Comparator< PriorityComparator, Reverse > Priority
Functor that compares two work item references or pointers by priority.
SYS_FORCE_INLINE T * SYSconst_cast(const T *foo)
void reverse(I begin, I end)
Order by a specific attribute value.
**But if you need a result
Comparator< FrameComparator, Reverse, const PDG_NodeArray * > Frame
Compars work items using their frame value.
Comparator< InputComparator, Reverse, const PDG_NodeArray * > Input
Comparator< AttributeComparator, Reverse, const PDG_AttributeEvaluator * > Attribute
Compares work items using an attribute.
Comparator< IndexComparator, Reverse, const PDG_NodeArray * > IndexInput
Functor for comparing work items for sorting by index and node.
void connectedNodes(PDG_NodeArray &nodes, PDG_PortType type, bool filter_bypassed=true, bool filter_reference=true) const
const PDG_SortOptions & sortOptions() const
Returns the node's sort options struct.
CompareResults OIIO_API compare(const ImageBuf &A, const ImageBuf &B, float failthresh, float warnthresh, ROI roi={}, int nthreads=0)
PDG_WorkItemSortOrder myOrder
The type of sort to use for work items.
UT_StringHolder myAttribute
The sort attribute, used when the sort order is SortAttribute.
static void sortItems(Array &work_items, const PDG_SortOptions &sort_options, const PDG_WorkItemConstBoolMap *required_items, const PDG_NodeArray *inputs)
Sorts the work items based on a sort options struct.
Order by the work item's frame value.
**If you just want to fire and args
bool myDirection
Sort ascending or descending.