Merge pull request #8 from slsdetectorgroup/use-unique-ptr

In Listener, remove raw pointers allocations, use `unique_ptr` instead.

slsReceiverSoftware/include/Listener.h

@@ -9,6 +9,8 @@
  *@short creates & manages a listener thread each
  */
 
+#include <memory>
+
 #include "ThreadObject.h"
 
 class GeneralData;
@@ -169,7 +171,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
 	 * Pop free addresses, listen to udp socket,
 	 * write to memory & push the address into fifo
 	 */
-	void ThreadExecution();
+	void ThreadExecution() override;
 
 	/**
 	 * Pushes non empty buffers into fifo/ frees empty buffer,
@@ -207,7 +209,6 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
 	/** Fifo structure */
 	Fifo* fifo;
 
-
 	// individual members
 	/** Detector Type */
 	detectorType myDetectorType;
@@ -216,7 +217,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
 	runStatus* status;
 
 	/** UDP Socket - Detector to Receiver */
-	genericSocket* udpSocket;
+	std::unique_ptr<genericSocket> udpSocket;
 
 	/** UDP Port Number */
 	uint32_t* udpPortNumber;
@@ -293,10 +294,10 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
 	bool carryOverFlag;
 
 	/** Carry over packet buffer */
-	char* carryOverPacket;
+	std::unique_ptr<char []> carryOverPacket;
 
 	/** Listening buffer for one packet - might be removed when we can peek and eiger fnum is in header */
-	char* listeningPacket;
+	std::unique_ptr<char []> listeningPacket;
 
 	/** if the udp socket is connected */
 	bool udpSocketAlive;

slsReceiverSoftware/src/Listener.cpp

@@ -10,6 +10,7 @@
 #include "GeneralData.h"
 #include "Fifo.h"
 #include "genericSocket.h"
+#include "container_utils.h" // For sls::make_unique<>
 
 #include <iostream>
 #include <errno.h>
@@ -50,8 +51,6 @@ Listener::Listener(int ind, detectorType dtype, Fifo* f, runStatus* s,
 		lastCaughtFrameIndex(0),
 		currentFrameIndex(0),
 		carryOverFlag(0),
-		carryOverPacket(nullptr),
-		listeningPacket(nullptr),
 		udpSocketAlive(0),
 		numPacketsStatistic(0),
 		numFramesStatistic(0),
@@ -66,13 +65,10 @@ Listener::Listener(int ind, detectorType dtype, Fifo* f, runStatus* s,
 
 Listener::~Listener() {
 	if (udpSocket){
-		delete udpSocket;
 		sem_post(&semaphore_socket);
     	sem_destroy(&semaphore_socket);
 	} 
 
-	if (carryOverPacket) delete [] carryOverPacket;
-	if (listeningPacket) delete [] listeningPacket;
 	ThreadObject::DestroyThread();
 }
 
@@ -131,14 +127,10 @@ void Listener::ResetParametersforNewMeasurement() {
 	numPacketsCaught = 0;
 	firstMeasurementIndex = 0;
 	carryOverFlag = false;
-	if (carryOverPacket)
-		delete [] carryOverPacket;
-	carryOverPacket = new char[generalData->packetSize];
-	memset(carryOverPacket,0,generalData->packetSize);
-	if (listeningPacket)
-		delete [] listeningPacket;
-	listeningPacket = new char[generalData->packetSize];
-	memset(listeningPacket,0,generalData->packetSize);
+	carryOverPacket = sls::make_unique<char[]>(generalData->packetSize);
+	memset(carryOverPacket.get(),0,generalData->packetSize);
+	listeningPacket = sls::make_unique<char[]>(generalData->packetSize);
+	memset(carryOverPacket.get(),0,generalData->packetSize);
 
 	numPacketsStatistic = 0;
 	numFramesStatistic = 0;
@@ -204,10 +196,9 @@ int Listener::CreateUDPSockets() {
 	ShutDownUDPSocket();
 
 	try{
-	    genericSocket* g = new genericSocket(*udpPortNumber, genericSocket::UDP,
+	    udpSocket = sls::make_unique<genericSocket>(*udpPortNumber, genericSocket::UDP,
 				generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize,
 				*udpSocketBufferSize);
-	    udpSocket = g;
 		FILE_LOG(logINFO) << index << ": UDP port opened at port " << *udpPortNumber;
 	} catch (...) {
 		FILE_LOG(logERROR) << "Could not create UDP socket on port " << *udpPortNumber;
@@ -235,8 +226,6 @@ void Listener::ShutDownUDPSocket() {
 		//give a post to semaphore(at stopListening)
 		if (runningFlag)
 			sem_wait(&semaphore_socket);
-        delete udpSocket;
-        udpSocket = nullptr;
 	    sem_destroy(&semaphore_socket);
 	}
 }
@@ -261,13 +250,11 @@ int Listener::CreateDummySocketForUDPSocketBufferSize(uint64_t s) {
     // shutdown if any open
     if(udpSocket){
         udpSocket->ShutDownSocket();
-        delete udpSocket;
-        udpSocket = nullptr;
     }
 
     //create dummy socket
     try {
-    	udpSocket = new genericSocket(*udpPortNumber, genericSocket::UDP,
+    	udpSocket = sls::make_unique<genericSocket>(*udpPortNumber, genericSocket::UDP,
             generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize,
             *udpSocketBufferSize);
     } catch (...) {
@@ -287,8 +274,6 @@ int Listener::CreateDummySocketForUDPSocketBufferSize(uint64_t s) {
     if(udpSocket){
         udpSocketAlive = false;
         udpSocket->ShutDownSocket();
-        delete udpSocket;
-        udpSocket = nullptr;
     }
 
     return OK;
@@ -422,13 +407,13 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		//check if its the current image packet
 		// -------------------------- new header ----------------------------------------------------------------------
 		if (standardheader) {
-			old_header = (sls_detector_header*) (carryOverPacket + esize);
+			old_header = (sls_detector_header*) (&carryOverPacket[esize]);
 			fnum = old_header->frameNumber;
 			pnum = old_header->packetNumber;
 		}
 		// -------------------old header -----------------------------------------------------------------------------
 		else {
-			generalData->GetHeaderInfo(index, carryOverPacket + esize,
+			generalData->GetHeaderInfo(index, &carryOverPacket[esize],
 					*dynamicRange, oddStartingPacket, fnum, pnum, snum, bid);
 		}
 		//------------------------------------------------------------------------------------------------------------
@@ -462,19 +447,19 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		//				2nd packet: 4 bytes fnum, previous 1*2 bytes data  + 640*2 bytes data !!
 		case GOTTHARD:
 			if(!pnum)
-				memcpy(buf + fifohsize , carryOverPacket + hsize+4, dsize-2);
+				memcpy(buf + fifohsize , &carryOverPacket[hsize+4], dsize-2);
 			else
-				memcpy(buf + fifohsize + dsize - 2, carryOverPacket + hsize, dsize+2);
+				memcpy(buf + fifohsize + dsize - 2, &carryOverPacket[hsize], dsize+2);
 			break;
 		case CHIPTESTBOARD:
 		case MOENCH:
 			if (pnum == (pperFrame-1))
-				memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize, corrected_dsize);
+				memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize], corrected_dsize);
 			else
-				memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize,  dsize);
+				memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize],  dsize);
 			break;
 		default:
-			memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize, dsize);
+			memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize], dsize);
 			break;
 		}
 
@@ -510,7 +495,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		//listen to new packet
 		rc = 0;
 		if (udpSocketAlive){
-			rc = udpSocket->ReceiveDataOnly(listeningPacket);
+			rc = udpSocket->ReceiveDataOnly(&listeningPacket[0]);
 		}
 		// end of acquisition
 		if(rc <= 0) {
@@ -540,7 +525,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 
 		// -------------------------- new header ----------------------------------------------------------------------
 		if (standardheader) {
-			old_header = (sls_detector_header*) (listeningPacket + esize);
+			old_header = (sls_detector_header*) (&listeningPacket[esize]);
 			fnum = old_header->frameNumber;
 			pnum = old_header->packetNumber;
 		}
@@ -548,10 +533,10 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		else {
             // set first packet to be odd or even (check required when switching from roi to no roi)
             if (myDetectorType == GOTTHARD && !measurementStartedFlag) {
-                oddStartingPacket = generalData->SetOddStartingPacket(index, listeningPacket + esize);
+                oddStartingPacket = generalData->SetOddStartingPacket(index, &listeningPacket[esize]);
             }
 
-			generalData->GetHeaderInfo(index, listeningPacket + esize,
+			generalData->GetHeaderInfo(index, &listeningPacket[esize],
 					*dynamicRange, oddStartingPacket, fnum, pnum, snum, bid);
 		}
 		//------------------------------------------------------------------------------------------------------------
@@ -582,7 +567,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		//future packet	by looking at image number  (all other detectors)
 		if (fnum != currentFrameIndex) {
 			carryOverFlag = true;
-			memcpy(carryOverPacket,listeningPacket, generalData->packetSize);
+			memcpy(carryOverPacket.get(), &listeningPacket[0], generalData->packetSize);
 
 			switch(*frameDiscardMode) {
 			case DISCARD_EMPTY_FRAMES:
@@ -608,19 +593,19 @@ uint32_t Listener::ListenToAnImage(char* buf) {
 		//				2nd packet: 4 bytes fnum, previous 1*2 bytes data  + 640*2 bytes data !!
 		case GOTTHARD:
 			if(!pnum)
-				memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize+4, dsize-2);
+				memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize+4], dsize-2);
 			else
-				memcpy(buf + fifohsize + (pnum * dsize) - 2, listeningPacket + hsize, dsize+2);
+				memcpy(buf + fifohsize + (pnum * dsize) - 2, &listeningPacket[hsize], dsize+2);
 			break;
 		case CHIPTESTBOARD:
 		case MOENCH:
 			if (pnum == (pperFrame-1))
-				memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, corrected_dsize);
+				memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], corrected_dsize);
 			else
-				memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, dsize);
+				memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], dsize);
 			break;
 		default:
-			memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, dsize);
+			memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], dsize);
 			break;
 		}
 		++numpackets;			//number of packets in this image (each time its copied to buf)

slsSupportLib/include/container_utils.h

@@ -8,6 +8,7 @@
 #include <vector>
 #include <sstream>
 #include <memory>
+
 namespace sls {
 
 
@@ -15,10 +16,20 @@ namespace sls {
 // C++11 make_unique implementation for exception safety
 // already available as std::make_unique in C++14
 template <typename T, typename... Args>
-std::unique_ptr<T> make_unique(Args &&... args) {
+typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(Args &&... args) {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
 
+template <typename T>
+typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
+make_unique(std::size_t n)
+{
+    typedef typename std::remove_extent<T>::type RT;
+    return std::unique_ptr<T>(new RT[n]);
+}
+
+
 template <typename T>
 bool allEqual(const std::vector<T>& container)
 {