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_Assert.h"
#include "UT_DirUtil.h"
#include "UT_SharedPtr.h"
#include "UT_StringArray.h"
#include "UT_StringMap.h"
#include "UT_StringSet.h"
#include "UT_StringStream.h"
#include "UT_VarScan.h"
#include <SYS/SYS_ParseNumber.h>
#include <SYS/SYS_Platform.h>
#include <SYS/SYS_VersionUtil.h>

#include <hboost/any.hpp>
#include <patchlevel.h> // PY_MAJOR_VERSION
#include <tools/henv.h>
#include <tools/hpath.h>

#include <cctype>
#include <iostream>

#ifdef NO_VALUE
#undef NO_VALUE
#endif

namespace UT_Package
{
namespace utils
{
constexpr UT_StringLit klog_error   = "ERROR";
constexpr UT_StringLit klog_info    = "INFO";
constexpr UT_StringLit klog_warning = "WARNING";
constexpr exint NO_VALUE            = SYS_INT64_MAX;

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_name, bool use_symbol=true, 
    const char * prefix=nullptr, const char * suffix=nullptr)
{
    // note: this helper is typically used with utils::expandVar
    UT_ASSERT(var_name != nullptr);
    UT_WorkBuffer wb;
    wb.format("{}{}{}{}", use_symbol ? "$" : "", prefix ? prefix : "", var_name, suffix ? suffix : "");
    return wb;
}

static void getBuildCompilerInfo(UT_StringHolder& out_name, exint& out_major, exint& out_minor)
{
#if defined(_MSC_VER)
    out_name = "cl";
    out_major = (_MSC_FULL_VER / 10000000) % 10000;
    out_minor = (_MSC_FULL_VER / 100000) % 100;

#elif defined(__clang__)
    out_name = "clang";
    out_major = __clang_major__;
    out_minor = __clang_minor__;

#elif defined(__GNUC__)
    out_name = "gcc";
    out_major = __GNUC__;
    out_minor = __GNUC_MINOR__;
#else
    out_name = "unknown";
    out_major = NO_VALUE;
    out_minor = NO_VALUE;
#endif
}

/*
Strip some unwanted chars from a variable value string.
*/
static UT_StringHolder cleanupValue(char const * value)
{
    if (value)
    {
        static constexpr UT_StringLit kStripables = "\t\n\r";
        UT_String sval(value);
        sval.strip(kStripables.asHolder());
        return sval.c_str();
    }
    return UT_StringHolder();
}

/*
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. 
*/
UT_API extern 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);

UT_API extern UT_StringHolder expandVar(const char *arg, bool want_marker);
UT_API extern UT_StringHolder makeVarRefPlatform(const char * var);

UT_API extern bool isCmdShell();
UT_API extern const char *pathSepShell();

// Normalizes and expands (optionally) a file path. 
//
// file_path: Path to normalize. We use UT_String to be compatible 
//            with UTnormalizeFilePath which returns the normalized 
//            file path by arg reference.
// expand: Expands the content of file_path after the path has been 
//         normalized.
// want_marker: If true, expandVar returns `&` if the path is empty. 
//              Mostly used by HOUDINI_PATH like paths.
//
// always_want_expanded_path: Always keep the result of the expanded 
//                            vars with the path even if the content 
//                            is empty.
// Assumes the input is an environment variable value, potentially 
// formatted as env var path.
UT_API extern void normalizeEnvVarPath(UT_String& file_path, bool want_marker=false, bool always_want_expanded_path=false);
UT_API extern void normalizePath(UT_String& file_path, bool want_marker=false, bool always_want_expanded_path=false);
UT_API extern void normalizePath(UT_StringHolder& file_path, bool want_marker=false, bool always_want_expanded_path=false);
// Returns a new normalized/expanded path
UT_API extern UT_StringHolder cnormalizePath(UT_StringHolder const & file_path, bool want_marker=false, bool always_want_expanded_path=false);

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)
        {
            UT_ASSERT(other.myMajor > -1);

            // Assign other build + patch with this if not set (-1)
            int other_minor = myMinor;
            int other_build = myBuild;
            int other_patch = myPatch;

            if (other.myMinor != -1)
            {
                other_minor = other.myMinor;
            }

            if (other.myBuild != -1)
            {
                other_build = other.myBuild;
            }

            if (other.myPatch != -1)
            {
                other_patch = other.myPatch;
            }

            return SYSversionCompare(
                myMajor, myMinor, myBuild, myPatch, other.myMajor, other_minor, other_build, other_patch);
        }

        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;
};

// Helper for handling Houdini python version with packages
class PYVersion
{
public:
    // Return the build version name
    static char const* toString()
    {
        static UT_WorkBuffer thePYVersion = []()
        {
            UT_WorkBuffer major;
            major.itoa(PY_MAJOR_VERSION);

            UT_WorkBuffer minor;
            minor.itoa(PY_MINOR_VERSION);

            UT_WorkBuffer pyver;
            pyver.format("{}{}.{}", "python", major.buffer(), minor.buffer());

            return pyver;
        }();

        return thePYVersion.buffer();
    }

    PYVersion()
        : myMajor(-1)
        , myMinor(-1)
        , myMicro(-1)
    {   
    }

    int compare( PYVersion const & other) const
    {
        if (myMajor != other.myMajor) 
        {
            return myMajor - other.myMajor;
        }
        
        if (myMinor == -1)
        {
            return 0;
        }

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

        if (other.myMicro != -1 && myMicro != other.myMicro) 
        {
            return myMicro - other.myMicro;
        }

        return 0;
    }

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

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

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

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

    bool operator == (PYVersion const & other) const
    {
        return compare(other) == 0;
    }

    // Convert a string formatted python version to PYVersion
    // pyver_str: <python><major>.<minor>.<micro>
    // Note: minor and micro are optional
    static PYVersion convert(char const * pyver_str)
    {
        PYVersion pyver;
        UT_String str(pyver_str);

        if (!str || !str.startsWith("python"))
        {
            return pyver;
        }
        
        // Remove the python token
        str.eraseHead(6);

        UT_StringArray tokens;
        str.tokenize(tokens, ".");

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

    static void getVersion(PYVersion& pyver)
    {
        pyver.myMajor = PY_MAJOR_VERSION;
        pyver.myMinor = PY_MINOR_VERSION;
        pyver.myMicro = PY_MICRO_VERSION;
    }

    int myMajor;
    int myMinor;
    int myMicro;
};

// Helper for handling the compiler version used for building Houdini.
class HPlatformBuildVersion
{
public:
    HPlatformBuildVersion()
        : myMajor(NO_VALUE)
        , myMinor(NO_VALUE)
    {
    }

    int compare(HPlatformBuildVersion const& other) const
    {
        if (myName != other.myName)
        {
            return -1;
        }

        if (myMajor != NO_VALUE && other.myMajor != NO_VALUE && myMajor != other.myMajor)
        {
            return myMajor - other.myMajor;
        }

        if (myMinor != NO_VALUE && other.myMinor != NO_VALUE && myMinor != other.myMinor)
        {
            return myMinor - other.myMinor;
        }

        return 0;
    }

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

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

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

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

    bool operator == (HPlatformBuildVersion const& other) const
    {
        return compare(other) == 0;
    }

    // Convert a string formatted platform build version to HPlatformBuildVersion
    // ver_str: <compiler name>.<major>.<minor>
    static HPlatformBuildVersion convert(char const* ver_str)
    {
        HPlatformBuildVersion pbver;

        if (!ver_str || !strlen(ver_str))
        {
            return pbver;
        }

        UT_StringArray tokens;
        UT_String ut_ver_str(ver_str);
        ut_ver_str.tokenize(tokens, ".");

        if (tokens.size() < 1 || tokens.size() > 3)
        {
            // wrong format
            return pbver;
        }

        if (tokens.size()==1)
        {
            pbver.myName = tokens[0].c_str();
        }
        else if (tokens.size()==2)
        {
            pbver.myName = tokens[0].c_str();
            pbver.myMajor = SYSatoi(tokens[1].c_str());
        }
        else
        {
            pbver.myName = tokens[0].c_str();
            pbver.myMajor = SYSatoi(tokens[1].c_str());
            pbver.myMinor = SYSatoi(tokens[2].c_str());
        }

        return pbver;
    }

    void getVersion(UT_StringHolder& out_name, exint& out_major, exint& out_minor)
    {
        out_name = myName;
        out_major = myMajor;
        out_minor = myMinor;
    }

    static 
    void getVersion(HPlatformBuildVersion& out_version)
    {   
        getBuildCompilerInfo(out_version.myName, out_version.myMajor, out_version.myMinor);
    }

    // Build the version string. Supported formats:
    // name.major.minor
    // name.major
    // name
    UT_StringHolder toString() const
    {
        if (myName.isEmpty())
        {
            static UT_StringHolder unknown("unknown");
            return unknown.c_str();
        }

        UT_WorkBuffer ver;

        if (myMajor != NO_VALUE && myMinor != NO_VALUE)
        {
            ver.format("{}.{}.{}", myName, myMajor, myMinor);
        }
        else if (myMajor != NO_VALUE && myMinor == NO_VALUE)
        {
            ver.format("{}.{}", myName, myMajor);
        }
        else
        {
            ver.format("{}", myName);
        }
        return ver.buffer();
    }

    UT_StringHolder myName;
    exint           myMajor;
    exint           myMinor;
};

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

    Value() = default;

    explicit Value(const char *value)
    {
        set(value);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    UT_WorkBuffer toWorkBuffer() const
    {
        UT_WorkBuffer wb;
        if (isA<fpreal64>())
        {
            wb.format("{}", hboost::any_cast<fpreal64>(myValue));
        }
        else if (isA<int64>())
        {
            wb.format("{}", hboost::any_cast<int64>(myValue));
        }
        else if (isA<bool>())
        {
            wb.format("{}", hboost::any_cast<bool>(myValue) ? "1" : "0");
        }
        else if (isA<std::string>())
        {
            wb.format("{}",hboost::any_cast<std::string>(myValue));
        }
        else if (isA<HVersion>())
        {
            auto && hver = hboost::any_cast<HVersion>(myValue);
            wb.format("{}.{}.{}.{}",hver.myMajor,hver.myMinor,hver.myBuild,hver.myPatch);
        }
        else if (isA<PYVersion>())
        {
            auto && pyver = hboost::any_cast<PYVersion>(myValue);
            wb.format("python{}.{}", pyver.myMajor,pyver.myMinor);
        }
        else if (isA<HPlatformBuildVersion>())
        {
            auto&& hbc_ver = hboost::any_cast<HPlatformBuildVersion>(myValue);
            wb = hbc_ver.toString();
        }
        else
        {
            UT_ASSERT(!"Unknown type in UT_Package::utils::Value");
        }

        return wb;
    }

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

    template <typename T>
    bool isA() const
    {
        return hboost::typeindex::type_id<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>();
        }

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

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

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

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

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

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

        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<PYVersion>() && other.isA<PYVersion>())
        {
            return get<PYVersion>() > other.get<PYVersion>();
        }

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

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

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

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

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

        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<PYVersion>() && other.isA<PYVersion>())
        {
            return get<PYVersion>() < other.get<PYVersion>();
        }

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

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

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

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

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

        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)
        , myVerboseFlag(false)
    {
    }

    void setAsVerbose(bool flag)
    {
        myVerboseFlag = flag;
    }

    bool verbose() const
    {
        return myVerboseFlag;
    }

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

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

    void info(char const* msg)
    {
        if (!myVerboseFlag)
        {
            return;
        }
        addToBuffer(klog_info.asHolder(), msg);
    }

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

    void message(char const* msg)
    {
        if (!myVerboseFlag)
        {
            return;
        }
        addToBuffer(nullptr, msg);
    }

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

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

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

    void clear()
    {
        myDefaultLog.clear();
        myEntryMap.clear();
        myEntryArray.clear();
        myErrorArray.clear();
        myWarningArray.clear();
        myHasErrorFlag = false;
    }

    void clearErrors()
    {
        myErrorArray.clear();
        myHasErrorFlag = false;
    }

    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(bool header=true) const
    {
        UT_OStringStream ss;
        toStream(ss);
        UT_StringHolder log;
        if (header && myVerboseFlag)
        {
            log += "= = = Houdini Package log = = =\n";
        }

        log += ss.str().buffer();

        if (header && myVerboseFlag)
        {
            log += "= = = = = = = = = = = = = = = =\n";
        }
        return log;
    }

    UT_StringArray const & errors() const
    {
        return myErrorArray;
    }

    UT_StringArray const & warnings() const
    {
        return myWarningArray;
    }

    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 (!msg || !strlen(msg))
        {
            return;
        }

        if (prefix)
        {
            buffer() += prefix;
            buffer() += ": ";
        }
        buffer() += msg;
        buffer() += "\n";

        if ( msg && prefix && klog_error.asHolder().equal(prefix))
        {
            myErrorArray.append(msg);
        }
        else if ( msg && prefix && klog_warning.asHolder().equal(prefix))
        {
            myWarningArray.append(msg);
        }
    }

    UT_StringHolder & buffer() 
    {
        return *myLog;
    }

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

    EntryArray          myEntryArray;
    EntryMap            myEntryMap;
    UT_StringHolder*    myLog;
    UT_StringHolder     myDefaultLog;
    UT_StringArray      myWarningArray;
    UT_StringArray      myErrorArray;
    bool                myHasErrorFlag;
    bool                myVerboseFlag;
}; // Logger

} // utils
} // UT_Package

#endif // UT_PackageUtils_H