SVHControlCommand.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 SVH 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 2014 SCHUNK Mobile Greifsysteme GmbH, Lauffen/Neckar Germany
// © Copyright 2014 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef SVHCONTROLCOMMAND_H
#define SVHCONTROLCOMMAND_H

#include <icl_comm/ByteOrderConversion.h>

namespace driver_svh {

struct SVHControlCommand
{
  int32_t position;

  SVHControlCommand(const int32_t& _position = 0):
    position(_position)
  {}

  bool operator == (const SVHControlCommand& other) const
  {
    return (position == other.position);
  }

};

struct SVHControlCommandAllChannels
{
  std::vector<SVHControlCommand> commands;

  SVHControlCommandAllChannels(const int32_t& _position0,const int32_t& _position1,const int32_t& _position2,
                                const int32_t& _position3,const int32_t& _position4,const int32_t& _position5,
                                const int32_t& _position6,const int32_t& _position7,const int32_t& _position8)
  {
    commands.push_back(SVHControlCommand(_position0));
    commands.push_back(SVHControlCommand(_position1));
    commands.push_back(SVHControlCommand(_position2));
    commands.push_back(SVHControlCommand(_position3));
    commands.push_back(SVHControlCommand(_position4));
    commands.push_back(SVHControlCommand(_position5));
    commands.push_back(SVHControlCommand(_position6));
    commands.push_back(SVHControlCommand(_position7));
    commands.push_back(SVHControlCommand(_position8));
  }

  SVHControlCommandAllChannels(const std::vector<int32_t>& positions)
  {
    commands.insert(commands.begin(),positions.begin(),positions.begin()+9);
  }

  SVHControlCommandAllChannels():
    commands(9,SVHControlCommand())
  { }

  bool operator == (const SVHControlCommandAllChannels& other) const
  {
    return (commands == other.commands);
  }
};


inline icl_comm::ArrayBuilder& operator << (icl_comm::ArrayBuilder& ab, const SVHControlCommand& data)
{
  ab << data.position;
  return ab;
}


inline icl_comm::ArrayBuilder& operator >> (icl_comm::ArrayBuilder& ab, SVHControlCommand& data)
{
  ab >> data.position;
  return ab;
}

inline std::ostream& operator << (std::ostream& o, const SVHControlCommand& cc)
{
  o << "Pos: " << cc.position << std::endl;
  return o;
}

inline icl_comm::ArrayBuilder& operator << (icl_comm::ArrayBuilder& ab, const SVHControlCommandAllChannels& data)
{
  // We could also just give the whole vector in ...
  for (std::vector<SVHControlCommand>::const_iterator it = data.commands.begin() ; it != data.commands.end(); ++it)
  {
    ab << *it;
  }
  return ab;
}


inline icl_comm::ArrayBuilder& operator >> (icl_comm::ArrayBuilder& ab, SVHControlCommandAllChannels& data)
{
  for (std::vector<SVHControlCommand>::iterator it = data.commands.begin() ; it != data.commands.end(); ++it)
  {
    ab >> *it;
  }
  return ab;
}


inline std::ostream& operator << (std::ostream& o, const SVHControlCommandAllChannels& cc)
{
  o << "Commands: " ;
  unsigned int i = 0;
  for (std::vector<SVHControlCommand>::const_iterator it = cc.commands.begin() ; it != cc.commands.end(); ++it)
  {
    o << "Chan " << i << " : "<< *it;
    ++i;
  }
  o << std::endl;
  return o;
}
}

#endif // SVHCONTROLCOMMAND_H