SetUtils.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright (C) 2014-2018 Allan Leal
//
// This library 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.
//
// This library 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, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// C++ includes
#include <algorithm>
#include <set>
#include <vector>
#include <string>
 
// Reaktoro includes
#include <Reaktoro/Common/Index.hpp>
#include <Reaktoro/Common/TraitsUtils.hpp>
 
namespace Reaktoro {
 
template<typename T>
auto index(const T& value, const std::vector<T>& values) -> Index;
 
auto index(const std::string& word, const std::vector<std::string>& strings) -> Index;
 
template<typename NamedValues>
auto index(const std::string& name, const NamedValues& values) -> Index;
 
template<typename NamedValue, typename NamedValues>
auto index(const NamedValue& value, const NamedValues& values) -> Index;
 
template<typename Names, typename NamedValues>
auto indexAny(const Names& names, const NamedValues& values) -> Index;
 
template<typename NamedValues>
auto indices(const std::vector<std::string>& names, const NamedValues& values) -> Indices;
 
template<typename NamedValues>
auto indices(const NamedValues& subvalues, const NamedValues& values) -> Indices;
 
auto indices(const std::vector<std::string>& words, const std::vector<std::string>& strings) -> Indices;
 
//template<typename Container, typename = typename std::enable_if<!std::is_same<typename Container::value_type, std::string>::value>::type>
//auto contained(const typename Container::value_type& value, const Container& values) -> bool;
 
template<typename Container>
auto contained(const Container& values1, const Container& values2) -> bool;
 
template<typename NamedValues>
auto contained(const std::string& name, const NamedValues& values) -> bool;
 
template<typename T>
auto unify(const std::vector<T>& values1, const std::vector<T>& values2) -> std::vector<T>;
 
template<typename T>
auto intersect(const std::vector<T>& values1, const std::vector<T>& values2) -> std::vector<T>;
 
template<typename T>
auto difference(const std::vector<T>& values1, const std::vector<T>& values2) -> std::vector<T>;
 
template<typename T>
auto emptyIntersection(const std::vector<T>& values1, const std::vector<T>& values2) -> bool;
 
template<typename T>
auto emptyDifference(const std::vector<T>& values1, const std::vector<T>& values2) -> bool;
 
template<typename Container>
auto equal(const Container& values1, const Container& values2) -> bool;
 
template<typename Container>
auto isunique(Container values) -> bool;
 
template<typename T>
auto unique(std::vector<T> values) -> std::vector<T>;
 
template<typename T>
auto range(T first, T last, T step) -> std::vector<T>;
 
template<typename T>
auto range(T first, T last) -> std::vector<T>;
 
template<typename T>
auto range(T last) -> std::vector<T>;
 
template<typename T, typename Predicate>
auto filter(const std::vector<T>& values, Predicate predicate) -> std::vector<T>;
 
template<typename T, typename Predicate>
auto remove(const std::vector<T>& values, Predicate predicate) -> std::vector<T>;
 
template<typename T>
auto extract(const std::vector<T>& values, const Indices& indices) -> std::vector<T>;
 
template<typename Container>
auto minValue(const Container& values) -> typename Container::value_type;
 
template<typename Container>
auto maxValue(const Container& values) -> typename Container::value_type;
 
} // namespace Reaktoro
 
#include <Reaktoro/Common/SetUtils.hxx>