PDG_AttributeFile.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_ATTRIBUTE_FILE_H__
#define __PDG_ATTRIBUTE_FILE_H__

#include "PDG_API.h"

#include "PDG_AttributeArray.h"
#include "PDG_File.h"

#include <UT/UT_StringHolder.h>

class PDG_AttributeEvaluator;
class UT_JSONValue;
class UT_JSONWriter;
class UT_OptionsHolder;

/**
 * File array attribute type
 */
class PDG_API PDG_AttributeFile : public PDG_AttributeArray<
                                                PDG_AttributeType::eFileArray,
                                                PDG_File,
                                                PDG_File::Array>
{
public:
    using Base = PDG_AttributeArray<PDG_AttributeType::eFileArray,
                                    PDG_File,
                                    PDG_File::Array>;
    using Base::Base;
    using Base::values;
    using Base::appendValue;

    /// Enumeration of different file types that can be queried from the
    /// attribute
    enum QueryType
    {
        /// Return any file type (real or expected)
        eQueryAny,

        /// Only return actual files that have been reported back to the
        /// task, not including any pending expected outputs
        eQueryReal,

        /// Only return expected outputs, and skip real files
        eQueryExpected
    };

public:

                                ~PDG_AttributeFile() override;

    /// Returns the total memory usage of all data on this attribute
    int64                       getMemoryUsage(bool inclusive) const override;

    /// Constructs a new file attribute that copies the data from this
    /// attribute
    PDG_AttributeData*          clone() const override;

    /// Writes the file data to the json writer, using the JSON serialization
    /// logic from PDG_File itself
    bool                        saveData(UT_JSONWriter& writer) const override;

    /// Writes the file data to the UT_OptionsHolder, using the serialization
    /// logic from PDG_File itself
    void                        saveData(
                                    const UT_StringHolder& key,
                                    UT_OptionsHolder& dict) const override;

    /// Reads the file data from the json value, using the deserialization
    /// logic on PDG_File itself
    bool                        loadData(const UT_JSONValue& value) override;

    /// Reads the file data from the dict
    bool                        loadData(
                                    const UT_StringHolder& key,
                                    const UT_OptionsHolder& dict) override;
    
    /// Removes all expected files from the array
    bool                        clearExpected();

    /// Removes all files that match the input filter set
    void                        clearMatching(const PDG_File::Set& file_set);


    /// Appends a file to the array, given the specified work item, path,
    /// file tag, hash, file type, owernship flag. Optionally replaces any
    /// matching expected outputs if they're found in the array
    const Data&                 appendValue(
                                    const PDG_WorkItem* work_item,
                                    const UT_StringHolder& path,
                                    const UT_StringHolder& tag,
                                    PDG_File::Hash hash,
                                    PDG_File::FileType file_type,
                                    bool own,
                                    bool replace_expected);

    /// Appends a file to the array using a reference to a file object.
    /// Optionally replaces any expected outputs if they're found in the array
    const Data&                 appendValue(
                                    const Data&,
                                    bool replace_expected);

    /// Returns all file paths that match the query type
    void                        values(
                                    Array& values,
                                    QueryType query=eQueryReal) const;

    /// Returns all file paths with the specified tag that match the query
    /// type
    void                        valuesForTag(
                                    Array& values,
                                    const UT_StringHolder& tag,
                                    QueryType query=eQueryReal) const;

    /// Returns the first matching file, starting from the specified index,
    /// that has the requested tag and type
    PDG_AttributeCast           valueForTag(
                                    Data& value,
                                    int index,
                                    const UT_StringHolder& tag,
                                    QueryType query=eQueryReal) const;

    /// Returns all file values using the configuration of the attribute
    /// evaluator object, filtered by the query type
    PDG_AttributeCast           valuesForEvaluator(
                                    UT_WorkBuffer& buffer,
                                    const PDG_AttributeEvaluator& evaluator,
                                    QueryType query=eQueryReal) const;
};

#endif