PDG_File.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_FILE_H
#define PDG_FILE_H

#include "PDG_API.h"

#include <UT/UT_Array.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_ValArray.h>

#include <SYS/SYS_Hash.h>

class UT_JSONValue;
class UT_JSONWriter;
class UT_OptionsHolder;

class PDG_Scheduler;
class PDG_WorkItem;

class PDG_API PDG_File
{
public:
    /// Array of files
    using Array         = UT_Array<PDG_File>;

    /// Set of files, which uses the default clear struct defined at the 
    /// bottom of this file
    using Set           = UT_ArraySet<PDG_File>;

    /// The file hash/modtime type
    using Hash          = int64;
    using HashArray     = UT_ValArray<Hash>;

    /// Enumeration of file types, used to maintain whether the file is an
    /// expected output, a generated output, or a file reported at cook time.
    enum FileType
    {
        eFileGenerated,
        eFileExpected,
        eFileRuntime,
        eFileRuntimeExpected,
    };

    /// Default/invalid hash value
    static constexpr Hash           theInvalidHash = 0;

    /// JSON Serialization keys
    static const UT_StringHolder    theDataKey;
    static const UT_StringHolder    theTagKey;
    static const UT_StringHolder    theHashKey;
    static const UT_StringHolder    theSizeKey;
    static const UT_StringHolder    theOwnKey;
    static const UT_StringHolder    theTypeKey;

    /// Global empty file and empty file list statics
    static const PDG_File           theEmptyFile;
    static const Array              theEmptyFileArray;

public:

                                PDG_File();
                                PDG_File(const UT_StringHolder& data,
                                         bool own);
                                PDG_File(const UT_StringHolder& data,
                                         const UT_StringHolder& tag,
                                         Hash hash,
                                         bool own);
                                PDG_File(const UT_StringHolder& data,
                                         const UT_StringHolder& tag,
                                         Hash hash,
                                         FileType type,
                                         bool own);

    int64                       getMemoryUsage(bool inclusive) const;
    /// Updates and return the local_path
    UT_StringHolder             localizePath(
                                    const PDG_Scheduler* scheduler) const;

    bool                        isExpected() const  { 
                                    return (myType == eFileExpected); }
    bool                        isGenerated() const { 
                                    return (myType == eFileGenerated); }

    /// Return the local path.  Note that this will not do the old __PDG_DIR__
    /// localization automatically, call `localizePath` first.
    const UT_StringHolder&      local_data() const;
    void                        setLocalData(const UT_StringHolder& local_data);
    const UT_StringHolder&      data() const { return myData; }
    void                        setData(const UT_StringHolder& data);

    const UT_StringHolder&      tag() const { return myTag; }
    void                        setTag(const UT_StringHolder& tag);

    Hash                        hash() const { return myHash; }
    void                        setHash(Hash hash);

    PDG_File::FileType          type() const { return myType; }
    void                        setType(FileType type);

    exint                       size() const { return mySize; }
    void                        setSize(exint size);

    bool                        own() const { return myOwn; }
    void                        setOwn(bool own);

    void                        updateStat(
                                    const PDG_WorkItem* work_item,
                                    bool force);
    void                        clearStat();

    bool                        operator==(const PDG_File& other)  const;
    bool                        operator!=(const PDG_File& other)  const;
    bool                        operator<(const PDG_File& other) const;
    bool                        operator<=(const PDG_File& other) const;
    bool                        operator>(const PDG_File& other) const;
    bool                        operator>=(const PDG_File& other) const;

    void                        save(UT_JSONWriter& writer) const;
    void                        save(UT_OptionsHolder& dict) const;

    bool                        load(const UT_JSONValue& value,
                                     bool strict=true);
    bool                        load(
                                    const UT_OptionsHolder& dict,
                                    bool strict=true);

    /// Saves a file array to json
    static void                 save(const Array& array, UT_JSONWriter& writer);

    /// Saves a file array to UT_Options
    static void                 save(
                                    const Array& array,
                                    const UT_StringHolder& key,
                                    UT_OptionsHolder& dict);

    /// Loads a fle array from json
    static bool                 load(Array& array,
                                     const UT_JSONValue& value,
                                     bool strict=true);

    /// Loads a file array from a dict
    static bool                 load(
                                    Array& array,
                                    const UT_StringHolder& key,
                                    const UT_OptionsHolder& options,
                                    bool strict=true);

private:
    mutable UT_StringHolder     myLocalData;
    UT_StringHolder             myData;
    UT_StringHolder             myTag;
    Hash                        myHash;
    exint                       mySize;
    FileType                    myType;
    bool                        myOwn;
};

SYS_FORCE_INLINE size_t hash_value(const PDG_File& file)
{
    SYS_HashType hash = hash_value(file.data());
    SYShashCombine(hash, hash_value(file.tag()));
    //The hash and ownership flag shouldn't be considered
    //when comparing work items
    SYShashCombine(hash, file.type());
    return hash;
}

namespace UT
{
    template <typename T>
    struct DefaultClearer;

    template <>
    struct DefaultClearer<PDG_File>
    {
        static void         clear(PDG_File& file)
                                { file = PDG_File::theEmptyFile; }
        static bool         isClear(const PDG_File& file)
                                { return (file == PDG_File::theEmptyFile); }
        static void         clearConstruct(PDG_File *p)
                                { new ((void *)p) PDG_File(); }
        static const bool   clearNeedsDestruction = false;
    };
}

#endif