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_Types.h"

#include <UT/UT_ArrayMap.h>
#include <UT/UT_Map.h>
#include <UT/UT_StringMap.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_WorkItemSet>;

public:
    /// Constructs a new partition holder
                                PDG_PartitionHolder();

    /// 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
    void                        addItemToAllPartitions(PDG_WorkItem* work_item);

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

    /// Sets the frame for the partition with the given name
    void                        setPartitionFrame(
                                            const UT_StringHolder& name,
                                            OptionalFrame 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_WorkItemSet&      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; }

    /// Return the frame specified for the partition with the given index
    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();

private:
    using IndexFrameMap         = UT_Map<int, OptionalFrame>;
    using StringFrameMap        = UT_StringMap<OptionalFrame>;
    using StringMap             = UT_ArrayMap<UT_StringHolder, PDG_WorkItemSet>;

    IndexMap                    myPartitions;
    IndexMap                    myRequiredMap;
    IndexFrameMap               myFrameMap;

    StringMap                   myNamedPartitions;
    StringMap                   myNamedRequiredMap;
    StringFrameMap              myNamedFrameMap;

    PDG_WorkItemSet             myAllSet;
    PDG_WorkItemArray           mySplitMissing;

    UT_StringHolder             mySplitAttrib;
    UT_StringHolder             mySplitValue;
    int                         myMaxIndex;
    int                         myIndexOffset;
    int                         myNumPartitions;
    bool                        myIsSplitting;
};

#endif