PDG_SerializationOptions.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_SERIALIZATION_OPTIONS_H__
#define __PDG_SERIALIZATION_OPTIONS_H__

#include "PDG_API.h"
#include "PDG_AttributeMap.h"

#include <UT/UT_Compression.h>
#include <UT/UT_StringHolder.h>

/*
 * Configuration options for serializing work items
 */
struct PDG_API PDG_SerializationOptions
{
    /// Enumeration of supported file compression t ypes
    enum CompressType
    {
        eCompressAutomatic,
        eCompressNone,
        eCompressGZip,
    };

    /// Constructs a new serialization struct with default values (automatic
    /// compression, flattened attributes, etc)
    PDG_SerializationOptions()
        : myAttribSaveType(PDG_AttributeMap::eSaveFlatten)
        , myCompressType(eCompressAutomatic)
        , myBinary(false)
        , myRecursive(false)
        , myPrettyPrint(false)
        , mySkipDefault(false)
        , mySaveGlobalAttributes(false)
        , mySaveBoundAttributes(false) {}

    /// Converts the compression settings and optional file path to a 
    /// UT_CompressionType. If the CompressType type is Automatic, then the
    /// extension on the file is used to determine whether or not gzip
    /// compression should be used
    UT_CompressionType          compressionType(
                                    const UT_StringHolder* file_path=nullptr) const
    {
        return compressionType(myCompressType, file_path);
    }

    /// Static version of the compressionType, whichc can be called without
    /// any arguments
    static UT_CompressionType   compressionType(
                                    CompressType compress_type,
                                    const UT_StringHolder* file_path=nullptr)
    {
        if (compress_type == PDG_SerializationOptions::eCompressGZip)
            return UT_COMPRESSION_TYPE_GZIP;
        else if (compress_type == PDG_SerializationOptions::eCompressNone)
            return UT_COMPRESSION_TYPE_NONE;

        if (!file_path || !isGZipFile(*file_path))
            return UT_COMPRESSION_TYPE_NONE;

        return UT_COMPRESSION_TYPE_GZIP;
    }

    /// Returns true if the specified file has the .gz extension, otherwise
    /// return false
    static bool                 isGZipFile(const UT_StringHolder& file_path)
    {
        const char* ext = UT_StringWrap(file_path).fileExtension();
        if (!ext)
            return false;
        return (SYSstrcasecmp(ext,".gz") == 0);
    }

    /// The attribute data flattening mode
    PDG_AttributeMap::SaveType      myAttribSaveType;

    /// Serialization compression mode
    CompressType                    myCompressType;

    /// Whether or not the work item should be stored as binary data
    bool                            myBinary;

    /// Whether or not the serialization should recurse into batches
    bool                            myRecursive;

    /// Whether or not the serialization should be human-readable or use
    /// minimal whitespace.
    bool                            myPrettyPrint;

    /// Whether or not the serialization should skip fields that are 
    /// at their default value
    bool                            mySkipDefault;

    /// Whether or not graph level global attributes should be saved
    bool                            mySaveGlobalAttributes;

    /// Whether or not bound attributes should be saved
    bool                            mySaveBoundAttributes;
};

#endif