PDG_PartitionHolder.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_PARTITION_HOLDER
#define PDG_PARTITION_HOLDER

#include "PDG_API.h"
#include "PDG_WorkItemTypes.h"

#include <UT/UT_ArrayMap.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_WorkBuffer.h>

class PDG_WorkItem;
 
/**
 * Factory/holder object that creates or updates partitions
 */
class PDG_API PDG_PartitionHolder
{
public:
    using IndexMap  = UT_ArrayMap<int, PDG_WorkItemIDSet>;

public:
    /// Constructs a new partition holder with a list of valid work items
                                PDG_PartitionHolder(
                                    const PDG_WorkItemArray& work_item);

    /// Adds a work item to the partition with the specified index
    bool                        addItemToPartition(
                                            PDG_WorkItemID id,
                                            int index,
                                            bool required,
                                            UT_WorkBuffer& errors);

    /// Adds a work item to the partition with the specified index
    bool                        addItemToPartition(
                                            PDG_WorkItem* work_item,
                                            int index,
                                            bool required,
                                            UT_WorkBuffer& errors);

    /// Adds a work item to the partition with the specified name
    bool                        addItemToPartition(
                                            PDG_WorkItem* work_item,
                                            const UT_StringHolder& name,
                                            bool required,
                                            UT_WorkBuffer& errors);

    /// Adds a work item to all partitions, without having to know the indices
    /// or number of partitions that exist
    bool                        addItemToAllPartitions(
                                            PDG_WorkItem* work_item,
                                            UT_WorkBuffer& errors);

    /// Sets the frame for the partition with the given index.
    void                        setPartitionFrame(
                                            int index,
                                            fpreal frame);

    /// Sets the frame for the partition with the given name
    void                        setPartitionFrame(
                                            const UT_StringHolder& name,
                                            fpreal frame);

    /// Returns the partition map
    const IndexMap&             partitions() const
                                    { return myPartitions; }

    /// Returns the items that should be marked as required for each partition
    const IndexMap&             required() const
                                    { return myRequiredMap; }

    /// Returns the all set, e.g. the set of items that should be added to all
    /// partitions
    const PDG_WorkItemIDSet&    allSet() const
                                    { return myAllSet; }


    /// Returns the current max index of all partitions added to the holder
    int                         maxIndex() const
                                    { return myMaxIndex; }

    /// Returns the number of partitions added to the holder. This is reset 
    /// after setSplitValue is called.
    int                         numPartitions() const
                                    { return myNumPartitions; }

    /// Returns the split attribute name
    const UT_StringHolder&      splitAttribute() const
                                    { return mySplitAttrib; }

    /// Returns the current split attribute value
    const UT_StringHolder&      splitValue() const
                                    { return mySplitValue; }

    /// Returns true if this holder is being used for partitioning with a
    /// split attribute.
    bool                        isSplitting() const
                                    { return myIsSplitting; }

    /// Returns the array of work items that are missing the split attribute,
    /// or nullptr if isSplitting() returns false;
    const PDG_WorkItemArray&    splitMissing() const
                                    { return mySplitMissing; }
    PDG_WorkItemArray&          splitMissing()
                                    { return mySplitMissing; }

    /// Returns the input work item for the specifed ID, or null if the ID
    /// is not a valid input
    PDG_WorkItem*               partitionInput(PDG_WorkItemID id) const
                                    {
                                        auto&& iter = myWorkItemMap.find(id);
                                        if (iter == myWorkItemMap.end())
                                            return nullptr;

                                        return iter->second;
                                    }

    /// Return the frame specified for the partition with the given index
    PDG_OptionalFrame           frameForPartition(int index) const;

    /// Returns true if the holder only consists of entries in the All Set.
    bool                        isAllSetOnly() const;
    
    /// Sets the global split attribute information for this holder. Called
    /// once during partitioning with a split attribute.
    void                        setSplitInfo(const UT_StringHolder& name);

    /// Sets the local split attribute information for this holder. Called
    /// once for each split attribute value during partitioning.
    void                        setSplitValue(const UT_StringHolder& value,
                                              int index_offset);

    /// Converts named partitions into real partitions
    void                        resolveNames();

    /// Determines the loop stack work item for a set of work item IDs, and
    /// returns false if the IDs don't form a valid partition for a loop.
    bool                        checkLoop(
                                        UT_WorkBuffer& errors,
                                        const PDG_WorkItemIDSet& ids,
                                        PDG_WorkItem** current_item,
                                        bool check_all) const;

    /// Determines the loop stack work item for a list of work items, and
    /// return false if the items don't form a valid partition for a loop
    bool                        checkLoop(
                                        UT_WorkBuffer& errors,
                                        const PDG_WorkItemArray& work_items,
                                        PDG_WorkItem** current_item) const;

private:
    bool                        validForLoop(
                                        UT_WorkBuffer& errors,
                                        PDG_WorkItem* work_item,
                                        PDG_WorkItem** current_item,
                                        int* current_size) const;
    bool                        validForLoop(
                                        UT_WorkBuffer& errors,
                                        const PDG_WorkItemIDSet& ids,
                                        PDG_WorkItem** current_item,
                                        int* current_size) const;

private:
    using IndexFrameMap         = UT_ArrayMap<int, fpreal>;
    using StringFrameMap        = UT_ArrayStringMap<fpreal>;
    using StringMap             = UT_ArrayStringMap<PDG_WorkItemIDSet>;

    IndexMap                    myPartitions;
    IndexMap                    myRequiredMap;
    IndexFrameMap               myFrameMap;

    StringMap                   myNamedPartitions;
    StringMap                   myNamedRequiredMap;
    StringFrameMap              myNamedFrameMap;

    PDG_WorkItemIDSet           myAllSet;
    PDG_WorkItemArray           mySplitMissing;

    PDG_WorkItemIDMap           myWorkItemMap;

    UT_StringHolder             mySplitAttrib;
    UT_StringHolder             mySplitValue;

    int                         myMaxIndex;
    int                         myIndexOffset;
    int                         myNumPartitions;

    bool                        myIsSplitting;
    bool                        myHasLoopInputs;
};

#endif