util.h

Go to the documentation of this file.

//======================================================================
//======================================================================
 
#ifndef UTIL_H_
#define UTIL_H_
 
 
//----------------------------------------------------------------------
// System Includes - include with <>
//----------------------------------------------------------------------
 
#include <math.h>
#include <vector>
#include <algorithm>
#include <iostream>
 
//----------------------------------------------------------------------
// Project Includes - include with ""
//----------------------------------------------------------------------
 
#include "sdhlibrary_settings.h"
#include "simplevector.h"
 
//----------------------------------------------------------------------
// Defines, enums, unions, structs,
//----------------------------------------------------------------------
 
NAMESPACE_SDH_START
 
 
//----------------------------------------------------------------------
// Global variables
//----------------------------------------------------------------------
 
 
//----------------------------------------------------------------------
// Function declarations
//----------------------------------------------------------------------
 
 
//----------------------------------------------------------------------
// Class declarations
//----------------------------------------------------------------------
 
 
 
//-----------------------------------------------------------------
 
#define DEFINE_TO_CASECOMMAND( _c ) case _c: return (#_c)
 
#define DEFINE_TO_CASECOMMAND_MSG( _c, ... ) case _c: return (#_c ": " __VA_ARGS__)
 
VCC_EXPORT bool InIndex( int v, int max );
 
 
VCC_EXPORT bool InRange( double v, double min, double max );
 
 
VCC_EXPORT bool InRange( int n, double const* v, double const* min, double const* max );
 
 
VCC_EXPORT double ToRange( double v, double min, double max );
 
 
VCC_EXPORT void ToRange( int n, double* v, double const* min, double const* max );
 
 
VCC_EXPORT void ToRange( std::vector<double>& v, std::vector<double> const& min, std::vector<double> const& max );
 
 
VCC_EXPORT void ToRange( cSimpleVector& v, std::vector<double> const& min, std::vector<double> const& max );
 
 
VCC_EXPORT double Approx( double a, double b, double eps );
 
 
VCC_EXPORT bool Approx( int n, double* a, double* b, double* eps );
 
 
VCC_EXPORT double DegToRad( double d );
 
 
VCC_EXPORT double RadToDeg( double r );
 
 
VCC_EXPORT void SleepSec( double t );
 
 
template<typename Function, typename Tp>
void apply( Function f, Tp& sequence )
{
    // concept requirements
 
    for ( typename Tp::iterator it = sequence.begin();
          it < sequence.end();
          it++ )
    {
        *it = f( *it );
    }
}
//----------------------------------------------------------------------
 
 
template<typename Function, typename InputIterator>
Function
apply( Function f, InputIterator first, InputIterator last)
{
    // concept requirements (not understood by gcc 3.2, thus commented out)
    //__glibcxx_function_requires(_InputIteratorConcept<InputIterator>)
    //  __glibcxx_requires_valid_range(first, last);
  for ( ; first != last; ++first)
        *first = f(*first);
}
//----------------------------------------------------------------------
 
template<typename Function, typename Tp>
Tp map(Function f, Tp sequence)
{
    Tp result (sequence);
 
    apply( f, result );
 
    return result;
}
//----------------------------------------------------------------------
 
template<typename T>
std::ostream& operator<<(std::ostream& stream, std::vector<T> const& v)
{
    char const* sep = "";
 
    typename std::vector<T>::const_iterator it;
    for ( it = v.begin();
          it != v.end();
          it++ )
    {
        stream << sep << *it ;
        sep = ", ";
    }
 
    return stream;
}
//----------------------------------------------------------------------
 
VCC_EXPORT int CompareReleases( char const* rev1, char const* rev2 );
//----------------------------------------------------------------------
 
template<typename T>
class VCC_EXPORT cSetValueTemporarily
{
    T* value_ptr;
    T  old_value;
public:
    cSetValueTemporarily( T* _value_ptr, T new_value )
    : value_ptr( _value_ptr ),
      old_value( *value_ptr )
    {
        *value_ptr = new_value;
    }
 
    ~cSetValueTemporarily()
    {
        *value_ptr = old_value;
    }
};
 
 
NAMESPACE_SDH_END
 
#endif
 
 
//======================================================================
/*
  Here are some settings for the emacs/xemacs editor (and can be safely ignored):
  (e.g. to explicitely set C++ mode for *.h header files)
 
  Local Variables:
  mode:C++
  mode:ELSE
  End:
*/
//======================================================================