OP/OP_Dependency.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.
 *
 * Produced by:
 *      Edward Lam
 *      Side Effects Software Inc.
 *      477 Richmond St. West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        OP_Dependency.h (C++)
 *
 * COMMENTS:
 *              OP_Dependency is used to keep track of op dependencies
 */

#ifndef _OP_Depdency_h_
#define _OP_Depdency_h_

#include "OP_API.h"
#include <stdio.h>
#include <string.h>
#include <UT/UT_Assert.h>
#include "OP_DataTypes.h"

class UT_String;
class CH_Channel;
class PRM_ParmList;

class OP_API OP_RefId
{
public:
    OP_RefId()
    {
        myParmIndex = -1;
        myParmSubIndex = -1;
    }
    ~OP_RefId()
    {
    }

    OP_RefId( const OP_RefId &copy )
    {
        myParmIndex = copy.myParmIndex;
        myParmSubIndex = copy.myParmSubIndex;
    }
    const OP_RefId &operator =( const OP_RefId &copy )
    {
        if( &copy != this )
        {
            myParmIndex = copy.myParmIndex;
            myParmSubIndex = copy.myParmSubIndex;
        }
        return *this;
    }

    bool isValid() const
            { return myParmIndex >= 0; }

    void setParmRef( int parm_index, int sub_index = -1 )
    {
        myParmIndex = parm_index;
        myParmSubIndex = sub_index;
    }
    int getParmRef() const
    {
        UT_ASSERT_P( isValid() );
        return myParmIndex;
    }
    int getParmSubIndex() const
    {
        UT_ASSERT_P( isValid() );
        return myParmSubIndex;
    }

    int operator==( const OP_RefId &other) const
    {
        return( myParmIndex == other.myParmIndex &&
                myParmSubIndex == other.myParmSubIndex );
    }
    // matches() is like operator==() except it also takes into account -1
    // subindices to mean there's no info about them
    bool matches(const OP_RefId &other) const
    {
        if (myParmIndex != other.myParmIndex)
            return false;
        if (myParmSubIndex == -1 || other.myParmSubIndex == -1)
            return true;
        return (myParmSubIndex == other.myParmSubIndex);
    }

    void getToken(const PRM_ParmList &parmlist, UT_String &token) const;
    void getAlias(const PRM_ParmList &parmlist, UT_String &alias) const;

private:
    int             myParmIndex;
    int             myParmSubIndex;
};

class OP_API OP_Reference
{
public:
    OP_Reference()
    {
        myRefOpId = -1;
        myRefCount = 0;
    }
    explicit OP_Reference( int ref_op_id )
    {
        myRefOpId = ref_op_id;
        myRefCount = 1;
    }

    void addRef()
    {
        UT_ASSERT_P( myRefCount >= 0 );
        myRefCount++;
    }
    int removeRef(int count = 1)
    {
        UT_ASSERT_P( myRefCount >= count );
        if( myRefCount >= count )
            myRefCount -= count;
        else
            myRefCount = 0;
        return myRefCount;
    }

    void clearRefOpId()         { myRefOpId = -1; }
    int getRefOpId() const      { return myRefOpId; }
    void setRefOpId(int op_id)  { myRefOpId = op_id; }

    int getRefCount() const     { return myRefCount; }

    int operator==( const OP_Reference &other )
    {
        return myRefOpId == other.myRefOpId;
    }

private:
    int myRefOpId;
    int myRefCount;
};

class OP_API OP_Dependency
{
public:
    OP_Dependency()
    {
        myRefOpId = -1;
        myInterestType = OP_INTEREST_NONE;
    }
    
    // ref_op_id    - The ID of the op who is dependent on our owner
    // source_ref   - A reference to a parm/channel in our owner on which
    //                ref_op_id is dependent
    // ref          - The parm/chan in the dependent that is dependent on our
    //                owner
    // interest     - The kind of interest the dependent will have
    OP_Dependency(int ref_op_id, const OP_RefId &source_ref,
                  const OP_RefId &ref, OP_InterestType interest)
    {
        myRefOpId      = ref_op_id;
        myRef          = ref;
        myInterestType = interest;
        mySourceRef    = source_ref;
    }

    const OP_Dependency &operator=(const OP_Dependency &other);

    void addInterest( OP_InterestType type )
    {
        myInterestType = (OP_InterestType) ((int) myInterestType | type);
    }
    OP_InterestType getInterest() const
    {
        return myInterestType;
    }

    int matches( int ref_op_id, const OP_RefId &ref,
                 OP_InterestType mask = OP_INTEREST_ALL ) const
    {
        return (myRefOpId == ref_op_id && myRef.matches(ref)
                && hasInterest(mask));
    }
    int matches( int ref_op_id, const OP_RefId &source_ref,
                 const OP_RefId &ref,
                 OP_InterestType mask = OP_INTEREST_ALL ) const
    {
        return myRefOpId == ref_op_id && mySourceRef == source_ref && 
               myRef == ref && hasInterest(mask);
    }
    int operator==( const OP_Dependency &other ) const
    {
        return matches( other.myRefOpId, other.mySourceRef, other.myRef );
    }

    // Returns true if the source ref matches exactly the removed parm index
    bool fixRemovedSourceRefParmIndex(int removed_parm_idx)
    {
        if (!mySourceRef.isValid())
            return false;

        if (mySourceRef.getParmRef() == removed_parm_idx)
        {
            UT_ASSERT_P(false);
            mySourceRef.setParmRef(-1, -1);
            return true;
        }
        else if (mySourceRef.getParmRef() > removed_parm_idx)
        {
            mySourceRef.setParmRef(mySourceRef.getParmRef() - 1,
                                   mySourceRef.getParmSubIndex());
        }
        return false;
    }

    int                 getRefOpId() const          { return myRefOpId; }
    void                clearRefOpId()              { myRefOpId = -1; }
    void                setRefOpId( int op_id )     { myRefOpId = op_id; }
    const OP_RefId     &getRefId() const            { return myRef; }
    const OP_RefId     &getSourceRefId() const      { return mySourceRef; }
    OP_InterestType     getInterestType() const     { return myInterestType; }
    int                 hasInterest(OP_InterestType interest) const
                        { return (myInterestType & interest) != 0; }

private:
    int             myRefOpId;
    OP_RefId        mySourceRef;
    OP_RefId        myRef;
    OP_InterestType myInterestType;
};

#endif // _OP_Depdency_h_

---