commonUtils.tpp

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_COMMON_UTILS_TPP__
#define __BITPIT_COMMON_UTILS_TPP__
 
namespace bitpit {
 
namespace utils {
 
template <typename T, typename Comparator>
bool addToOrderedVector(const T &value, std::vector<T> &list, Comparator comparator)
{
    if (list.empty()) {
        list.push_back(value);
        return true;
    }
 
    typename std::vector<T>::iterator itr = std::lower_bound(list.begin(), list.end(), value, comparator);
    if (itr == list.end() || *itr != value) {
        list.insert(itr, value);
        return true;
    } else {
        return false;
    }
};
 
template <typename T, typename Comparator>
typename std::vector<T>::const_iterator findInOrderedVector(const T &value, const std::vector<T> &list, Comparator comparator)
{
    typename std::vector<T>::const_iterator itr = std::lower_bound(list.begin(), list.end(), value, comparator);
    if (itr == list.end() || *itr != value) {
        return list.end();
    }
 
    return itr;
};
 
template<typename T>
void reorderVector(std::vector<size_t> &order, std::vector<T> &v, std::size_t size)
{
    reorderContainer(order, v, size);
}
 
template<typename OrderContainer, typename DataContainer>
void reorderContainer(OrderContainer &order, DataContainer &v, std::size_t size)
{
    for (std::size_t i = 0; i < size; i++) {
        std::size_t j;
        while (i != (j = order[i])) {
            std::size_t k = order[j];
 
            swapValue(v, j, k);
            std::swap(order[i], order[j]);
        }
    }
}
 
template<typename Container, typename Index>
void swapValue(Container &v, Index i, Index j)
{
    std::swap(v[i], v[j]);
}
 
template<class T>
void eraseValue(std::vector<T> &vec, const T &value)
{
    typename std::vector<T>::iterator it = find(vec.begin(), vec.end(), value);
    if (it != vec.end()) {
        vec.erase(it);
    }
}
 
template<class T>
std::vector<T> intersectionVector(const std::vector<T> &vec_1, const std::vector<T> &vec_2)
{
    std::vector<T> intersect;
    std::map<T, bool> storage;
 
    intersect.reserve(std::min(vec_1.size(), vec_2.size()));
    for (auto cit_ = vec_2.begin(); cit_ != vec_2.end(); ++cit_) {
        storage[*cit_] = true;
    }
 
    for (auto it_ = vec_1.begin(); it_ != vec_1.end(); ++it_) {
        if (storage[*it_]) {
            intersect.push_back(*it_);
        }
    }
 
    return intersect;
}
 
template <typename T>
auto is_iterable_impl(int) -> decltype (
    std::begin(std::declval<T&>()) != std::end(std::declval<T&>()),   // begin/end and operator !=
    ++std::declval<decltype(std::begin(std::declval<T&>()))&>(),      // operator ++
    *std::begin(std::declval<T&>()),                                  // operator*
    std::true_type{}
);
 
template <typename T>
std::false_type is_iterable_impl(...);
 
template <typename T>
using is_iterable = decltype(is_iterable_impl<T>(0));
 
}
 
}
 
#endif