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:
*/
//======================================================================