util.h

Go to the documentation of this file.

/*
 * Copyright (c) 2007 SCHUNK GmbH & Co. KG
 * Copyright (c) 2017 Fraunhofer Institute for Manufacturing Engineering and Automation (IPA)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0

 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

//======================================================================
//======================================================================

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