PDG_CookState.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_COOK_STATE_H
#define PDG_COOK_STATE_H

#include "PDG_API.h"

#include "PDG_CookOptions.h"
#include "PDG_Filter.h"
#include "PDG_NodeTypes.h"
#include "PDG_SchedulerTypes.h"

#include <UT/UT_StringArray.h>

class PDG_Graph;
class PDG_Scheduler;
class UT_WorkBuffer;

/**
 * Contains various state associated with a cook, e.g. the set of nodes being
 * cooked, the fringe set, the filters, etc
 */
class PDG_API PDG_CookState
{
public:
                                PDG_CookState();

    bool                        prepare(const PDG_Graph& graph,
                                        const PDG_CookOptions& options,
                                        PDG_Scheduler* default_scheduler,
                                        const PDG_SchedulerArray& schedulers,
                                        UT_WorkBuffer& errors);
    void                        clear();

    const PDG_CookOptions&      options() const
                                    { return myOptions; }
    PDG_CookOptions&            options()
                                    { return myOptions; }

    bool                        isGenerateOnly() const;
    bool                        isCook() const;

    PDG_CookOptions::CookType   cookType() const    
                                    { return myOptions.myCookType; }
    const UT_StringArray&       nodeNames() const
                                    { return myOptions.myNodeNames; }

    bool                        autoRecook() const
                                    { return myOptions.myAutoRecook; }
    int                         autoRecookInterval() const
                                    { return myOptions.myAutoRecookInterval; }
    bool                        blocking() const
                                    { return myOptions.myBlocking; }
    const PDG_Filter&           staticFilter() const
                                    { return myOptions.myStaticFilter; }
    fpreal                      cookTime() const
                                    { return myOptions.myCookTime; }

    bool                        isSaveScene() const
                                    { return myOptions.mySaveScene; }
    bool                        isStaticCook() const
                                    { return myIsStaticCook; }

    const PDG_NodeSet&          cookSet() const
                                    { return myCookSet; }
    const PDG_NodeSet&          leafSet() const
                                    { return myLeafSet; }
    const PDG_NodeSet&          errorSet() const
                                    { return myErrorSet; }
    const PDG_SchedulerSet&     schedulers() const
                                    { return mySchedulers; }

    void                        incCookCount()
                                    { myCookCount++; }
    int                         cookCount() const
                                    { return myCookCount; }

private:
    PDG_CookOptions             myOptions;
    PDG_NodeSet                 myCookSet;
    PDG_NodeSet                 myLeafSet;
    PDG_NodeSet                 myErrorSet;
    PDG_SchedulerSet            mySchedulers;
    int                         myCookCount;
    bool                        myIsStaticCook;
};

#endif