Utils.h

Go to the documentation of this file.

/*
        This file is part of the EnergyOptimizatorOfRoboticCells program.

        EnergyOptimizatorOfRoboticCells is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        EnergyOptimizatorOfRoboticCells 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 General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with EnergyOptimizatorOfRoboticCells. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef HLIDAC_PES_UTILS_H
#define HLIDAC_PES_UTILS_H

#include <map>
#include <string>
#include <typeinfo>
#include <type_traits>
#include <utility>
#include <vector>
#include <stdint.h>
#include "SolverConfig.h"
#include "Shared/Exceptions.h"

template <class C>
typename C::mapped_type getValue(const C& m, const typename C::key_type& key, std::string calledFrom)   {
        typename C::const_iterator it = m.find(key);
        if (it != m.cend())     {
                return it->second;
        } else {
                std::string msg = "Invalid key!\n\n";
                msg += "Called from:\n"+calledFrom;
                throw SolverException(caller(), msg);
        }
}

template <class C>
void setValueHelper(C& m, const typename C::key_type& key, const typename C::mapped_type& value, std::string calledFrom)    {
        auto p = m.insert({key, value});
        if (p.second == false)  {
                std::string msg = "Value with the same key already exists!\n\n";
                msg += "Called from:\n"+calledFrom;
                throw SolverException(caller(), msg);
        }
}

template <class C, class T = typename C::mapped_type>
void setValue(C& m, const typename C::key_type& key, const typename std::enable_if<std::is_pointer<T>::value, T>::type& value, std::string calledFrom)  {
        if (value == nullptr)   {
                std::string msg = "Attempt to store nullptr as a value!\n\n";
                msg += "Called from:\n"+calledFrom;
                throw SolverException(caller(), msg);
        }

        setValueHelper(m, key, value, calledFrom);
}

template <class C, class T = typename C::mapped_type>
void setValue(C& m, const typename C::key_type& key, const typename std::enable_if<!std::is_pointer<T>::value, T>::type& value, std::string calledFrom) {
        setValueHelper(m, key, value, calledFrom);
}
// @}

uint64_t pack(const uint32_t& v1, const uint32_t& v2);
std::pair<uint32_t, uint32_t> unpack(const uint64_t& v);

template <class C>
extern uint64_t hashOW(const C& v);

template <class C>
extern uintptr_t hashEW(const C& v);


bool fileExists(const std::string& pathToFile);

#endif