helper.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-
// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of the SCHUNK Canopen Driver suite.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 SCHUNK GmbH, Lauffen/Neckar Germany
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
// -- END LICENSE BLOCK ------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------

#ifndef HELPER_H
#define HELPER_H

#include <boost/shared_ptr.hpp>
#include "CanOpenReceiveThread.h"
#include "Logging.h"

namespace icl_hardware{
namespace canopen_schunk{

typedef boost::shared_ptr<CanOpenReceiveThread> CanOpenReceiveThreadPtr;
typedef boost::shared_ptr<icl_hardware::can::tCanDevice> CanDevPtr;
typedef icl_hardware::can::tCanMessage CanMsg;


std::string hexToString (const uint64_t num);

std::string hexArrayToString( const unsigned char* msg, const uint8_t length);

template <typename T>
std::string binaryString (const T num)
{
  const size_t T_size = sizeof(T) * 8;
  std::bitset<T_size> bs(num);
  std::stringstream ss;
  ss << "0b" << bs;
  return ss.str();
}

std::string sanitizeString(const std::string& text);


std::map<uint32_t, std::string> getErrorMapFromConfigFile(const std::string& filename,
                                                          const std::string& category = "error_codes");

template <typename T>
inline std::vector<uint8_t> convertToCharVector(const T value)
{
  std::vector<uint8_t> out_vec;
  if (boost::is_fundamental<T>::value)
  {
    int32_t full_byte = 0xff;
    size_t num_bytes = sizeof(T);
    int32_t cast_int;

    if ( num_bytes <= 4)
    {
      std::memcpy(&cast_int, &value, num_bytes);
      for (size_t i = 0; i < num_bytes; ++i)
      {
        int32_t unary = cast_int & full_byte;
        out_vec.push_back(static_cast<uint8_t>( unary >> i*8));
        full_byte = full_byte << 8;
      }
    }
    else
    {
      LOGGING_ERROR (CanOpen, "The given data is too large. The maximum datatype size is 4 bytes." << endl);
      throw std::bad_cast();
    }
  }
  else
  {
    LOGGING_ERROR (CanOpen, "Only fundamental datatypes can be casted with the help of " << "this function. Fundamental types include integral, floating point and void types." << endl);
    throw std::bad_cast();
  }

  return out_vec;
}


template <typename T>
inline T convertFromCharVector(const std::vector<uint8_t>& vec)
{
  T ret_val = 0;
 size_t num_bytes = sizeof(T);
  if (boost::is_fundamental<T>::value && vec.size() == num_bytes)
  {
    std::memcpy(&ret_val, &vec[0], num_bytes);
  }
  else
  {
    LOGGING_ERROR (CanOpen, "Only fundamental datatypes can be casted with the help of " << "this function. Fundamental types include integral, floating point and void types." << endl);
    throw std::bad_cast();
  }
  return ret_val;
}

}} // NS

#endif // HELPER_H