/scr/tee1/isis/lib/Core/CoreUtils/common.hpp

Go to the documentation of this file.

//
// C++ Interface: common
//
// Description:
//
//
// Author: Enrico Reimer<reimer@cbs.mpg.de>, (C) 2009
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef CORE_COMMON_HPP
#define CORE_COMMON_HPP

#ifdef _MSC_VER
#define NOMINMAX 1
#endif

#include <utility>
#include <ostream>
#include <map>
#include <string>
#include <sstream>
#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/mpl/assert.hpp>
#include <set>
#include <cmath>
#include "log.hpp"
#include "log_modules.hpp"
#include "../config.hpp"

#ifdef WIN32
#include <Windows.h>
#endif

namespace isis
{
namespace util
{

std::string getLastSystemError();

template<class InputIterator, typename _CharT, typename _Traits> std::basic_ostream<_CharT, _Traits> &
listToOStream( InputIterator start, InputIterator end,
               std::basic_ostream<_CharT, _Traits> &o,
               const std::string delim = ",",
               const std::string prefix = "{", const std::string suffix = "}" )
{
    o << prefix;

    if ( start != end ) {
        o << *start;
        start++;
    }

    for ( InputIterator i = start; i != end; i++ )
        o << delim << *i;

    o << suffix;
    return o;
}

// specialization to print char-list as number lists, not strings
//@todo check if this works for VC
template<typename _CharT, typename _Traits> std::basic_ostream<_CharT, _Traits> &
listToOStream( const unsigned char *start, const unsigned char *end,
               std::basic_ostream<_CharT, _Traits> &o,
               const std::string delim = ",",
               const std::string prefix = "{", const std::string suffix = "}" )
{
    o << prefix;

    if ( start != end ) {
        o << ( unsigned short )*start;
        start++;
    }

    for ( const unsigned char *i = start; i != end; i++ )
        o << delim << ( unsigned short )*i;

    o << suffix;
    return o;
}

template<class InputIterator> std::string listToString(
    InputIterator start, InputIterator end,
    const std::string delim = ",",
    const std::string prefix = "{", const std::string suffix = "}" )
{
    std::ostringstream ret;
    listToOStream( start, end, ret, delim, prefix, suffix );
    return ret.str();
}
template<typename T, typename InputIterator> std::list<T> listToList( InputIterator start, InputIterator end )
{
    std::list<T> ret;

    for ( ; start != end; start++ )
        ret.push_back( boost::lexical_cast<T>( *start ) );

    return ret;
}

template<typename TARGET> std::list<TARGET> stringToList(
    std::string source, const boost::regex &separator,
    boost::regex prefix, boost::regex postfix )
{
    std::list<TARGET> ret;
    assert( ! separator.empty() );

    if ( ! prefix.empty() ) {
        if ( prefix.str()[0] != '^' )
            prefix = boost::regex( std::string( "^" ) + prefix.str(), prefix.flags() );

        source = boost::regex_replace( source, prefix, "", boost::format_first_only | boost::match_default );
    }

    if ( ! postfix.empty() ) {
        if ( postfix.str()[postfix.size() - 1] != '$' )
            postfix = boost::regex( postfix.str() + "$", postfix.flags() );

        source = boost::regex_replace( source, postfix, "", boost::format_first_only | boost::match_default );
    }

    boost::sregex_token_iterator i = boost::make_regex_token_iterator( source, separator, -1 );
    const boost::sregex_token_iterator token_end;

    while ( i != token_end ) {
        ret.push_back( boost::lexical_cast<TARGET>( ( i++ )->str() ) );
    }

    return ret;
}
template<typename TARGET> std::list<TARGET> stringToList(
    std::string source,
    const boost::regex separator = boost::regex( "[[:space:]]" ) )
{
    return stringToList<TARGET>( source, separator, separator, separator );
}

//@todo test
template<typename TARGET, typename charT, typename traits> std::list<TARGET>
stringToList( const std::basic_string<charT, traits> &source,  charT separator )
{
    std::list<TARGET> ret;

    for (
        size_t next = source.find_first_not_of( separator );
        next != std::string::npos;
        next = source.find_first_not_of( separator, next )
    ) {
        const size_t start = next;
        next = source.find( separator, start );
        ret.push_back( boost::lexical_cast<TARGET>( source.substr( start, next - start ) ) );
    }

    return ret;
}

template<typename T> bool fuzzyEqual( T a, T b, unsigned short scale = 10 )
{
    BOOST_MPL_ASSERT( ( boost::is_float<T> ) );

    const T epsilon = std::numeric_limits<T>::epsilon(); // get the distange between 1 and the next representable value
    T bigger, smaller;

    a = std::abs( a );
    b = std::abs( b );

    if( a < b ) {
        bigger = b;
        smaller = a;
    } else {
        smaller = b;
        bigger = a;
    }

    if( smaller == 0 )
        return bigger < std::numeric_limits<T>::min() * scale;

    const T factor = 1 / smaller; // scale smaller to that value
    return ( bigger * factor ) <= ( 1 + epsilon * scale ); //scaled bigger should be between 1 and the next representable value
}

typedef CoreDebug Debug;
typedef CoreLog Runtime;

template<typename HANDLE> void enableLog( LogLevel level )
{
    ENABLE_LOG( CoreLog, HANDLE, level );
    ENABLE_LOG( CoreDebug, HANDLE, level );
}
}//util

template<typename HANDLE> void enableLogGlobal( LogLevel level )
{
    ENABLE_LOG( CoreLog, HANDLE, level );
    ENABLE_LOG( CoreDebug, HANDLE, level );
    ENABLE_LOG( ImageIoLog, HANDLE, level );
    ENABLE_LOG( ImageIoDebug, HANDLE, level );
    ENABLE_LOG( DataLog, HANDLE, level );
    ENABLE_LOG( DataDebug, HANDLE, level );
}
}//isis

namespace std
{
template<typename charT, typename _FIRST, typename _SECOND > basic_ostream<charT, std::char_traits<charT> >&
operator<<( basic_ostream<charT, std::char_traits<charT> > &out, const pair<_FIRST, _SECOND> &s )
{
    return out << s.first << ":" << s.second;
}

template<typename charT, typename _Key, typename _Tp, typename _Compare, typename _Alloc >
basic_ostream<charT, std::char_traits<charT> >& operator<<( basic_ostream<charT, std::char_traits<charT> > &out, const map<_Key, _Tp, _Compare, _Alloc>& s )
{
    isis::util::listToOStream( s.begin(), s.end(), out, "\n", "", "" );
    return out;
}

template<typename charT, typename _Tp, typename _Compare, typename _Alloc >
basic_ostream<charT, std::char_traits<charT> >& operator<<( basic_ostream<charT, std::char_traits<charT> > &out, const map<std::string, _Tp, _Compare, _Alloc>& s )
{
    size_t key_len = 0;
    typedef typename map<std::string, _Tp, _Compare, _Alloc>::const_iterator m_iterator;

    for ( m_iterator i = s.begin(); i != s.end(); i++ )
        if ( key_len < i->first.length() )
            key_len = i->first.length();

    for ( m_iterator i = s.begin(); i != s.end(); ) {
        out << make_pair( i->first + std::string( key_len - i->first.length(), ' ' ), i->second );

        if ( ++i != s.end() )
            out << std::endl;
    }

    return out;
}

template<typename charT, typename _Tp, typename _Alloc >
basic_ostream<charT, std::char_traits<charT> >& operator<<( basic_ostream<charT, std::char_traits<charT> > &out, const list<_Tp, _Alloc>& s )
{
    isis::util::listToOStream( s.begin(), s.end(), out );
    return out;
}
template<typename charT, typename _Tp, typename _Alloc >
basic_ostream<charT, std::char_traits<charT> >& operator<<( basic_ostream<charT, std::char_traits<charT> > &out, const set<_Tp, _Alloc>& s )
{
    isis::util::listToOStream( s.begin(), s.end(), out );
    return out;
}

}
#endif //CORE_COMMON_HPP