util.h

Go to the documentation of this file.

/*
 *  VieSched++ Very Long Baseline Interferometry (VLBI) Scheduling Software
 *  Copyright (C) 2018  Matthias Schartner
 *
 *  This program 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.
 *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef GIT_COMMIT_HASH
#define GIT_COMMIT_HASH "unknown"
#endif

#ifndef UTILITY_H
#define UTILITY_H


#include <boost/date_time.hpp>
#include <boost/format.hpp>
#include <boost/property_tree/ptree.hpp>
#include <cmath>
#include <numeric>
#include <vector>

#include "Constants.h"


namespace VieVS {
enum class Timestamp {
    start,  
    end     
};
}  // namespace VieVS

namespace VieVS {
namespace util {

unsigned long getNumberOfStations( const boost::property_tree::ptree &xml );


std::vector<std::string> getStationNames( const boost::property_tree::ptree &xml );


std::string ra2dms( double angle );


std::string ra2dms_astFormat( double angle );


std::string dc2hms( double angle );


std::string dc2hms_astFormat( double angle );


double freqency2wavelenth( double frequency );


double wavelength2frequency( double wavelength );


double wrap2twoPi( double angle );


double wrap2pi( double angle );


int duration( const boost::posix_time::ptime &start, const boost::posix_time::ptime &end );


std::string version();


template <typename T>
T absDiff( const T &a, const T &b ) {
    return ( a > b ) ? ( a - b ) : ( b - a );
}


template <typename T>
std::vector<int> sortIndexes( const std::vector<T> &v ) {
    // initialize original index locations
    std::vector<int> idx( v.size() );
    std::iota( idx.begin(), idx.end(), 0 );

    // sort indexes based on comparing values in v
    std::sort( idx.begin(), idx.end(), [&v]( int i1, int i2 ) { return v[i1] < v[i2]; } );

    return idx;
}


template <typename K, typename V>
bool valueExists( std::map<K, V> mapOfElemen, V value ) {
    auto it = mapOfElemen.begin();
    // Iterate through the map
    while ( it != mapOfElemen.end() ) {
        // Check if value of this entry matches with given value
        if ( it->second == value ) {
            return true;
        }
        // Go to next entry in map
        it++;
    }
    return false;
}


void outputObjectList( const std::string &title, const std::vector<std::string> &names, std::ofstream &of,
                       unsigned long indents = 4 );


std::string weekDay2string( int weekday );


std::string month2string( int month );

template <typename A, typename B>
std::pair<B, A> flip_pair( const std::pair<A, B> &p ) {
    return std::pair<B, A>( p.second, p.first );
}

template <typename A, typename B>
std::map<B, A> flip_map( const std::map<A, B> &src ) {
    std::map<B, A> dst;
    for ( const auto &any : src ) dst[any.second] = any.first;
    return dst;
}

char numberOfScans2char( long n );

std::string numberOfScans2char_header();


void simplify_inline( std::string &str );

std::string simplify( const std::string &str );
std::string milliseconds2string( long long int usec, bool forceSeconds = false );

std::string version2prefix(int version);


}  // namespace util
}  // namespace VieVS

#endif  // UTILITY_H