detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-18 15:57:13 +02:00
Code Issues Actions Packages Releases Activity

rxr: renamed files, removed unnecessary comments

Browse Source
This commit is contained in:
maliakal_d
2019-11-18 16:19:46 +01:00
parent 5ce79ec9fa
commit c4e7086d99
8 changed files with 607 additions and 1587 deletions
Download Patch File Download Diff File Expand all files Collapse all files

316
slsReceiverSoftware/src/slsReceiverTCPIPInterface.cpp → slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -1,14 +1,6 @@
/**********************************************
* @file
*slsReceiverTCPIPInterface.cpp
* @short interface between
*receiver and client
***********************************************/
#include "slsReceiverTCPIPInterface.h"
#include "ClientInterface.h"
#include "FixedCapacityContainer.h"
#include "ServerSocket.h"
#include "slsReceiverImplementation.h"
#include "sls_detector_exceptions.h"
#include "string_utils.h"
#include "versionAPI.h"
@ -28,15 +20,15 @@ using sls::RuntimeError;
using sls::SocketError;
using Interface = sls::ServerInterface2;
slsReceiverTCPIPInterface::~slsReceiverTCPIPInterface() { stop(); }
ClientInterface::~ClientInterface() { stopTCPSocket(); }
slsReceiverTCPIPInterface::slsReceiverTCPIPInterface(int pn)
: myDetectorType(GOTTHARD), portNumber(pn > 0 ? pn : DEFAULT_PORTNO + 2) {
ClientInterface::ClientInterface(int portNumber)
: myDetectorType(GOTTHARD), portNumber(portNumber > 0 ? portNumber : DEFAULT_PORTNO + 2) {
function_table();
start();
startTCPSocket();
}
void slsReceiverTCPIPInterface::start() {
void ClientInterface::startTCPSocket() {
FILE_LOG(logDEBUG) << "Creating TCP Server Thread";
killTCPServerThread = 0;
if (pthread_create(&TCPServer_thread, nullptr, startTCPServerThread,
@ -47,7 +39,7 @@ void slsReceiverTCPIPInterface::start() {
FILE_LOG(logDEBUG) << "TCP Server thread created successfully.";
}
void slsReceiverTCPIPInterface::stop() {
void ClientInterface::stopTCPSocket() {
if (tcpThreadCreated) {
FILE_LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber;
killTCPServerThread = 1;
@ -62,39 +54,39 @@ void slsReceiverTCPIPInterface::stop() {
}
}
int64_t slsReceiverTCPIPInterface::getReceiverVersion() { return APIRECEIVER; }
int64_t ClientInterface::getReceiverVersion() { return APIRECEIVER; }
/***callback functions***/
void slsReceiverTCPIPInterface::registerCallBackStartAcquisition(
void ClientInterface::registerCallBackStartAcquisition(
int (*func)(std::string, std::string, uint64_t, uint32_t, void *), void *arg) {
startAcquisitionCallBack = func;
pStartAcquisition = arg;
}
void slsReceiverTCPIPInterface::registerCallBackAcquisitionFinished(
void ClientInterface::registerCallBackAcquisitionFinished(
void (*func)(uint64_t, void *), void *arg) {
acquisitionFinishedCallBack = func;
pAcquisitionFinished = arg;
}
void slsReceiverTCPIPInterface::registerCallBackRawDataReady(
void ClientInterface::registerCallBackRawDataReady(
void (*func)(char *, char *, uint32_t, void *), void *arg) {
rawDataReadyCallBack = func;
pRawDataReady = arg;
}
void slsReceiverTCPIPInterface::registerCallBackRawDataModifyReady(
void ClientInterface::registerCallBackRawDataModifyReady(
void (*func)(char *, char *, uint32_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func;
pRawDataReady = arg;
}
void *slsReceiverTCPIPInterface::startTCPServerThread(void *this_pointer) {
((slsReceiverTCPIPInterface *)this_pointer)->startTCPServer();
void *ClientInterface::startTCPServerThread(void *this_pointer) {
((ClientInterface *)this_pointer)->startTCPServer();
return this_pointer;
}
void slsReceiverTCPIPInterface::startTCPServer() {
void ClientInterface::startTCPServer() {
FILE_LOG(logINFOBLUE) << "Created [ TCP server Tid: " << syscall(SYS_gettid)
<< "]";
FILE_LOG(logINFO) << "SLS Receiver starting TCP Server on port "
@ -144,72 +136,72 @@ void slsReceiverTCPIPInterface::startTCPServer() {
}
}
// clang-format off
int slsReceiverTCPIPInterface::function_table(){
flist[F_EXEC_RECEIVER_COMMAND] = &slsReceiverTCPIPInterface::exec_command;
flist[F_EXIT_RECEIVER] = &slsReceiverTCPIPInterface::exit_server;
flist[F_LOCK_RECEIVER] = &slsReceiverTCPIPInterface::lock_receiver;
flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &slsReceiverTCPIPInterface::get_last_client_ip;
flist[F_SET_RECEIVER_PORT] = &slsReceiverTCPIPInterface::set_port;
flist[F_UPDATE_RECEIVER_CLIENT] = &slsReceiverTCPIPInterface::update_client;
flist[F_GET_RECEIVER_VERSION] = &slsReceiverTCPIPInterface::get_version;
flist[F_GET_RECEIVER_TYPE] = &slsReceiverTCPIPInterface::set_detector_type;
flist[F_SEND_RECEIVER_DETHOSTNAME] = &slsReceiverTCPIPInterface::set_detector_hostname;
flist[F_RECEIVER_SET_ROI] = &slsReceiverTCPIPInterface::set_roi;
flist[F_RECEIVER_SET_NUM_FRAMES] = &slsReceiverTCPIPInterface::set_num_frames;
flist[F_RECEIVER_SET_NUM_ANALOG_SAMPLES]= &slsReceiverTCPIPInterface::set_num_analog_samples;
flist[F_RECEIVER_SET_NUM_DIGITAL_SAMPLES]= &slsReceiverTCPIPInterface::set_num_digital_samples;
flist[F_RECEIVER_SET_EXPTIME] = &slsReceiverTCPIPInterface::set_exptime;
flist[F_RECEIVER_SET_PERIOD] = &slsReceiverTCPIPInterface::set_period;
flist[F_RECEIVER_SET_SUB_EXPTIME] = &slsReceiverTCPIPInterface::set_subexptime;
flist[F_RECEIVER_SET_SUB_DEADTIME] = &slsReceiverTCPIPInterface::set_subdeadtime;
flist[F_SET_RECEIVER_DYNAMIC_RANGE] = &slsReceiverTCPIPInterface::set_dynamic_range;
flist[F_RECEIVER_STREAMING_FREQUENCY] = &slsReceiverTCPIPInterface::set_streaming_frequency;
flist[F_GET_RECEIVER_STATUS] = &slsReceiverTCPIPInterface::get_status;
flist[F_START_RECEIVER] = &slsReceiverTCPIPInterface::start_receiver;
flist[F_STOP_RECEIVER] = &slsReceiverTCPIPInterface::stop_receiver;
flist[F_SET_RECEIVER_FILE_PATH] = &slsReceiverTCPIPInterface::set_file_dir;
flist[F_SET_RECEIVER_FILE_NAME] = &slsReceiverTCPIPInterface::set_file_name;
flist[F_SET_RECEIVER_FILE_INDEX] = &slsReceiverTCPIPInterface::set_file_index;
flist[F_GET_RECEIVER_FRAME_INDEX] = &slsReceiverTCPIPInterface::get_frame_index;
flist[F_GET_RECEIVER_FRAMES_CAUGHT] = &slsReceiverTCPIPInterface::get_frames_caught;
flist[F_ENABLE_RECEIVER_FILE_WRITE] = &slsReceiverTCPIPInterface::enable_file_write;
flist[F_ENABLE_RECEIVER_MASTER_FILE_WRITE] = &slsReceiverTCPIPInterface::enable_master_file_write;
flist[F_ENABLE_RECEIVER_OVERWRITE] = &slsReceiverTCPIPInterface::enable_overwrite;
flist[F_ENABLE_RECEIVER_TEN_GIGA] = &slsReceiverTCPIPInterface::enable_tengiga;
flist[F_SET_RECEIVER_FIFO_DEPTH] = &slsReceiverTCPIPInterface::set_fifo_depth;
flist[F_RECEIVER_ACTIVATE] = &slsReceiverTCPIPInterface::set_activate;
flist[F_STREAM_DATA_FROM_RECEIVER] = &slsReceiverTCPIPInterface::set_data_stream_enable;
flist[F_RECEIVER_STREAMING_TIMER] = &slsReceiverTCPIPInterface::set_streaming_timer;
flist[F_SET_FLIPPED_DATA_RECEIVER] = &slsReceiverTCPIPInterface::set_flipped_data;
flist[F_SET_RECEIVER_FILE_FORMAT] = &slsReceiverTCPIPInterface::set_file_format;
flist[F_SEND_RECEIVER_DETPOSID] = &slsReceiverTCPIPInterface::set_detector_posid;
flist[F_SEND_RECEIVER_MULTIDETSIZE] = &slsReceiverTCPIPInterface::set_multi_detector_size;
flist[F_SET_RECEIVER_STREAMING_PORT] = &slsReceiverTCPIPInterface::set_streaming_port;
flist[F_RECEIVER_STREAMING_SRC_IP] = &slsReceiverTCPIPInterface::set_streaming_source_ip;
flist[F_SET_RECEIVER_SILENT_MODE] = &slsReceiverTCPIPInterface::set_silent_mode;
flist[F_ENABLE_GAPPIXELS_IN_RECEIVER] = &slsReceiverTCPIPInterface::enable_gap_pixels;
flist[F_RESTREAM_STOP_FROM_RECEIVER] = &slsReceiverTCPIPInterface::restream_stop;
flist[F_ADDITIONAL_JSON_HEADER] = &slsReceiverTCPIPInterface::set_additional_json_header;
flist[F_GET_ADDITIONAL_JSON_HEADER] = &slsReceiverTCPIPInterface::get_additional_json_header;
flist[F_RECEIVER_UDP_SOCK_BUF_SIZE] = &slsReceiverTCPIPInterface::set_udp_socket_buffer_size;
flist[F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]= &slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size;
flist[F_SET_RECEIVER_FRAMES_PER_FILE] = &slsReceiverTCPIPInterface::set_frames_per_file;
flist[F_RECEIVER_CHECK_VERSION] = &slsReceiverTCPIPInterface::check_version_compatibility;
flist[F_RECEIVER_DISCARD_POLICY] = &slsReceiverTCPIPInterface::set_discard_policy;
flist[F_RECEIVER_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_padding_enable;
flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &slsReceiverTCPIPInterface::set_deactivated_padding_enable;
flist[F_RECEIVER_SET_READOUT_MODE] = &slsReceiverTCPIPInterface::set_readout_mode;
flist[F_RECEIVER_SET_ADC_MASK] = &slsReceiverTCPIPInterface::set_adc_mask;
flist[F_SET_RECEIVER_DBIT_LIST] = &slsReceiverTCPIPInterface::set_dbit_list;
flist[F_GET_RECEIVER_DBIT_LIST] = &slsReceiverTCPIPInterface::get_dbit_list;
flist[F_RECEIVER_DBIT_OFFSET] = &slsReceiverTCPIPInterface::set_dbit_offset;
flist[F_SET_RECEIVER_QUAD] = &slsReceiverTCPIPInterface::set_quad_type;
flist[F_SET_RECEIVER_READ_N_LINES] = &slsReceiverTCPIPInterface::set_read_n_lines;
flist[F_SET_RECEIVER_UDP_IP] = &slsReceiverTCPIPInterface::set_udp_ip;
flist[F_SET_RECEIVER_UDP_IP2] = &slsReceiverTCPIPInterface::set_udp_ip2;
flist[F_SET_RECEIVER_UDP_PORT] = &slsReceiverTCPIPInterface::set_udp_port;
flist[F_SET_RECEIVER_UDP_PORT2] = &slsReceiverTCPIPInterface::set_udp_port2;
flist[F_SET_RECEIVER_NUM_INTERFACES] = &slsReceiverTCPIPInterface::set_num_interfaces;
int ClientInterface::function_table(){
flist[F_EXEC_RECEIVER_COMMAND] = &ClientInterface::exec_command;
flist[F_EXIT_RECEIVER] = &ClientInterface::exit_server;
flist[F_LOCK_RECEIVER] = &ClientInterface::lock_receiver;
flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &ClientInterface::get_last_client_ip;
flist[F_SET_RECEIVER_PORT] = &ClientInterface::set_port;
flist[F_UPDATE_RECEIVER_CLIENT] = &ClientInterface::update_client;
flist[F_GET_RECEIVER_VERSION] = &ClientInterface::get_version;
flist[F_GET_RECEIVER_TYPE] = &ClientInterface::set_detector_type;
flist[F_SEND_RECEIVER_DETHOSTNAME] = &ClientInterface::set_detector_hostname;
flist[F_RECEIVER_SET_ROI] = &ClientInterface::set_roi;
flist[F_RECEIVER_SET_NUM_FRAMES] = &ClientInterface::set_num_frames;
flist[F_RECEIVER_SET_NUM_ANALOG_SAMPLES]= &ClientInterface::set_num_analog_samples;
flist[F_RECEIVER_SET_NUM_DIGITAL_SAMPLES]= &ClientInterface::set_num_digital_samples;
flist[F_RECEIVER_SET_EXPTIME] = &ClientInterface::set_exptime;
flist[F_RECEIVER_SET_PERIOD] = &ClientInterface::set_period;
flist[F_RECEIVER_SET_SUB_EXPTIME] = &ClientInterface::set_subexptime;
flist[F_RECEIVER_SET_SUB_DEADTIME] = &ClientInterface::set_subdeadtime;
flist[F_SET_RECEIVER_DYNAMIC_RANGE] = &ClientInterface::set_dynamic_range;
flist[F_RECEIVER_STREAMING_FREQUENCY] = &ClientInterface::set_streaming_frequency;
flist[F_GET_RECEIVER_STATUS] = &ClientInterface::get_status;
flist[F_START_RECEIVER] = &ClientInterface::start_receiver;
flist[F_STOP_RECEIVER] = &ClientInterface::stop_receiver;
flist[F_SET_RECEIVER_FILE_PATH] = &ClientInterface::set_file_dir;
flist[F_SET_RECEIVER_FILE_NAME] = &ClientInterface::set_file_name;
flist[F_SET_RECEIVER_FILE_INDEX] = &ClientInterface::set_file_index;
flist[F_GET_RECEIVER_FRAME_INDEX] = &ClientInterface::get_frame_index;
flist[F_GET_RECEIVER_FRAMES_CAUGHT] = &ClientInterface::get_frames_caught;
flist[F_ENABLE_RECEIVER_FILE_WRITE] = &ClientInterface::enable_file_write;
flist[F_ENABLE_RECEIVER_MASTER_FILE_WRITE] = &ClientInterface::enable_master_file_write;
flist[F_ENABLE_RECEIVER_OVERWRITE] = &ClientInterface::enable_overwrite;
flist[F_ENABLE_RECEIVER_TEN_GIGA] = &ClientInterface::enable_tengiga;
flist[F_SET_RECEIVER_FIFO_DEPTH] = &ClientInterface::set_fifo_depth;
flist[F_RECEIVER_ACTIVATE] = &ClientInterface::set_activate;
flist[F_STREAM_DATA_FROM_RECEIVER] = &ClientInterface::set_data_stream_enable;
flist[F_RECEIVER_STREAMING_TIMER] = &ClientInterface::set_streaming_timer;
flist[F_SET_FLIPPED_DATA_RECEIVER] = &ClientInterface::set_flipped_data;
flist[F_SET_RECEIVER_FILE_FORMAT] = &ClientInterface::set_file_format;
flist[F_SEND_RECEIVER_DETPOSID] = &ClientInterface::set_detector_posid;
flist[F_SEND_RECEIVER_MULTIDETSIZE] = &ClientInterface::set_multi_detector_size;
flist[F_SET_RECEIVER_STREAMING_PORT] = &ClientInterface::set_streaming_port;
flist[F_RECEIVER_STREAMING_SRC_IP] = &ClientInterface::set_streaming_source_ip;
flist[F_SET_RECEIVER_SILENT_MODE] = &ClientInterface::set_silent_mode;
flist[F_ENABLE_GAPPIXELS_IN_RECEIVER] = &ClientInterface::enable_gap_pixels;
flist[F_RESTREAM_STOP_FROM_RECEIVER] = &ClientInterface::restream_stop;
flist[F_ADDITIONAL_JSON_HEADER] = &ClientInterface::set_additional_json_header;
flist[F_GET_ADDITIONAL_JSON_HEADER] = &ClientInterface::get_additional_json_header;
flist[F_RECEIVER_UDP_SOCK_BUF_SIZE] = &ClientInterface::set_udp_socket_buffer_size;
flist[F_RECEIVER_REAL_UDP_SOCK_BUF_SIZE]= &ClientInterface::get_real_udp_socket_buffer_size;
flist[F_SET_RECEIVER_FRAMES_PER_FILE] = &ClientInterface::set_frames_per_file;
flist[F_RECEIVER_CHECK_VERSION] = &ClientInterface::check_version_compatibility;
flist[F_RECEIVER_DISCARD_POLICY] = &ClientInterface::set_discard_policy;
flist[F_RECEIVER_PADDING_ENABLE] = &ClientInterface::set_padding_enable;
flist[F_RECEIVER_DEACTIVATED_PADDING_ENABLE] = &ClientInterface::set_deactivated_padding_enable;
flist[F_RECEIVER_SET_READOUT_MODE] = &ClientInterface::set_readout_mode;
flist[F_RECEIVER_SET_ADC_MASK] = &ClientInterface::set_adc_mask;
flist[F_SET_RECEIVER_DBIT_LIST] = &ClientInterface::set_dbit_list;
flist[F_GET_RECEIVER_DBIT_LIST] = &ClientInterface::get_dbit_list;
flist[F_RECEIVER_DBIT_OFFSET] = &ClientInterface::set_dbit_offset;
flist[F_SET_RECEIVER_QUAD] = &ClientInterface::set_quad_type;
flist[F_SET_RECEIVER_READ_N_LINES] = &ClientInterface::set_read_n_lines;
flist[F_SET_RECEIVER_UDP_IP] = &ClientInterface::set_udp_ip;
flist[F_SET_RECEIVER_UDP_IP2] = &ClientInterface::set_udp_ip2;
flist[F_SET_RECEIVER_UDP_PORT] = &ClientInterface::set_udp_port;
flist[F_SET_RECEIVER_UDP_PORT2] = &ClientInterface::set_udp_port2;
flist[F_SET_RECEIVER_NUM_INTERFACES] = &ClientInterface::set_num_interfaces;
for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) {
// FILE_LOG(logDEBUG1) << "function fnum: " << i << " (" <<
@ -219,7 +211,7 @@ int slsReceiverTCPIPInterface::function_table(){
return OK;
}
// clang-format on
int slsReceiverTCPIPInterface::decode_function(Interface &socket) {
int ClientInterface::decode_function(Interface &socket) {
ret = FAIL;
socket.Receive(fnum);
if (fnum <= NUM_DET_FUNCTIONS || fnum >= NUM_REC_FUNCTIONS) {
@ -237,14 +229,14 @@ int slsReceiverTCPIPInterface::decode_function(Interface &socket) {
return ret;
}
void slsReceiverTCPIPInterface::functionNotImplemented() {
void ClientInterface::functionNotImplemented() {
std::ostringstream os;
// os << "Function: " << getFunctionNameFromEnum((enum detFuncs)fnum)
// << ", is is not implemented for this detector";
throw RuntimeError(os.str());
}
void slsReceiverTCPIPInterface::modeNotImplemented(const std::string &modename,
void ClientInterface::modeNotImplemented(const std::string &modename,
int mode) {
std::ostringstream os;
os << modename << " (" << mode << ") is not implemented for this detector";
@ -252,7 +244,7 @@ void slsReceiverTCPIPInterface::modeNotImplemented(const std::string &modename,
}
template <typename T>
void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename,
void ClientInterface::validate(T arg, T retval, std::string modename,
numberMode hex) {
if (ret == OK && arg != -1 && retval != arg) {
auto format = (hex == HEX) ? std::hex : std::dec;
@ -264,13 +256,13 @@ void slsReceiverTCPIPInterface::validate(T arg, T retval, std::string modename,
}
}
void slsReceiverTCPIPInterface::VerifyLock() {
void ClientInterface::VerifyLock() {
if (lockStatus && server->getThisClient() != server->getLockedBy()) {
throw sls::SocketError("Receiver locked\n");
}
}
void slsReceiverTCPIPInterface::VerifyIdle(Interface &socket) {
void ClientInterface::VerifyIdle(Interface &socket) {
if (impl()->getStatus() != IDLE) {
std::ostringstream oss;
oss << "Can not execute " << getFunctionNameFromEnum((enum detFuncs)fnum)
@ -279,7 +271,7 @@ void slsReceiverTCPIPInterface::VerifyIdle(Interface &socket) {
}
}
int slsReceiverTCPIPInterface::exec_command(Interface &socket) {
int ClientInterface::exec_command(Interface &socket) {
char cmd[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(cmd);
@ -301,13 +293,13 @@ int slsReceiverTCPIPInterface::exec_command(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::exit_server(Interface &socket) {
int ClientInterface::exit_server(Interface &socket) {
FILE_LOG(logINFO) << "Closing server";
socket.Send(OK);
return GOODBYE;
}
int slsReceiverTCPIPInterface::lock_receiver(Interface &socket) {
int ClientInterface::lock_receiver(Interface &socket) {
auto lock = socket.Receive<int>();
FILE_LOG(logDEBUG1) << "Locking Server to " << lock;
if (lock >= 0) {
@ -322,11 +314,11 @@ int slsReceiverTCPIPInterface::lock_receiver(Interface &socket) {
return socket.sendResult(lockStatus);
}
int slsReceiverTCPIPInterface::get_last_client_ip(Interface &socket) {
int ClientInterface::get_last_client_ip(Interface &socket) {
return socket.sendResult(server->getLastClient());
}
int slsReceiverTCPIPInterface::set_port(Interface &socket) {
int ClientInterface::set_port(Interface &socket) {
auto p_number = socket.Receive<int>();
if (p_number < 1024)
throw RuntimeError("Port Number: " + std::to_string(p_number) +
@ -341,7 +333,7 @@ int slsReceiverTCPIPInterface::set_port(Interface &socket) {
return OK;
}
int slsReceiverTCPIPInterface::update_client(Interface &socket) {
int ClientInterface::update_client(Interface &socket) {
if (receiver == nullptr)
throw sls::SocketError(
"Receiver not set up. Please use rx_hostname first.\n");
@ -349,7 +341,7 @@ int slsReceiverTCPIPInterface::update_client(Interface &socket) {
return send_update(socket);
}
int slsReceiverTCPIPInterface::send_update(Interface &socket) {
int ClientInterface::send_update(Interface &socket) {
int n = 0;
int i32 = -1;
int64_t i64 = -1;
@ -452,11 +444,11 @@ int slsReceiverTCPIPInterface::send_update(Interface &socket) {
return OK;
}
int slsReceiverTCPIPInterface::get_version(Interface &socket) {
int ClientInterface::get_version(Interface &socket) {
return socket.sendResult(getReceiverVersion());
}
int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) {
int ClientInterface::set_detector_type(Interface &socket) {
auto arg = socket.Receive<detectorType>();
// set
if (arg >= 0) {
@ -479,7 +471,7 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) {
}
if (receiver == nullptr) {
receiver = sls::make_unique<slsReceiverImplementation>();
receiver = sls::make_unique<Implementation>();
}
myDetectorType = arg;
if (impl()->setDetectorType(myDetectorType) == FAIL) {
@ -503,7 +495,7 @@ int slsReceiverTCPIPInterface::set_detector_type(Interface &socket) {
return socket.sendResult(myDetectorType);
}
int slsReceiverTCPIPInterface::set_detector_hostname(Interface &socket) {
int ClientInterface::set_detector_hostname(Interface &socket) {
char hostname[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(hostname);
@ -520,7 +512,7 @@ int slsReceiverTCPIPInterface::set_detector_hostname(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_roi(Interface &socket) {
int ClientInterface::set_roi(Interface &socket) {
static_assert(sizeof(ROI) == 2 * sizeof(int), "ROI not packed");
ROI arg;
socket.Receive(arg);
@ -535,14 +527,14 @@ int slsReceiverTCPIPInterface::set_roi(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_num_frames(Interface &socket) {
int ClientInterface::set_num_frames(Interface &socket) {
auto value = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Setting num frames to " << value;
impl()->setNumberOfFrames(value);
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_num_analog_samples(Interface &socket) {
int ClientInterface::set_num_analog_samples(Interface &socket) {
auto value = socket.Receive<int>();
FILE_LOG(logDEBUG1) << "Setting num analog samples to " << value;
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
@ -553,7 +545,7 @@ int slsReceiverTCPIPInterface::set_num_analog_samples(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_num_digital_samples(Interface &socket) {
int ClientInterface::set_num_digital_samples(Interface &socket) {
auto value = socket.Receive<int>();
FILE_LOG(logDEBUG1) << "Setting num digital samples to " << value;
if (myDetectorType != CHIPTESTBOARD && myDetectorType != MOENCH) {
@ -563,28 +555,28 @@ int slsReceiverTCPIPInterface::set_num_digital_samples(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_exptime(Interface &socket) {
int ClientInterface::set_exptime(Interface &socket) {
auto value = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Setting exptime to " << value << "ns";
impl()->setAcquisitionTime(value);
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_period(Interface &socket) {
int ClientInterface::set_period(Interface &socket) {
auto value = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Setting period to " << value << "ns";
impl()->setAcquisitionPeriod(value);
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_subexptime(Interface &socket) {
int ClientInterface::set_subexptime(Interface &socket) {
auto value = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Setting period to " << value << "ns";
impl()->setSubExpTime(value);
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_subdeadtime(Interface &socket) {
int ClientInterface::set_subdeadtime(Interface &socket) {
auto value = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Setting sub deadtime to " << value << "ns";
impl()->setSubPeriod(value + impl()->getSubExpTime());
@ -592,7 +584,7 @@ int slsReceiverTCPIPInterface::set_subdeadtime(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_dynamic_range(Interface &socket) {
int ClientInterface::set_dynamic_range(Interface &socket) {
auto dr = socket.Receive<int>();
if (dr >= 0) {
VerifyIdle(socket);
@ -631,7 +623,7 @@ int slsReceiverTCPIPInterface::set_dynamic_range(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_streaming_frequency(Interface &socket) {
int ClientInterface::set_streaming_frequency(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -646,13 +638,13 @@ int slsReceiverTCPIPInterface::set_streaming_frequency(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::get_status(Interface &socket) {
int ClientInterface::get_status(Interface &socket) {
auto retval = impl()->getStatus();
FILE_LOG(logDEBUG1) << "Status:" << sls::ToString(retval);
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::start_receiver(Interface &socket) {
int ClientInterface::start_receiver(Interface &socket) {
if (impl()->getStatus() == IDLE) {
FILE_LOG(logDEBUG1) << "Starting Receiver";
std::string err;
@ -664,7 +656,7 @@ int slsReceiverTCPIPInterface::start_receiver(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::stop_receiver(Interface &socket) {
int ClientInterface::stop_receiver(Interface &socket) {
if (impl()->getStatus() == RUNNING) {
FILE_LOG(logDEBUG1) << "Stopping Receiver";
impl()->stopReceiver();
@ -677,7 +669,7 @@ int slsReceiverTCPIPInterface::stop_receiver(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_file_dir(Interface &socket) {
int ClientInterface::set_file_dir(Interface &socket) {
char fPath[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(fPath);
@ -698,7 +690,7 @@ int slsReceiverTCPIPInterface::set_file_dir(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_file_name(Interface &socket) {
int ClientInterface::set_file_name(Interface &socket) {
char fName[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(fName);
@ -715,7 +707,7 @@ int slsReceiverTCPIPInterface::set_file_name(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_file_index(Interface &socket) {
int ClientInterface::set_file_index(Interface &socket) {
auto index = socket.Receive<int64_t>();
if (index >= 0) {
VerifyIdle(socket);
@ -728,19 +720,19 @@ int slsReceiverTCPIPInterface::set_file_index(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::get_frame_index(Interface &socket) {
int ClientInterface::get_frame_index(Interface &socket) {
uint64_t retval = impl()->getAcquisitionIndex();
FILE_LOG(logDEBUG1) << "frame index:" << retval;
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::get_frames_caught(Interface &socket) {
int ClientInterface::get_frames_caught(Interface &socket) {
int64_t retval = impl()->getFramesCaught();
FILE_LOG(logDEBUG1) << "frames caught:" << retval;
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::enable_file_write(Interface &socket) {
int ClientInterface::enable_file_write(Interface &socket) {
auto enable = socket.Receive<int>();
if (enable >= 0) {
VerifyIdle(socket);
@ -753,7 +745,7 @@ int slsReceiverTCPIPInterface::enable_file_write(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) {
int ClientInterface::enable_master_file_write(Interface &socket) {
auto enable = socket.Receive<int>();
if (enable >= 0) {
VerifyIdle(socket);
@ -766,7 +758,7 @@ int slsReceiverTCPIPInterface::enable_master_file_write(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) {
int ClientInterface::enable_overwrite(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -779,7 +771,7 @@ int slsReceiverTCPIPInterface::enable_overwrite(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) {
int ClientInterface::enable_tengiga(Interface &socket) {
auto val = socket.Receive<int>();
if (myDetectorType != EIGER && myDetectorType != CHIPTESTBOARD &&
myDetectorType != MOENCH)
@ -796,7 +788,7 @@ int slsReceiverTCPIPInterface::enable_tengiga(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_fifo_depth(Interface &socket) {
int ClientInterface::set_fifo_depth(Interface &socket) {
auto value = socket.Receive<int>();
if (value >= 0) {
VerifyIdle(socket);
@ -809,7 +801,7 @@ int slsReceiverTCPIPInterface::set_fifo_depth(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_activate(Interface &socket) {
int ClientInterface::set_activate(Interface &socket) {
auto enable = socket.Receive<int>();
if (myDetectorType != EIGER)
functionNotImplemented();
@ -825,7 +817,7 @@ int slsReceiverTCPIPInterface::set_activate(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_data_stream_enable(Interface &socket) {
int ClientInterface::set_data_stream_enable(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -838,7 +830,7 @@ int slsReceiverTCPIPInterface::set_data_stream_enable(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) {
int ClientInterface::set_streaming_timer(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -851,7 +843,7 @@ int slsReceiverTCPIPInterface::set_streaming_timer(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) {
int ClientInterface::set_flipped_data(Interface &socket) {
auto arg = socket.Receive<int>();
if (myDetectorType != EIGER)
@ -868,7 +860,7 @@ int slsReceiverTCPIPInterface::set_flipped_data(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_file_format(Interface &socket) {
int ClientInterface::set_file_format(Interface &socket) {
fileFormat f = GET_FILE_FORMAT;
socket.Receive(f);
if (f >= 0) {
@ -882,7 +874,7 @@ int slsReceiverTCPIPInterface::set_file_format(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_detector_posid(Interface &socket) {
int ClientInterface::set_detector_posid(Interface &socket) {
auto arg = socket.Receive<int>();
if (arg >= 0) {
VerifyIdle(socket);
@ -895,7 +887,7 @@ int slsReceiverTCPIPInterface::set_detector_posid(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_multi_detector_size(Interface &socket) {
int ClientInterface::set_multi_detector_size(Interface &socket) {
int arg[]{-1, -1};
socket.Receive(arg);
if ((arg[0] > 0) && (arg[1] > 0)) {
@ -910,7 +902,7 @@ int slsReceiverTCPIPInterface::set_multi_detector_size(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_streaming_port(Interface &socket) {
int ClientInterface::set_streaming_port(Interface &socket) {
auto port = socket.Receive<int>();
if (port >= 0) {
VerifyIdle(socket);
@ -923,7 +915,7 @@ int slsReceiverTCPIPInterface::set_streaming_port(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_streaming_source_ip(Interface &socket) {
int ClientInterface::set_streaming_source_ip(Interface &socket) {
sls::IpAddr arg = 0u;
socket.Receive(arg);
VerifyIdle(socket);
@ -939,7 +931,7 @@ int slsReceiverTCPIPInterface::set_streaming_source_ip(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_silent_mode(Interface &socket) {
int ClientInterface::set_silent_mode(Interface &socket) {
auto value = socket.Receive<int>();
if (value >= 0) {
VerifyIdle(socket);
@ -952,7 +944,7 @@ int slsReceiverTCPIPInterface::set_silent_mode(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::enable_gap_pixels(Interface &socket) {
int ClientInterface::enable_gap_pixels(Interface &socket) {
auto enable = socket.Receive<int>();
if (myDetectorType != EIGER)
functionNotImplemented();
@ -968,7 +960,7 @@ int slsReceiverTCPIPInterface::enable_gap_pixels(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::restream_stop(Interface &socket) {
int ClientInterface::restream_stop(Interface &socket) {
VerifyIdle(socket);
if (!impl()->getDataStreamEnable()) {
throw RuntimeError(
@ -980,7 +972,7 @@ int slsReceiverTCPIPInterface::restream_stop(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_additional_json_header(Interface &socket) {
int ClientInterface::set_additional_json_header(Interface &socket) {
char arg[MAX_STR_LENGTH]{};
char retval[MAX_STR_LENGTH]{};
socket.Receive(arg);
@ -992,14 +984,14 @@ int slsReceiverTCPIPInterface::set_additional_json_header(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::get_additional_json_header(Interface &socket) {
int ClientInterface::get_additional_json_header(Interface &socket) {
char retval[MAX_STR_LENGTH]{};
sls::strcpy_safe(retval, impl()->getAdditionalJsonHeader().c_str());
FILE_LOG(logDEBUG1) << "additional json header:" << retval;
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(Interface &socket) {
int ClientInterface::set_udp_socket_buffer_size(Interface &socket) {
auto index = socket.Receive<int64_t>();
if (index >= 0) {
VerifyIdle(socket);
@ -1018,14 +1010,14 @@ int slsReceiverTCPIPInterface::set_udp_socket_buffer_size(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::get_real_udp_socket_buffer_size(
int ClientInterface::get_real_udp_socket_buffer_size(
Interface &socket) {
auto size = impl()->getActualUDPSocketBufferSize();
FILE_LOG(logDEBUG1) << "Actual UDP socket size :" << size;
return socket.sendResult(size);
}
int slsReceiverTCPIPInterface::set_frames_per_file(Interface &socket) {
int ClientInterface::set_frames_per_file(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -1038,7 +1030,7 @@ int slsReceiverTCPIPInterface::set_frames_per_file(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) {
int ClientInterface::check_version_compatibility(Interface &socket) {
auto arg = socket.Receive<int64_t>();
FILE_LOG(logDEBUG1) << "Checking versioning compatibility with value "
<< arg;
@ -1066,7 +1058,7 @@ int slsReceiverTCPIPInterface::check_version_compatibility(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_discard_policy(Interface &socket) {
int ClientInterface::set_discard_policy(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -1079,7 +1071,7 @@ int slsReceiverTCPIPInterface::set_discard_policy(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_padding_enable(Interface &socket) {
int ClientInterface::set_padding_enable(Interface &socket) {
auto index = socket.Receive<int>();
if (index >= 0) {
VerifyIdle(socket);
@ -1092,7 +1084,7 @@ int slsReceiverTCPIPInterface::set_padding_enable(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_deactivated_padding_enable(
int ClientInterface::set_deactivated_padding_enable(
Interface &socket) {
auto enable = socket.Receive<int>();
if (myDetectorType != EIGER)
@ -1109,7 +1101,7 @@ int slsReceiverTCPIPInterface::set_deactivated_padding_enable(
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_readout_mode(Interface &socket) {
int ClientInterface::set_readout_mode(Interface &socket) {
auto arg = socket.Receive<readoutMode>();
if (myDetectorType != CHIPTESTBOARD)
@ -1127,7 +1119,7 @@ int slsReceiverTCPIPInterface::set_readout_mode(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_adc_mask(Interface &socket) {
int ClientInterface::set_adc_mask(Interface &socket) {
auto arg = socket.Receive<uint32_t>();
VerifyIdle(socket);
FILE_LOG(logDEBUG1) << "Setting ADC enable mask: " << arg;
@ -1143,7 +1135,7 @@ int slsReceiverTCPIPInterface::set_adc_mask(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_dbit_list(Interface &socket) {
int ClientInterface::set_dbit_list(Interface &socket) {
sls::FixedCapacityContainer<int, MAX_RX_DBIT> args;
socket.Receive(args);
FILE_LOG(logDEBUG1) << "Setting DBIT list";
@ -1156,14 +1148,14 @@ int slsReceiverTCPIPInterface::set_dbit_list(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::get_dbit_list(Interface &socket) {
int ClientInterface::get_dbit_list(Interface &socket) {
sls::FixedCapacityContainer<int, MAX_RX_DBIT> retval;
retval = impl()->getDbitList();
FILE_LOG(logDEBUG1) << "Dbit list size retval:" << retval.size();
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_dbit_offset(Interface &socket) {
int ClientInterface::set_dbit_offset(Interface &socket) {
auto arg = socket.Receive<int>();
if (arg >= 0) {
VerifyIdle(socket);
@ -1176,7 +1168,7 @@ int slsReceiverTCPIPInterface::set_dbit_offset(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_quad_type(Interface &socket) {
int ClientInterface::set_quad_type(Interface &socket) {
auto quadEnable = socket.Receive<int>();
if (quadEnable >= 0) {
VerifyIdle(socket);
@ -1192,7 +1184,7 @@ int slsReceiverTCPIPInterface::set_quad_type(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_read_n_lines(Interface &socket) {
int ClientInterface::set_read_n_lines(Interface &socket) {
auto arg = socket.Receive<int>();
if (arg >= 0) {
VerifyIdle(socket);
@ -1206,7 +1198,7 @@ int slsReceiverTCPIPInterface::set_read_n_lines(Interface &socket) {
}
int slsReceiverTCPIPInterface::set_udp_ip(Interface &socket) {
int ClientInterface::set_udp_ip(Interface &socket) {
auto arg = socket.Receive<sls::IpAddr>();
VerifyIdle(socket);
FILE_LOG(logINFO) << "Received UDP IP: " << arg;
@ -1233,7 +1225,7 @@ int slsReceiverTCPIPInterface::set_udp_ip(Interface &socket) {
}
int slsReceiverTCPIPInterface::set_udp_ip2(Interface &socket) {
int ClientInterface::set_udp_ip2(Interface &socket) {
auto arg = socket.Receive<sls::IpAddr>();
VerifyIdle(socket);
if (myDetectorType != JUNGFRAU) {
@ -1260,7 +1252,7 @@ int slsReceiverTCPIPInterface::set_udp_ip2(Interface &socket) {
return socket.sendResult(retval);
}
int slsReceiverTCPIPInterface::set_udp_port(Interface &socket) {
int ClientInterface::set_udp_port(Interface &socket) {
auto arg = socket.Receive<int>();
VerifyIdle(socket);
FILE_LOG(logDEBUG1) << "Setting UDP Port:" << arg;
@ -1268,7 +1260,7 @@ int slsReceiverTCPIPInterface::set_udp_port(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_udp_port2(Interface &socket) {
int ClientInterface::set_udp_port2(Interface &socket) {
auto arg = socket.Receive<int>();
VerifyIdle(socket);
if (myDetectorType != JUNGFRAU && myDetectorType != EIGER) {
@ -1279,7 +1271,7 @@ int slsReceiverTCPIPInterface::set_udp_port2(Interface &socket) {
return socket.Send(OK);
}
int slsReceiverTCPIPInterface::set_num_interfaces(Interface &socket) {
int ClientInterface::set_num_interfaces(Interface &socket) {
auto arg = socket.Receive<int>();
arg = (arg > 1 ? 2 : 1);
VerifyIdle(socket);

242
slsReceiverSoftware/src/slsReceiverImplementation.cpp → slsReceiverSoftware/src/Implementation.cpp
View File

@ -1,4 +1,4 @@
#include "slsReceiverImplementation.h"
#include "Implementation.h"
#include "DataProcessor.h"
#include "DataStreamer.h"
#include "Fifo.h"
@ -18,17 +18,17 @@
/** cosntructor & destructor */
slsReceiverImplementation::slsReceiverImplementation() {
Implementation::Implementation() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
InitializeMembers();
}
slsReceiverImplementation::~slsReceiverImplementation() {
Implementation::~Implementation() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
DeleteMembers();
}
void slsReceiverImplementation::DeleteMembers() {
void Implementation::DeleteMembers() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (generalData) {
delete generalData;
@ -42,7 +42,7 @@ void slsReceiverImplementation::DeleteMembers() {
ctbDbitList.clear();
}
void slsReceiverImplementation::InitializeMembers() {
void Implementation::InitializeMembers() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
//**detector parameters***
myDetectorType = GENERIC;
@ -123,101 +123,101 @@ void slsReceiverImplementation::InitializeMembers() {
*************************************************************************/
/**initial parameters***/
int *slsReceiverImplementation::getMultiDetectorSize() const {
int *Implementation::getMultiDetectorSize() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return (int *)numDet;
}
int slsReceiverImplementation::getDetectorPositionId() const {
int Implementation::getDetectorPositionId() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return detID;
}
std::string slsReceiverImplementation::getDetectorHostname() const {
std::string Implementation::getDetectorHostname() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return detHostname;
}
int slsReceiverImplementation::getFlippedDataX() const {
int Implementation::getFlippedDataX() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return flippedDataX;
}
bool slsReceiverImplementation::getGapPixelsEnable() const {
bool Implementation::getGapPixelsEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return gapPixelsEnable;
}
bool slsReceiverImplementation::getQuad() const {
bool Implementation::getQuad() const {
FILE_LOG(logDEBUG) << __AT__ << " starting";
return quadEnable;
}
int slsReceiverImplementation::getReadNLines() const {
int Implementation::getReadNLines() const {
FILE_LOG(logDEBUG) << __AT__ << " starting";
return numLinesReadout;
}
slsDetectorDefs::readoutMode
slsReceiverImplementation::getReadoutMode() const {
Implementation::getReadoutMode() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return readoutType;
}
/***file parameters***/
slsDetectorDefs::fileFormat slsReceiverImplementation::getFileFormat() const {
slsDetectorDefs::fileFormat Implementation::getFileFormat() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileFormatType;
}
std::string slsReceiverImplementation::getFileName() const {
std::string Implementation::getFileName() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileName;
}
std::string slsReceiverImplementation::getFilePath() const {
std::string Implementation::getFilePath() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return filePath;
}
uint64_t slsReceiverImplementation::getFileIndex() const {
uint64_t Implementation::getFileIndex() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileIndex;
}
uint32_t slsReceiverImplementation::getFramesPerFile() const {
uint32_t Implementation::getFramesPerFile() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return framesPerFile;
}
slsDetectorDefs::frameDiscardPolicy
slsReceiverImplementation::getFrameDiscardPolicy() const {
Implementation::getFrameDiscardPolicy() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return frameDiscardMode;
}
bool slsReceiverImplementation::getFramePaddingEnable() const {
bool Implementation::getFramePaddingEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return framePadding;
}
bool slsReceiverImplementation::getFileWriteEnable() const {
bool Implementation::getFileWriteEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fileWriteEnable;
}
bool slsReceiverImplementation::getMasterFileWriteEnable() const {
bool Implementation::getMasterFileWriteEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return masterFileWriteEnable;
}
bool slsReceiverImplementation::getOverwriteEnable() const {
bool Implementation::getOverwriteEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return overwriteEnable;
}
/***acquisition count parameters***/
uint64_t slsReceiverImplementation::getFramesCaught() const {
uint64_t Implementation::getFramesCaught() const {
uint64_t min = -1;
uint32_t flagsum = 0;
@ -233,7 +233,7 @@ uint64_t slsReceiverImplementation::getFramesCaught() const {
return min;
}
uint64_t slsReceiverImplementation::getAcquisitionIndex() const {
uint64_t Implementation::getAcquisitionIndex() const {
uint64_t min = -1;
uint32_t flagsum = 0;
@ -250,159 +250,159 @@ uint64_t slsReceiverImplementation::getAcquisitionIndex() const {
}
/***connection parameters***/
uint32_t slsReceiverImplementation::getUDPPortNumber() const {
uint32_t Implementation::getUDPPortNumber() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpPortNum[0];
}
uint32_t slsReceiverImplementation::getUDPPortNumber2() const {
uint32_t Implementation::getUDPPortNumber2() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpPortNum[1];
}
std::string slsReceiverImplementation::getEthernetInterface() const {
std::string Implementation::getEthernetInterface() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return eth[0];
}
std::string slsReceiverImplementation::getEthernetInterface2() const {
std::string Implementation::getEthernetInterface2() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return eth[1];
}
int slsReceiverImplementation::getNumberofUDPInterfaces() const {
int Implementation::getNumberofUDPInterfaces() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numUDPInterfaces;
}
/***acquisition parameters***/
slsDetectorDefs::ROI slsReceiverImplementation::getROI() const {
slsDetectorDefs::ROI Implementation::getROI() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return roi;
}
uint32_t slsReceiverImplementation::getADCEnableMask() const {
uint32_t Implementation::getADCEnableMask() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return adcEnableMask;
}
uint32_t slsReceiverImplementation::getStreamingFrequency() const {
uint32_t Implementation::getStreamingFrequency() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingFrequency;
}
uint32_t slsReceiverImplementation::getStreamingTimer() const {
uint32_t Implementation::getStreamingTimer() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingTimerInMs;
}
bool slsReceiverImplementation::getDataStreamEnable() const {
bool Implementation::getDataStreamEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return dataStreamEnable;
}
uint64_t slsReceiverImplementation::getAcquisitionPeriod() const {
uint64_t Implementation::getAcquisitionPeriod() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return acquisitionPeriod;
}
uint64_t slsReceiverImplementation::getAcquisitionTime() const {
uint64_t Implementation::getAcquisitionTime() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return acquisitionTime;
}
uint64_t slsReceiverImplementation::getSubExpTime() const {
uint64_t Implementation::getSubExpTime() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return subExpTime;
}
uint64_t slsReceiverImplementation::getSubPeriod() const {
uint64_t Implementation::getSubPeriod() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return subPeriod;
}
uint64_t slsReceiverImplementation::getNumberOfFrames() const {
uint64_t Implementation::getNumberOfFrames() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfFrames;
}
uint32_t slsReceiverImplementation::getNumberofAnalogSamples() const {
uint32_t Implementation::getNumberofAnalogSamples() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfAnalogSamples;
}
uint32_t slsReceiverImplementation::getNumberofDigitalSamples() const {
uint32_t Implementation::getNumberofDigitalSamples() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return numberOfDigitalSamples;
}
uint32_t slsReceiverImplementation::getDynamicRange() const {
uint32_t Implementation::getDynamicRange() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return dynamicRange;
}
bool slsReceiverImplementation::getTenGigaEnable() const {
bool Implementation::getTenGigaEnable() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return tengigaEnable;
}
uint32_t slsReceiverImplementation::getFifoDepth() const {
uint32_t Implementation::getFifoDepth() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return fifoDepth;
}
/***receiver status***/
slsDetectorDefs::runStatus slsReceiverImplementation::getStatus() const {
slsDetectorDefs::runStatus Implementation::getStatus() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return status;
}
bool slsReceiverImplementation::getSilentMode() const {
bool Implementation::getSilentMode() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return silentMode;
}
std::vector<int> slsReceiverImplementation::getDbitList() const {
std::vector<int> Implementation::getDbitList() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return ctbDbitList;
}
int slsReceiverImplementation::getDbitOffset() const {
int Implementation::getDbitOffset() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return ctbDbitOffset;
}
bool slsReceiverImplementation::getActivate() const {
bool Implementation::getActivate() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return activated;
}
bool slsReceiverImplementation::getDeactivatedPadding() const {
bool Implementation::getDeactivatedPadding() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return deactivatedPaddingEnable;
}
uint32_t slsReceiverImplementation::getStreamingPort() const {
uint32_t Implementation::getStreamingPort() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingPort;
}
sls::IpAddr slsReceiverImplementation::getStreamingSourceIP() const {
sls::IpAddr Implementation::getStreamingSourceIP() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return streamingSrcIP;
}
std::string slsReceiverImplementation::getAdditionalJsonHeader() const {
std::string Implementation::getAdditionalJsonHeader() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return additionalJsonHeader;
}
int64_t slsReceiverImplementation::getUDPSocketBufferSize() const {
int64_t Implementation::getUDPSocketBufferSize() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return udpSocketBufferSize;
}
int64_t slsReceiverImplementation::getActualUDPSocketBufferSize() const {
int64_t Implementation::getActualUDPSocketBufferSize() const {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
return actualUDPSocketBufferSize;
}
@ -414,7 +414,7 @@ int64_t slsReceiverImplementation::getActualUDPSocketBufferSize() const {
/**initial parameters***/
void slsReceiverImplementation::setDetectorHostname(const std::string& c) {
void Implementation::setDetectorHostname(const std::string& c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (!c.empty())
@ -422,7 +422,7 @@ void slsReceiverImplementation::setDetectorHostname(const std::string& c) {
FILE_LOG(logINFO) << "Detector Hostname: " << detHostname;
}
void slsReceiverImplementation::setMultiDetectorSize(const int *size) {
void Implementation::setMultiDetectorSize(const int *size) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
std::string log_message = "Detector Size (ports): (";
for (int i = 0; i < MAX_DIMENSIONS; ++i) {
@ -452,7 +452,7 @@ void slsReceiverImplementation::setMultiDetectorSize(const int *size) {
FILE_LOG(logINFO) << log_message;
}
void slsReceiverImplementation::setFlippedDataX(int enable) {
void Implementation::setFlippedDataX(int enable) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
flippedDataX = (enable == 0) ? 0 : 1;
@ -471,7 +471,7 @@ void slsReceiverImplementation::setFlippedDataX(int enable) {
FILE_LOG(logINFO) << "Flipped Data X: " << flippedDataX;
}
int slsReceiverImplementation::setGapPixelsEnable(const bool b) {
int Implementation::setGapPixelsEnable(const bool b) {
if (gapPixelsEnable != b) {
gapPixelsEnable = b;
@ -487,7 +487,7 @@ int slsReceiverImplementation::setGapPixelsEnable(const bool b) {
}
int slsReceiverImplementation::setQuad(const bool b) {
int Implementation::setQuad(const bool b) {
if (quadEnable != b) {
quadEnable = b;
@ -518,12 +518,12 @@ int slsReceiverImplementation::setQuad(const bool b) {
return OK;
}
void slsReceiverImplementation::setReadNLines(const int value) {
void Implementation::setReadNLines(const int value) {
numLinesReadout = value;
FILE_LOG(logINFO) << "Number of Lines to readout: " << numLinesReadout;
}
int slsReceiverImplementation::setReadoutMode(const readoutMode f) {
int Implementation::setReadoutMode(const readoutMode f) {
if (readoutType != f) {
readoutType = f;
@ -543,7 +543,7 @@ int slsReceiverImplementation::setReadoutMode(const readoutMode f) {
return OK;
}
void slsReceiverImplementation::setFileFormat(const fileFormat f) {
void Implementation::setFileFormat(const fileFormat f) {
switch (f) {
#ifdef HDF5C
case HDF5:
@ -561,7 +561,7 @@ void slsReceiverImplementation::setFileFormat(const fileFormat f) {
FILE_LOG(logINFO) << "File Format: " << sls::ToString(fileFormatType);
}
void slsReceiverImplementation::setFileName(const std::string& c) {
void Implementation::setFileName(const std::string& c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (!c.empty())
@ -569,7 +569,7 @@ void slsReceiverImplementation::setFileName(const std::string& c) {
FILE_LOG(logINFO) << "File name: " << fileName;
}
void slsReceiverImplementation::setFilePath(const std::string& c) {
void Implementation::setFilePath(const std::string& c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (!c.empty()) {
@ -579,21 +579,21 @@ void slsReceiverImplementation::setFilePath(const std::string& c) {
FILE_LOG(logINFO) << "File path: " << filePath;
}
void slsReceiverImplementation::setFileIndex(const uint64_t i) {
void Implementation::setFileIndex(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
fileIndex = i;
FILE_LOG(logINFO) << "File Index: " << fileIndex;
}
void slsReceiverImplementation::setFramesPerFile(const uint32_t i) {
void Implementation::setFramesPerFile(const uint32_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
framesPerFile = i;
FILE_LOG(logINFO) << "Frames per file: " << framesPerFile;
}
void slsReceiverImplementation::setFrameDiscardPolicy(
void Implementation::setFrameDiscardPolicy(
const frameDiscardPolicy i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
@ -604,14 +604,14 @@ void slsReceiverImplementation::setFrameDiscardPolicy(
<< sls::ToString(frameDiscardMode);
}
void slsReceiverImplementation::setFramePaddingEnable(const bool i) {
void Implementation::setFramePaddingEnable(const bool i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
framePadding = i;
FILE_LOG(logINFO) << "Frame Padding: " << framePadding;
}
void slsReceiverImplementation::setFileWriteEnable(const bool b) {
void Implementation::setFileWriteEnable(const bool b) {
if (fileWriteEnable != b) {
fileWriteEnable = b;
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
@ -625,14 +625,14 @@ void slsReceiverImplementation::setFileWriteEnable(const bool b) {
FILE_LOG(logINFO) << "File Write Enable: " << (fileWriteEnable ? "enabled" : "disabled");
}
void slsReceiverImplementation::setMasterFileWriteEnable(const bool b) {
void Implementation::setMasterFileWriteEnable(const bool b) {
masterFileWriteEnable = b;
FILE_LOG(logINFO) << "Master File Write Enable: "
<< (masterFileWriteEnable ? "enabled" : "disabled");
}
void slsReceiverImplementation::setOverwriteEnable(const bool b) {
void Implementation::setOverwriteEnable(const bool b) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
overwriteEnable = b;
@ -640,35 +640,35 @@ void slsReceiverImplementation::setOverwriteEnable(const bool b) {
}
/***connection parameters***/
void slsReceiverImplementation::setUDPPortNumber(const uint32_t i) {
void Implementation::setUDPPortNumber(const uint32_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
udpPortNum[0] = i;
FILE_LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0];
}
void slsReceiverImplementation::setUDPPortNumber2(const uint32_t i) {
void Implementation::setUDPPortNumber2(const uint32_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
udpPortNum[1] = i;
FILE_LOG(logINFO) << "UDP Port Number[1]: " << udpPortNum[1];
}
void slsReceiverImplementation::setEthernetInterface(const std::string &c) {
void Implementation::setEthernetInterface(const std::string &c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
eth[0] = c;
FILE_LOG(logINFO) << "Ethernet Interface: " << eth[0];
}
void slsReceiverImplementation::setEthernetInterface2(const std::string &c) {
void Implementation::setEthernetInterface2(const std::string &c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
eth[1] = c;
FILE_LOG(logINFO) << "Ethernet Interface 2: " << eth[1];
}
int slsReceiverImplementation::setNumberofUDPInterfaces(const int n) {
int Implementation::setNumberofUDPInterfaces(const int n) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (numUDPInterfaces != n) {
@ -783,7 +783,7 @@ int slsReceiverImplementation::setNumberofUDPInterfaces(const int n) {
return OK;
}
int slsReceiverImplementation::setUDPSocketBufferSize(const int64_t s) {
int Implementation::setUDPSocketBufferSize(const int64_t s) {
int64_t size = (s == 0) ? udpSocketBufferSize : s;
size_t listSize = listener.size();
@ -802,7 +802,7 @@ int slsReceiverImplementation::setUDPSocketBufferSize(const int64_t s) {
}
/***acquisition parameters***/
int slsReceiverImplementation::setROI(slsDetectorDefs::ROI arg) {
int Implementation::setROI(slsDetectorDefs::ROI arg) {
if (roi.xmin != arg.xmin || roi.xmax != arg.xmax) {
roi.xmin = arg.xmin;
roi.xmax = arg.xmax;
@ -822,7 +822,7 @@ int slsReceiverImplementation::setROI(slsDetectorDefs::ROI arg) {
return OK;
}
int slsReceiverImplementation::setADCEnableMask(uint32_t mask) {
int Implementation::setADCEnableMask(uint32_t mask) {
if (adcEnableMask != mask) {
adcEnableMask = mask;
@ -843,7 +843,7 @@ int slsReceiverImplementation::setADCEnableMask(uint32_t mask) {
return OK;
}
int slsReceiverImplementation::setStreamingFrequency(const uint32_t freq) {
int Implementation::setStreamingFrequency(const uint32_t freq) {
if (streamingFrequency != freq) {
streamingFrequency = freq;
}
@ -851,14 +851,14 @@ int slsReceiverImplementation::setStreamingFrequency(const uint32_t freq) {
return OK;
}
void slsReceiverImplementation::setStreamingTimer(const uint32_t time_in_ms) {
void Implementation::setStreamingTimer(const uint32_t time_in_ms) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
streamingTimerInMs = time_in_ms;
FILE_LOG(logINFO) << "Streamer Timer: " << streamingTimerInMs;
}
int slsReceiverImplementation::setDataStreamEnable(const bool enable) {
int Implementation::setDataStreamEnable(const bool enable) {
if (dataStreamEnable != enable) {
dataStreamEnable = enable;
@ -895,25 +895,25 @@ int slsReceiverImplementation::setDataStreamEnable(const bool enable) {
return OK;
}
void slsReceiverImplementation::setStreamingPort(const uint32_t i) {
void Implementation::setStreamingPort(const uint32_t i) {
streamingPort = i;
FILE_LOG(logINFO) << "Streaming Port: " << streamingPort;
}
void slsReceiverImplementation::setStreamingSourceIP(const sls::IpAddr ip) {
void Implementation::setStreamingSourceIP(const sls::IpAddr ip) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
streamingSrcIP = ip;
FILE_LOG(logINFO) << "Streaming Source IP: " << streamingSrcIP;
}
void slsReceiverImplementation::setAdditionalJsonHeader(const std::string& c) {
void Implementation::setAdditionalJsonHeader(const std::string& c) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
additionalJsonHeader = c;
FILE_LOG(logINFO) << "Additional JSON Header: " << additionalJsonHeader;
}
void slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i) {
void Implementation::setAcquisitionPeriod(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
acquisitionPeriod = i;
@ -921,7 +921,7 @@ void slsReceiverImplementation::setAcquisitionPeriod(const uint64_t i) {
<< (double)acquisitionPeriod / (1E9) << "s";
}
void slsReceiverImplementation::setAcquisitionTime(const uint64_t i) {
void Implementation::setAcquisitionTime(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
acquisitionTime = i;
@ -929,7 +929,7 @@ void slsReceiverImplementation::setAcquisitionTime(const uint64_t i) {
<< "s";
}
void slsReceiverImplementation::setSubExpTime(const uint64_t i) {
void Implementation::setSubExpTime(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
subExpTime = i;
@ -937,7 +937,7 @@ void slsReceiverImplementation::setSubExpTime(const uint64_t i) {
<< "s";
}
void slsReceiverImplementation::setSubPeriod(const uint64_t i) {
void Implementation::setSubPeriod(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
subPeriod = i;
@ -945,14 +945,14 @@ void slsReceiverImplementation::setSubPeriod(const uint64_t i) {
<< "s";
}
void slsReceiverImplementation::setNumberOfFrames(const uint64_t i) {
void Implementation::setNumberOfFrames(const uint64_t i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
numberOfFrames = i;
FILE_LOG(logINFO) << "Number of Frames: " << numberOfFrames;
}
int slsReceiverImplementation::setNumberofAnalogSamples(const uint32_t i) {
int Implementation::setNumberofAnalogSamples(const uint32_t i) {
if (numberOfAnalogSamples != i) {
numberOfAnalogSamples = i;
@ -971,7 +971,7 @@ int slsReceiverImplementation::setNumberofAnalogSamples(const uint32_t i) {
return OK;
}
int slsReceiverImplementation::setNumberofDigitalSamples(const uint32_t i) {
int Implementation::setNumberofDigitalSamples(const uint32_t i) {
if (numberOfDigitalSamples != i) {
numberOfDigitalSamples = i;
@ -991,7 +991,7 @@ int slsReceiverImplementation::setNumberofDigitalSamples(const uint32_t i) {
return OK;
}
int slsReceiverImplementation::setDynamicRange(const uint32_t i) {
int Implementation::setDynamicRange(const uint32_t i) {
// only eiger
if (dynamicRange != i) {
dynamicRange = i;
@ -1007,7 +1007,7 @@ int slsReceiverImplementation::setDynamicRange(const uint32_t i) {
return OK;
}
int slsReceiverImplementation::setTenGigaEnable(const bool b) {
int Implementation::setTenGigaEnable(const bool b) {
if (tengigaEnable != b) {
tengigaEnable = b;
// side effects
@ -1035,7 +1035,7 @@ int slsReceiverImplementation::setTenGigaEnable(const bool b) {
return OK;
}
int slsReceiverImplementation::setFifoDepth(const uint32_t i) {
int Implementation::setFifoDepth(const uint32_t i) {
if (fifoDepth != i) {
fifoDepth = i;
if (SetupFifoStructure() == FAIL)
@ -1046,14 +1046,14 @@ int slsReceiverImplementation::setFifoDepth(const uint32_t i) {
}
/***receiver parameters***/
bool slsReceiverImplementation::setActivate(bool enable) {
bool Implementation::setActivate(bool enable) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
activated = enable;
FILE_LOG(logINFO) << "Activation: " << (activated ? "enabled" : "disabled");
return activated;
}
bool slsReceiverImplementation::setDeactivatedPadding(bool enable) {
bool Implementation::setDeactivatedPadding(bool enable) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
deactivatedPaddingEnable = enable;
FILE_LOG(logINFO) << "Deactivated Padding Enable: "
@ -1061,19 +1061,19 @@ bool slsReceiverImplementation::setDeactivatedPadding(bool enable) {
return deactivatedPaddingEnable;
}
void slsReceiverImplementation::setSilentMode(const bool i) {
void Implementation::setSilentMode(const bool i) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
silentMode = i;
FILE_LOG(logINFO) << "Silent Mode: " << i;
}
void slsReceiverImplementation::setDbitList(const std::vector<int> v) {
void Implementation::setDbitList(const std::vector<int> v) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
ctbDbitList = v;
}
void slsReceiverImplementation::setDbitOffset(const int s) {
void Implementation::setDbitOffset(const int s) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
ctbDbitOffset = s;
}
@ -1084,7 +1084,7 @@ void slsReceiverImplementation::setDbitOffset(const int s) {
*************************************************************************/
/***initial functions***/
int slsReceiverImplementation::setDetectorType(const detectorType d) {
int Implementation::setDetectorType(const detectorType d) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
DeleteMembers();
InitializeMembers();
@ -1177,7 +1177,7 @@ int slsReceiverImplementation::setDetectorType(const detectorType d) {
return OK;
}
void slsReceiverImplementation::setDetectorPositionId(const int id) {
void Implementation::setDetectorPositionId(const int id) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
detID = id;
FILE_LOG(logINFO) << "Detector Position Id:" << detID;
@ -1198,7 +1198,7 @@ void slsReceiverImplementation::setDetectorPositionId(const int id) {
}
int slsReceiverImplementation::startReceiver(std::string& err) {
int Implementation::startReceiver(std::string& err) {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
FILE_LOG(logINFO) << "Starting Receiver";
ResetParametersforNewAcquisition();
@ -1244,7 +1244,7 @@ int slsReceiverImplementation::startReceiver(std::string& err) {
return OK;
}
void slsReceiverImplementation::stopReceiver() {
void Implementation::stopReceiver() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
FILE_LOG(logINFO) << "Stopping Receiver";
@ -1336,7 +1336,7 @@ void slsReceiverImplementation::stopReceiver() {
FILE_LOG(logINFO) << "Status: " << sls::ToString(status);
}
void slsReceiverImplementation::startReadout() {
void Implementation::startReadout() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
if (status == RUNNING) {
// wait for incoming delayed packets
@ -1372,13 +1372,13 @@ void slsReceiverImplementation::startReadout() {
shutDownUDPSockets();
}
void slsReceiverImplementation::shutDownUDPSockets() {
void Implementation::shutDownUDPSockets() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (const auto &it : listener)
it->ShutDownUDPSocket();
}
void slsReceiverImplementation::closeFiles() {
void Implementation::closeFiles() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
uint64_t maxIndexCaught = 0;
bool anycaught = false;
@ -1394,7 +1394,7 @@ void slsReceiverImplementation::closeFiles() {
dataProcessor[0]->EndofAcquisition(anycaught, maxIndexCaught);
}
int slsReceiverImplementation::restreamStop() {
int Implementation::restreamStop() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (const auto &it : dataStreamer) {
if (it->RestreamStop() == FAIL)
@ -1405,19 +1405,19 @@ int slsReceiverImplementation::restreamStop() {
}
/***callback functions***/
void slsReceiverImplementation::registerCallBackStartAcquisition(
void Implementation::registerCallBackStartAcquisition(
int (*func)(std::string, std::string, uint64_t, uint32_t, void *), void *arg) {
startAcquisitionCallBack = func;
pStartAcquisition = arg;
}
void slsReceiverImplementation::registerCallBackAcquisitionFinished(
void Implementation::registerCallBackAcquisitionFinished(
void (*func)(uint64_t, void *), void *arg) {
acquisitionFinishedCallBack = func;
pAcquisitionFinished = arg;
}
void slsReceiverImplementation::registerCallBackRawDataReady(
void Implementation::registerCallBackRawDataReady(
void (*func)(char *, char *, uint32_t, void *), void *arg) {
rawDataReadyCallBack = func;
pRawDataReady = arg;
@ -1425,7 +1425,7 @@ void slsReceiverImplementation::registerCallBackRawDataReady(
it->registerCallBackRawDataReady(rawDataReadyCallBack, pRawDataReady);
}
void slsReceiverImplementation::registerCallBackRawDataModifyReady(
void Implementation::registerCallBackRawDataModifyReady(
void (*func)(char *, char *, uint32_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func;
pRawDataReady = arg;
@ -1434,7 +1434,7 @@ void slsReceiverImplementation::registerCallBackRawDataModifyReady(
pRawDataReady);
}
void slsReceiverImplementation::SetLocalNetworkParameters() {
void Implementation::SetLocalNetworkParameters() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
// to increase Max length of input packet queue
@ -1462,7 +1462,7 @@ void slsReceiverImplementation::SetLocalNetworkParameters() {
}
}
void slsReceiverImplementation::SetThreadPriorities() {
void Implementation::SetThreadPriorities() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (const auto &it : listener) {
@ -1480,7 +1480,7 @@ void slsReceiverImplementation::SetThreadPriorities() {
FILE_LOG(logINFO) << osfn.str();
}
int slsReceiverImplementation::SetupFifoStructure() {
int Implementation::SetupFifoStructure() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
fifo.clear();
@ -1517,7 +1517,7 @@ int slsReceiverImplementation::SetupFifoStructure() {
return OK;
}
void slsReceiverImplementation::ResetParametersforNewAcquisition() {
void Implementation::ResetParametersforNewAcquisition() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
for (const auto &it : listener)
@ -1534,7 +1534,7 @@ void slsReceiverImplementation::ResetParametersforNewAcquisition() {
}
}
int slsReceiverImplementation::CreateUDPSockets() {
int Implementation::CreateUDPSockets() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
bool error = false;
@ -1554,7 +1554,7 @@ int slsReceiverImplementation::CreateUDPSockets() {
return OK;
}
int slsReceiverImplementation::SetupWriter() {
int Implementation::SetupWriter() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
bool error = false;
masterAttributes attr;
@ -1596,7 +1596,7 @@ int slsReceiverImplementation::SetupWriter() {
return OK;
}
void slsReceiverImplementation::StartRunning() {
void Implementation::StartRunning() {
FILE_LOG(logDEBUG3) << __SHORT_AT__ << " called";
// set running mask and post semaphore to start the inner loop in execution
// thread

5
slsReceiverSoftware/src/Receiver.cpp
View File

@ -1,5 +1,4 @@
#include "Receiver.h"
#include "slsReceiverTCPIPInterface.h"
#include "sls_detector_exceptions.h"
#include "versionAPI.h"
#include "container_utils.h"
@ -71,14 +70,14 @@ Receiver::Receiver(int argc, char *argv[]):
}
// might throw an exception
tcpipInterface = sls::make_unique<slsReceiverTCPIPInterface>(tcpip_port_no);
tcpipInterface = sls::make_unique<ClientInterface>(tcpip_port_no);
}
Receiver::Receiver(int tcpip_port_no)
{
// might throw an exception
tcpipInterface = sls::make_unique<slsReceiverTCPIPInterface>(tcpip_port_no);
tcpipInterface = sls::make_unique<ClientInterface>(tcpip_port_no);
}
int64_t Receiver::getReceiverVersion(){