UT_PackageUtils.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.
 *
 * NAME: UT_PackageUtils.h
 *
 * COMMENTS:    Package utility classes and helpers.
 */

#ifndef UT_PackageUtils_H
#define UT_PackageUtils_H

#include "UT_API.h"
#include "UT_Array.h"
#include "UT_SharedPtr.h"
#include "UT_StringMap.h"
#include "UT_StringSet.h"
#include "UT_StringStream.h"
#include "UT_VarScan.h"
#include <SYS/SYS_Platform.h>
#include <SYS/SYS_VersionUtil.h>
#include <hboost/any.hpp>
#include <tools/henv.h>
#include <tools/hpath.h>

#include <cctype>
#include <iostream>

namespace UT_Package
{
namespace utils
{
const UT_StringHolder klog_error    = "ERROR";
const UT_StringHolder klog_info     = "INFO";
const UT_StringHolder klog_warning  = "WARNING";
const UT_StringHolder kvardef_sep   = "-";

static const char *path_sep()
{
    return PATH_SEP_STRING;
}

static char path_sep_char()
{
    return PATH_SEP_CHAR;
}

static const char *vardef_sep()
{
    return "-";
}

static UT_StringHolder makeVarRef(const char * var)
{
    // note: this helper is typically used with utils::expandVar
    UT_WorkBuffer wb;
    wb.format("${}", var);
    return wb;
}

/*
Build an array of unset variables found in a given value expression.
Update a dependency map to hold dependency information between variables.
May returns a list of variables marked as circular dependent. 
*/
static bool buildVarDependency(
    UT_StringHolder const&      var_name,
    const char *                var_value, 
    UT_StringArray&             unset_vars,
    UT_StringMap<UT_StringSet>& vars_dep_map,
    UT_StringMap<UT_StringSet>& vars_circ_dep)
{
    struct Lookup
    {
        struct Data
        {
            Data(UT_StringHolder const&     var_name,
                UT_StringArray&             unset_vars,
                UT_StringMap<UT_StringSet>& vars_dep_map,
                UT_StringMap<UT_StringSet>& vars_circ_dep)
                : myVarName(var_name)
                , myUnsetVars(unset_vars)
                , myVarsDepMap(vars_dep_map)
                , myVarsCircDepMap(vars_circ_dep)
            {
            }

            /*
                Check if var is set in the environment, if not, we add 
                it to a list of unset vars. Also catch any circular 
                reference between var and myVarName.
            */
            const char* process(UT_StringHolder const& var)
            {
                if (var == myVarName)
                {
                    // nothing to do
                    return nullptr;
                }

                // Make myVarName dependent of var
                auto && it = myVarsDepMap.find(myVarName);              
                if (it != myVarsDepMap.end())
                {
                    it->second.insert(var);
                }
                else
                {
                    UT_StringSet var_dep_set;
                    var_dep_set.insert(var);

                    myVarsDepMap[myVarName] = var_dep_set;
                }

                // Check circular reference between the var to process 
                // and myVarName
                myCircularDependency = false;
                if (checkCircularDep(myVarName, var))
                {
                    auto && it = myVarsCircDepMap.find(myVarName);              
                    if (it != myVarsCircDepMap.end())
                    {
                        it->second.insert(var);
                    }
                    else
                    {
                        UT_StringSet var_circ_dep_set;
                        var_circ_dep_set.insert(var);

                        myVarsCircDepMap[myVarName] = var_circ_dep_set;
                    }

                    myCircularDependency = true;
                    return nullptr;
                }

                const char* value = HoudiniGetenv(var.c_str());
                if (!value)
                {
                    myUnsetVars.append(var, true /*check for duplicates*/);
                }

                // all fine
                return value;
            }

            /* 
                Returns true is there is a circular dependency between 
                a dependent and a dependee variable. 
            */
            bool checkCircularDep(UT_StringHolder const& dependent_var, UT_StringHolder const& dependee_var)
            {
                auto && dependent = myVarsDepMap.find(dependent_var);
                if (dependent == myVarsDepMap.end())
                {
                    return false;
                }

                auto && dependee = myVarsDepMap.find(dependee_var);
                if (dependee == myVarsDepMap.end())
                {
                    return false;
                }

                // Check explicit circular reference
                if (dependent->second.contains(dependee_var) && dependee->second.contains(dependent_var))
                {
                    return true;
                }

                // Check implicit circular reference
                return checkImplicitCircularDep(dependent_var, dependent->second);
            }

            /*
                Find an implicit circular dependency between a dependent 
                and a dependee variable. The function looks for a matching 
                dependent in its dependee set. If nothing is found, it 
                continues recursively by querying the dependent map with 
                each dependee of the dependent variable.
            */
            bool checkImplicitCircularDep(UT_StringHolder const& dependent_var, UT_StringSet const& dependee_set)
            {
                if (dependee_set.contains(dependent_var))
                {
                    return true;
                }

                for (auto && dependee_var : dependee_set)
                {
                    auto && dependee = myVarsDepMap.find(dependee_var);

                    if (dependee == myVarsDepMap.end())
                    {
                        continue;
                    }

                    if (checkImplicitCircularDep(dependent_var, dependee->second))
                    {
                        return true;
                    }
                }

                return false;
            }

            bool                        myCircularDependency = false;
            UT_StringArray&             myUnsetVars;
            const UT_StringHolder&      myVarName;
            UT_StringMap<UT_StringSet>& myVarsDepMap;
            UT_StringMap<UT_StringSet>& myVarsCircDepMap;
        };

        static const char *
        callback(const char *arg, void *user_data)
        {
            Data& data = *(Data*)user_data;

            return data.process(arg);
        }
    };

    Lookup::Data data(var_name, unset_vars, vars_dep_map, vars_circ_dep);

    UT_WorkBuffer result;
    UTVariableScan(result, var_value, Lookup::callback, &data);
    return !data.myCircularDependency;
}

static UT_StringHolder expandVar(const char *arg, bool want_marker)
{    
    // Return expanded env var (arg) if set, otherwise return the path 
    // marker (&) if arg is unset.

    struct Lookup
    {
        struct Data
        {
            Data() : myWantMarkerFlag(false)
            {
            }

            UT_WorkBuffer myWB;
            bool myWantMarkerFlag;
        };

        // Lookup callback to return the value of an env var (arg) or a 
        // marker if arg is unset.
        static const char *
        callback(const char *arg, void *data)
        {
            const char *value = Lookup::getValue(arg, data);

            Lookup::Data* p = (Lookup::Data*)data;
            if (p->myWantMarkerFlag)
            {
                return value ? value : "&";
            }
            return value;
        }

        // Returns the value of an env var (arg). If arg is formatted with
        // a default value like VAR-DEFAULT, DEFAULT is expanded if VAR is 
        // unset, otherwise it returns the value of VAR.
        static const char *
        getValue(const char *arg, void* data)
        {
            Lookup::Data* p = (Lookup::Data*)data;
            UT_StringArray tokens;
            UT_String(arg).tokenize(tokens, vardef_sep());
            if (tokens.size() > 1)
            {
                // use left token as var name
                const char* expanded_var = HoudiniGetenv(tokens[0].c_str());
                if (expanded_var)
                {
                    return expanded_var;
                }

                // Left token is undefined. Assembles, expands and returns 
                // the right token value.
                UT_String right_token;
                right_token = tokens[1];
                for (exint i=2; i<tokens.size(); i++)
                {
                    right_token += vardef_sep();
                    right_token += tokens[i];
                }

                p->myWB = utils::expandVar(right_token.c_str(), p->myWantMarkerFlag);
                return p->myWB.buffer();
            }
            return HoudiniGetenv(arg);
        }
    };

    Lookup::Data data;
    data.myWantMarkerFlag = want_marker;

    UT_WorkBuffer result;
    UTVariableScan(result, arg, Lookup::callback, &data);    
     
    return result.buffer();
}

static UT_StringHolder makeVarRefPlatform(const char * var)
{
    UT_WorkBuffer wb;
#if defined(WIN32)    
    wb.format("%%{}%%", var);
#else
    wb.format("${}", var);
#endif
    return wb;
}

static bool isCmdShell()
{
#if defined(WIN32)
    char const * shell = ::HoudiniGetenv("SHELL");
    if (shell && strstr(shell, "cmd.exe"))
    {
        return true;
    }
#endif
    return false;
}

static const char *pathSepShell()
{
#if defined(WIN32)    
    if (isCmdShell())
    {
        return ";";
    }
#endif
    return ":";
}

// Convert all '\' separators to '/' on all platforms.
static void normalizePath( UT_String& path_var)
{
    if (!path_var.length())
    {
        return;
    }

    path_var.substitute( '\\', '/' );
}

struct Factory
{
    template <typename T, typename... Args>
    static UT_SharedPtr<T> make(Args &&... args)
    {
        return UTmakeShared<T>(std::forward<Args>(args)...);
    }
};

// Helper for handling Houdini version values
class HVersion
{
    public:
    HVersion() 
        : myMajor(-1)
        , myMinor(-1)
        , myBuild(-1)
        , myPatch(-1)
    {
    }

    int compare( HVersion const & other, bool full=true ) const
    {
        if (full)
        {
            return SYSversionCompare(
                myMajor, myMinor, myBuild, myPatch, 
                other.myMajor, other.myMinor, other.myBuild, other.myPatch);
        }

        if (myMajor != other.myMajor) 
        {
            return myMajor - other.myMajor;
        }
        
        // compare the rest if the other components are provided (!= -1)
        
        if (other.myMinor != -1 && myMinor != other.myMinor) 
        {
            return myMinor - other.myMinor;
        }

        if (other.myBuild != -1 && myBuild != other.myBuild) 
        {
            return myBuild - other.myBuild;
        }
        if (other.myPatch != -1 && myPatch != other.myPatch) 
        {
            return myPatch - other.myPatch;
        }
        return 0;
    }

    bool operator > (HVersion const & other) const
    {
        return compare(other) > 0;
    }

    bool operator >= (HVersion const & other) const
    {
        return operator>(other) || operator==(other);
    }

    bool operator < (HVersion const & other) const
    {
        return compare(other) < 0;
    }

    bool operator <= (HVersion const & other) const
    {
        return operator<(other) || operator==(other);
    }

    bool operator == (HVersion const & other) const
    {
        return compare(other,false /*full*/) == 0;
    }

    static HVersion convert(UT_StringRef const & str)
    {
        UT_StringArray tokens;
        UT_String(str.c_str()).tokenize( tokens, "." );

        HVersion hver;

        if (tokens.size() > 4)
        {
            // wrong format
            return hver;
        }
        else if (tokens.size()==1)
        {
            hver.myMajor = SYSatoi(tokens[0].c_str());
        }
        else if (tokens.size()==2)
        {
            hver.myMajor = SYSatoi(tokens[0].c_str());
            hver.myMinor = SYSatoi(tokens[1].c_str());
        }
        else if (tokens.size()==3)
        {
            hver.myMajor = SYSatoi(tokens[0].c_str());
            hver.myMinor = SYSatoi(tokens[1].c_str());
            hver.myBuild = SYSatoi(tokens[2].c_str());
        }
        else 
        {
            hver.myMajor = SYSatoi(tokens[0].c_str());
            hver.myMinor = SYSatoi(tokens[1].c_str());
            hver.myBuild = SYSatoi(tokens[2].c_str());
            hver.myPatch = SYSatoi(tokens[3].c_str());
        }
        return hver;
    }

    int myMajor;
    int myMinor;
    int myBuild;
    int myPatch;
};

// Encapsulates variant values used by UT_Package
class Value
{
    public:
    using Array = UT_Array<Value>;

    Value() = default;
    ~Value() = default;

    explicit Value(const char *value)
    {
        if (value)
        {
            myValue = std::string(value, strlen(value));
        }
    }

    explicit Value(UT_StringRef const & value)
    {
        if (value.isstring())
        {
            myValue = std::string(value.c_str(), value.length());
        }
    }

    explicit Value(fpreal64 value) 
    { 
        myValue = value; 
    }

    explicit Value(int64 value) 
    { 
        myValue = value; 
    }

    explicit Value(bool value) 
    { 
        myValue = value; 
    }

    explicit Value(HVersion value) 
    { 
        myValue = value; 
    }

    hboost::any const & value() const
    {
        return myValue;
    }

    void set(const char *value)
    {
        if (value)
        {
            myValue = std::string(value, strlen(value));
        }
    }

    void set(fpreal64 value) 
    { 
        myValue = value; 
    }

    void set(int64 value) 
    { 
        myValue = value; 
    }

    void set(bool value) 
    { 
        myValue = value; 
    }

    void set(HVersion value) 
    { 
        myValue = value; 
    }

    UT_StringHolder toString() const
    {
        return toWorkBuffer().buffer();
    }

    UT_WorkBuffer toWorkBuffer() const
    {
        UT_WorkBuffer wb;
        if (typeid(fpreal64) == myValue.type())
        {
            wb.format("{}", hboost::any_cast<fpreal64>(myValue));
        }
        else if (typeid(int64) == myValue.type())
        {
            wb.format("{}", hboost::any_cast<int64>(myValue));
        }
        else if (typeid(bool) == myValue.type())
        {
            wb.format("{}", hboost::any_cast<bool>(myValue) ? "1" : "0");
        }
        else if (typeid(std::string) == myValue.type())
        {
            wb.format("{}",hboost::any_cast<std::string>(myValue));
        }
        else if (typeid(HVersion) == myValue.type())
        {
            auto && hver = hboost::any_cast<HVersion>(myValue);
            wb.format("{}.{}.{}.{}",hver.myMajor,hver.myMinor,hver.myBuild,hver.myPatch);
        }

        return wb;
    }

    template <typename T>
    T const & get() const
    {
        return hboost::any_cast<T const &>(myValue);
    }

    template <typename T>
    bool isA() const
    {
        return typeid(T) == myValue.type();
    }

    bool valid() const
    {
        return !myValue.empty();
    }

    bool isEqual(utils::Value const & other, bool ignore_case=false) const
    {
        if (isA<std::string>() && other.isA<std::string>())
        {
            if (ignore_case)
            {
                auto && lhs = hboost::any_cast<std::string>(myValue);
                auto && rhs = hboost::any_cast<std::string>(other.value());
                return compareIgnoreCase(lhs, rhs);
            }
            else
            {
                return get<std::string>() == other.get<std::string>();
            }
        }

        if (isA<int64>() && other.isA<int64>())
        {
            return get<int64>() == other.get<int64>();
        }

        if (isA<fpreal64>() && other.isA<fpreal64>())
        {
            return get<fpreal64>() == other.get<fpreal64>();
        }

        if (isA<bool>() && other.isA<bool>())
        {
            return get<bool>() == other.get<bool>();
        }

        if (isA<HVersion>() && other.isA<HVersion>())
        {
            return get<HVersion>() == other.get<HVersion>();
        }

        if (isA<HVersion>() && other.isA<std::string>())
        {
            HVersion hver = HVersion::convert(other.get<std::string>().c_str());
            return get<HVersion>() == hver;
        }

        if (isA<std::string>() && other.isA<HVersion>())
        {
            HVersion hver = HVersion::convert(get<std::string>().c_str());
            return hver == other.get<HVersion>();
        }

        throw std::runtime_error("utils::Value::isEqual: unsupported type");
    }

    bool isGreater(utils::Value const & other) const
    {
        if ( isA<std::string>() && other.isA<std::string>() )
        {
            return get<std::string>() > other.get<std::string>();
        }

        if (isA<HVersion>() && other.isA<HVersion>())
        {
            return get<HVersion>() > other.get<HVersion>();
        }

        if (isA<HVersion>() && other.isA<std::string>())
        {
            HVersion hver = HVersion::convert(other.get<std::string>().c_str());
            return get<HVersion>() > hver;
        }

        if (isA<std::string>() && other.isA<HVersion>())
        {
            HVersion hver = HVersion::convert(get<std::string>().c_str());
            return hver > other.get<HVersion>();
        }

        if ( isA<std::string>() || other.isA<std::string>() )
        {
            throw std::runtime_error("utils::Value::isGreater: unsupported types");
        }

        return get<fpreal64>() > other.get<fpreal64>();
    }

    bool isGreaterEqual(utils::Value const & other) const
    {
        return isGreater(other) || isEqual(other);
    }

    bool isLess(utils::Value const & other) const
    {
        if ( isA<std::string>() && other.isA<std::string>() )
        {
            return get<std::string>() < other.get<std::string>();
        }

        if (isA<HVersion>() && other.isA<HVersion>())
        {
            return get<HVersion>() < other.get<HVersion>();
        }

        if (isA<HVersion>() && other.isA<std::string>())
        {
            HVersion hver = HVersion::convert(other.get<std::string>().c_str());
            return get<HVersion>() < hver;
        }

        if (isA<std::string>() && other.isA<HVersion>())
        {
            HVersion hver = HVersion::convert(get<std::string>().c_str());
            return hver < other.get<HVersion>();
        }

        if ( isA<std::string>() || other.isA<std::string>() )
        {
            throw std::runtime_error("utils::Value::isLess: unsupported types");
        }

        return get<fpreal64>() < other.get<fpreal64>();
    }

    bool isLessEqual(utils::Value const & other) const
    {
        return isLess(other) || isEqual(other);
    }

    // Substiture all occurances of find with replace_with
    bool substitute(char const* find, char const* replace_with)
    {
        if (valid() && isA<std::string>())
        {
            auto && to_replace = get<std::string>();
            UT_WorkBuffer wb(to_replace.c_str());
            if (wb.substitute(find, replace_with))
            {
                set(wb.buffer());
                return true;
            }
        }
        return false;
    }

private:
    bool compareIgnoreCase(std::string & s1, std::string & s2) const
    {
        return ((s1.size() == s2.size()) && 
            std::equal(s1.begin(), s1.end(), s2.begin(), 
                [](char & c1, char & c2)
                {
                    return (c1 == c2 || std::toupper(c1) == std::toupper(c2));
                }
        ));
    }
    hboost::any myValue;
}; // Value

// Loggger to hold warning/errors/info messages 
class Logger
{
    public:
    using EntryMap      = UT_StringMap<UT_StringHolder>;
    using EntryArray    = UT_StringArray;

    enum class Flags : unsigned
    {
        all,
        info,
        warning,
        error
    };

    Logger() 
        : myHasErrorFlag(false)
        , myLog(&myDefaultLog)
    {
    }

    ~Logger() = default;

    void error(char const* msg)
    {
        addToBuffer(klog_error, msg);
        myHasErrorFlag = true;
    }

    template< typename ...Args >
    void error(char const* msg, Args&&... args)
    {
        addToBuffer(klog_error, formatMsg(msg, std::forward<Args>(args)...));
        myHasErrorFlag = true;
    }

    void info(char const* msg)
    {
        addToBuffer(klog_info, msg);
    }

    template< typename ...Args >
    void info(char const* msg, Args&&... args)
    {
        addToBuffer(klog_info, formatMsg(msg, std::forward<Args>(args)...));
    }

    void message(char const* msg)
    {
        addToBuffer(nullptr, msg);
    }

    template< typename ...Args >
    void message(char const* msg, Args&&... args)
    {
        addToBuffer(nullptr, formatMsg(msg, std::forward<Args>(args)...));
    }

    void warning(char const* msg)
    {
        addToBuffer(klog_warning, msg);
    }

    template< typename ...Args >
    void warning(char const* msg, Args&&... args)
    {
        addToBuffer(klog_warning, formatMsg(msg, std::forward<Args>(args)...));
    }

    void clear()
    {
        myDefaultLog.clear();
        myEntryMap.clear();
        myEntryArray.clear();
    }

    void toStream(std::ostream &os) const
    {
        for (auto && entry : myEntryArray)
        {
            os << entry.c_str() << std::endl;
            auto && it = myEntryMap.find(entry);
            os << it->second.c_str() << std::endl;          
        }

        if (myDefaultLog)
        {
            os << myDefaultLog.c_str() << std::endl;
        }
    }

    UT_StringHolder toString() const
    {
        UT_OStringStream ss;
        toStream(ss);
        UT_StringHolder log = "= = = Houdini Package log = = =\n";
        log += ss.str().buffer();
        return log;
    }

    void log(char const* title, Flags flags=Flags::all) const
    {   
        if (flags == Flags::all)
        {
            std::cout << title << std::endl;
            toStream(std::cout);
        }
        else if (myHasErrorFlag && flags == Flags::error)
        {
            std::cerr << title << std::endl;
            toStream(std::cerr);
        }
    }
 
    void start(char const * entry)
    {
        if (!entry)
        {
            // global logging
            myLog = &myDefaultLog;
            return;
        }

        // logging done per entry
        if (!myEntryMap.count(entry))
        {
            myEntryMap[entry] = UT_StringHolder();
            myEntryArray.append(entry);
        }
        myLog = &myEntryMap[entry];
    }

    bool hasErrors() const
    {
        return myHasErrorFlag;
    }

    void append(Logger const & logger)
    {
        UT_OStringStream ss;
        logger.toStream(ss);

        UT_WorkBuffer wb;
        wb += ss.str().buffer();

        if (wb.buffer())
        {
            buffer() += wb.buffer();
        }
    }

    private:
    template< typename ...Args >
    UT_StringHolder formatMsg( const char* format, Args &&... args )
    {
        UT_WorkBuffer wb;
        wb.format(format, args...);
        return wb;
    }

    void addToBuffer(const char* prefix, const char* msg)
    {
        if (prefix)
        {
            buffer() += prefix;
            buffer() += ": ";
        }
        buffer() += msg;
        buffer() += "\n";
    }

    UT_StringHolder & buffer() 
    {
        return *myLog;
    }

    UT_StringHolder const & buffer() const
    {
        return *myLog;
    }

    EntryArray          myEntryArray;
    EntryMap            myEntryMap;
    UT_StringHolder*    myLog;
    UT_StringHolder     myDefaultLog;
    bool                myHasErrorFlag;
}; // Logger

} // utils
} // UT_Package

#endif // UT_PackageUtils_H