wmudgfunctions.h

Go to the documentation of this file.

#ifndef WMUDGFUNCTIONS_H
#define WMUDGFUNCTIONS_H
 
// Wm includes
#include "warpxm/warpxm_config.h"
#include "wxexcept.h"
 
// STL includes
#include <algorithm>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <typeinfo>
 
// This is just a namespace to hold some useful functions I keep using for DG
 
#define SAFE_DELETE(ptr)                                                                 \
    if (ptr)                                                                             \
    {                                                                                    \
        delete ptr;                                                                      \
        ptr = NULL;                                                                      \
    }
#define SAFE_DELETE_ARRAY(ptr)                                                           \
    if (ptr)                                                                             \
    {                                                                                    \
        delete[] ptr;                                                                    \
        ptr = NULL;                                                                      \
    }
#define SAFE_DELETE_POINTER_VECTOR(vec)                                                  \
    for (int i = 0; i < vec.size(); i++)                                                 \
    {                                                                                    \
        SAFE_DELETE(vec[i]);                                                             \
    }                                                                                    \
    vec.clear();
 
namespace WmUDGFunctions
{
inline size_t getTypeSize(const std::type_info& typeinfo)
{
 
    size_t typeSize = 0;
 
    if (typeinfo == typeid(float))
    {
        typeSize = sizeof(float);
    }
    else if (typeinfo == typeid(double))
    {
        typeSize = sizeof(double);
    }
    else if (typeinfo == typeid(int))
    {
        typeSize = sizeof(int);
    }
    else if (typeinfo == typeid(unsigned))
    {
        typeSize = sizeof(unsigned);
    }
    else
    {
        WxExcept wxe("WmPatchedProcessingObject::getTypeSize : ");
        wxe << "Not yet setup for type '" << typeinfo.name() << "'" << std::endl;
        throw wxe;
    }
 
    return typeSize;
}
 
template<class T> struct typeString;
 
template<> struct typeString<int>
{
    static constexpr char const* value = "int";
};
 
template<> struct typeString<unsigned>
{
    static constexpr char const* value = "unsigned";
};
 
template<> struct typeString<float>
{
    static constexpr char const* value = "float";
};
 
template<> struct typeString<double>
{
    static constexpr char const* value = "double";
};
 
inline bool isaspace(unsigned char const c)
{
    return std::isspace(c);
}
 
inline bool isjustaspace(unsigned char const c)
{
    return c == ' ';
}
 
inline bool isacomma(unsigned char const c)
{
    return c == ',';
}
 
template<typename T> inline T stringToValue(const std::string& text)
{
    std::stringstream ss(text);
    T result;
    return ss >> result ? result : 0;
}
 
template<typename T> inline std::vector<T> stringToValueVec(const std::string& text)
{
    std::vector<T> vec;
    std::string::const_iterator start = text.begin(), end;
    const std::string delimiter = ",";
    while (true)
    {
        end = std::find_first_of(start, text.end(), delimiter.begin(), delimiter.end());
        const std::string substr(start, end);
        // std::cout << "Line '" << text << "' subline '" << substr << "'" << std::endl;
        vec.push_back(WmUDGFunctions::stringToValue<T>(substr));
        if (end == text.end())
        {
            break;
        }
        start = end + 1;
    }
    return vec;
}
 
template<typename T> inline std::string valueToString(T value)
{
    std::stringstream ss;
    ss << value;
    return ss.str();
}
 
template<typename T> inline void arrayPrinter(const T* array, const int n)
{
    std::cout << "[";
    for (int i = 0; i < n; i++)
    {
        std::cout << array[i];
        if (i != n - 1)
        {
            std::cout << ", ";
        }
    }
    std::cout << "]" << std::endl;
}
 
template<typename T> inline void arrayPrinter(const std::vector<T>& array)
{
    arrayPrinter(&(array[0]), array.size());
}
 
template<typename T> inline std::string defineOption(const std::string& name, T value)
{
    std::stringstream ss;
    ss << " -D" << name << "=(" << value << ") ";
    return ss.str();
}
 
template<typename T> inline std::string define(const std::string& name, T value)
{
    std::stringstream ss;
    ss << "#define " << name << " " << value << " \n";
    return ss.str();
}
 
inline std::string readFile(const std::string& filename)
{
    std::ifstream fileString;
    fileString.open(filename.c_str());
    if (!fileString.good())
    {
        WxExcept wxe("WmUDGFunctions::readFile : ");
        wxe << "File '" << filename << "' does not exist\n";
        throw wxe;
    }
    std::stringstream ss;
    ss << fileString.rdbuf();
    std::string srccode(ss.str());
    // std::string srccode((std::istreambuf_iterator<char>(fileString)),
    // std::istreambuf_iterator<char>());
    fileString.close();
    return srccode;
}
 
inline void writeFile(const std::string& filename, const std::string& text)
{
    std::ofstream out(filename.c_str());
    out << text;
    out.close();
}
 
template<typename T>
T parseStringForValue(const std::string& string, const std::string& key)
{
    size_t start = string.find(key);
    if (start == string.npos)
    {
        WxExcept wxe("WmUDGFunctions::parseString : ");
        wxe << "Key '" << key << "' not found\n";
        throw wxe;
    }
    size_t valStart = string.find('=', start) + 1;
    size_t valLength = string.find('\n', start) - valStart;
    std::string valString = string.substr(valStart, valLength);
    valString.erase(
        std::remove_if(valString.begin(), valString.end(), WmUDGFunctions::isaspace),
        valString.end());
    // std::cout << "looking for '" << key << "'', found '"<<string.substr(start,
    // string.find('\n',start)-start)<<"' for ("<<start<<" ("<<valStart<<"),
    // "<<string.find('\n',start)<<") giving value string '"<<valString<<"'" << std::endl;
    return WmUDGFunctions::stringToValue<T>(valString);
}
 
template<typename T>
std::vector<T> parseStringForVector(const std::string& string,
                                    const std::string& key,
                                    const int expectedLength = -1)
{
    size_t start = string.find(key);
    if (start == string.npos)
    {
        WxExcept wxe("WmUDGFunctions::parseString : ");
        wxe << "Key '" << key << "' not found\n";
        throw wxe;
    }
    size_t valStart = string.find('=', start) + 1;
    size_t valLength = string.find('\n', start) - valStart;
    std::string valString = string.substr(valStart, valLength);
    valString.erase(
        std::remove_if(valString.begin(), valString.end(), WmUDGFunctions::isaspace),
        valString.end());
    // std::cout << "looking for '" << key << "'', found '"<<string.substr(start,
    // string.find('\n',start)-start)<<"' for ("<<start<<" ("<<valStart<<"),
    // "<<string.find('\n',start)<<") giving value string '"<<valString<<"'" << std::endl;
    std::vector<T> vals = WmUDGFunctions::stringToValueVec<T>(valString);
    if (expectedLength >= 0)
    {
        if (vals.size() != expectedLength)
        {
            WxExcept wxe("WmUDGFunctions::parseString : ");
            wxe << "Key '" << key << "' array size '" << vals.size()
                << "' was not the expected '" << expectedLength << "'\n";
            throw wxe;
        }
    }
    return vals;
}
 
template<typename T> inline std::string toString(const T& val)
{
    std::stringstream ss;
    if ((typeid(T) == typeid(double)) || (typeid(T) == typeid(float)))
    {
        ss << std::setprecision(12) << std::scientific;
    }
    ss << val;
    return ss.str();
}
 
template<typename T> inline bool hasDuplicates(const std::vector<T>& array)
{
    std::vector<T> vec = array;
    std::sort(vec.begin(), vec.end());
    // There is a way to do this with std::unique, but it wasn't intuitive...
    bool exists = false;
    for (int i = 1; i < vec.size(); i++)
    {
        if (vec[i] == vec[i - 1])
        {
            exists = true;
        }
    }
    return exists;
}
} // namespace WmUDGFunctions
 
#endif // WMUDGFUNCTIONS_H