PDG_CheckpointManager.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_CHECKPOINT_MANAGER_H__
#define __PDG_CHECKPOINT_MANAGER_H__

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

#include <UT/UT_Array.h>
#include <UT/UT_OFStream.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_TBBSpinLock.h>

class PDG_WorkItem;

/**
 * Helper class for queuing and writing checkpoint files
 */
class PDG_API PDG_CheckpointManager
{
public:
                                PDG_CheckpointManager();

    void                        setEnabled(bool enabled)
                                    { myIsEnabled = enabled; }
    void                        setCheckpointRate(exint rate)
                                    { myCheckpointRate = rate; }
    bool                        setFilePath(
                                    const UT_StringHolder& path,
                                    UT_WorkBuffer& errors);

    bool                        enabled() const
                                    { return myIsEnabled; }

    void                        writeAddedDependency(
                                    const PDG_WorkItem* from,
                                    const PDG_WorkItem* to,
                                    bool required,
                                    bool user_defined,
                                    bool immediate);
    void                        writeGeneratedItems(
                                    const PDG_WorkItemArray& work_items);
    void                        writeGeneratedBatches(
                                    const PDG_BatchWorkItemSet& batches);
    void                        writeExistingItems(
                                    const PDG_WorkItemArray& work_items,
                                    bool immediate);
    void                        writeCookedItem(
                                    const PDG_WorkItem* work_item,
                                    bool immediate);

    void                        flush();

private:
    void                        flushPendingWrites(bool force);
    void                        writeDependencyPair(
                                    const PDG_WorkItem* from,
                                    const PDG_WorkItem* to,
                                    bool required,
                                    bool user_defined,
                                    bool immediate);
    void                        writeWorkItemArray(
                                    const PDG_WorkItemArray& work_items);

private:
    enum EntryType
    {
        eWorkItem,
        eDependency,
    };

    struct Entry
    {
        const PDG_WorkItem*         myWorkItem;

        const PDG_WorkItem*         myDependency;
        bool                        myDependencyRequired;
        bool                        myDependencyUserDefined;

        EntryType                   myType;
    };

private:
    UT_Array<Entry>             myPendingEntries;
    UT_OFStream                 myOutputStream;
    UT_StringHolder             myFilePath;

    PDG_SerializationOptions    myUpdateOptions;
    PDG_SerializationOptions    myInitialOptions;

    exint                       myCheckpointRate;

    mutable UT_TBBSpinLock      myLock;
    bool                        myIsEnabled;
};

#endif