UDPClient.hh

#ifndef __UDPCLIENT__
#define __UDPCLIENT__

#include <bias_config.h>

#include <stdlib.h>
#include <vector>

#ifdef WIN32
#include <winsock.h>
#else
#include <netinet/in.h>
#endif
#include "UDPDataConsumer.hh"

namespace BIAS {


struct message_frame_buffer {

  bool is_free;
  int number;
  int frame_number;
  int frame_size;
  int frames_total; // WARNING: DO WE NEED FRAMES TOTAL REALLY?
  char* frame_data;
};

 

/** 
  @class UDPClient
  @brief class for receiving UDP packages
    @ingroup network
  @author Ingo Thomsen
  */
class BIASNetworkComm_EXPORT UDPClient {

public:

  UDPClient();

  /**
     Destructor
  **/
  ~UDPClient();

  /**
    @param port Wait for incoming UDP packages on this port
    @param bind_to_ip bin to this IP, of NULL is given use any ip
  */
  void Init(int port,const char* bind_to_ip=NULL);

  /**
     Start receiving UDP packages. The is done in a seperated thread.
     @author Ingo Thomsen
     @param number_of_package_buffers How UDP packages shall be buffered?
     @param max_message_size The maximum size of a completed message
     @param number_of_message_buffers How many messages can be buffered (at least 1). Therefore
     the allocated memory size is at least max_message_size * number_of_message_buffers !
     @param uc The UDPDataConsumer whose  consume_complete_message()-method is
     called, when a message has been completed by this client.
     @returns -1 if there occurs an error before or while creating the thread and returns 0 otherwise
  **/
  int  start(int max_message_size, int number_of_message_buffers, 
         UDPDataConsumer* uc, bool UseTCP = false);

  
  /** 
      Stop the running client thread
      
      @author Ingo Thomsen
      @todo Leave the multicast group
  **/
  void stop();


  // Is the UDPClient started?
  inline bool IsActive() {return is_active_;}

  char *GetServerAddr(){return ServerAddr_;}

  void receive_loop();

protected:

  long message_counter;

  UDPDataConsumer* udc;

  char** completed_message;

  void check_for_complete_message(int last_number, int frames_total);

  int get_a_free_buffer();

  // Use multicast?
  bool isMulticast_;

  // Is true while client is started
  bool is_active_;
  // true when client loop has ended
  bool has_ended_;

  // The local  socket address
  struct sockaddr_in local_socket_address_;

  // descriptor of the UDP socket
  int socket_fd_;

  //  void* receive_loop(void* udpclient);

  std::vector<message_frame_buffer> Buffers_;

  void create_buffer_structure(unsigned int numbuffers);
  void destroy_buffer_structure();
  
  // the servers IP address in numbers-and-dots notation
  char *ServerAddr_;

  // number of UDP Package buffers
  int number_of_package_buffers_;
  bool TCPinsteadOfUDP_;

}; // class MulticastClient

} // namespace BIAS

#endif