SickMessage.hh

Go to the documentation of this file.

#ifndef SICK_MESSAGE
#define SICK_MESSAGE

/* Dependencies */
#include <arpa/inet.h>
#include <iomanip>
#include <iostream>

/* Associate the namespace */
namespace SickToolbox {

  template < unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  class SickMessage {

  public:

    static const unsigned int MESSAGE_HEADER_LENGTH = MSG_HEADER_LENGTH;
    static const unsigned int MESSAGE_TRAILER_LENGTH = MSG_TRAILER_LENGTH;
    static const unsigned int MESSAGE_PAYLOAD_MAX_LENGTH = MSG_PAYLOAD_MAX_LENGTH;
    static const unsigned int MESSAGE_MAX_LENGTH = MESSAGE_HEADER_LENGTH + MESSAGE_PAYLOAD_MAX_LENGTH + MESSAGE_TRAILER_LENGTH;
        
    SickMessage( );

    void BuildMessage( const uint8_t * const payload_buffer, const unsigned int payload_length );
    
    virtual void ParseMessage( const uint8_t * const message_buffer ) = 0;

    void GetMessage( uint8_t * const message_buffer ) const;

    unsigned int GetMessageLength( ) const { return _message_length; }
    
    void GetPayload( uint8_t * const payload_buffer ) const;

    void GetPayloadAsCStr( char * const payload_str ) const;
    
    void GetPayloadSubregion( uint8_t * const payload_sub_buffer, const unsigned int start_idx,
                              const unsigned int stop_idx ) const;
    
    unsigned int GetPayloadLength( ) const { return _payload_length; } 
    
    bool IsPopulated( ) const { return _populated; };
    
    virtual void Clear( );

    virtual void Print( ) const;

    virtual ~SickMessage( );

  protected:

    unsigned int _payload_length;

    unsigned int _message_length;

    uint8_t _message_buffer[MESSAGE_MAX_LENGTH];

    bool _populated;

  };


  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::SickMessage( ) { }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::BuildMessage( const uint8_t * const payload_buffer, const unsigned int payload_length ) {
    
    /* Clear the object */
    Clear();
    
    /* Assign the payload and message lengths */
    _payload_length = payload_length;
    _message_length = MESSAGE_HEADER_LENGTH + MESSAGE_TRAILER_LENGTH + _payload_length;

    /* Copy the payload into the message buffer */
    memcpy(&_message_buffer[MESSAGE_HEADER_LENGTH],payload_buffer,_payload_length);

    /* Mark the object container as being populated */
    _populated = true;
    
  }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::ParseMessage( const uint8_t * const message_buffer ) {

    /* Clear the message container/object */
    Clear(); 

    /* Mark the object as populated */
    _populated = true;    
  }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::GetMessage( uint8_t * const message_buffer ) const {
    memcpy(message_buffer,_message_buffer,_message_length);
  }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::GetPayload( uint8_t * const payload_buffer ) const {
    memcpy(payload_buffer,&_message_buffer[MESSAGE_HEADER_LENGTH],_payload_length);
  }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::GetPayloadAsCStr( char * const payload_buffer ) const {
    memcpy(payload_buffer,&_message_buffer[MESSAGE_HEADER_LENGTH],_payload_length);
    payload_buffer[_payload_length] = '\0';
  }
  
  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::GetPayloadSubregion( uint8_t * const payload_sub_buffer,
                                                                                                          const unsigned int start_idx,
                                                                                                          const unsigned int stop_idx ) const {
    /* Extract the subregion */
    memcpy(payload_sub_buffer,&_message_buffer[MESSAGE_HEADER_LENGTH+start_idx],stop_idx+1);
  }
  
  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::Clear( ) {

    /* Reset the parent integer variables */
    _message_length = _payload_length = 0;

    /* Clear the message buffer */
    memset(_message_buffer,0,MESSAGE_MAX_LENGTH);

    /* Set the flag indicating this message object/container is empty */
    _populated = false;
  }
  
  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  void SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::Print( ) const {

    std::cout << "Payload length: " << GetPayloadLength() << std::endl;
    std::cout << "Message length: " << GetMessageLength() << std::endl;
    std::cout << std::flush;

    std::cout << "Message (hex):" << std::endl;
    std::cout.setf(std::ios::hex,std::ios::basefield);
    for (unsigned int i = 0; i < _message_length; i++) {
      std::cout << (int)_message_buffer[i] << " ";
    }
    std::cout << std::endl << std::flush;

    std::cout << "Message (ASCII):" << std::endl;
    std::cout.setf(std::ios::dec,std::ios::basefield);
    for (unsigned int i = 0; i < _message_length; i++) {
      std::cout << _message_buffer[i] << " ";
    }
    std::cout << std::endl << std::flush;    
  }

  template< unsigned int MSG_HEADER_LENGTH, unsigned int MSG_PAYLOAD_MAX_LENGTH, unsigned int MSG_TRAILER_LENGTH >
  SickMessage< MSG_HEADER_LENGTH, MSG_PAYLOAD_MAX_LENGTH, MSG_TRAILER_LENGTH >::~SickMessage() { }
  
} /* namespace SickToolbox */

#endif /* SICK_MESSAGE */