utils.h

Go to the documentation of this file.

//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //
//                                                                                   //
//                       / /   / /    __    \ \  / /                                 //
//                      / /__ / /   / _ \    \ \/ /                                  //
//                     /  ___  /   | |/_/    / /\ \                                  //
//                    / /   / /    \_\      / /  \ \                                 //
//                                                                                   //
//                                                                                   //
//  Copyright (c) 2016, Jakub Benda, Charles University in Prague                    //
//                                                                                   //
// MIT License:                                                                      //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a          //
// copy of this software and associated documentation files (the "Software"),        //
// to deal in the Software without restriction, including without limitation         //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,          //
// and/or sell copies of the Software, and to permit persons to whom the             //
// Software is furnished to do so, subject to the following conditions:              //
//                                                                                   //
//  The above copyright notice and this permission notice shall be included          //
// in all copies or substantial portions of the Software.                            //
//                                                                                   //
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS          //
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE       //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, //
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF         //
// OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  //
//                                                                                   //
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //

#ifndef HEX_DB_UTIL_H
#define HEX_DB_UTIL_H

#include <iostream>
#include <string>
#include <map>
#include <vector>

#include "hex-arrays.h"
#include "hex-vec3d.h"

#include "db.h"

double change_units (eUnit A, eUnit B);

double change_units (lUnit A, lUnit B);

double change_units (aUnit A, aUnit B);

std::string unit_name (eUnit u);

std::string unit_name (lUnit u);

std::string unit_name (aUnit u);

inline std::ostream & operator << (std::ostream & os, std::pair<geom::vec3d,geom::vec3d> const & p)
{
    os << p.first << " " << p.second;
    return os;
}

inline std::istream & operator >> (std::istream & is, std::pair<geom::vec3d,geom::vec3d> & p)
{
    is >> p.first;
    is >> p.second;
    return is;
}

inline std::istream & operator >> (std::istream & is, iArray & p)
{
    std::string token;
    p.resize(0);
    while (std::getline(is, token, ','))
    {
        std::size_t idx, idx1, idx2;
        int value = std::stoi(token, &idx);
        
        // convert token to integer
        if (idx == token.size())
        {
            p.push_back(value);
        }
        
        // convert token to range
        else
        {
            std::size_t pos = token.find('-', 1);
            if (pos == std::string::npos)
                HexException("Failed to parse \"%s\"", token.c_str());
            
            std::string str_a = token.substr(0, pos);
            std::string str_b = token.substr(pos + 1);
            int a = std::stoi(str_a, &idx1);
            int b = std::stoi(str_b, &idx2);
            if (idx1 != str_a.size() or idx2 != str_b.size())
                HexException("Failed to parse \"%s\"", token.c_str());
            
            iArray values = linspace(a, b, b - a + 1);
            p.append(values.begin(), values.end());
        }
    }
    return is;
}

template<typename T> std::vector<T> readStandardInput ()
{
    std::vector<T> data;
    
    T x;
    while (not std::cin.eof())
    {
        std::cin >> std::ws;
        std::cin >> x;
        std::cin >> std::ws;
        data.push_back(x);
    }
    
    return data;
}

template <typename T> T Conv
(
    std::map<std::string,std::string> const & dict,
    std::string const & keyword,
    std::string const & name
)
{
    // check existence of the keyword
    std::map<std::string,std::string>::const_iterator it = dict.find(keyword);
    if (it == dict.end())
        throw exception ("ERROR: \"%s\" requires specifying the parameter \"--%s\"!\n", name.c_str(), keyword.c_str());
    
    // convert to int
    T x;
    std::istringstream ss(it->second);
    ss >> x;
    return x;
}

#endif