util.h

Go to the documentation of this file.

#ifndef __UTIL_H
#define __UTIL_H

/* Copyright (C) 2017 - James Terman
 *
 * milo is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * milo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <string>
#include <vector>
#include <array>
#include <complex>
#include <algorithm>
#include <unordered_map>
#include <boost/functional/hash.hpp>

bool isZero(double x);

bool isZero(std::complex<double> z);

bool isInteger(const std::string& n);

bool isInteger(double value);

inline std::string to_hexstring(unsigned long x)
{
    std::string hex;
    while (x != 0) {
        int n = x % 16; x /= 16;
        char d = (n < 10) ? '0' + n : 'A' + n - 10;
        hex.insert(0, 1, d);
    }
    return hex;
}

template <class T>
inline auto find(const std::vector<T>& v, const T& val) -> decltype( v.cbegin() )
{
    return std::find(v.cbegin(), v.cend(), val);
}

template <class T>
inline void freeVector(std::vector<T*>& v)
{
    for ( auto p : v ) { delete p; }
    v.clear();
}

template <class T>
inline void mergeVectors(std::vector<T>& a, std::vector<T>& b)
{
    a.reserve(a.size() + b.size());
    for ( auto e : b ) { a.insert(a.end(), e); }
    b.clear();
}

template <class T>
inline void eraseElement(std::vector<T>& v, int index)
{
    v.erase((index < 0 ? v.end() - 1 : v.begin()) + index);
}

template <class T>
inline void insertElement(std::vector<T>& v, int index, const T& e)
{
    v.insert((index < 0 ? v.end() : v.begin()) + index, e);
}

template <class T>
auto AddAfter(std::vector<T>& v, decltype(v.begin()) it, const T& elem)->decltype(v.begin())
{
    if (v.empty()) {
        v.push_back(elem);
        return v.begin();
    }
    if (it == v.end()) {
        return v.insert(v.begin(), elem);
    }
    ++it;
    return v.insert(it, elem);
}

template <typename K, typename V>
const K searchMapValue(const std::unordered_map<K, V>&kv_map,  V value) 
{
    for ( auto& kv : kv_map ) {
        if ( kv.second == value ) {
            return kv.first;
        }
    }
    return 0;
}

template <class T>
class Rectangle
{
public:
    Rectangle() : m_rect{0, 0, 0, 0} {}

    Rectangle(T x, T y, T x0, T y0) : m_rect{x, y, x0, y0} {}

    void set(T x, T y, T x0, T y0) { m_rect = {x, y, x0, y0}; }

    void setOrigin(T x0, T y0)     { m_rect[X0] = x0; m_rect[Y0] = y0; }

    void setSize(T x, T y)         { m_rect[WIDTH] = x; m_rect[HEIGHT] = y; }

    int& x0() { return m_rect[X0]; }

    int& y0() { return m_rect[Y0]; }

    int& width()   { return m_rect[WIDTH]; }

    int& height()  { return m_rect[HEIGHT]; }

    int x0() const { return m_rect[X0]; }

    int y0() const { return m_rect[Y0]; }

    int width()  const { return m_rect[WIDTH]; }

    int height() const { return m_rect[HEIGHT]; }

    std::string toString()
    {
        std::string s = "width: " + std::to_string(width()) + ", height: " + std::to_string(height()) +
                        ", x0: " + std::to_string(x0()) + ", y0: " + std::to_string(y0());
        return s;
    }

    T area() { return width()*height(); }
    
    bool inside(T x, T y) const { 
        return ( x >= x0() && x < (x0() + width()) && 
                 y >= y0() && y < (y0() + height()) );
    }

    bool inside(Rectangle r) const {
        return ( x0() >= r.x0() && (x0() + width())  <= (r.x0() + r.width()) && 
                 y0() >= r.y0() && (y0() + height()) <= (r.y0() + r.height()) );
    }

    bool intersect(const Rectangle& r) const {
        bool noOverlap = (x0() - r.x0()) > r.width() ||
                         (r.x0() - x0()) > width() ||
                         (y0() - r.y0()) > r.height() ||
                         (r.y0() - y0()) > height();
        return !noOverlap;
    }

    void merge(const Rectangle& r) {
        T x0 = min(x0(), r.x0());
        T y0 = min(y0(), r.y0());
        T x1 = max(x0() + width(), r.x0() + r.width());
        T y1 = max(y0() + height(), r.y0() + r.height());
        set(x1 - x0, y1 - y0, x0, y0);
    }

    static Rectangle merge(const Rectangle& r1, const Rectangle& r2) {
        Rectangle r{r1};
        r.merge(r2);
        return r;
    }

private:
    enum { WIDTH, HEIGHT, X0, Y0, SIZE }; 
    std::array<T, SIZE> m_rect;           
};

using Box = Rectangle<int>;                                     
using StringMap = std::unordered_map<std::string, std::string>; 


template <class T> inline std::size_t hash_calculate(std::initializer_list<T> l)
{
    std::size_t seed = 0;
    for (T n : l) {
        boost::hash_combine<T>(seed, n);
    }
    return seed;
}

namespace Log
{
    void msg(const std::string& m);
}

#define LOG_TRACE_MSG(m) Log::msg(string("") + __FILE__ + ": " + to_string(__LINE__) + ": " + (m))
#define LOG_TRACE_FILE "/tmp/milo.log"
#define LOG_TRACE_CLEAR() remove(LOG_TRACE_FILE)

#define QUOTE(arg) #arg
#define STR(macro) QUOTE(macro)

#ifndef INSTALL_PATH
#define INSTALL_PATH /usr/local/milo
#endif

#define INSTALL_PATH_STR STR(INSTALL_PATH)

#endif // __UTIL_H