dataManagerBasedExecutor.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_DATA_MANAGER_BASED_EXECUTOR_H
#define PXR_EXEC_VDF_DATA_MANAGER_BASED_EXECUTOR_H


#include "pxr/pxr.h"

#include "pxr/exec/vdf/executorInterface.h"
#include "pxr/exec/vdf/output.h"
#include "pxr/exec/vdf/vector.h"

PXR_NAMESPACE_OPEN_SCOPE


template<typename DataManagerType, typename BaseClass>
class VdfDataManagerBasedExecutor : public BaseClass
{
public:

    VdfDataManagerBasedExecutor() {}

    explicit VdfDataManagerBasedExecutor(
        const VdfExecutorInterface *parentExecutor) :
        BaseClass(parentExecutor)
    {}

    virtual ~VdfDataManagerBasedExecutor() {}

    virtual void Resize(const VdfNetwork &network) override {
        _dataManager.Resize(network);
    }

    virtual void SetOutputValue(
        const VdfOutput &output,
        const VdfVector &value,
        const VdfMask &mask) override {
        _dataManager.SetOutputValue(output, value, mask);
    }

    virtual bool TakeOutputValue(
        const VdfOutput &output,
        VdfVector *value,
        const VdfMask &mask) override {
        return _dataManager.TakeOutputValue(output, value, mask);
    }

    virtual void DuplicateOutputData(
        const VdfOutput &sourceOutput,
        const VdfOutput &destOutput) override {
        _dataManager.DuplicateOutputData(sourceOutput, destOutput);
    }

    virtual bool IsEmpty() const override {
        return _dataManager.IsEmpty();
    }

    virtual bool HasInvalidationTimestampMismatch(
        const VdfOutput &source, 
        const VdfOutput &dest) const override {
        return _dataManager.HasInvalidationTimestampMismatch(
            _dataManager.GetDataHandle(source.GetId()),
            _dataManager.GetDataHandle(dest.GetId()));
    }

protected:

    virtual const VdfVector *_GetInputValue(
        const VdfConnection &connection,
        const VdfMask &mask) const override {
        return _dataManager.GetInputValue(connection, mask);
    }

    virtual const VdfVector *_GetOutputValueForReading(
        const VdfOutput &output,
        const VdfMask &mask) const override {
        return _dataManager.GetOutputValueForReading(
            _dataManager.GetDataHandle(output.GetId()), mask);
    }

    virtual VdfVector *_GetOutputValueForWriting(
        const VdfOutput &output) const override {
        return _dataManager.GetOrCreateOutputValueForWriting(
            output, _dataManager.GetDataHandle(output.GetId()));
    }

    void _ClearDataForOutput(
        const VdfId outputId, const VdfId nodeId) override {
        _dataManager.ClearDataForOutput(outputId);
    }

    virtual bool _IsOutputInvalid(
        const VdfId outputId,
        const VdfMask &invalidationMask) const override {
        return _dataManager.IsOutputInvalid(outputId, invalidationMask);
    }

    virtual bool _InvalidateOutput(
        const VdfOutput &output,
        const VdfMask &invalidationMask) override
    {
        return _dataManager.InvalidateOutput(output, invalidationMask);
    }

    virtual void _UpdateInvalidationTimestamp() override
    {
        _dataManager.UpdateInvalidationTimestamp(
            BaseClass::GetExecutorInvalidationTimestamp());
    }

    virtual void _SetReferenceOutputValue(
        const VdfOutput &destOutput,
        const VdfOutput &sourceOutput,
        const VdfMask &sourceMask) const override {
        // XXX: We are getting the cached output value from the executor, which
        //      may give us a pointer into the parent executor data manager. We
        //      cannot take ownership of values stored outside of this
        //      executor's data manager. We have to come up with a way to
        //      support reference outputs as a core concept! 
        const VdfVector *sourceValue =
            _GetOutputValueForReading(sourceOutput, sourceMask);
        _dataManager.SetReferenceOutputValue(sourceValue, destOutput.GetId());
    }

    virtual void _TouchOutput(const VdfOutput &output) const override
    {
        _dataManager.DataManagerType::Base::Touch(output);
    }


protected:

    // This object manages the data needed for this executor, including all
    // the cached output values.
    DataManagerType _dataManager;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif