clang-tidy

.clang-tidy

@@ -28,7 +28,9 @@ Checks:          '*,
                     -modernize-use-trailing-return-type,
                     -llvmlibc-*'
 
-HeaderFilterRegex: \.h
+# HeaderFilterRegex: \.h
+HeaderFilterRegex: '^(?!.*([/\\])libs([/\\])).*'
+#AnalyzeTemporaryDtors: false
 FormatStyle:     none
 CheckOptions:
   - { key: readability-identifier-naming.NamespaceCase,       value: lower_case }

docs/CMakeLists.txt

@@ -11,8 +11,7 @@ add_executable(gendoc src/gendoc.cpp)
 # This is a bit hacky, but better than exposing stuff? 
 target_include_directories(gendoc PRIVATE ${PROJECT_SOURCE_DIR}/slsDetectorSoftware/src)
 target_link_libraries(gendoc PRIVATE
-  slsDetectorStatic
-
+  slsDetectorShared
 )
 set_target_properties(gendoc PROPERTIES 
   RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin

docs/src/gendoc.cpp

@@ -19,7 +19,7 @@ std::string replace_all(const std::string &src, const std::string &from,
                         const std::string &to) {
 
     std::string results;
-    std::string::const_iterator end = src.end();
+    std::string::const_iterator const end = src.end();
     std::string::const_iterator current = src.begin();
     std::string::const_iterator next =
         std::search(current, end, from.begin(), from.end());

python/CMakeLists.txt

@@ -12,7 +12,6 @@ pybind11_add_module(_slsdet
     src/duration.cpp
     src/DurationWrapper.cpp
     src/pedestal.cpp
-    src/bit.cpp
 )
 
 target_link_libraries(_slsdet PUBLIC 

python/scripts/generate_functions.py

@@ -8,7 +8,6 @@ to be installed.
 When the Detector API is updated this file should be run
 manually.
 """
-import os
 from clang import cindex
 import subprocess
 import argparse
@@ -34,24 +33,6 @@ def green(msg):
     return f"{GREENC}{msg}{ENDC}"
 
 
-def find_libclang():
-    """Find libclang in the current Conda/Mamba environment."""
-    conda_prefix = os.environ.get("CONDA_PREFIX")
-    if conda_prefix:
-        lib_dir = os.path.join(conda_prefix, "lib")
-        # Look for libclang*.so files
-        for f in os.listdir(lib_dir):
-            if f.startswith("libclang") and f.endswith(".so"):
-                return os.path.join(lib_dir, f)
-
-    # fallback: system-wide search
-    path = ctypes.util.find_library("clang")
-    if path:
-        return path
-
-    raise FileNotFoundError("libclang not found in CONDA_PREFIX or system paths.")
-
-
 def check_libclang_version(required="12"):
     # Use already-loaded libclang, or let cindex resolve it
     lib = ctypes.CDLL(cindex.Config.library_file or ctypes.util.find_library("clang"))
@@ -221,8 +202,6 @@ if __name__ == "__main__":
     )
     cargs = parser.parse_args()
 
-    libclang_path = find_libclang()
-    cindex.Config.set_library_file(libclang_path)
     check_libclang_version("12")
     check_clang_format_version(12)
     check_for_compile_commands_json(cargs.build_path)

python/slsdet/__init__.py

@@ -27,9 +27,6 @@ from .defines import *
 
 IpAddr = _slsdet.IpAddr
 MacAddr = _slsdet.MacAddr
-RegisterAddress = _slsdet.RegisterAddress
-BitAddress = _slsdet.BitAddress
-RegisterValue = _slsdet.RegisterValue
 scanParameters = _slsdet.scanParameters
 currentSrcParameters = _slsdet.currentSrcParameters
 DurationWrapper = _slsdet.DurationWrapper

python/slsdet/detector.py

@@ -3,7 +3,6 @@
 from ._slsdet import CppDetectorApi
 from ._slsdet import slsDetectorDefs
 from ._slsdet import IpAddr, MacAddr
-from ._slsdet import RegisterAddress, RegisterValue, BitAddress
 
 runStatus = slsDetectorDefs.runStatus
 timingMode = slsDetectorDefs.timingMode
@@ -1815,148 +1814,6 @@ class Detector(CppDetectorApi):
         """
         return self._register
 
-    def define_reg(self, *, name: str, addr):
-        """
-        [Ctb] Define a name for a register to be used later with reg.
-
-        Example
-        --------
-
-        d.define_reg('myreg',addr=0x6)
-        d.define_reg('myreg',addr=RegisterAddress(0x6))')
-        """
-        if isinstance(addr, int):
-            addr = RegisterAddress(addr)
-        elif not isinstance(addr, RegisterAddress):
-            raise ValueError("addr must int or RegisterAddress")
-        self.setRegisterDefinition(name, addr)
-
-
-    def define_bit(self, *, name: str, addr, bit_position:int=None):
-        """
-        [Ctb] Define a name for a bit in a register to be used later with setBit/clearBit/getBit
-
-        Example
-        --------
-
-        bit1 = BitAddress(RegisterAddress(0x6),7)
-        d.define_bit('mybit',addr=bit1)
-        d.define_bit('mybit',addr=0x6, bit=7)
-        d.define_bit('mybit',addr=RegisterAddress(0x6), bit=7)
-        d.define_bit('mybit',addr='myreg', bit=7) #if myreg defined before
-        """
-
-        # bitAddress
-        if isinstance(addr, BitAddress):
-            if bit_position is not None:
-                raise ValueError("If addr is BitAddress, bit_position must be None")
-            bitaddr = addr
-        # register name/address + bit_position
-        else:
-            if isinstance(addr, str):
-                addr = self.getRegisterAddress(addr)
-            elif isinstance(addr, int):
-                addr = RegisterAddress(addr)
-            elif not isinstance(addr, RegisterAddress):
-                raise ValueError("addr must be str, int or RegisterAddress")
-            
-            if bit_position is None:
-                raise ValueError("bit_position must be provided if addr is used.")
-            if not isinstance(bit_position, int):
-                raise ValueError("bit_position must be int")
-
-            bitaddr = BitAddress(addr, bit_position)
-
-        self.setBitDefinition(name, bitaddr)
-
-    def _resolve_bit_name_or_addr(self, bitname_or_addr, bit_position=None):
-        """
-        Internal function to resolve bit name or address arguments for setBit, clearBit and getBit
-        Returns a BitAddress
-        """
-        #Old usage passing two ints  or [RegisterAddress and int]
-        if isinstance(bitname_or_addr, (int, RegisterAddress)):
-            if bit_position is None:
-                raise ValueError("bit_position must be provided when passing int address")
-            if not isinstance(bit_position, int):
-                raise ValueError("bit_position must be int")
-            return BitAddress(bitname_or_addr, bit_position)
-
-        # New usage with str or BitAddress
-        # str
-        if isinstance(bitname_or_addr, str):
-            bitname_or_addr = self.getBitAddress(bitname_or_addr)
-
-        if bit_position is not None:
-            raise ValueError("bit_position must be None when passing str or BitAddress")
-
-        #must now be a BitAddress
-        if not isinstance(bitname_or_addr, BitAddress):
-            raise ValueError("bitname_or_addr must be str, BitAddress, int or RegisterAddress")
-
-        return bitname_or_addr
-        
-
-    def setBit(self, bitname_or_addr, bit_position=None):
-        """
-        Set a bit in a register
-        [Ctb] Can use a named bit address
-
-        Example
-        --------
-        d.setBit(0x5, 3)
-        d.setBit(RegisterAddress(0x5), 3)
-        
-        #Ctb
-        d.setBit('mybit')
-
-        myreg = RegisterAddress(0x5)
-        mybit = BitAddress(myreg, 5) 
-        d.setBit(mybit)
-        """
-        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
-        return super().setBit(resolved)
-        
-    def clearBit(self, bitname_or_addr, bit_position=None):
-        """
-        Clear a bit in a register
-        [Ctb] Can use a named bit address
-
-        Example
-        --------
-        d.clearBit(0x5, 3)
-        
-        #Ctb
-        d.clearBit('mybit')
-
-        myreg = RegisterAddress(0x5)
-        mybit = BitAddress(myreg, 5) 
-        d.clearBit(mybit)
-        """
-        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
-        return super().clearBit(resolved)
-
-    @element
-    def getBit(self, bitname_or_addr, bit_position=None):
-        """
-        Get a bit from a register
-        [Ctb] Can use a named bit address
-
-        Example
-        --------
-        d.getBit(0x5, 3)
-        
-        #Ctb
-        d.getBit('mybit')
-
-        myreg = RegisterAddress(0x5)
-        mybit = BitAddress(myreg, 5) 
-        d.getBit(mybit)
-        """
-        resolved = self._resolve_bit_name_or_addr(bitname_or_addr, bit_position)
-        return super().getBit(resolved)  
-
-
     @property
     def slowadc(self):
         """

python/slsdet/registers.py

@@ -1,30 +1,13 @@
 # SPDX-License-Identifier: LGPL-3.0-or-other
 # Copyright (C) 2021 Contributors to the SLS Detector Package
-
-from ._slsdet import RegisterValue, RegisterAddress
-from .utils import element
-
 class Register:
     def __init__(self, detector):
         self._detector = detector
 
-    @element
     def __getitem__(self, key):
-        if isinstance(key, str):
-            key = self._detector.getRegisterAddress(key)
-        elif isinstance(key, int):
-            key = RegisterAddress(key)
         return self._detector.readRegister(key)
 
     def __setitem__(self, key, value):
-        if isinstance(key, str):
-            key = self._detector.getRegisterAddress(key)
-        elif isinstance(key, int):
-            key = RegisterAddress(key)
-
-        if isinstance(value, int):
-            value = RegisterValue(value)
-
         self._detector.writeRegister(key, value, False)
 
 class Adc_register:

python/slsdet/utils.py

@@ -141,19 +141,20 @@ def make_ip(arg):
 def make_mac(arg):
     return _make(arg, _slsdet.MacAddr)
 
+
 def make_path(arg):
     return _make(arg, Path)
 
 
 def _make(arg, transform):
-    """Helper function for make_mac, make_ip and other special cases for
+    """Helper function for make_mac and make_ip special cases for
     dict, list and tuple. Otherwise just calls transform"""
     if isinstance(arg, dict):
-        return {key: _make(value, transform) for key, value in arg.items()}
+        return {key: transform(value) for key, value in arg.items()}
     elif isinstance(arg, list):
-        return [_make(a, transform) for a in arg]
+        return [transform(a) for a in arg]
     elif isinstance(arg, tuple):
-        return tuple(_make(a, transform) for a in arg)
+        return tuple(transform(a) for a in arg)
     else:
         return transform(arg)
 

python/src/bit.cpp

@@ -1,67 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-other
-// Copyright (C) 2021 Contributors to the SLS Detector Package
-/*
-This file contains Python bindings for the RegisterAddr, BitAddress and
-RegisterValue classes.
-*/
-#include "py_headers.h"
-#include "sls/bit_utils.h"
-
-namespace py = pybind11;
-
-using sls::BitAddress;
-using sls::RegisterAddress;
-using sls::RegisterValue;
-
-void init_bit(py::module &m) {
-
-    py::class_<RegisterAddress>(m, "RegisterAddress")
-        .def(py::init())
-        .def(py::init<uint32_t>())
-        .def(py::init<const RegisterAddress &>())
-        .def("__repr__",
-             [](const RegisterAddress &addr) {
-                 return "RegisterAddress(" + addr.str() + ")";
-             })
-        .def("__str__", &RegisterAddress::str)
-        .def("value", &RegisterAddress::value)
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<BitAddress>(m, "BitAddress")
-        .def(py::init())
-        .def(py::init<RegisterAddress, uint32_t>())
-        .def("__repr__",
-             [](const BitAddress &addr) {
-                 return "BitAddress(" + addr.str() + ")";
-             })
-        .def("__str__", &BitAddress::str)
-        .def("address", &BitAddress::address)
-        .def("bitPosition", &BitAddress::bitPosition)
-        .def(py::self == py::self)
-        .def(py::self != py::self);
-
-    py::class_<RegisterValue>(m, "RegisterValue")
-        .def(py::init<>())
-        .def(py::init<uint32_t>())
-        .def(py::init<const RegisterValue &>())
-        .def("__repr__",
-             [](const RegisterValue &val) {
-                 return "RegisterValue(" + val.str() + ")";
-             })
-        .def("__str__", &RegisterValue::str)
-        .def("value", &RegisterValue::value)
-        .def(py::self == py::self)
-        .def(py::self != py::self)
-        .def("__or__", [](const RegisterValue &lhs,
-                          const RegisterValue &rhs) { return lhs | rhs; })
-        .def("__or__",
-             [](const RegisterValue &lhs, uint32_t rhs) { return lhs | rhs; })
-        .def(
-            "__ior__",
-            [](RegisterValue &lhs, uint32_t rhs) -> RegisterValue & {
-                lhs |= rhs;
-                return lhs;
-            },
-            py::return_value_policy::reference_internal);
-}

python/src/detector.cpp

@@ -8,7 +8,6 @@
 #include "sls/Detector.h"
 #include "sls/TimeHelper.h"
 #include "sls/ToString.h"
-#include "sls/bit_utils.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 
@@ -16,13 +15,10 @@
 #include <chrono>
 namespace py = pybind11;
 void init_det(py::module &m) {
-    using sls::BitAddress;
     using sls::defs;
     using sls::Detector;
     using sls::ns;
     using sls::Positions;
-    using sls::RegisterAddress;
-    using sls::RegisterValue;
     using sls::Result;
 
     m.def("freeSharedMemory",
@@ -946,6 +942,7 @@ void init_det(py::module &m) {
                        (void (Detector::*)(const std::vector<defs::ROI> &)) &
                            Detector::setRxROI,
                        py::arg());
+
     CppDetectorApi.def("clearRxROI",
                        (void (Detector::*)()) & Detector::clearRxROI);
     CppDetectorApi.def(
@@ -1799,82 +1796,6 @@ void init_det(py::module &m) {
                        (std::string(Detector::*)(const defs::dacIndex) const) &
                            Detector::getSlowADCName,
                        py::arg());
-    CppDetectorApi.def("getRegisterDefinitionsCount",
-                       (int (Detector::*)() const) &
-                           Detector::getRegisterDefinitionsCount);
-    CppDetectorApi.def(
-        "setRegisterDefinition",
-        (void (Detector::*)(const std::string &, sls::RegisterAddress)) &
-            Detector::setRegisterDefinition,
-        py::arg(), py::arg());
-    CppDetectorApi.def("hasRegisterDefinition",
-                       (bool (Detector::*)(const std::string &) const) &
-                           Detector::hasRegisterDefinition,
-                       py::arg());
-    CppDetectorApi.def("hasRegisterDefinition",
-                       (bool (Detector::*)(sls::RegisterAddress) const) &
-                           Detector::hasRegisterDefinition,
-                       py::arg());
-    CppDetectorApi.def(
-        "getRegisterAddress",
-        (sls::RegisterAddress(Detector::*)(const std::string &) const) &
-            Detector::getRegisterAddress,
-        py::arg());
-    CppDetectorApi.def("getRegisterName",
-                       (std::string(Detector::*)(sls::RegisterAddress) const) &
-                           Detector::getRegisterName,
-                       py::arg());
-    CppDetectorApi.def("clearRegisterDefinitions",
-                       (void (Detector::*)()) &
-                           Detector::clearRegisterDefinitions);
-    CppDetectorApi.def(
-        "setRegisterDefinitions",
-        (void (Detector::*)(const std::map<std::string, RegisterAddress> &)) &
-            Detector::setRegisterDefinitions,
-        py::arg());
-    CppDetectorApi.def(
-        "getRegisterDefinitions",
-        (std::map<std::string, RegisterAddress>(Detector::*)() const) &
-            Detector::getRegisterDefinitions);
-    CppDetectorApi.def("getBitDefinitionsCount",
-                       (int (Detector::*)() const) &
-                           Detector::getBitDefinitionsCount);
-    CppDetectorApi.def(
-        "setBitDefinition",
-        (void (Detector::*)(const std::string &, sls::BitAddress)) &
-            Detector::setBitDefinition,
-        py::arg(), py::arg());
-    CppDetectorApi.def("hasBitDefinition",
-                       (bool (Detector::*)(const std::string &) const) &
-                           Detector::hasBitDefinition,
-                       py::arg());
-    CppDetectorApi.def("hasBitDefinition",
-                       (bool (Detector::*)(sls::BitAddress) const) &
-                           Detector::hasBitDefinition,
-                       py::arg());
-    CppDetectorApi.def("toRegisterNameBitString",
-                       (std::string(Detector::*)(sls::BitAddress) const) &
-                           Detector::toRegisterNameBitString,
-                       py::arg());
-    CppDetectorApi.def(
-        "getBitAddress",
-        (sls::BitAddress(Detector::*)(const std::string &) const) &
-            Detector::getBitAddress,
-        py::arg());
-    CppDetectorApi.def("getBitName",
-                       (std::string(Detector::*)(sls::BitAddress) const) &
-                           Detector::getBitName,
-                       py::arg());
-    CppDetectorApi.def("clearBitDefinitions",
-                       (void (Detector::*)()) & Detector::clearBitDefinitions);
-    CppDetectorApi.def(
-        "setBitDefinitions",
-        (void (Detector::*)(const std::map<std::string, BitAddress> &)) &
-            Detector::setBitDefinitions,
-        py::arg());
-    CppDetectorApi.def("getBitDefinitions", (std::map<std::string, BitAddress>(
-                                                Detector::*)() const) &
-                                                Detector::getBitDefinitions);
     CppDetectorApi.def("configureTransceiver",
                        (void (Detector::*)(sls::Positions)) &
                            Detector::configureTransceiver,
@@ -2048,58 +1969,6 @@ void init_det(py::module &m) {
                        (void (Detector::*)(const bool, sls::Positions)) &
                            Detector::setUpdateMode,
                        py::arg(), py::arg() = Positions{});
-    CppDetectorApi.def("readRegister",
-                       (Result<sls::RegisterValue>(Detector::*)(
-                           sls::RegisterAddress, sls::Positions) const) &
-                           Detector::readRegister,
-                       py::arg(), py::arg() = Positions{});
-    CppDetectorApi.def(
-        "writeRegister",
-        (void (Detector::*)(sls::RegisterAddress, sls::RegisterValue, bool,
-                            sls::Positions)) &
-            Detector::writeRegister,
-        py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "setBit",
-        (void (Detector::*)(sls::BitAddress, bool, sls::Positions)) &
-            Detector::setBit,
-        py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "clearBit",
-        (void (Detector::*)(sls::BitAddress, bool, sls::Positions)) &
-            Detector::clearBit,
-        py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "getBit",
-        (Result<int>(Detector::*)(sls::BitAddress, sls::Positions) const) &
-            Detector::getBit,
-        py::arg(), py::arg() = Positions{});
-    CppDetectorApi.def("readRegister",
-                       (Result<sls::RegisterValue>(Detector::*)(
-                           const std::string &, sls::Positions) const) &
-                           Detector::readRegister,
-                       py::arg(), py::arg() = Positions{});
-    CppDetectorApi.def(
-        "writeRegister",
-        (void (Detector::*)(const std::string &, sls::RegisterValue, bool,
-                            sls::Positions)) &
-            Detector::writeRegister,
-        py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "setBit",
-        (void (Detector::*)(const std::string &, bool, sls::Positions)) &
-            Detector::setBit,
-        py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "clearBit",
-        (void (Detector::*)(const std::string &, bool, sls::Positions)) &
-            Detector::clearBit,
-        py::arg(), py::arg() = false, py::arg() = Positions{});
-    CppDetectorApi.def(
-        "getBit",
-        (Result<int>(Detector::*)(const std::string &, sls::Positions) const) &
-            Detector::getBit,
-        py::arg(), py::arg() = Positions{});
     CppDetectorApi.def(
         "readRegister",
         (Result<uint32_t>(Detector::*)(uint32_t, sls::Positions) const) &
@@ -2122,7 +1991,7 @@ void init_det(py::module &m) {
         py::arg(), py::arg(), py::arg() = false, py::arg() = Positions{});
     CppDetectorApi.def(
         "getBit",
-        (Result<int>(Detector::*)(uint32_t, int, sls::Positions) const) &
+        (Result<int>(Detector::*)(uint32_t, int, sls::Positions)) &
             Detector::getBit,
         py::arg(), py::arg(), py::arg() = Positions{});
     CppDetectorApi.def("executeFirmwareTest",

python/src/detector_in.cpp

@@ -7,19 +7,15 @@
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 #include "sls/TimeHelper.h"
-#include "sls/bit_utils.h"
 
 #include <array>
 #include <chrono>
 namespace py = pybind11;
 void init_det(py::module &m) {
-    using sls::BitAddress;
     using sls::defs;
     using sls::Detector;
     using sls::ns;
     using sls::Positions;
-    using sls::RegisterAddress;
-    using sls::RegisterValue;
     using sls::Result;
 
     m.def("freeSharedMemory", (void (*)(const int, const int)) &sls::freeSharedMemory, py::arg() = 0, py::arg() = -1);

python/src/duration.cpp

@@ -24,7 +24,7 @@ void init_duration(py::module &m) {
     m.def(
         "test_return_DurationWrapper",
         []() {
-            DurationWrapper t(1.3);
+            DurationWrapper const t(1.3);
             return t;
         },
         R"(

python/src/enums.cpp

@@ -9,7 +9,7 @@
 #include "sls/sls_detector_defs.h"
 namespace py = pybind11;
 void init_enums(py::module &m) {
-    py::class_<slsDetectorDefs> Defs(m, "slsDetectorDefs");
+    py::class_<slsDetectorDefs> const Defs(m, "slsDetectorDefs");
     py::class_<slsDetectorDefs::xy> xy(m, "xy");
     xy.def(py::init());
     xy.def(py::init<int, int>());

python/src/main.cpp

@@ -20,7 +20,6 @@ void init_scan(py::module &);
 void init_source(py::module &);
 void init_duration(py::module &);
 void init_pedestal(py::module &);
-void init_bit(py::module &);
 
 PYBIND11_MODULE(_slsdet, m) {
     m.doc() = R"pbdoc(
@@ -41,7 +40,6 @@ PYBIND11_MODULE(_slsdet, m) {
     init_source(m);
     init_duration(m);
     init_pedestal(m);
-    init_bit(m);
     //  init_experimental(m);
 
     py::module io = m.def_submodule("io", "Submodule for io");

python/src/pattern.cpp

@@ -15,7 +15,7 @@ void init_pattern(py::module &m) {
 
     patternParameters.def(py::init());
     patternParameters.def("numpy_view", [](py::object &obj) {
-        pat &o = obj.cast<pat &>();
+        pat  const&o = obj.cast<pat &>();
         return py::array_t<pat>(1, &o, obj);
     });
 

python/tests/test_CtbAPI.py

@@ -1,385 +0,0 @@
-'''
-cd python/tests
-Specific test: pytest -s -x test_CtbAPI.py::test_define_bit  #-x=abort on first failure
-Specific test with specific server: pytest -s -x test_CtbAPI.py::test_define_reg[ctb]
-
-'''
-
-import pytest, sys, traceback
-
-from pathlib import Path
-current_dir = Path(__file__).resolve().parents[2]
-scripts_dir = current_dir / "tests" / "scripts"
-sys.path.append(str(scripts_dir))
-print(sys.path)
-
-from utils_for_test import (
-    Log,
-    LogLevel,
-    cleanup,
-    startDetectorVirtualServer,
-    connectToVirtualServers,
-    SERVER_START_PORTNO, 
-)
-
-from slsdet import Detector, detectorType
-
-
-@pytest.fixture(
-    scope="session", 
-    params=['ctb', 'xilinx_ctb', 'mythen3']
-)
-def simulator(request):
-    """Fixture to start the detector server once and clean up at the end."""
-    det_name = request.param
-    num_mods = 1
-    fp = sys.stdout
-
-    # set up: once per server
-    Log(LogLevel.INFOBLUE, f'---- {det_name} ----')
-    cleanup(fp)
-    startDetectorVirtualServer(det_name, num_mods, fp)
-
-    Log(LogLevel.INFOBLUE, f'Waiting for server to start up and connect')
-    connectToVirtualServers(det_name, num_mods)
-
-    yield det_name # tests run here
-
-    cleanup(fp)
-
-
-@pytest.mark.withdetectorsimulators
-def test_define_reg(simulator, request):
-    """ Test setting define_reg for ctb and xilinx_ctb."""
-    det_name = simulator
-    from slsdet import RegisterAddress
-
-    d = Detector()
-    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
-
-    if det_name in ['ctb', 'xilinx_ctb']:
-        prev_reg_defs = d.getRegisterDefinitions()
-        prev_bit_defs = d.getBitDefinitions()
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-
-        addr1 = RegisterAddress(0x201)
-        addr2 = RegisterAddress(0x202)
-        d.define_reg(name="test_reg", addr=RegisterAddress(0x200)) # valid
-        d.define_reg(name="test_reg", addr=addr1) # takes a register address
-        d.define_reg(name="test_reg2", addr=0x202) # takes an int
-
-        # not using keyword arguments
-        with pytest.raises(TypeError) as exc_info:
-            d.define_reg("randomreg", 0x203)
-
-        # invalid value type
-        with pytest.raises(Exception) as exc_info:
-            d.define_reg(name="test_reg3", addr='0x203')
-        assert "addr must int or RegisterAddress" in str(exc_info.value)
-
-        # defining with duplicate value
-        with pytest.raises(Exception) as exc_info:
-            d.define_reg(name="test_reg3", addr=addr1)
-        assert "Value already assigned" in str(exc_info.value)
-
-        assert(d.getRegisterAddress("test_reg") == addr1)
-        assert(d.getRegisterName(addr1) == "test_reg")
-
-        # accessing non existent reg name
-        with pytest.raises(Exception) as exc_info:
-            d.reg['random_reg']
-        assert "No entry found for key" in str(exc_info.value)
-
-        # get non existing reg address
-        with pytest.raises(Exception) as exc_info:
-            d.getRegisterName(RegisterAddress(0x300))
-        assert "No entry found for value" in str(exc_info.value)
-
-        d.clearRegisterDefinitions()
-        
-        d.setRegisterDefinitions(prev_reg_defs)
-        d.setBitDefinitions(prev_bit_defs)  
-
-    else:
-        with pytest.raises(Exception) as exc_info:
-            d.define_reg(name="test_reg", addr=0x201)
-        assert "Register Definitions only for CTB" in str(exc_info.value)
-
-    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
-
-
-@pytest.mark.withdetectorsimulators
-def test_define_bit(simulator, request):
-    """ Test setting define_bit for ctb and xilinx_ctb."""
-    det_name = simulator
-    from slsdet import RegisterAddress, BitAddress
-
-    # setup
-    d = Detector()
-    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
-
-    if det_name in ['ctb', 'xilinx_ctb']:
-        prev_reg_defs = d.getRegisterDefinitions()
-        prev_bit_defs = d.getBitDefinitions()
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-
-        addr1 = RegisterAddress(0x201)
-        addr2 = RegisterAddress(0x202)
-        d.define_reg(name="test_reg1", addr=addr1) 
-        d.define_reg(name="test_reg2", addr=addr2)
-
-        # not using keyword arguments
-        with pytest.raises(TypeError) as exc_info:
-            d.define_bit("randombit", 0x203, 1)
-
-        # invalid value type (bit=string)
-        with pytest.raises(ValueError) as exc_info:
-            d.define_bit(name="test_bit1", addr='test_reg1', bit_position='1')
-        
-        # invalid bit_position
-        with pytest.raises(Exception) as exc_info:
-            d.define_bit(name="test_bit1", addr='test_reg1', bit_position=32)
-        assert "Bit position must be between 0 and 31" in str(exc_info.value)
-
-        # defining with random reg value
-        with pytest.raises(Exception) as exc_info:
-            d.define_bit(name='test_bit1', addr='random_reg', bit_position=1)
-        assert "No entry found for key" in str(exc_info.value)
-
-        bit1 = BitAddress(addr1, 2)
-        bit2 = BitAddress(addr1, 4)
-        bit3 = BitAddress(addr2, 3)
-
-        # defining bit address with bit_position as well
-        with pytest.raises(ValueError) as exc_info:
-            d.define_bit(name='test_bit1', addr=bit1, bit_position=1)
-        assert "bit_position must be None" in str(exc_info.value)
-
-
-        d.define_bit(name="test_bit1", addr='test_reg2', bit_position=1)
-        d.define_bit(name="test_bit1", addr='test_reg1', bit_position=1) # modify reg
-        d.define_bit(name='test_bit1', addr=bit1) # modify pos
-        d.define_bit(name="test_bit2", addr=0x201, bit_position=4) # int addr
-        d.define_bit(name="test_bit3", addr=addr2, bit_position=3) # RegisterAddress addr
-
-
-        assert(d.getBitAddress('test_bit1') == bit1)
-        assert(d.getBitAddress('test_bit2') == bit2)
-        assert(d.getBitAddress('test_bit3') == bit3)
-        assert(d.getBitAddress('test_bit1').address() == addr1)
-        assert(d.getBitAddress('test_bit1').bitPosition() == 2)
-        assert(d.getBitAddress('test_bit2') == BitAddress(addr1, 4))
-
-        assert(d.getBitName(bit1) == 'test_bit1')
-        assert(d.getBitName(bit2) == 'test_bit2')
-        assert(d.getBitName(bit3) == 'test_bit3')
-        assert(d.getBitName(BitAddress(addr2,3)) == 'test_bit3')
-
-        # bit doesnt exist for that reg
-        with pytest.raises(Exception) as exc_info:
-            d.getBitName(BitAddress(addr1, 5))
-        assert "No entry found for value" in str(exc_info.value)
-
-        # addr doesnt exist for that reg
-        with pytest.raises(Exception) as exc_info:
-            d.getBitName(BitAddress(RegisterAddress(0x300), 5))
-        assert "No entry found for value" in str(exc_info.value)
-
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-        
-        d.setRegisterDefinitions(prev_reg_defs)
-        d.setBitDefinitions(prev_bit_defs)  
-    else:
-        with pytest.raises(Exception) as exc_info:
-           d.define_bit(name="test_bit", addr=0x300, bit_position=1)
-        assert "Bit Definitions only for CTB" in str(exc_info.value)
-    
-        
-    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
-
-
-@pytest.mark.withdetectorsimulators
-def test_using_defined_reg_and_bit(simulator, request):
-    """ Test using defined reg and bit define_bit for ctb and xilinx_ctb."""
-    det_name = simulator
-    from slsdet import RegisterAddress, BitAddress, RegisterValue
-
-    # setup
-    d = Detector()
-    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
-
-    if det_name in ['ctb', 'xilinx_ctb']:
-        prev_reg_defs = d.getRegisterDefinitions()
-        prev_bit_defs = d.getBitDefinitions()
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-
-        addr1 = RegisterAddress(0x201)
-        addr2 = RegisterAddress(0x202)
-        d.setRegisterDefinition('test_reg1', addr1)
-        d.setRegisterDefinition('test_reg2', addr2)
-        bit1 = BitAddress(addr1, 2)
-        bit2 = BitAddress(addr1, 4)
-        bit3 = BitAddress(addr2, 3)
-        d.setBitDefinition('test_bit1', bit1)
-        d.setBitDefinition('test_bit2', bit2)
-        d.setBitDefinition('test_bit3', bit3)
-
-        prev_val_addr1 = d.reg[addr1]
-        prev_val_addr2 = d.reg[addr2]
-
-        # reg name doesnt exist
-        with pytest.raises(Exception) as exc_info:
-            d.reg['random_reg']
-        assert "No entry found for key" in str(exc_info.value)
-        with pytest.raises(Exception) as exc_info:
-            d.setBit('random_reg')
-        assert "No entry found for key" in str(exc_info.value)
-        with pytest.raises(Exception) as exc_info:
-            d.clearBit('random_reg')
-        assert "No entry found for key" in str(exc_info.value)
-        with pytest.raises(Exception) as exc_info:
-            d.getBit('random_reg')
-        assert "No entry found for key" in str(exc_info.value)
-
-        # bit name doesnt exist
-        with pytest.raises(Exception) as exc_info:
-            d.setBit('test_bit1', bit_position=5)
-        assert "bit_position must be None" in str(exc_info.value)
-        with pytest.raises(Exception) as exc_info:
-            d.clearBit('test_bit1', bit_position=5)
-        assert "bit_position must be None" in str(exc_info.value)
-        with pytest.raises(Exception) as exc_info:
-            d.getBit('test_bit1', bit_position=5)
-        assert "bit_position must be None" in str(exc_info.value)
-
-        d.reg['test_reg1'] = RegisterValue(0x0)
-        assert(d.reg['test_reg1'].value() == 0x0)
-
-        d.reg['test_reg1'] = RegisterValue(0x10)
-        assert(d.reg['test_reg1'].value() == 0x10)
-
-        d.setBit('test_bit1')
-        assert(d.reg['test_reg1'].value() == 0x14) # 0x10 | (1 << 2)
-
-        d.clearBit('test_bit1')
-        assert(d.reg['test_reg1'].value() == 0x10)
-
-        assert(d.getBit('test_bit1') == 0)
-
-        # restore previous values
-        d.reg[addr1] = prev_val_addr1
-        d.reg[addr2] = prev_val_addr2
-
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-        
-        d.setRegisterDefinitions(prev_reg_defs)
-        d.setBitDefinitions(prev_bit_defs)  
-    else:
-        with pytest.raises(Exception) as exc_info:
-            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
-        assert "Bit Definitions only for CTB" in str(exc_info.value)
-
-    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
-
-
-@pytest.mark.withdetectorsimulators
-def test_definelist_reg(simulator, request):
-    """ Test using definelist_reg for ctb and xilinx_ctb."""
-    det_name = simulator
-    from slsdet import RegisterAddress, BitAddress, RegisterValue
-
-    # setup
-    d = Detector()
-    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
-
-    if det_name in ['ctb', 'xilinx_ctb']:
-        prev_reg_defs = d.getRegisterDefinitions()
-        prev_bit_defs = d.getBitDefinitions()
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-
-        addr1 = RegisterAddress(0x201)
-        addr2 = RegisterAddress(0x202)
-        bit1 = BitAddress(addr1, 2)
-        bit2 = BitAddress(addr1, 4)
-        bit3 = BitAddress(addr2, 3)
-
-        d.setRegisterDefinitions({
-            'test_reg1': RegisterAddress(0x201),
-            'test_reg2': RegisterAddress(0x202)
-        })
-
-        res = d.getRegisterDefinitions()
-        assert(res['test_reg1'] == addr1)
-        assert(res['test_reg2'] == addr2)
-        assert(len(res) == 2)
-
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-        
-        d.setRegisterDefinitions(prev_reg_defs)
-        d.setBitDefinitions(prev_bit_defs)  
-    else:
-        with pytest.raises(Exception) as exc_info:
-            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
-        assert "Bit Definitions only for CTB" in str(exc_info.value)
-
-    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")
-
-
-@pytest.mark.withdetectorsimulators
-def test_definelist_bit(simulator, request):
-    """ Test using definelist_bit for ctb and xilinx_ctb."""
-    det_name = simulator
-    from slsdet import RegisterAddress, BitAddress, RegisterValue
-
-    # setup
-    d = Detector()
-    d.hostname = f"localhost:{SERVER_START_PORTNO}" 
-
-    if det_name in ['ctb', 'xilinx_ctb']:
-        prev_reg_defs = d.getRegisterDefinitions()
-        prev_bit_defs = d.getBitDefinitions()
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-
-        addr1 = RegisterAddress(0x201)
-        addr2 = RegisterAddress(0x202)
-        bit1 = BitAddress(addr1, 2)
-        bit2 = BitAddress(addr1, 4)
-        bit3 = BitAddress(addr2, 3)
-
-        d.setRegisterDefinitions({
-            'test_reg1': RegisterAddress(0x201),
-            'test_reg2': RegisterAddress(0x202)
-        })
-        d.setBitDefinitions({
-            'test_bit1': BitAddress(addr1, 2),
-            'test_bit2': BitAddress(addr1, 4),
-            'test_bit3': BitAddress(addr2, 3)
-        })
-
-        res = d.getBitDefinitions()
-        assert(len(res) == 3)
-        assert(res['test_bit1'] == bit1)
-        assert(res['test_bit2'] == bit2)
-        assert(res['test_bit3'] == bit3)
-        assert(res['test_bit2'].address() == addr1)
-        assert(res['test_bit2'].bitPosition() == 4) 
-
-        d.clearRegisterDefinitions()
-        d.clearBitDefinitions()
-        
-        d.setRegisterDefinitions(prev_reg_defs)
-        d.setBitDefinitions(prev_bit_defs)  
-    else:
-        with pytest.raises(Exception) as exc_info:
-            d.define_bit(name="test_bit", addr=0x300, bit_position=1)
-        assert "Bit Definitions only for CTB" in str(exc_info.value)
-
-    Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed")

python/tests/test_utils.py

@@ -8,7 +8,7 @@ Testing functions from utils.py
 
 import pytest
 from slsdet.utils import *
-from slsdet import IpAddr, MacAddr, DurationWrapper, RegisterAddress, RegisterValue, BitAddress
+from slsdet import IpAddr, MacAddr, DurationWrapper
 import datetime as dt
 import pathlib
 from pathlib import Path
@@ -199,7 +199,6 @@ def test_make_mac_from_tuple():
                              MacAddr("84:a9:3e:24:32:aa"))
 
 
-
 def test_make_path_from_str():
     assert make_path("/") == Path("/")
     assert make_path("/home") == Path("/home")

sample/CMakeLists.txt

@@ -4,20 +4,12 @@ add_executable(using_logger using_logger.cpp)
 target_link_libraries(using_logger 
     slsSupportShared
 )  
+
 set_target_properties(using_logger PROPERTIES
     RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
 )
 
 
-add_executable(using_registers using_registers.cpp)
-target_link_libraries(using_registers 
-    slsDetectorShared
-)  
-set_target_properties(using_registers PROPERTIES
-    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
-)
-
-
 # add_executable(result useResult.cpp)
 # target_link_libraries(result 
 #     slsDetectorShared

sample/using_logger.cpp

@@ -3,22 +3,14 @@
 #include "sls/logger.h"
 #include <iostream>
 #include <chrono>
-
-using sls::logINFO;
-using sls::logINFORED;
-using sls::logINFOBLUE;
-using sls::logINFOGREEN;
-using sls::logERROR;
-using sls::logWARNING;
-
-
 int main() {
 
     //compare old and new
     std::cout << "Compare output between old and new:\n";
     LOG(logINFO) << "Some info message";
     LOG(logERROR) << "This is an error";
-    LOG(logWARNING) << "While this is only a warning";
+    LOG(logWARNING) << "While this is only a warning";    prefix="/afs/psi.ch/project/sls_det_software/dhanya_softwareDevelopment/mySoft/slsDetectorPackage/"
+    p=${file#"$prefix"}
 
     //Logging level can be configure at runtime
     std::cout << "\n\n";

sample/using_registers.cpp

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-other
-// Copyright (C) 2021 Contributors to the SLS Detector Package
-
-/* This example assumes that you have a ctb configured or using the virtual ctb detector server*/
-
-#include "sls/Detector.h"
-#include "sls/bit_utils.h"
-#include <iostream>
-
-
-void somefunc(uint32_t addr){
-    std::cout << "somefunc called with: " << addr << std::endl;
-}
-
-int main(){
-
-    // Config file has the following defines
-    // define addr somereg 0x5
-    // define bit mybit somereg 7
-    
-    sls::Detector d;
-    auto somereg = d.getRegisterDefinition("somereg");
-    d.writeRegister(somereg, sls::RegisterValue(0));
-    auto val = d.readRegister(somereg);
-
-    std::cout << "somereg has the address: " << somereg <<  " and value " << val.squash() << std::endl;
-
-
-    auto mybit = d.getBitDefinition("mybit");
-    std::cout << "mybit refers to register: " << mybit.address() << " bit nr: " << mybit.bitPosition() << std::endl;
-    d.setBit(mybit);
-    val = d.readRegister(somereg);
-    std::cout << "somereg has the address: " << somereg <<  " and value " << val.squash() << std::endl;
-    std::cout << "mybit: " << d.getBit(mybit) << std::endl;
-
-
-    //Let's define a bit 
-    sls::BitAddress newbit(sls::RegisterAddress(0x6), 4);
-    d.setBitDefinition("newbit", newbit);
-    //This can now be usef from command line "g getbit newbit"
-
-
-
-
-    uint32_t addr = somereg; //I'm not sure this should compile
-    somefunc(somereg); //This should also not compile 
-
-    
-}

slsDetectorServers/slsDetectorServer/include/XILINX_FMC.h

@@ -1,5 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-other
-// Copyright (C) 2021 Contributors to the SLS Detector Package
-
-int XILINX_FMC_enable_all(char *error_message, int message_size);
-int XILINX_FMC_disable_all(char *error_message, int message_size);

slsDetectorServers/slsDetectorServer/src/XILINX_FMC.c

@@ -1,83 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-other
-// Copyright (C) 2021 Contributors to the SLS Detector Package
-#include "XILINX_FMC.h"
-#include "arm64.h"
-#include "clogger.h"
-#include <math.h>
-#include <stdbool.h>
-#include <unistd.h>
-
-// clang-format off
-#define FMC_BASE_PATH "/root/fmc/"
-#define FMC_VADJ_EN "FMC_VADJ_EN"
-#define FMCP_VADJ_EN "FMCP_VADJ_EN"
-#define FMCP_3V3_EN "FMCP_3V3_EN"
-#define FMC_3V3_EN "FMC_3V3_EN"
-#define FMC_12V_EN "FMC_12V_EN"
-#define FMCP_12V_EN "FMCP_12V_EN"
-
-static const char *fmc_files[] = {
-    FMC_VADJ_EN,
-    FMCP_VADJ_EN,
-    FMCP_3V3_EN,
-    FMC_3V3_EN,
-    FMC_12V_EN,
-    FMCP_12V_EN
-};
-#define FMC_NUM_FILES (sizeof(fmc_files) / sizeof(fmc_files[0]))
-// clang-format on
-
-int XILINX_FMC_enable_all(char *error_message, int message_size) {
-    LOG(logINFOBLUE, ("enable FMC power\n"));
-#ifdef VIRTUAL
-    return;
-#endif
-    char full_path[64];
-    for (size_t i = 0; i < FMC_NUM_FILES; ++i) {
-        const char *file = fmc_files[i];
-        snprintf(full_path, sizeof(full_path), "%s%s", FMC_BASE_PATH, file);
-        FILE *fp = fopen(full_path, "w");
-        if (fp == NULL) {
-            snprintf(error_message, message_size,
-                     "XILINX_FMC: Couuld not enable.\n");
-            LOG(logERROR, (error_message));
-            return 1;
-        }
-
-        if (fprintf(fp, "1\n") != 2) {
-            snprintf(error_message, message_size,
-                     "XILINX_FMC: Could not write enable.\n");
-            LOG(logERROR, (error_message));
-            return 1;
-        }
-        fclose(fp);
-    }
-    return 0;
-}
-
-int XILINX_FMC_disable_all(char *error_message, int message_size) {
-    LOG(logINFOBLUE, ("disable FMC power\n"));
-#ifdef VIRTUAL
-    return;
-#endif
-    char full_path[64];
-    for (size_t i = 0; i < FMC_NUM_FILES; ++i) {
-        const char *file = fmc_files[i];
-        snprintf(full_path, sizeof(full_path), "%s%s", FMC_BASE_PATH, file);
-        FILE *fp = fopen(full_path, "w");
-        if (fp == NULL) {
-            snprintf(error_message, message_size,
-                     "XILINX_FMC: Could not disable\n");
-            LOG(logERROR, (error_message));
-            return 1;
-        }
-        if (fprintf(fp, "0\n") != 2) {
-            snprintf(error_message, message_size,
-                     "XILINX_FMC: Could not write disable.\n");
-            LOG(logERROR, (error_message));
-            return 1;
-        }
-        fclose(fp);
-    }
-    return 0;
-}

slsDetectorServers/xilinx_ctbDetectorServer/CMakeLists.txt

@@ -7,7 +7,6 @@ add_executable(xilinx_ctbDetectorServer_virtual
     ../slsDetectorServer/src/communication_funcs.c
     ../slsDetectorServer/src/arm64.c
     ../slsDetectorServer/src/XILINX_PLL.c
-    ../slsDetectorServer/src/XILINX_FMC.c
     ../slsDetectorServer/src/common.c
     ../slsDetectorServer/src/sharedMemory.c
     ../slsDetectorServer/src/loadPattern.c

slsDetectorServers/xilinx_ctbDetectorServer/Makefile

@@ -23,7 +23,7 @@ DESTDIR		?= 	bin
 INSTMODE	= 	0777
 
 SRCS 		= 	slsDetectorFunctionList.c  
-SRCS		+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)arm64.c $(main_src)XILINX_PLL.c $(main_src)XILINX_FMC.c $(main_src)common.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c $(md5_dir)md5.c $(main_src)programViaArm.c $(main_src)LTC2620_Driver.c 
+SRCS		+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)arm64.c $(main_src)XILINX_PLL.c $(main_src)common.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c $(md5_dir)md5.c $(main_src)programViaArm.c $(main_src)LTC2620_Driver.c 
 
 OBJS 		= 	$(SRCS:.c=.o) 
  

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c

@@ -9,8 +9,8 @@
 #include "sls/versionAPI.h"
 
 #include "LTC2620_Driver.h"
-#include "XILINX_FMC.h"
 #include "XILINX_PLL.h"
+
 #include "loadPattern.h"
 #ifdef VIRTUAL
 #include "communication_funcs_UDP.h"
@@ -257,17 +257,17 @@ int testFixedFPGAPattern() {
     LOG(logINFO, ("Testing FPGA Fixed Pattern:\n"));
 #ifndef VIRTUAL
     uint32_t val = bus_r(FIXEDPATTERNREG);
-    if (val == FIXEDPATTERNREG_PRESET) {
+    if (val == FIXEDPATTERNVAL) {
         LOG(logINFO, ("\tFixed pattern: successful match (0x%08x)\n", val));
     } else {
         LOG(logERROR,
             ("Fixed pattern does not match! Read 0x%08x, expected 0x%08x\n",
-             val, FIXEDPATTERNREG_PRESET));
+             val, FIXEDPATTERNVAL));
         return FAIL;
     }
 #endif
-    LOG(logINFO, ("\tSuccessfully read FPGA Fixed Pattern (0x%x)\n",
-                  FIXEDPATTERNREG_PRESET));
+    LOG(logINFO,
+        ("\tSuccessfully read FPGA Fixed Pattern (0x%x)\n", FIXEDPATTERNVAL));
     return OK;
 }
 
@@ -405,13 +405,6 @@ void setupDetector() {
 
     LTC2620_D_SetDefines(DAC_MIN_MV, DAC_MAX_MV, DAC_DRIVER_FILE_NAME, NDAC,
                          NPWR, DAC_POWERDOWN_DRIVER_FILE_NAME);
-
-    // power LTC2620 before talking to it:
-    initError = XILINX_FMC_enable_all(initErrorMessage, MAX_STR_LENGTH);
-    if (initError == FAIL) {
-        return;
-    }
-
     LOG(logINFOBLUE, ("Powering down all dacs\n"));
     for (int idac = 0; idac < NDAC; ++idac) {
         setDAC(idac, LTC2620_D_GetPowerDownValue(), 0);
@@ -586,10 +579,9 @@ int powerChip(int on, char *mess) {
     } else {
         LOG(logINFOBLUE, ("Powering chip: off\n"));
         bus_w(addr, bus_r(addr) & ~mask);
+
         chipConfigured = 0;
-        if (FAIL == XILINX_FMC_disable_all(mess, MAX_STR_LENGTH)) {
-            return FAIL;
-        }
+
 #ifdef VIRTUAL
         setTransceiverAlignment(0);
 #endif

slsDetectorSoftware/generator/Caller.in.h

@@ -74,24 +74,6 @@ class Caller {
     static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
                                   uint32_t subFrameIndex, void *this_pointer);
 
-    std::string bitoperations(int action);
-
-    // parsing from args
-    // parse from string to RegisterAddress
-    RegisterAddress parseRegisterAddress(const std::string &addr) const;
-    // parse from 2 strings to BitAddress
-    BitAddress parseBitAddress(const std::string &addr,
-                               const std::string &bitPos) const;
-    // parse from string to RegisterValue
-    RegisterValue parseRegisterValue(const std::string &addr) const;
-    // parse validate flag from args and remove it from args
-    bool parseValidate();
-
-    // parses from args, but also gets addresses from shared memory if
-    // applicable
-    RegisterAddress getRegisterAddress(const std::string &saddr) const;
-    BitAddress getBitAddress() const;
-
     FunctionMap functions{
         {"list", &Caller::list},
 

slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh

@@ -80,7 +80,7 @@ _sd() {
   local IS_PATH=0
 
 
-local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
+local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
 __acquire() {
 FCN_RETURN=""
 return 0
@@ -682,54 +682,6 @@ fi
 fi
 return 0
 }
-__define_bit() {
-FCN_RETURN=""
-if [[ ${IS_GET} -eq 1 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-fi
-if [[ ${IS_GET} -eq 0 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "4" ]]; then
-FCN_RETURN=""
-fi
-fi
-return 0
-}
-__define_reg() {
-FCN_RETURN=""
-if [[ ${IS_GET} -eq 1 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-fi
-if [[ ${IS_GET} -eq 0 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-fi
-return 0
-}
-__definelist_bit() {
-FCN_RETURN=""
-return 0
-}
-__definelist_reg() {
-FCN_RETURN=""
-return 0
-}
 __delay() {
 FCN_RETURN=""
 if [[ ${IS_GET} -eq 1 ]]; then

slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh

@@ -4,7 +4,7 @@
 _sd() {
 
 
-local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
+local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port powerchip powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_a v_b v_c v_chip v_d v_io v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport "
 __acquire() {
 FCN_RETURN=""
 return 0
@@ -606,54 +606,6 @@ fi
 fi
 return 0
 }
-__define_bit() {
-FCN_RETURN=""
-if [[ ${IS_GET} -eq 1 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-fi
-if [[ ${IS_GET} -eq 0 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "4" ]]; then
-FCN_RETURN=""
-fi
-fi
-return 0
-}
-__define_reg() {
-FCN_RETURN=""
-if [[ ${IS_GET} -eq 1 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-fi
-if [[ ${IS_GET} -eq 0 ]]; then
-if [[ "${cword}" == "2" ]]; then
-FCN_RETURN=""
-fi
-if [[ "${cword}" == "3" ]]; then
-FCN_RETURN=""
-fi
-fi
-return 0
-}
-__definelist_bit() {
-FCN_RETURN=""
-return 0
-}
-__definelist_reg() {
-FCN_RETURN=""
-return 0
-}
 __delay() {
 FCN_RETURN=""
 if [[ ${IS_GET} -eq 1 ]]; then

slsDetectorSoftware/generator/commands.yaml

@@ -2761,90 +2761,6 @@ sleep:
             - argc: 2
               arg_types: [ int, special::time_unit ]
 
-define_reg:
-    is_description: true
-    actions:
-        GET:
-          argc: 1
-          arg_types: [ std::string ]
-        PUT:
-          argc: 2
-          arg_types: [ std::string, int ]
-
-define_bit:
-    is_description: true
-    actions:
-        GET:
-          args:
-            - argc: 1
-              arg_types: [ std::string ]
-            - argc: 2
-              arg_types: [ std::string, int ]
-        PUT:
-          argc: 3
-          arg_types: [ std::string, std::string, int ]
-
-definelist_reg:
-    is_description: true
-    actions:
-        GET:
-          argc: 0
-
-definelist_bit:
-    is_description: true
-    actions:
-        GET:
-          argc: 0
-
-reg:
-    is_description: true
-    actions:
-        GET:
-          argc: 1
-          arg_types: [ std::string]
-        PUT:
-          args:
-            - argc: 2
-              arg_types: [ uint32_t, uint32_t ]
-            - argc: 3
-              arg_types: [ uint32_t, uint32_t, special::validate ]
-
-
-getbit:
-    is_description: true
-    actions:
-        GET:
-          args:
-            - argc: 1
-              arg_types: [ std::string ]
-            - argc: 2
-              arg_types: [ std::string, std::string ]
-
-
-setbit:
-    is_description: true
-    actions:
-        PUT:
-          args:
-            - argc: 1
-              arg_types: [ std::string ]
-            - argc: 2
-              arg_types: [ std::string, std::string ]
-            - argc: 3
-              arg_types: [ std::string, std::string, special::validate ]
-
-clearbit:
-    is_description: true
-    actions:
-        PUT:
-          args:
-            - argc: 1
-              arg_types: [ std::string ]
-            - argc: 2
-              arg_types: [ std::string, std::string ]
-            - argc: 3
-              arg_types: [ std::string, std::string, special::validate ]
-
 
 ################# special commands ##########################
 
@@ -4256,6 +4172,36 @@ update:
       input_types: [ std::string, std::string ]
       output: [ '"successful"' ]
 
+reg:
+  help: "[address] [32 bit value][(optional)--validate]\n\t[Mythen3][Gotthard2] Reads/writes to a 32 bit register in hex. Advanced Function!\n\tGoes to stop server. Hence, can be called while calling blocking acquire().\n\t\t Use --validate to force validation when writing to it.\n\t[Eiger] +0x100 for only left, +0x200 for only right."
+  actions:
+    GET:
+      argc: 1
+      require_det_id: true
+      function: readRegister
+      input: [ 'args[0]' ]
+      input_types: [ uint32_t ]
+      cast_input: [ true ]
+      output: [ OutStringHex(t) ]
+    PUT:
+      require_det_id: true
+      function: writeRegister
+      output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]
+      args:
+        - argc: 2
+          input: [ 'args[0]', 'args[1]', '"0"' ]
+          input_types: [ uint32_t, uint32_t, bool ]
+          arg_types: [ uint32_t, uint32_t ]
+          cast_input: [ true, true, true ]
+        - argc: 3
+          arg_types: [ uint32_t, uint32_t, special::validate ]
+          exceptions:
+            - condition: 'args[2] != "--validate"'
+              message: '"Could not scan third argument. Did you mean --validate?"'
+          input: [ 'args[0]', 'args[1]', '"1"' ]
+          input_types: [ uint32_t, uint32_t, bool ]
+          cast_input: [ true, true, true ]
+
 adcreg:
   help: "[address] [value]\n\t[Jungfrau][Moench][Ctb] Writes to an adc register in hex. Advanced user Function!"
   actions:
@@ -4268,7 +4214,62 @@ adcreg:
       cast_input: [ true, true ]
       output: [ ToString(args) ]
 
+getbit:
+  help: "[reg address in hex] [bit index]\n\tGets bit in address."
+  actions:
+    GET:
+      argc: 2
+      exceptions:
+        - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
+          message: '"Bit number out of range: " + args[1]'
+      require_det_id: true
+      function: getBit
+      input: [ 'args[0]', 'args[1]' ]
+      input_types: [ uint32_t, int ]
+      cast_input: [ true, true ]
+      output: [ OutString(t) ]
 
+Setbit:
+  template: true
+  actions:
+    PUT:
+      require_det_id: true
+      function: setBit
+      output: [ '"["', 'args[0]', '", "', 'args[1]', '"]"' ]    
+      args:
+        - argc: 2
+          exceptions:
+            - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
+              message: '"Bit number out of range: " + args[1]'
+          input: [ 'args[0]', 'args[1]', '"0"' ]  
+          input_types: [ uint32_t, int, bool ]
+          arg_types: [ uint32_t, int ]
+          cast_input: [ true, true, true ]
+        - argc: 3
+          arg_types: [ uint32_t, int, special::validate ]
+          exceptions:
+            - condition: 'StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31'
+              message: '"Bit number out of range: " + args[1]'
+            - condition: 'args[2] != "--validate"'
+              message: '"Could not scan third argument. Did you mean --validate?"'
+          input: [ 'args[0]', 'args[1]', '"1"' ]
+          input_types: [ uint32_t, int, bool ]
+          cast_input: [ true, true, true ]
+
+
+setbit:
+  inherit_actions: Setbit
+  help: "[reg address in hex] [bit index]\n\tSets bit in address.\n\tUse --validate to force validation."
+  actions:
+    PUT:
+      function: setBit
+
+clearbit:
+  inherit_actions: Setbit
+  help: "[reg address in hex] [bit index]\n\tClears bit in address.\n\tUse --validate to force validation."
+  actions:
+    PUT:
+      function: clearBit
 
 initialchecks:
   help: "[0, 1]\n\t[Mythen3][Gotthard2] Enable or disable intial compatibility and other checks at detector start up. It is enabled by default. Must come before 'hostname' command to take effect. Can be used to reprogram fpga when current firmware is incompatible.\n\tAdvanced User function!"

slsDetectorSoftware/generator/extended_commands.yaml

@@ -1096,49 +1096,74 @@ clearbit:
     PUT:
       args:
       - arg_types:
-        - std::string
-        argc: 1
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: false
-      - arg_types:
-        - std::string
-        - std::string
+        - uint32_t
+        - int
         argc: 2
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
+          message: '"Bit number out of range: " + args[1]'
+        function: clearBit
+        input:
+        - args[0]
+        - args[1]
+        - '"0"'
+        input_types:
+        - uint32_t
+        - int
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
       - arg_types:
-        - std::string
-        - std::string
+        - uint32_t
+        - int
         - special::validate
         argc: 3
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
+          message: '"Bit number out of range: " + args[1]'
+        - condition: args[2] != "--validate"
+          message: '"Could not scan third argument. Did you mean --validate?"'
+        function: clearBit
+        input:
+        - args[0]
+        - args[1]
+        - '"1"'
+        input_types:
+        - uint32_t
+        - int
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
   command_name: clearbit
   function_alias: clearbit
-  help: ''
+  help: "[reg address in hex] [bit index]\n\tClears bit in address.\n\tUse --validate\
+    \ to force validation."
   infer_action: true
-  is_description: true
+  template: true
 clearbusy:
   actions:
     PUT:
@@ -2475,132 +2500,6 @@ defaultpattern:
     \ to go back to initial settings."
   infer_action: true
   template: true
-define_bit:
-  actions:
-    GET:
-      args:
-      - arg_types:
-        - std::string
-        argc: 1
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-      - arg_types:
-        - std::string
-        - int
-        argc: 2
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-    PUT:
-      args:
-      - arg_types:
-        - std::string
-        - std::string
-        - int
-        argc: 3
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: false
-  command_name: define_bit
-  function_alias: define_bit
-  help: ''
-  infer_action: true
-  is_description: true
-define_reg:
-  actions:
-    GET:
-      args:
-      - arg_types:
-        - std::string
-        argc: 1
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-    PUT:
-      args:
-      - arg_types:
-        - std::string
-        - int
-        argc: 2
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: false
-  command_name: define_reg
-  function_alias: define_reg
-  help: ''
-  infer_action: true
-  is_description: true
-definelist_bit:
-  actions:
-    GET:
-      args:
-      - arg_types: []
-        argc: 0
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-  command_name: definelist_bit
-  function_alias: definelist_bit
-  help: ''
-  infer_action: true
-  is_description: true
-definelist_reg:
-  actions:
-    GET:
-      args:
-      - arg_types: []
-        argc: 0
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-  command_name: definelist_reg
-  function_alias: definelist_reg
-  help: ''
-  infer_action: true
-  is_description: true
 delay:
   actions:
     GET:
@@ -4807,35 +4706,32 @@ getbit:
     GET:
       args:
       - arg_types:
-        - std::string
-        argc: 1
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: true
-      - arg_types:
-        - std::string
-        - std::string
+        - uint32_t
+        - int
         argc: 2
-        cast_input: []
+        cast_input:
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
+          message: '"Bit number out of range: " + args[1]'
+        function: getBit
+        input:
+        - args[0]
+        - args[1]
+        input_types:
+        - uint32_t
+        - int
+        output:
+        - OutString(t)
+        require_det_id: true
         store_result_in_t: true
   command_name: getbit
   function_alias: getbit
-  help: ''
+  help: "[reg address in hex] [bit index]\n\tGets bit in address."
   infer_action: true
-  is_description: true
 hardwareversion:
   actions:
     GET:
@@ -7974,16 +7870,20 @@ reg:
     GET:
       args:
       - arg_types:
-        - std::string
+        - uint32_t
         argc: 1
-        cast_input: []
+        cast_input:
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        function: readRegister
+        input:
+        - args[0]
+        input_types:
+        - uint32_t
+        output:
+        - OutStringHex(t)
+        require_det_id: true
         store_result_in_t: true
     PUT:
       args:
@@ -7991,34 +7891,68 @@ reg:
         - uint32_t
         - uint32_t
         argc: 2
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        function: writeRegister
+        input:
+        - args[0]
+        - args[1]
+        - '"0"'
+        input_types:
+        - uint32_t
+        - uint32_t
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
       - arg_types:
         - uint32_t
         - uint32_t
         - special::validate
         argc: 3
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: args[2] != "--validate"
+          message: '"Could not scan third argument. Did you mean --validate?"'
+        function: writeRegister
+        input:
+        - args[0]
+        - args[1]
+        - '"1"'
+        input_types:
+        - uint32_t
+        - uint32_t
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
   command_name: reg
   function_alias: reg
-  help: ''
+  help: "[address] [32 bit value][(optional)--validate]\n\t[Mythen3][Gotthard2] Reads/writes\
+    \ to a 32 bit register in hex. Advanced Function!\n\tGoes to stop server. Hence,\
+    \ can be called while calling blocking acquire().\n\t\t Use --validate to force\
+    \ validation when writing to it.\n\t[Eiger] +0x100 for only left, +0x200 for only\
+    \ right."
   infer_action: true
-  is_description: true
 resetdacs:
   actions:
     PUT:
@@ -9643,49 +9577,74 @@ setbit:
     PUT:
       args:
       - arg_types:
-        - std::string
-        argc: 1
-        cast_input: []
-        check_det_id: false
-        convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
-        store_result_in_t: false
-      - arg_types:
-        - std::string
-        - std::string
+        - uint32_t
+        - int
         argc: 2
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
+          message: '"Bit number out of range: " + args[1]'
+        function: setBit
+        input:
+        - args[0]
+        - args[1]
+        - '"0"'
+        input_types:
+        - uint32_t
+        - int
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
       - arg_types:
-        - std::string
-        - std::string
+        - uint32_t
+        - int
         - special::validate
         argc: 3
-        cast_input: []
+        cast_input:
+        - true
+        - true
+        - true
         check_det_id: false
         convert_det_id: true
-        function: ''
-        input: []
-        input_types: []
-        output: []
-        require_det_id: false
+        exceptions:
+        - condition: StringTo<int>(args[1]) < 0 || StringTo<int>(args[1]) > 31
+          message: '"Bit number out of range: " + args[1]'
+        - condition: args[2] != "--validate"
+          message: '"Could not scan third argument. Did you mean --validate?"'
+        function: setBit
+        input:
+        - args[0]
+        - args[1]
+        - '"1"'
+        input_types:
+        - uint32_t
+        - int
+        - bool
+        output:
+        - '"["'
+        - args[0]
+        - '", "'
+        - args[1]
+        - '"]"'
+        require_det_id: true
         store_result_in_t: false
   command_name: setbit
   function_alias: setbit
-  help: ''
+  help: "[reg address in hex] [bit index]\n\tSets bit in address.\n\tUse --validate\
+    \ to force validation."
   infer_action: true
-  is_description: true
+  template: true
 settings:
   actions:
     GET:

slsDetectorSoftware/include/sls/Detector.h

@@ -3,7 +3,6 @@
 #pragma once
 #include "sls/Pattern.h"
 #include "sls/Result.h"
-#include "sls/bit_utils.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
 #include <chrono>
@@ -1838,64 +1837,6 @@ class Detector {
     /** [CTB][Xilinx CTB] */
     std::string getSlowADCName(const defs::dacIndex i) const;
 
-    /** [CTB][Xilinx CTB] */
-    int getRegisterDefinitionsCount() const;
-
-    /** [CTB][Xilinx CTB] */
-    void setRegisterDefinition(const std::string &name, RegisterAddress addr);
-
-    /** [CTB][Xilinx CTB] */
-    bool hasRegisterDefinition(const std::string &name) const;
-
-    /** [CTB][Xilinx CTB] */
-    bool hasRegisterDefinition(RegisterAddress addr) const;
-
-    /** [CTB][Xilinx CTB] */
-    RegisterAddress getRegisterAddress(const std::string &name) const;
-
-    /** [CTB][Xilinx CTB] */
-    std::string getRegisterName(RegisterAddress addr) const;
-
-    /** [CTB][Xilinx CTB] */
-    void clearRegisterDefinitions();
-
-    /** [CTB][Xilinx CTB] */
-    void
-    setRegisterDefinitions(const std::map<std::string, RegisterAddress> &list);
-
-    /** [CTB][Xilinx CTB] */
-    std::map<std::string, RegisterAddress> getRegisterDefinitions() const;
-
-    /** [CTB][Xilinx CTB] */
-    int getBitDefinitionsCount() const;
-
-    /** [CTB][Xilinx CTB] */
-    void setBitDefinition(const std::string &name, BitAddress addr);
-
-    /** [CTB][Xilinx CTB] */
-    bool hasBitDefinition(const std::string &name) const;
-
-    /** [CTB][Xilinx CTB] */
-    bool hasBitDefinition(BitAddress addr) const;
-
-    /** [CTB][Xilinx CTB] */
-    std::string toRegisterNameBitString(BitAddress addr) const;
-
-    /** [CTB][Xilinx CTB] returns bit position and address */
-    BitAddress getBitAddress(const std::string &name) const;
-
-    /** [CTB][Xilinx CTB] */
-    std::string getBitName(BitAddress addr) const;
-
-    /** [CTB][Xilinx CTB] */
-    void clearBitDefinitions();
-
-    /** [CTB][Xilinx CTB] */
-    void setBitDefinitions(const std::map<std::string, BitAddress> &list);
-
-    /** [CTB][Xilinx CTB] */
-    std::map<std::string, BitAddress> getBitDefinitions() const;
-
     ///@}
 
     /** @name Xilinx CTB Specific */
@@ -2104,71 +2045,26 @@ class Detector {
     /** Advanced user Function! \n
      * Goes to stop server. Hence, can be called while calling blocking
      * acquire(). \n [Eiger] Address is +0x100 for only left, +0x200 for only
-     * right.*/
-    Result<RegisterValue> readRegister(RegisterAddress addr,
-                                       Positions pos = {}) const;
+     * right. */
+    Result<uint32_t> readRegister(uint32_t addr, Positions pos = {}) const;
 
     /** Advanced user Function! \n
      * Goes to stop server. Hence, can be called while calling blocking
      * acquire(). \n [Eiger] Address is +0x100 for only left, +0x200 for only
-     * right.*/
-    void writeRegister(RegisterAddress addr, RegisterValue val,
-                       bool validate = false, Positions pos = {});
+     * right. */
+    void writeRegister(uint32_t addr, uint32_t val, bool validate = false,
+                       Positions pos = {});
 
-    /** Advanced user Function! */
-    void setBit(BitAddress addr, bool validate = false, Positions pos = {});
-
-    /** Advanced user Function!*/
-    void clearBit(BitAddress addr, bool validate = false, Positions pos = {});
-
-    /** Advanced user Function! */
-    Result<int> getBit(BitAddress addr, Positions pos = {}) const;
-
-    /** [CTB][Xilinx CTB] Advanced user Function! */
-    Result<RegisterValue> readRegister(const std::string &reg_name,
-                                       Positions pos = {}) const;
-
-    /** [CTB][Xilinx CTB] Advanced user Function! */
-    void writeRegister(const std::string &reg_name, RegisterValue val,
-                       bool validate = false, Positions pos = {});
-
-    /** [CTB][Xilinx CTB] Advanced user Function! */
-    void setBit(const std::string &bit_name, bool validate = false,
+    /** Advanced user Function!  */
+    void setBit(uint32_t addr, int bitnr, bool validate = false,
                 Positions pos = {});
 
-    /** [CTB][Xilinx CTB] Advanced user Function! */
-    void clearBit(const std::string &bit_name, bool validate = false,
+    /** Advanced user Function!  */
+    void clearBit(uint32_t addr, int bitnr, bool validate = false,
                   Positions pos = {});
 
-    /** [CTB][Xilinx CTB] Advanced user Function! */
-    Result<int> getBit(const std::string &bit_name, Positions pos = {}) const;
-
-    /** Deprecated Advanced user Function! */
-    [[deprecated("Use the overload taking RegisterAddress instead of "
-                 "uint32_t")]] Result<uint32_t>
-    readRegister(uint32_t addr, Positions pos = {}) const;
-
-    /** Deprecated Advanced user Function! */
-    [[deprecated("Use the overload taking RegisterAddress and RegisterValue "
-                 "instead of uint32_t")]] void
-    writeRegister(uint32_t addr, uint32_t val, bool validate = false,
-                  Positions pos = {});
-
-    /** Deprecated Advanced user Function! */
-    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
-                 "int")]] void
-    setBit(uint32_t addr, int bitnr, bool validate = false, Positions pos = {});
-
-    /** Deprecated Advanced user Function! */
-    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
-                 "int")]] void
-    clearBit(uint32_t addr, int bitnr, bool validate = false,
-             Positions pos = {});
-
-    /** Deprecated Advanced user Function! */
-    [[deprecated("Use the overload taking BitAddress instead of uint32_t and "
-                 "int")]] Result<int>
-    getBit(uint32_t addr, int bitnr, Positions pos = {}) const;
+    /** Advanced user Function!  */
+    Result<int> getBit(uint32_t addr, int bitnr, Positions pos = {});
 
     /** [Jungfrau][Moench][Mythen3][Gotthard2][CTB] Advanced user
      * Function! */

slsDetectorSoftware/include/sls/detectorData.h

@@ -25,21 +25,21 @@ class detectorData {
     ~detectorData(){};
 
     int64_t getChannel(int i) {
-        int off = dynamicRange / 8;
+        const int off = dynamicRange / 8;
         if (off == 1) {
-            char val = *(data + i);
+            const char val = *(data + i);
             return val;
         }
         if (off == 2) {
-            int16_t val = *((int16_t *)(data + i * off));
+            const int16_t val = *((int16_t *)(data + i * off));
             return val;
         }
         if (off == 4) {
-            int32_t val = *((int32_t *)(data + i * off));
+            const int32_t val = *((int32_t *)(data + i * off));
             return val;
         }
         if (off == 8) {
-            int64_t val = *((int64_t *)(data + i * off));
+            const int64_t val = *((int64_t *)(data + i * off));
             return val;
         }
         return -1;

slsDetectorSoftware/src/Caller.h

@@ -107,10 +107,6 @@ class Caller {
     std::string dbitpipeline(int action);
     std::string defaultdac(int action);
     std::string defaultpattern(int action);
-    std::string define_bit(int action);
-    std::string define_reg(int action);
-    std::string definelist_bit(int action);
-    std::string definelist_reg(int action);
     std::string delay(int action);
     std::string delayl(int action);
     std::string detectorserverversion(int action);
@@ -402,24 +398,6 @@ class Caller {
     static void EmptyDataCallBack(detectorData *data, uint64_t frameIndex,
                                   uint32_t subFrameIndex, void *this_pointer);
 
-    std::string bitoperations(int action);
-
-    // parsing from args
-    // parse from string to RegisterAddress
-    RegisterAddress parseRegisterAddress(const std::string &addr) const;
-    // parse from 2 strings to BitAddress
-    BitAddress parseBitAddress(const std::string &addr,
-                               const std::string &bitPos) const;
-    // parse from string to RegisterValue
-    RegisterValue parseRegisterValue(const std::string &addr) const;
-    // parse validate flag from args and remove it from args
-    bool parseValidate();
-
-    // parses from args, but also gets addresses from shared memory if
-    // applicable
-    RegisterAddress getRegisterAddress(const std::string &saddr) const;
-    BitAddress getBitAddress() const;
-
     FunctionMap functions{
         {"list", &Caller::list},
 
@@ -473,10 +451,6 @@ class Caller {
         {"dbitpipeline", &Caller::dbitpipeline},
         {"defaultdac", &Caller::defaultdac},
         {"defaultpattern", &Caller::defaultpattern},
-        {"define_bit", &Caller::define_bit},
-        {"define_reg", &Caller::define_reg},
-        {"definelist_bit", &Caller::definelist_bit},
-        {"definelist_reg", &Caller::definelist_reg},
         {"delay", &Caller::delay},
         {"delayl", &Caller::delayl},
         {"detectorserverversion", &Caller::detectorserverversion},

slsDetectorSoftware/src/CallerSpecial.cpp

@@ -102,7 +102,7 @@ std::string Caller::list(int action) {
 /* Network Configuration (Detector<->Receiver) */
 
 IpAddr Caller::getDstIpFromAuto() {
-    std::string rxHostname =
+    std::string const rxHostname =
         det->getRxHostname(std::vector<int>{det_id}).squash("none");
     // Hostname could be ip try to decode otherwise look up the hostname
     auto val = IpAddr{rxHostname};
@@ -113,7 +113,7 @@ IpAddr Caller::getDstIpFromAuto() {
 }
 
 IpAddr Caller::getSrcIpFromAuto() {
-    std::string hostname =
+    std::string const hostname =
         det->getHostname(std::vector<int>{det_id}).squash("none");
     // Hostname could be ip try to decode otherwise look up the hostname
     auto val = IpAddr{hostname};
@@ -128,9 +128,9 @@ UdpDestination Caller::getUdpEntry() {
     udpDestination.entry = rx_id;
 
     for (auto it : args) {
-        size_t pos = it.find('=');
-        std::string key = it.substr(0, pos);
-        std::string value = it.substr(pos + 1);
+        size_t const pos = it.find('=');
+        std::string const key = it.substr(0, pos);
+        std::string const value = it.substr(pos + 1);
         if (key == "ip") {
             if (value == "auto") {
                 auto val = getDstIpFromAuto();
@@ -177,7 +177,7 @@ int Caller::GetLevelAndInsertIntoArgs(std::string levelSeparatedCommand) {
         LOG(logWARNING) << "This command is deprecated and will be removed. "
                            "Please migrate to "
                         << levelSeparatedCommand;
-        int level = cmd[cmd.find_first_of("012")] - '0';
+        int const level = cmd[cmd.find_first_of("012")] - '0';
         args.insert(args.begin(), std::to_string(level));
         return true;
     }
@@ -295,8 +295,8 @@ std::string Caller::versions(int action) {
         bool receiver = false;
         std::string vReceiver = "Unknown";
 
-        std::string vRelease = det->getPackageVersion();
-        std::string vClient = det->getClientVersion();
+        std::string const vRelease = det->getPackageVersion();
+        std::string const vClient = det->getClientVersion();
 
         if (det->size() != 0) {
             // shared memory has detectors
@@ -382,7 +382,7 @@ std::string Caller::threshold(int action) {
         if (!args.empty()) {
             WrongNumberOfParameters(0);
         }
-        defs::detectorType type = det->getDetectorType().squash();
+        defs::detectorType const type = det->getDetectorType().squash();
         if (type == defs::EIGER) {
             auto t = det->getThresholdEnergy(std::vector<int>{det_id});
             os << OutString(t) << '\n';
@@ -393,7 +393,7 @@ std::string Caller::threshold(int action) {
             throw RuntimeError("Not implemented for this detector\n");
         }
     } else if (action == defs::PUT_ACTION) {
-        defs::detectorType type = det->getDetectorType().squash();
+        defs::detectorType const type = det->getDetectorType().squash();
         if (type == defs::EIGER && args.size() != 1 && args.size() != 2) {
             WrongNumberOfParameters(1);
         }
@@ -401,7 +401,7 @@ std::string Caller::threshold(int action) {
             WrongNumberOfParameters(1);
         }
 
-        bool trimbits = (cmd == "thresholdnotb") ? false : true;
+        bool const trimbits = (cmd == "thresholdnotb") ? false : true;
         std::array<int, 3> energy = {StringTo<int>(args[0]), 0, 0};
         energy[1] = energy[0];
         energy[2] = energy[0];
@@ -708,7 +708,7 @@ std::string Caller::rx_hostname(int action) {
     return os.str();
 }
 std::string Caller::rx_zmqip(int action) {
-    std::string helpMessage =
+    std::string const helpMessage =
         "\n\t[deprecated] The receiver zmq socket (publisher) will "
         "listen to all interfaces ('tcp://0.0.0.0:[port]'to all interfaces "
         "(from v9.0.0). This command does nothing and will be removed "
@@ -729,7 +729,7 @@ std::string Caller::rx_zmqip(int action) {
 
 std::string Caller::rx_roi(int action) {
     std::ostringstream os;
-    std::string helpMessage =
+    std::string const helpMessage =
         std::string("[xmin] [xmax] [ymin] [ymax]\n") +
         "\tDefines a single region of interest (ROI) in the receiver.\n"
         "\tFor example, to set a single ROI: 0 100 20 30\n\n"
@@ -771,7 +771,7 @@ std::string Caller::rx_roi(int action) {
         }
         // Support multiple args with bracketed ROIs, or single arg with
         // semicolon-separated vector in quotes
-        bool isVectorInput =
+        bool const isVectorInput =
             std::all_of(args.begin(), args.end(), [](const std::string &a) {
                 return a.find('[') != std::string::npos &&
                        a.find(']') != std::string::npos;
@@ -870,7 +870,7 @@ std::string Caller::ratecorr(int action) {
         if (args.size() != 1) {
             WrongNumberOfParameters(1);
         }
-        int tau = StringTo<int>(args[0]);
+        int const tau = StringTo<int>(args[0]);
         if (tau == -1) {
             det->setDefaultRateCorrection(std::vector<int>{det_id});
             auto t = det->getRateCorrection(std::vector<int>{det_id});
@@ -905,7 +905,7 @@ std::string Caller::burstmode(int action) {
             }
             defs::burstMode t;
             try {
-                int ival = StringTo<int>(args[0]);
+                int const ival = StringTo<int>(args[0]);
                 switch (ival) {
                 case 0:
                     t = defs::BURST_INTERNAL;
@@ -1001,7 +1001,7 @@ std::string Caller::counters(int action) {
         // convert vector to counter enable mask
         uint32_t mask = 0;
         for (size_t i = 0; i < args.size(); ++i) {
-            int val = StringTo<int>(args[i]);
+            int const val = StringTo<int>(args[i]);
             // already enabled earlier
             if (mask & (1 << val)) {
                 std::ostringstream oss;
@@ -1036,9 +1036,9 @@ std::string Caller::samples(int action) {
             auto d = det->getNumberOfDigitalSamples(std::vector<int>{det_id});
             auto t =
                 det->getNumberOfTransceiverSamples(std::vector<int>{det_id});
-            int as = a.squash(-1);
-            int ds = d.squash(-1);
-            int ts = t.squash(-1);
+            int const as = a.squash(-1);
+            int const ds = d.squash(-1);
+            int const ts = t.squash(-1);
             if (as == -1 || ds == -1 || ts == -1 || as != ds ||
                 as != ts) { // check if a == d?
                 throw RuntimeError(
@@ -1077,7 +1077,7 @@ std::string Caller::slowadc(int action) {
         if (args.size() != 1) {
             WrongNumberOfParameters(0);
         }
-        int nchan = StringTo<int>(args[0]);
+        int const nchan = StringTo<int>(args[0]);
         if (nchan < 0 || nchan > 7) {
             throw RuntimeError("Unknown adc argument " + args[0]);
         }
@@ -1109,7 +1109,7 @@ std::string Caller::patwaittime(int action) {
     }
 
     // parse level
-    bool deprecated_cmd = GetLevelAndInsertIntoArgs("patwaittime");
+    bool const deprecated_cmd = GetLevelAndInsertIntoArgs("patwaittime");
     int level = 0;
     try {
         if (args.size() > 0)
@@ -1141,7 +1141,7 @@ std::string Caller::patwaittime(int action) {
         // clocks (all digits)
         if (args.size() == 2 &&
             std::all_of(args[1].begin(), args[1].end(), ::isdigit)) {
-            uint64_t waittime = StringTo<uint64_t>(args[1]);
+            uint64_t const waittime = StringTo<uint64_t>(args[1]);
             det->setPatternWaitClocks(level, waittime,
                                       std::vector<int>{det_id});
             os << waittime << '\n';
@@ -1152,7 +1152,7 @@ std::string Caller::patwaittime(int action) {
             try {
                 if (args.size() == 2) {
                     std::string tmp_time(args[1]);
-                    std::string unit = RemoveUnit(tmp_time);
+                    std::string const unit = RemoveUnit(tmp_time);
                     converted_time = StringTo<time::ns>(tmp_time, unit);
                 } else {
                     converted_time = StringTo<time::ns>(args[1], args[2]);
@@ -1205,7 +1205,7 @@ std::string Caller::rx_dbitlist(int action) {
         }
         // 'none' option already covered as t is empty by default
         else if (args[0] != "none") {
-            unsigned int ntrim = args.size();
+            unsigned int const ntrim = args.size();
             t.resize(ntrim);
             for (unsigned int i = 0; i < ntrim; ++i) {
                 t[i] = StringTo<int>(args[i]);
@@ -1421,7 +1421,7 @@ std::string Caller::sleep(int action) {
         try {
             if (args.size() == 1) {
                 std::string tmp_time(args[0]);
-                std::string unit = RemoveUnit(tmp_time);
+                std::string const unit = RemoveUnit(tmp_time);
                 converted_time = StringTo<time::ns>(tmp_time, unit);
             } else {
                 converted_time = StringTo<time::ns>(args[0], args[1]);
@@ -1437,365 +1437,4 @@ std::string Caller::sleep(int action) {
     return os.str();
 }
 
-std::string Caller::define_reg(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        os << "[Ctb][Xilinx Ctb]"
-              "\n\t[reg name] [reg address]"
-              "\n\n\tSets a user defined register in shared memory. The name "
-              "can be upto 32 characters long."
-              "\n\teg."
-              "\n\tsls_detector_put define_reg test_reg 0x200"
-              "\n\n\tOne can retrieve the address using the name and vice "
-              "versa."
-              "\n\teg."
-              "\n\tsls_detector_get define_reg test_reg"
-              "\n\tsls_detector_get define_reg 0x200"
-              "\n\n\tOne can then use this user-defined name in other commands "
-              "instead of hard coding the address such as for reg, setbit, "
-              "clearbit and getbit commands."
-              "\n\teg."
-              "\n\tsls_detector_put reg test_reg 0x1"
-              "\n\tsls_detector_put setbit test_reg 2"
-              "\n\tsls_detector_put clearbit test_reg 2"
-              "\n\tsls_detector_get getbit test_reg 2"
-           << '\n';
-        return os.str();
-    }
-    if (det_id != -1) {
-        throw RuntimeError("Cannot use define at module level. Use the default "
-                           "multi-module level");
-    }
-    if (action == defs::GET_ACTION) {
-        if (args.size() != 1) {
-            WrongNumberOfParameters(1);
-        }
-        // get name from address
-        if (is_hex_or_dec_uint(args[0])) {
-            auto addr = parseRegisterAddress(args[0]);
-            auto t = det->getRegisterName(addr);
-            os << t << '\n';
-        }
-        // get address from name
-        else {
-            auto t = det->getRegisterAddress(args[0]);
-            os << t.str() << '\n';
-        }
-    } else if (action == defs::PUT_ACTION) {
-        if (args.size() != 2) {
-            WrongNumberOfParameters(2);
-        }
-        auto name = args[0];
-        auto addr = parseRegisterAddress(args[1]);
-        det->setRegisterDefinition(name, addr);
-        os << "addr " << name << ' ' << addr.str() << '\n';
-    } else {
-        throw RuntimeError("Unknown action");
-    }
-
-    return os.str();
-}
-
-std::string Caller::define_bit(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        os << "[Ctb][Xilinx Ctb]"
-              "\n\t[bit name] [regiser name/address] [bit position]"
-              "\n\n\tSets a user defined bit name in shared memory "
-              "representing the register address and the bit position. The "
-              "address can be named prior using define_reg command. The name "
-              "can be upto 32 characters long."
-              "\n\teg."
-              "\n\tsls_detector_put define_bit test_bit test_reg 2"
-              "\n\tsls_detector_put define_bit test_bit 0x200 2"
-              "\n\n\tOne can retrieve the bit address using the name and vice "
-              "versa using both register name or address and bit position."
-              "\n\teg."
-              "\n\tsls_detector_get define_bit test_bit"
-              "\n\tsls_detector_get define_bit test_reg 2"
-              "\n\tsls_detector_get define_bit 0x200 2"
-              "\n\n\tOne can then use this user-defined name in other commands "
-              "such as for setbit, clearbit and getbit commands. When using "
-              "bit names, please dont use register name or address as bit name "
-              "is already tied to a specific register."
-              "\n\teg."
-              "\n\tsls_detector_put setbit test_bit"
-              "\n\tsls_detector_put clearbit test_bit"
-              "\n\tsls_detector_get getbit test_bit"
-           << '\n';
-        return os.str();
-    }
-    if (det_id != -1) {
-        throw RuntimeError("Cannot use define at module level. Use the default "
-                           "multi-module level");
-    }
-    if (action == defs::GET_ACTION) {
-        // get position from name
-        if (args.size() == 1) {
-            auto t = det->getBitAddress(args[0]);
-            os << det->toRegisterNameBitString(t) << '\n';
-        }
-        // get name from position and address
-        else if (args.size() == 2) {
-            auto addr = parseBitAddress(args[0], args[1]);
-            auto t = det->getBitName(addr);
-            os << t << '\n';
-
-        } else {
-            WrongNumberOfParameters(1);
-        }
-    } else if (action == defs::PUT_ACTION) {
-        if (args.size() != 3) {
-            WrongNumberOfParameters(3);
-        }
-        if (!is_int(args[2])) {
-            throw RuntimeError("Bit position must be an integer value.");
-        }
-        auto name = args[0];
-        auto addr = parseBitAddress(args[1], args[2]);
-        det->setBitDefinition(name, addr);
-        os << ToString(args) << '\n';
-    } else {
-        throw RuntimeError("Unknown action");
-    }
-
-    return os.str();
-}
-
-std::string Caller::definelist_reg(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        os << "List of user-defined register definitions in shared memory."
-           << '\n';
-    } else if (action == defs::PUT_ACTION) {
-        throw RuntimeError("cannot put");
-    } else if (action == defs::GET_ACTION) {
-        if (!args.empty()) {
-            WrongNumberOfParameters(0);
-        }
-        auto t = det->getRegisterDefinitions();
-        os << '\n' << ToString(t) << '\n';
-    } else {
-        throw RuntimeError("Unknown action");
-    }
-    return os.str();
-}
-
-std::string Caller::definelist_bit(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        os << "List of user-defined bit definitions in shared memory." << '\n';
-    } else if (action == defs::PUT_ACTION) {
-        throw RuntimeError("cannot put");
-    } else if (action == defs::GET_ACTION) {
-        if (!args.empty()) {
-            WrongNumberOfParameters(0);
-        }
-        auto t = det->getBitDefinitions();
-        os << "\n[";
-        for (const auto &[key, val] : t) {
-            os << key << ": ";
-            os << det->toRegisterNameBitString(val);
-            if (&key != &t.rbegin()->first) {
-                os << ", ";
-            }
-            os << '\n';
-        }
-        os << "]\n";
-    } else {
-        throw RuntimeError("Unknown action");
-    }
-    return os.str();
-}
-
-std::string Caller::reg(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        os << "[address] [32 bit value][(optional)--validate]"
-              "\n\tReads/writes to a 32 bit register in hex."
-              "\n\tAdvanced Function!\n\tGoes to stop server. Hence, can be "
-              "called while calling blocking acquire()."
-              "\n\t\t Use --validate to enforce validation when writing to "
-              "register."
-              "\n\t[Eiger] +0x100 for only left, +0x200 for only right."
-              "\n\t[Ctb][Xilinx_Ctb] Address can also be a user-defined name "
-              "that was set previously using the define command."
-              "\n\t\teg."
-              "\n\t\tsls_detector_put reg 0x200 0xFFF --validate"
-              "\n\t\tsls_detector_get reg test_reg"
-              "\n\t\tsls_detector_put reg test_reg 0xFF"
-           << '\n';
-    } else {
-        if (action == defs::PUT_ACTION) {
-            if (args.size() < 2 || args.size() > 3) {
-                WrongNumberOfParameters(2);
-            }
-            auto validate = parseValidate();
-            auto addr = getRegisterAddress(args[0]);
-            auto val = parseRegisterValue(args[1]);
-            det->writeRegister(addr, val, validate, std::vector<int>{det_id});
-            os << addr.str() << " " << val.str() << '\n';
-        } else if (action == defs::GET_ACTION) {
-            if (args.size() != 1) {
-                WrongNumberOfParameters(1);
-            }
-            auto addr = getRegisterAddress(args[0]);
-            auto t = det->readRegister(addr, std::vector<int>{det_id});
-            os << OutString(t) << '\n';
-        } else {
-            throw RuntimeError("Unknown action");
-        }
-    }
-    return os.str();
-}
-
-std::string Caller::getbit(int action) { return bitoperations(action); }
-
-std::string Caller::setbit(int action) { return bitoperations(action); }
-
-std::string Caller::clearbit(int action) { return bitoperations(action); }
-
-std::string Caller::bitoperations(int action) {
-    std::ostringstream os;
-    if (action == defs::HELP_ACTION) {
-        if (cmd == "getbit") {
-            os << "[reg address in hex] [bit index]\n\tGets bit in address."
-               << '\n';
-        } else if (cmd == "setbit") {
-            os << "[reg address in hex] [bit index]\n\tSets bit in "
-                  "address.\n\tUse --validate to force validation."
-               << '\n';
-        } else if (cmd == "clearbit") {
-            os << "[reg address in hex] [bit index]\n\tClears bit in "
-                  "address.\n\tUse --validate to force validation."
-               << '\n';
-        } else {
-            throw RuntimeError("Unknown command");
-        }
-        os << "\n\t\t[Ctb][Xilinx_Ctb] Address or bit position can also be a "
-              "user-defined name that was set previously using the define "
-              "command. When using bit names, avoid register name/ address as "
-              "the bit name is tied to a specific register already."
-              "\n\n\teg."
-              "\n\tsls_detector_get getbit 0x200 2"
-              "\n\tsls_detector_get getbit test_reg 2"
-              "\n\tsls_detector_get getbit test_bit"
-              "\n\tsls_detector_put setbit 0x200 2"
-              "\n\tsls_detector_put setbit test_reg 2"
-              "\n\tsls_detector_put setbit test_bit"
-              "\n\tsls_detector_put clearbit test_bit";
-        os << '\n';
-    } else {
-        if (action != defs::GET_ACTION && action != defs::PUT_ACTION) {
-            throw RuntimeError("Unknown action");
-        }
-
-        auto validate = parseValidate();
-        auto addr = getBitAddress();
-        if (action == defs::GET_ACTION) {
-            if (cmd == "setbit" || cmd == "clearbit")
-                throw RuntimeError("Cannot get");
-
-            auto t = det->getBit(addr, std::vector<int>{det_id});
-            os << OutString(t) << '\n';
-        } else {
-            if (cmd == "getbit")
-                throw RuntimeError("Cannot put");
-            if (cmd == "setbit")
-                det->setBit(addr, validate, std::vector<int>{det_id});
-            else if (cmd == "clearbit")
-                det->clearBit(addr, validate, std::vector<int>{det_id});
-            else
-                throw RuntimeError("Unknown command");
-            os << ToString(args) << "\n";
-        }
-    }
-    return os.str();
-}
-
-RegisterAddress Caller::parseRegisterAddress(const std::string &addr) const {
-    try {
-        return RegisterAddress(StringTo<uint32_t>(addr));
-    } catch (const std::exception &e) {
-        throw RuntimeError("Could not parse register address " + addr +
-                           ". Must be an integer value");
-    }
-}
-
-BitAddress Caller::parseBitAddress(const std::string &addr,
-                                   const std::string &bitPos) const {
-    auto address = getRegisterAddress(addr);
-    uint32_t bitPosition = 0;
-
-    // parse bit position
-    if (!is_hex_or_dec_uint(bitPos)) {
-        throw RuntimeError("Bit position must be an integer value.");
-    }
-    try {
-        bitPosition = StringTo<uint32_t>(bitPos);
-    } catch (const std::exception &e) {
-        throw RuntimeError("Could not parse bit position " + bitPos +
-                           ". Must be an integer value");
-    }
-    return BitAddress(address, bitPosition);
-}
-
-RegisterValue Caller::parseRegisterValue(const std::string &addr) const {
-    try {
-        return RegisterValue(StringTo<uint32_t>(addr));
-    } catch (const std::exception &e) {
-        throw RuntimeError("Could not parse register value " + addr +
-                           ". Must be an integer value");
-    }
-}
-
-bool Caller::parseValidate() {
-    auto it = std::find(args.begin(), args.end(), "--validate");
-    bool validate = (it != args.end());
-
-    // invalid argument (--options), throw
-    if (!validate) {
-        auto invalid_it =
-            std::find_if(args.begin(), args.end(), [](const auto &s) {
-                // only looks for the first characters
-                return s.rfind("--", 0) == 0 && s != "--validate";
-            });
-        if (invalid_it != args.end()) {
-            throw RuntimeError("Unknown option '" + *invalid_it +
-                               "'. Did you mean '--validate'?");
-        }
-    }
-
-    // --validate should be the last argument (remove it from args)
-    else {
-        if (it != args.end() - 1) {
-            throw RuntimeError("'--validate' should be the last argument.");
-        }
-        args.pop_back();
-    }
-    return validate;
-}
-
-RegisterAddress Caller::getRegisterAddress(const std::string &saddr) const {
-    if (is_hex_or_dec_uint(saddr)) {
-        return parseRegisterAddress(saddr);
-    }
-    return det->getRegisterAddress(saddr);
-}
-
-BitAddress Caller::getBitAddress() const {
-    int args_size = args.size();
-
-    // address and bit position
-    if (args_size == 2) {
-        return parseBitAddress(args[0], args[1]);
-    }
-
-    // bit name
-    if (args_size == 1) {
-        return det->getBitAddress(args[0]);
-    }
-    throw RuntimeError("Invalid number of parameters for bit address.");
-}
-
 } // namespace sls

slsDetectorSoftware/src/CmdApp.cpp

@@ -83,7 +83,7 @@ int main(int argc, char *argv[]) {
     try {
         if (action == -1) {
             action = inferAction.infer(parser);
-            std::string actionString =
+            std::string const actionString =
                 (action == slsDetectorDefs::GET_ACTION) ? "GET" : "PUT";
             std::cout << "inferred action: " << actionString << std::endl;
         }

slsDetectorSoftware/src/CtbConfig.cpp

@@ -28,298 +28,214 @@ CtbConfig::CtbConfig() {
     for (size_t i = 0; i != num_slowADCs; ++i) {
         setSlowADCName(i, "SLOWADC" + ToString(i));
     }
-    registers.clear();
-    bits.clear();
+}
+
+void CtbConfig::check_dac_index(size_t i) const {
+    if (i >= num_dacs) {
+        std::ostringstream oss;
+        oss << "Invalid DAC index. Options: 0 - " << num_dacs;
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_adc_index(size_t i) const {
+    if (i >= num_adcs) {
+        std::ostringstream oss;
+        oss << "Invalid ADC index. Options: 0 - " << num_adcs;
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_signal_index(size_t i) const {
+    if (i >= num_signals) {
+        std::ostringstream oss;
+        oss << "Invalid Signal index. Options: 0 - " << num_signals;
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_power_index(size_t i) const {
+    if (i >= num_powers) {
+        std::ostringstream oss;
+        oss << "Invalid Power index. Options: 0 - " << num_powers
+            << " or V_POWER_A - V_POWER_IO";
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_slow_adc_index(size_t i) const {
+    if (i >= num_slowADCs) {
+        std::ostringstream oss;
+        oss << "Invalid Slow ADC index. Options: 0 - " << num_slowADCs
+            << " or SLOW_ADC0 - SLOW_ADC7";
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_size(const std::string &name) const {
+
+    if (name.empty())
+        throw RuntimeError("Name needs to be at least one character");
+
+    // name_length -1 to account for \0 termination
+    if (!(name.size() < (name_length - 1))) {
+        std::ostringstream oss;
+        oss << "Length of name needs to be less than " << name_length - 1
+            << " chars";
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::setDacName(size_t index, const std::string &name) {
+    check_dac_index(index);
+    check_size(name);
+    char *dst = &dacnames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setDacNames(const std::vector<std::string> &names) {
+    if (names.size() != num_dacs) {
+        throw RuntimeError("Dac names need to be of size " +
+                           std::to_string(num_dacs));
+    }
+    for (size_t i = 0; i != num_dacs; ++i) {
+        setDacName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getDacName(size_t index) const {
+    check_dac_index(index);
+    return dacnames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getDacNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_dacs; ++i)
+        names.push_back(getDacName(i));
+    return names;
+}
+
+void CtbConfig::setAdcName(size_t index, const std::string &name) {
+    check_adc_index(index);
+    check_size(name);
+    char *dst = &adcnames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setAdcNames(const std::vector<std::string> &names) {
+    if (names.size() != num_adcs) {
+        throw RuntimeError("Adc names need to be of size " +
+                           std::to_string(num_adcs));
+    }
+    for (size_t i = 0; i != num_adcs; ++i) {
+        setAdcName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getAdcName(size_t index) const {
+    check_adc_index(index);
+    return adcnames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getAdcNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_adcs; ++i)
+        names.push_back(getAdcName(i));
+    return names;
+}
+
+void CtbConfig::setSignalName(size_t index, const std::string &name) {
+    check_signal_index(index);
+    check_size(name);
+    char *dst = &signalnames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setSignalNames(const std::vector<std::string> &names) {
+    if (names.size() != num_signals) {
+        throw RuntimeError("Signal names need to be of size " +
+                           std::to_string(num_signals));
+    }
+    for (size_t i = 0; i != num_signals; ++i) {
+        setSignalName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getSignalName(size_t index) const {
+    check_signal_index(index);
+    return signalnames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getSignalNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_signals; ++i)
+        names.push_back(getSignalName(i));
+    return names;
+}
+
+void CtbConfig::setPowerName(size_t index, const std::string &name) {
+    check_power_index(index);
+    check_size(name);
+    char *dst = &powernames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setPowerNames(const std::vector<std::string> &names) {
+    if (names.size() != num_powers) {
+        throw RuntimeError("Power names need to be of size " +
+                           std::to_string(num_powers));
+    }
+    for (size_t i = 0; i != num_powers; ++i) {
+        setPowerName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getPowerName(size_t index) const {
+    check_power_index(index);
+    return powernames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getPowerNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_powers; ++i)
+        names.push_back(getPowerName(i));
+    return names;
+}
+
+void CtbConfig::setSlowADCName(size_t index, const std::string &name) {
+    check_slow_adc_index(index);
+    check_size(name);
+    char *dst = &slowADCnames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setSlowADCNames(const std::vector<std::string> &names) {
+    if (names.size() != num_slowADCs) {
+        throw RuntimeError("Slow ADC names need to be of size " +
+                           std::to_string(num_slowADCs));
+    }
+    for (size_t i = 0; i != num_slowADCs; ++i) {
+        setSlowADCName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getSlowADCName(size_t index) const {
+    check_slow_adc_index(index);
+    return slowADCnames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getSlowADCNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_slowADCs; ++i)
+        names.push_back(getSlowADCName(i));
+    return names;
 }
 
 const char *CtbConfig::shm_tag() { return shm_tag_; }
 
-void CtbConfig::check_index(size_t index, size_t max, const std::string &name,
-                            const std::string &suffix) const {
-    if (index >= max) {
-        std::ostringstream oss;
-        oss << "Invalid " << name << " index. Options: 0 - " << max;
-        if (!suffix.empty()) {
-            oss << " " << suffix;
-        }
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::set_name(const std::string &name, char dst[][name_length],
-                         size_t index) {
-    if (name.empty())
-        throw RuntimeError("Name needs to be at least one character");
-
-    strcpy_checked<name_length>(dst[index], name);
-}
-
-void CtbConfig::setNames(const std::vector<std::string> &names,
-                         size_t expected_size,
-                         void (CtbConfig::*setNameFunc)(size_t,
-                                                        const std::string &)) {
-    if (names.size() != expected_size) {
-        throw RuntimeError("Name list need to be of size " +
-                           std::to_string(expected_size));
-    }
-    for (size_t i = 0; i != expected_size; ++i) {
-        (this->*setNameFunc)(i, names[i]);
-    }
-}
-
-std::vector<std::string>
-CtbConfig::getNames(size_t expected_size,
-                    std::string (CtbConfig::*getNameFunc)(size_t) const) const {
-    std::vector<std::string> result;
-    result.reserve(expected_size);
-    for (size_t i = 0; i != expected_size; ++i) {
-        result.push_back((this->*getNameFunc)(i));
-    }
-    return result;
-}
-
-void CtbConfig::setDacName(size_t index, const std::string &name) {
-    check_index(index, num_dacs, "DAC");
-    set_name(name, dacnames, index);
-}
-
-void CtbConfig::setDacNames(const std::vector<std::string> &names) {
-    setNames(names, num_dacs, &CtbConfig::setDacName);
-}
-
-std::string CtbConfig::getDacName(size_t index) const {
-    check_index(index, num_dacs, "DAC");
-    return dacnames[index];
-}
-
-std::vector<std::string> CtbConfig::getDacNames() const {
-    return getNames(num_dacs, &CtbConfig::getDacName);
-}
-
-void CtbConfig::setAdcName(size_t index, const std::string &name) {
-    check_index(index, num_adcs, "ADC");
-    set_name(name, adcnames, index);
-}
-
-void CtbConfig::setAdcNames(const std::vector<std::string> &names) {
-    setNames(names, num_adcs, &CtbConfig::setAdcName);
-}
-
-std::string CtbConfig::getAdcName(size_t index) const {
-    check_index(index, num_adcs, "ADC");
-    return adcnames[index];
-}
-
-std::vector<std::string> CtbConfig::getAdcNames() const {
-    return getNames(num_adcs, &CtbConfig::getAdcName);
-}
-
-void CtbConfig::setSignalName(size_t index, const std::string &name) {
-    check_index(index, num_signals, "Signal");
-    set_name(name, signalnames, index);
-}
-
-void CtbConfig::setSignalNames(const std::vector<std::string> &names) {
-    setNames(names, num_signals, &CtbConfig::setSignalName);
-}
-
-std::string CtbConfig::getSignalName(size_t index) const {
-    check_index(index, num_signals, "Signal");
-    return signalnames[index];
-}
-
-std::vector<std::string> CtbConfig::getSignalNames() const {
-    return getNames(num_signals, &CtbConfig::getSignalName);
-}
-
-void CtbConfig::setPowerName(size_t index, const std::string &name) {
-    check_index(index, num_powers, "Power");
-    set_name(name, powernames, index);
-}
-
-void CtbConfig::setPowerNames(const std::vector<std::string> &names) {
-    setNames(names, num_powers, &CtbConfig::setPowerName);
-}
-
-std::string CtbConfig::getPowerName(size_t index) const {
-    check_index(index, num_powers, "Power");
-    return powernames[index];
-}
-
-std::vector<std::string> CtbConfig::getPowerNames() const {
-    return getNames(num_powers, &CtbConfig::getPowerName);
-}
-
-void CtbConfig::setSlowADCName(size_t index, const std::string &name) {
-    check_index(index, num_slowADCs, "Slow ADC", "or SLOW_ADC0 - SLOW_ADC7");
-    set_name(name, slowADCnames, index);
-}
-
-void CtbConfig::setSlowADCNames(const std::vector<std::string> &names) {
-    setNames(names, num_slowADCs, &CtbConfig::setSlowADCName);
-}
-
-std::string CtbConfig::getSlowADCName(size_t index) const {
-    check_index(index, num_slowADCs, "Slow ADC", "or SLOW_ADC0 - SLOW_ADC7");
-    return slowADCnames[index];
-}
-
-std::vector<std::string> CtbConfig::getSlowADCNames() const {
-    return getNames(num_slowADCs, &CtbConfig::getSlowADCName);
-}
-
-int CtbConfig::getRegisterNamesCount() const { return registers.size(); }
-
-bool CtbConfig::hasRegisterName(const std::string &name) const {
-    auto fixed_name = FixedString<name_length>(name);
-    return registers.containsKey(fixed_name);
-}
-
-bool CtbConfig::hasRegisterAddress(RegisterAddress addr) const {
-    return registers.hasValue(addr);
-}
-
-void CtbConfig::clearRegisterNames() { registers.clear(); }
-
-void CtbConfig::setRegisterName(const std::string &name, RegisterAddress addr) {
-    try {
-        auto fixed_name = FixedString<name_length>(name);
-        registers.addKeyOrSetValue(fixed_name, addr);
-    } catch (const std::runtime_error &e) {
-        std::ostringstream oss;
-        oss << e.what();
-        if (strstr(e.what(), "Maximum capacity reached")) {
-            oss << ". Clear shared memory and try again.";
-        }
-        throw RuntimeError("Could not set register name '" + name +
-                           "': " + oss.str());
-    }
-}
-
-RegisterAddress CtbConfig::getRegisterAddress(const std::string &name) const {
-    try {
-        auto fixed_name = FixedString<name_length>(name);
-        return registers.getValue(fixed_name);
-    } catch (const std::runtime_error &e) {
-        throw RuntimeError("Could not get register address for name '" + name +
-                           "': " + std::string(e.what()));
-    }
-}
-
-std::string CtbConfig::getRegisterName(RegisterAddress addr) const {
-    try {
-        return registers.getKey(addr).str();
-    } catch (const std::runtime_error &e) {
-        throw RuntimeError("Could not get register name for address '" +
-                           addr.str() + "': " + std::string(e.what()));
-    }
-}
-
-void CtbConfig::setRegisterNames(
-    const std::map<std::string, RegisterAddress> &list) {
-    try {
-        std::map<FixedString<name_length>, RegisterAddress> fixed_list;
-        for (const auto &[name, value] : list) {
-            auto fixed_name = FixedString<name_length>(name);
-            fixed_list[fixed_name] = value;
-        }
-        registers.setMap(fixed_list);
-    } catch (const std::runtime_error &e) {
-        throw RuntimeError("Could not set register names: " +
-                           std::string(e.what()));
-    }
-}
-
-std::map<std::string, RegisterAddress> CtbConfig::getRegisterNames() const {
-    auto fixed_result = registers.getMap();
-    std::map<std::string, RegisterAddress> result;
-    for (const auto &[fixed_name, value] : fixed_result) {
-        result[fixed_name.str()] = value;
-    }
-    return result;
-}
-
-int CtbConfig::getBitNamesCount() const { return bits.size(); }
-
-bool CtbConfig::hasBitName(const std::string &name) const {
-    auto fixed_name = FixedString<name_length>(name);
-    return bits.containsKey(fixed_name);
-}
-
-bool CtbConfig::hasBitAddress(BitAddress addr) const {
-    return bits.hasValue(addr);
-}
-
-void CtbConfig::clearBitNames() { bits.clear(); }
-
-void CtbConfig::setBitName(const std::string &name, BitAddress addr) {
-    try {
-        auto fixed_name = FixedString<name_length>(name);
-        bits.addKeyOrSetValue(fixed_name, addr);
-    } catch (const std::runtime_error &e) {
-        std::ostringstream oss;
-        oss << e.what();
-        if (strstr(e.what(), "Maximum capacity reached")) {
-            oss << ". Clear shared memory and try again.";
-        }
-        throw RuntimeError("Could not set bit name '" + name +
-                           "': " + oss.str());
-    }
-}
-
-BitAddress CtbConfig::getBitAddress(const std::string &name) const {
-    try {
-        auto fixed_name = FixedString<name_length>(name);
-        return bits.getValue(fixed_name);
-    } catch (const std::runtime_error &e) {
-        throw RuntimeError("Could not get bit address for name '" + name +
-                           "': " + std::string(e.what()));
-    }
-}
-
-std::string CtbConfig::toRegisterNameBitString(BitAddress addr) const {
-    std::ostringstream oss;
-    if (registers.hasValue(addr.address())) {
-        oss << "[" << registers.getKey(addr.address()).str() << ", "
-            << std::to_string(addr.bitPosition()) << "]";
-    } else {
-        oss << addr.str();
-    }
-    return oss.str();
-}
-
-std::string CtbConfig::getBitName(BitAddress addr) const {
-    try {
-        return bits.getKey(addr).str();
-    } catch (const std::runtime_error &e) {
-        std::ostringstream oss;
-        oss << "Could not get bit name for bit address ";
-        oss << "'" << toRegisterNameBitString(addr) << "'";
-        oss << ":" << e.what();
-        throw RuntimeError(oss.str());
-    }
-}
-
-void CtbConfig::setBitNames(const std::map<std::string, BitAddress> &list) {
-    try {
-        std::map<FixedString<name_length>, BitAddress> fixed_list;
-        for (const auto &[name, value] : list) {
-            auto fixed_name = FixedString<name_length>(name);
-            fixed_list[fixed_name] = value;
-        }
-        bits.setMap(fixed_list);
-    } catch (const std::runtime_error &e) {
-        throw RuntimeError("Could not set bit names: " + std::string(e.what()));
-    }
-}
-
-std::map<std::string, BitAddress> CtbConfig::getBitNames() const {
-    auto fixed_result = bits.getMap();
-    std::map<std::string, BitAddress> result;
-    for (const auto &[fixed_name, value] : fixed_result) {
-        result[fixed_name.str()] = value;
-    }
-    return result;
-}
-
 } // namespace sls

slsDetectorSoftware/src/CtbConfig.h

@@ -1,57 +1,44 @@
 #pragma once
-
-#include "MapOnStack.h"
-#include "sls/bit_utils.h"
-#include "sls/sls_detector_defs.h"
-#include "sls/string_utils.h"
-
+#include <string>
 #include <vector>
-
 namespace sls {
 
+#define CTB_SHMAPIVERSION 0x250820
+#define CTB_SHMVERSION    0x250820
+
 class CtbConfig {
   public:
     /** fixed pattern */
-    static constexpr int SHM_VERSION = 0x251215;
-    int shmversion{SHM_VERSION};
+    int shmversion{CTB_SHMVERSION};
     bool isValid{true}; // false if freed to block access from python or c++ api
                         /** end of fixed pattern */
-
   private:
-    static constexpr const char *shm_tag_ = "ctbdacs";
-    static constexpr size_t name_length = 32;
-
+    static constexpr size_t name_length = 20;
     static constexpr size_t num_dacs = 18;
     static constexpr size_t num_adcs = 32;
     static constexpr size_t num_signals = 64;
     static constexpr size_t num_powers = 5;
     static constexpr size_t num_slowADCs = 8;
-    char dacnames[num_dacs][name_length]{};
-    char adcnames[num_adcs][name_length]{};
-    char signalnames[num_signals][name_length]{};
-    char powernames[num_powers][name_length]{};
-    char slowADCnames[num_slowADCs][name_length]{};
+    static constexpr const char *shm_tag_ = "ctbdacs";
+    char dacnames[name_length * num_dacs]{};
+    char adcnames[name_length * num_adcs]{};
+    char signalnames[name_length * num_signals]{};
+    char powernames[name_length * num_powers]{};
+    char slowADCnames[name_length * num_slowADCs]{};
 
-    void check_index(size_t index, size_t max, const std::string &name,
-                     const std::string &suffix = "") const;
-    void set_name(const std::string &name, char dst[][name_length],
-                  size_t index);
-
-    void setNames(const std::vector<std::string> &names, size_t expected_size,
-                  void (CtbConfig::*setNameFunc)(size_t, const std::string &));
-    std::vector<std::string>
-    getNames(size_t expected_size,
-             std::string (CtbConfig::*getNameFunc)(size_t) const) const;
-
-    static constexpr size_t Max_Named_Regs = 1024;
-    static constexpr size_t Max_Named_Bits = 32 * 1024;
-    MapOnStack<FixedString<name_length>, RegisterAddress, Max_Named_Regs, true>
-        registers;
-    MapOnStack<FixedString<name_length>, BitAddress, Max_Named_Bits, true> bits;
+    void check_dac_index(size_t i) const;
+    void check_adc_index(size_t i) const;
+    void check_signal_index(size_t i) const;
+    void check_power_index(size_t i) const;
+    void check_slow_adc_index(size_t i) const;
+    void check_size(const std::string &name) const;
 
   public:
     CtbConfig();
-    static const char *shm_tag();
+    CtbConfig(const CtbConfig &) = default;
+    CtbConfig(CtbConfig &&) = default;
+    CtbConfig &operator=(const CtbConfig &) = default;
+    ~CtbConfig() = default;
 
     void setDacNames(const std::vector<std::string> &names);
     void setDacName(size_t index, const std::string &name);
@@ -77,27 +64,7 @@ class CtbConfig {
     void setSlowADCName(size_t index, const std::string &name);
     std::string getSlowADCName(size_t index) const;
     std::vector<std::string> getSlowADCNames() const;
-
-    int getRegisterNamesCount() const;
-    bool hasRegisterName(const std::string &name) const;
-    bool hasRegisterAddress(RegisterAddress addr) const;
-    void clearRegisterNames();
-    void setRegisterName(const std::string &name, RegisterAddress addr);
-    RegisterAddress getRegisterAddress(const std::string &name) const;
-    std::string getRegisterName(RegisterAddress addr) const;
-    void setRegisterNames(const std::map<std::string, RegisterAddress> &list);
-    std::map<std::string, RegisterAddress> getRegisterNames() const;
-
-    int getBitNamesCount() const;
-    void clearBitNames();
-    bool hasBitName(const std::string &name) const;
-    bool hasBitAddress(BitAddress addr) const;
-    std::string toRegisterNameBitString(BitAddress addr) const;
-    void setBitName(const std::string &name, BitAddress addr);
-    BitAddress getBitAddress(const std::string &name) const;
-    std::string getBitName(BitAddress addr) const;
-    void setBitNames(const std::map<std::string, BitAddress> &list);
-    std::map<std::string, BitAddress> getBitNames() const;
+    static const char *shm_tag();
 };
 
 } // namespace sls

slsDetectorSoftware/src/Detector.cpp

@@ -128,7 +128,7 @@ Detector &Detector::operator=(Detector &&other) noexcept = default;
 // Configuration
 
 void Detector::loadConfig(const std::string &fname) {
-    int shm_id = getShmId();
+    const int shm_id = getShmId();
     freeSharedMemory(shm_id);
     pimpl = make_unique<DetectorImpl>(shm_id);
     LOG(logINFO) << "Loading configuration file: " << fname;
@@ -205,7 +205,7 @@ int Detector::getShmId() const { return pimpl->getDetectorIndex(); }
 std::string Detector::getPackageVersion() const { return SLS_DET_VERSION; }
 
 std::string Detector::getClientVersion() const {
-    Version v(APILIB);
+    const Version v(APILIB);
     return v.concise();
 }
 
@@ -266,7 +266,7 @@ defs::xy Detector::getPortPerModuleGeometry() const {
 
 Result<defs::xy> Detector::getPortSize(Positions pos) const {
     Result<defs::xy> res = pimpl->Parallel(&Module::getNumberOfChannels, pos);
-    defs::xy portGeometry = getPortPerModuleGeometry();
+    const defs::xy portGeometry = getPortPerModuleGeometry();
     if ((portGeometry.x != 1 && portGeometry.x != 2) ||
         (portGeometry.y != 1 && portGeometry.y != 2)) {
         throw RuntimeError(
@@ -346,9 +346,9 @@ Detector::getAllThresholdEnergy(Positions pos) const {
 void Detector::setThresholdEnergy(int threshold_ev,
                                   defs::detectorSettings settings,
                                   bool trimbits, Positions pos) {
-    defs::detectorType type = getDetectorType().squash();
+    const defs::detectorType type = getDetectorType().squash();
     if (type == defs::MYTHEN3) {
-        std::array<int, 3> energy = {threshold_ev, threshold_ev, threshold_ev};
+        const std::array<int, 3> energy = {threshold_ev, threshold_ev, threshold_ev};
         setThresholdEnergy(energy, settings, trimbits, pos);
         return;
     }
@@ -753,7 +753,6 @@ void Detector::setImageTestMode(int value, Positions pos) {
 }
 
 std::vector<defs::dacIndex> Detector::getTemperatureList() const {
-    std::vector<defs::dacIndex> retval;
     switch (getDetectorType().squash()) {
     case defs::CHIPTESTBOARD:
         return std::vector<defs::dacIndex>{defs::SLOW_ADC_TEMP};
@@ -1096,9 +1095,9 @@ void Detector::setNumberofUDPInterfaces_(int n, Positions pos) {
     if (!size()) {
         throw RuntimeError("No modules added.");
     }
-    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
-    uint16_t clientStartingPort = getClientZmqPort({0}).squash(0);
-    bool useReceiver = getUseReceiverFlag().squash(false);
+    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    const uint16_t clientStartingPort = getClientZmqPort({0}).squash(0);
+    const bool useReceiver = getUseReceiverFlag().squash(false);
     bool previouslyReceiverStreaming = false;
     uint16_t rxStartingPort = 0;
     if (useReceiver) {
@@ -1564,7 +1563,7 @@ Result<uint16_t> Detector::getRxZmqPort(Positions pos) const {
 }
 
 void Detector::setRxZmqPort(uint16_t port, int module_id) {
-    bool previouslyReceiverStreaming =
+    const bool previouslyReceiverStreaming =
         getRxZmqDataStream(std::vector<int>{module_id}).squash(false);
     if (module_id == -1) {
         std::vector<uint16_t> port_list = getValidPortNumbers(port);
@@ -1587,7 +1586,7 @@ Result<uint16_t> Detector::getClientZmqPort(Positions pos) const {
 }
 
 void Detector::setClientZmqPort(uint16_t port, int module_id) {
-    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
     if (module_id == -1) {
         std::vector<uint16_t> port_list = getValidPortNumbers(port);
         for (int idet = 0; idet < size(); ++idet) {
@@ -1609,7 +1608,7 @@ Result<IpAddr> Detector::getClientZmqIp(Positions pos) const {
 }
 
 void Detector::setClientZmqIp(const IpAddr ip, Positions pos) {
-    bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
+    const bool previouslyClientStreaming = pimpl->getDataStreamingToClient();
     pimpl->Parallel(&Module::setClientStreamingIP, pos, ip);
     if (previouslyClientStreaming) {
         pimpl->setDataStreamingToClient(false);
@@ -1628,7 +1627,7 @@ Result<int> Detector::getRxZmqHwm(Positions pos) const {
 }
 
 void Detector::setRxZmqHwm(const int limit) {
-    bool previouslyReceiverStreaming = getRxZmqDataStream().squash(false);
+    const bool previouslyReceiverStreaming = getRxZmqDataStream().squash(false);
     pimpl->Parallel(&Module::setReceiverStreamingHwm, {}, limit);
     if (previouslyReceiverStreaming) {
         setRxZmqDataStream(false, {});
@@ -1994,15 +1993,15 @@ Result<defs::streamingInterface> Detector::getVetoStream(Positions pos) const {
 void Detector::setVetoStream(defs::streamingInterface interface,
                              Positions pos) {
     // 3gbe
-    bool LOW_LATENCY_LINK =
+    const bool LOW_LATENCY_LINK =
         ((interface & defs::streamingInterface::LOW_LATENCY_LINK) ==
          defs::streamingInterface::LOW_LATENCY_LINK);
     pimpl->Parallel(&Module::setVetoStream, pos, LOW_LATENCY_LINK);
 
     // 10gbe (debugging interface) opens 2nd udp interface in receiver
-    int old_numinterfaces = getNumberofUDPInterfaces(pos).tsquash(
+    const int old_numinterfaces = getNumberofUDPInterfaces(pos).tsquash(
         "retrieved inconsistent number of udp interfaces");
-    int numinterfaces =
+    const int numinterfaces =
         (((interface & defs::streamingInterface::ETHERNET_10GB) ==
           defs::streamingInterface::ETHERNET_10GB)
              ? 2
@@ -2377,21 +2376,26 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
 }
 
 void Detector::setDacNames(const std::vector<std::string> names) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named dacs only for CTB");
     pimpl->setCtbDacNames(names);
 }
 
 std::vector<std::string> Detector::getDacNames() const {
-    if (pimpl->isChipTestBoard())
+    std::vector<std::string> names;
+    auto type = getDetectorType().squash();
+    if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD)
         return pimpl->getCtbDacNames();
 
-    std::vector<std::string> names;
     for (const auto &index : getDacList())
         names.push_back(ToString(index));
     return names;
 }
 
 defs::dacIndex Detector::getDacIndex(const std::string &name) const {
-    if (pimpl->isChipTestBoard()) {
+    auto type = getDetectorType().squash();
+    if (type == defs::CHIPTESTBOARD || type == defs::XILINX_CHIPTESTBOARD) {
         auto names = getDacNames();
         auto it = std::find(names.begin(), names.end(), name);
         if (it == names.end())
@@ -2402,24 +2406,37 @@ defs::dacIndex Detector::getDacIndex(const std::string &name) const {
 }
 
 void Detector::setDacName(const defs::dacIndex i, const std::string &name) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named dacs only for CTB");
     pimpl->setCtbDacName(i, name);
 }
 
 std::string Detector::getDacName(const defs::dacIndex i) const {
-    if (pimpl->isChipTestBoard())
+    auto dettype = getDetectorType().squash();
+    if (dettype == defs::CHIPTESTBOARD || dettype == defs::XILINX_CHIPTESTBOARD)
         return pimpl->getCtbDacName(i);
     return ToString(i);
 }
 
 void Detector::setAdcNames(const std::vector<std::string> names) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named adcs only for CTB");
     pimpl->setCtbAdcNames(names);
 }
 
 std::vector<std::string> Detector::getAdcNames() const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named adcs only for CTB");
     return pimpl->getCtbAdcNames();
 }
 
 int Detector::getAdcIndex(const std::string &name) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named adcs only for CTB");
     auto names = getAdcNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2428,22 +2445,37 @@ int Detector::getAdcIndex(const std::string &name) const {
 }
 
 void Detector::setAdcName(const int index, const std::string &name) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named adcs only for CTB");
     pimpl->setCtbAdcName(index, name);
 }
 
 std::string Detector::getAdcName(const int i) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named adcs only for CTB");
     return pimpl->getCtbAdcName(i);
 }
 
 void Detector::setSignalNames(const std::vector<std::string> names) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named signals only for CTB");
     pimpl->setCtbSignalNames(names);
 }
 
 std::vector<std::string> Detector::getSignalNames() const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named signals only for CTB");
     return pimpl->getCtbSignalNames();
 }
 
 int Detector::getSignalIndex(const std::string &name) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named signals only for CTB");
     auto names = getSignalNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2452,22 +2484,38 @@ int Detector::getSignalIndex(const std::string &name) const {
 }
 
 void Detector::setSignalName(const int index, const std::string &name) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named signals only for CTB");
     pimpl->setCtbSignalName(index, name);
 }
 
 std::string Detector::getSignalName(const int i) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named signals only for CTB");
     return pimpl->getCtbSignalName(i);
 }
 
 void Detector::setPowerNames(const std::vector<std::string> names) {
+    auto dettype = getDetectorType().squash();
+    if (getDetectorType().squash() != defs::CHIPTESTBOARD &&
+        dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named powers only for CTB");
     pimpl->setCtbPowerNames(names);
 }
 
 std::vector<std::string> Detector::getPowerNames() const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named powers only for CTB");
     return pimpl->getCtbPowerNames();
 }
 
 defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named powers only for CTB");
     auto names = getPowerNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2477,22 +2525,37 @@ defs::dacIndex Detector::getPowerIndex(const std::string &name) const {
 
 void Detector::setPowerName(const defs::dacIndex index,
                             const std::string &name) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named powers only for CTB");
     pimpl->setCtbPowerName(index, name);
 }
 
 std::string Detector::getPowerName(const defs::dacIndex i) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named powers only for CTB");
     return pimpl->getCtbPowerName(i);
 }
 
 void Detector::setSlowADCNames(const std::vector<std::string> names) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named SlowADCs only for CTB");
     pimpl->setCtbSlowADCNames(names);
 }
 
 std::vector<std::string> Detector::getSlowADCNames() const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named SlowADCs only for CTB");
     return pimpl->getCtbSlowADCNames();
 }
 
 defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named SlowADCs only for CTB");
     auto names = getSlowADCNames();
     auto it = std::find(names.begin(), names.end(), name);
     if (it == names.end())
@@ -2502,89 +2565,19 @@ defs::dacIndex Detector::getSlowADCIndex(const std::string &name) const {
 
 void Detector::setSlowADCName(const defs::dacIndex index,
                               const std::string &name) {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named SlowADCs only for CTB");
     pimpl->setCtbSlowADCName(index, name);
 }
 
 std::string Detector::getSlowADCName(const defs::dacIndex i) const {
+    auto dettype = getDetectorType().squash();
+    if (dettype != defs::CHIPTESTBOARD && dettype != defs::XILINX_CHIPTESTBOARD)
+        throw RuntimeError("Named SlowADCs only for CTB");
     return pimpl->getCtbSlowADCName(i);
 }
 
-int Detector::getRegisterDefinitionsCount() const {
-    return pimpl->getRegisterDefinitionsCount();
-}
-
-void Detector::setRegisterDefinition(const std::string &name,
-                                     RegisterAddress addr) {
-    pimpl->setRegisterDefinition(name, addr);
-}
-
-bool Detector::hasRegisterDefinition(const std::string &name) const {
-    return pimpl->hasRegisterDefinition(name);
-}
-
-bool Detector::hasRegisterDefinition(RegisterAddress addr) const {
-    return pimpl->hasRegisterDefinition(addr);
-}
-
-RegisterAddress Detector::getRegisterAddress(const std::string &name) const {
-    return pimpl->getRegisterAddress(name);
-}
-
-std::string Detector::getRegisterName(RegisterAddress addr) const {
-    return pimpl->getRegisterName(addr);
-}
-
-void Detector::clearRegisterDefinitions() { pimpl->clearRegisterDefinitions(); }
-
-void Detector::setRegisterDefinitions(
-    const std::map<std::string, RegisterAddress> &list) {
-    pimpl->setRegisterDefinitions(list);
-}
-
-std::map<std::string, RegisterAddress>
-Detector::getRegisterDefinitions() const {
-    return pimpl->getRegisterDefinitions();
-}
-
-int Detector::getBitDefinitionsCount() const {
-    return pimpl->getBitDefinitionsCount();
-}
-
-void Detector::setBitDefinition(const std::string &name, BitAddress addr) {
-    pimpl->setBitDefinition(name, addr);
-}
-
-bool Detector::hasBitDefinition(const std::string &name) const {
-    return pimpl->hasBitDefinition(name);
-}
-
-bool Detector::hasBitDefinition(BitAddress addr) const {
-    return pimpl->hasBitDefinition(addr);
-}
-
-std::string Detector::toRegisterNameBitString(BitAddress addr) const {
-    return pimpl->toRegisterNameBitString(addr);
-}
-
-BitAddress Detector::getBitAddress(const std::string &name) const {
-    return pimpl->getBitAddress(name);
-}
-
-std::string Detector::getBitName(BitAddress addr) const {
-    return pimpl->getBitName(addr);
-}
-
-void Detector::clearBitDefinitions() { pimpl->clearBitDefinitions(); }
-
-void Detector::setBitDefinitions(
-    const std::map<std::string, BitAddress> &list) {
-    pimpl->setBitDefinitions(list);
-}
-
-std::map<std::string, BitAddress> Detector::getBitDefinitions() const {
-    return pimpl->getBitDefinitions();
-}
-
 // Xilinx Ctb Specific
 
 void Detector::configureTransceiver(Positions pos) {
@@ -2736,7 +2729,7 @@ void Detector::programFPGA(const std::string &fname,
                            const bool forceDeleteNormalFile, Positions pos) {
     LOG(logINFO) << "Updating Firmware...";
     LOG(logINFO) << "Hardware Version: " << getHardwareVersion();
-    std::vector<char> buffer = pimpl->readProgrammingFile(fname);
+    const std::vector<char> buffer = pimpl->readProgrammingFile(fname);
     pimpl->Parallel(&Module::programFPGA, pos, buffer, forceDeleteNormalFile);
     rebootController(pos);
 }
@@ -2747,8 +2740,8 @@ void Detector::resetFPGA(Positions pos) {
 
 void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
-    std::vector<char> buffer = readBinaryFile(fname, "Update Detector Server");
-    std::string filename = getFileNameFromFilePath(fname);
+    const std::vector<char> buffer = readBinaryFile(fname, "Update Detector Server");
+    const std::string filename = getFileNameFromFilePath(fname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     if (getDetectorType().squash() != defs::EIGER) {
         rebootController(pos);
@@ -2757,7 +2750,7 @@ void Detector::updateDetectorServer(const std::string &fname, Positions pos) {
 
 void Detector::updateKernel(const std::string &fname, Positions pos) {
     LOG(logINFO) << "Updating Kernel...";
-    std::vector<char> buffer = readBinaryFile(fname, "Update Kernel");
+    const std::vector<char> buffer = readBinaryFile(fname, "Update Kernel");
     pimpl->Parallel(&Module::updateKernel, pos, buffer);
     rebootController(pos);
 }
@@ -2771,8 +2764,8 @@ void Detector::updateFirmwareAndServer(const std::string &sname,
                                        Positions pos) {
     LOG(logINFO) << "Updating Firmware and Detector Server (no tftp)...";
     LOG(logINFO) << "Updating Detector Server (no tftp)...";
-    std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
-    std::string filename = getFileNameFromFilePath(sname);
+    const std::vector<char> buffer = readBinaryFile(sname, "Update Detector Server");
+    const std::string filename = getFileNameFromFilePath(sname);
     pimpl->Parallel(&Module::updateDetectorServer, pos, buffer, filename);
     programFPGA(fname, false, pos);
 }
@@ -2788,78 +2781,26 @@ void Detector::setUpdateMode(const bool updatemode, Positions pos) {
     }
 }
 
-Result<RegisterValue> Detector::readRegister(RegisterAddress addr,
-                                             Positions pos) const {
-    return pimpl->readRegister(addr, pos);
-}
-
-void Detector::writeRegister(RegisterAddress addr, RegisterValue val,
-                             bool validate, Positions pos) {
-    pimpl->writeRegister(addr, val, validate, pos);
-}
-
-void Detector::setBit(BitAddress addr, bool validate, Positions pos) {
-    pimpl->setBit(addr, validate, pos);
-}
-
-void Detector::clearBit(BitAddress addr, bool validate, Positions pos) {
-    pimpl->clearBit(addr, validate, pos);
-}
-
-Result<int> Detector::getBit(BitAddress addr, Positions pos) const {
-    return pimpl->getBit(addr, pos);
-}
-
-Result<RegisterValue> Detector::readRegister(const std::string &reg_name,
-                                             Positions pos) const {
-    return pimpl->readRegister(reg_name, pos);
-}
-
-void Detector::writeRegister(const std::string &reg_name, RegisterValue val,
-                             bool validate, Positions pos) {
-    pimpl->writeRegister(reg_name, val, validate, pos);
-}
-
-void Detector::setBit(const std::string &bit_name, bool validate,
-                      Positions pos) {
-    pimpl->setBit(bit_name, validate, pos);
-}
-
-void Detector::clearBit(const std::string &bit_name, bool validate,
-                        Positions pos) {
-    pimpl->clearBit(bit_name, validate, pos);
-}
-
-Result<int> Detector::getBit(const std::string &bit_name, Positions pos) const {
-    return pimpl->getBit(bit_name, pos);
-}
-
 Result<uint32_t> Detector::readRegister(uint32_t addr, Positions pos) const {
-    auto t = pimpl->readRegister(RegisterAddress(addr), pos);
-    Result<uint32_t> res;
-    for (const auto &val : t) {
-        res.push_back(val.value());
-    }
-    return res;
+    return pimpl->Parallel(&Module::readRegister, pos, addr);
 }
 
 void Detector::writeRegister(uint32_t addr, uint32_t val, bool validate,
                              Positions pos) {
-    pimpl->writeRegister(RegisterAddress(addr), RegisterValue(val), validate,
-                         pos);
+    pimpl->Parallel(&Module::writeRegister, pos, addr, val, validate);
 }
 
 void Detector::setBit(uint32_t addr, int bitnr, bool validate, Positions pos) {
-    pimpl->setBit(BitAddress(RegisterAddress(addr), bitnr), validate, pos);
+    pimpl->Parallel(&Module::setBit, pos, addr, bitnr, validate);
 }
 
 void Detector::clearBit(uint32_t addr, int bitnr, bool validate,
                         Positions pos) {
-    pimpl->clearBit(BitAddress(RegisterAddress(addr), bitnr), validate, pos);
+    pimpl->Parallel(&Module::clearBit, pos, addr, bitnr, validate);
 }
 
-Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) const {
-    return pimpl->getBit(BitAddress(RegisterAddress(addr), bitnr), pos);
+Result<int> Detector::getBit(uint32_t addr, int bitnr, Positions pos) {
+    return pimpl->Parallel(&Module::getBit, pos, addr, bitnr);
 }
 
 void Detector::executeFirmwareTest(Positions pos) {
@@ -2940,7 +2881,7 @@ Result<ns> Detector::getMeasurementTime(Positions pos) const {
 }
 
 std::vector<uint16_t> Detector::getValidPortNumbers(uint16_t start_port) {
-    int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
+    const int num_sockets_per_detector = getNumberofUDPInterfaces({}).tsquash(
         "Number of UDP Interfaces is not consistent among modules");
 
     validatePortRange(start_port, size() * num_sockets_per_detector);
@@ -2948,7 +2889,7 @@ std::vector<uint16_t> Detector::getValidPortNumbers(uint16_t start_port) {
     std::vector<uint16_t> res;
     res.reserve(size());
     for (int idet = 0; idet < size(); ++idet) {
-        uint16_t port = start_port + (idet * num_sockets_per_detector);
+        const uint16_t port = start_port + (idet * num_sockets_per_detector);
         res.push_back(port);
     }
     return res;

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -80,10 +80,10 @@ void DetectorImpl::initSharedMemory() {
         }
         if (ctb_shm.exists()) {
             ctb_shm.openSharedMemory(true);
-            if (ctb_shm()->shmversion != CtbConfig::SHM_VERSION) {
+            if (ctb_shm()->shmversion != CTB_SHMVERSION) {
                 LOG(logERROR)
                     << "CTB shared memory version mismatch (expected 0x"
-                    << std::hex << CtbConfig::SHM_VERSION << " but got 0x"
+                    << std::hex << CTB_SHMVERSION << " but got 0x"
                     << ctb_shm()->shmversion << std::dec
                     << ". Free Shared memory to continue.";
                 ctb_shm.unmapSharedMemory();
@@ -198,11 +198,11 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
 void DetectorImpl::addModule(const std::string &name) {
     LOG(logINFO) << "Adding module " << name;
     auto host = verifyUniqueDetHost(name);
-    std::string hostname = host.first;
-    uint16_t port = host.second;
+    std::string const hostname = host.first;
+    uint16_t const port = host.second;
 
     // get type by connecting
-    detectorType type = Module::getTypeFromDetector(hostname, port);
+    detectorType const type = Module::getTypeFromDetector(hostname, port);
 
     // gotthard2 cannot have more than 2 modules (50um=1, 25um=2
     if (type == GOTTHARD2 && modules.size() > 2) {
@@ -227,7 +227,7 @@ void DetectorImpl::addModule(const std::string &name) {
     modules[pos]->updateNumberofUDPInterfaces();
 
     // update zmq port in case numudpinterfaces changed
-    int numInterfaces = modules[pos]->getNumberofUDPInterfacesFromShm();
+    int const numInterfaces = modules[pos]->getNumberofUDPInterfacesFromShm();
     modules[pos]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
                                          pos * numInterfaces);
 }
@@ -245,7 +245,7 @@ void DetectorImpl::updateDetectorSize() {
     int nModx = 0, nMody = 0;
     // 1d, add modules along x axis
     if (modSize.y == 1) {
-        int detSizeX = shm()->numberOfChannels.x;
+        int const detSizeX = shm()->numberOfChannels.x;
         int maxChanX = modSize.x * size();
         // user given detsizex used only within max value
         if (detSizeX > 1 && detSizeX <= maxChanX) {
@@ -271,7 +271,7 @@ void DetectorImpl::updateDetectorSize() {
     }
     // 2d, add modules along y axis (due to eiger top/bottom)
     else {
-        int detSizeY = shm()->numberOfChannels.y;
+        int const detSizeY = shm()->numberOfChannels.y;
         int maxChanY = modSize.y * size();
         // user given detsizey used only within max value
         if (detSizeY > 1 && detSizeY <= maxChanY) {
@@ -467,7 +467,7 @@ void DetectorImpl::createReceivingDataSockets() {
     if (shm()->detType == GOTTHARD2) {
         numUDPInterfaces = 1;
     }
-    size_t numSockets = modules.size() * numUDPInterfaces;
+    size_t const numSockets = modules.size() * numUDPInterfaces;
 
     for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
         uint32_t portnum =
@@ -481,7 +481,7 @@ void DetectorImpl::createReceivingDataSockets() {
                                            .c_str(),
                                        portnum));
             // set high water mark
-            int hwm = shm()->zmqHwm;
+            int const hwm = shm()->zmqHwm;
             if (hwm >= 0) {
                 zmqSocket[iSocket]->SetReceiveHighWaterMark(hwm);
                 // need not reconnect. cannot be connected (detector idle)
@@ -504,7 +504,7 @@ void DetectorImpl::createReceivingDataSockets() {
 
 void DetectorImpl::readFrameFromReceiver() {
 
-    bool gapPixels = shm()->gapPixels;
+    bool const gapPixels = shm()->gapPixels;
     LOG(logDEBUG) << "Gap pixels: " << gapPixels;
     int nX = 0;
     int nY = 0;
@@ -644,10 +644,10 @@ void DetectorImpl::readFrameFromReceiver() {
 
                 // creating multi image
                 {
-                    uint32_t xoffset = coordX * nPixelsX * bytesPerPixel;
-                    uint32_t yoffset = coordY * nPixelsY;
+                    uint32_t const xoffset = coordX * nPixelsX * bytesPerPixel;
+                    uint32_t const yoffset = coordY * nPixelsY;
                     uint32_t singledetrowoffset = nPixelsX * bytesPerPixel;
-                    uint32_t rowoffset = nX * singledetrowoffset;
+                    uint32_t const rowoffset = nX * singledetrowoffset;
                     if (shm()->detType == CHIPTESTBOARD ||
                         shm()->detType == defs::XILINX_CHIPTESTBOARD) {
                         singledetrowoffset = size;
@@ -694,7 +694,7 @@ void DetectorImpl::readFrameFromReceiver() {
             int nDetActualPixelsY = nDetPixelsY;
 
             if (gapPixels) {
-                int n = insertGapPixels(multiframe.get(), multigappixels,
+                int const n = insertGapPixels(multiframe.get(), multigappixels,
                                         quadEnable, dynamicRange,
                                         nDetActualPixelsX, nDetActualPixelsY);
                 callbackImage = multigappixels;
@@ -742,38 +742,38 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
                   << "\n\t quadEnable: " << quadEnable << "\n\t dr: " << dr;
 
     // inter module gap pixels
-    int modGapPixelsx = 8;
-    int modGapPixelsy = 36;
+    int const modGapPixelsx = 8;
+    int const modGapPixelsy = 36;
     // inter chip gap pixels
-    int chipGapPixelsx = 2;
-    int chipGapPixelsy = 2;
+    int const chipGapPixelsx = 2;
+    int const chipGapPixelsy = 2;
     // number of pixels in a chip
-    int nChipPixelsx = 256;
-    int nChipPixelsy = 256;
+    int const nChipPixelsx = 256;
+    int const nChipPixelsy = 256;
     // 1 module
     // number of chips in a module
     int nMod1Chipx = 4;
-    int nMod1Chipy = 2;
+    int const nMod1Chipy = 2;
     if (quadEnable) {
         nMod1Chipx = 2;
     }
     // number of pixels in a module
-    int nMod1Pixelsx = nChipPixelsx * nMod1Chipx;
-    int nMod1Pixelsy = nChipPixelsy * nMod1Chipy;
+    int const nMod1Pixelsx = nChipPixelsx * nMod1Chipx;
+    int const nMod1Pixelsy = nChipPixelsy * nMod1Chipy;
     // number of gap pixels in a module
-    int nMod1GapPixelsx = (nMod1Chipx - 1) * chipGapPixelsx;
-    int nMod1GapPixelsy = (nMod1Chipy - 1) * chipGapPixelsy;
+    int const nMod1GapPixelsx = (nMod1Chipx - 1) * chipGapPixelsx;
+    int const nMod1GapPixelsy = (nMod1Chipy - 1) * chipGapPixelsy;
     // total number of modules
-    int nModx = nPixelsx / nMod1Pixelsx;
-    int nMody = nPixelsy / nMod1Pixelsy;
+    int const nModx = nPixelsx / nMod1Pixelsx;
+    int const nMody = nPixelsy / nMod1Pixelsy;
 
     // check if not full modules
     // (setting gap pixels and then adding half module or disabling quad)
     if (nPixelsy / nMod1Pixelsy == 0) {
         LOG(logERROR) << "Gap pixels can only be enabled with full modules. "
                          "Sending dummy data without gap pixels.\n";
-        double bytesPerPixel = (double)dr / 8.00;
-        int imagesize = nPixelsy * nPixelsx * bytesPerPixel;
+        double const bytesPerPixel = (double)dr / 8.00;
+        int const imagesize = nPixelsy * nPixelsx * bytesPerPixel;
         if (gpImage == nullptr) {
             gpImage = new char[imagesize];
         }
@@ -782,28 +782,28 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
     }
 
     // total number of pixels
-    int nTotx =
+    int const nTotx =
         nPixelsx + (nMod1GapPixelsx * nModx) + (modGapPixelsx * (nModx - 1));
-    int nToty =
+    int const nToty =
         nPixelsy + (nMod1GapPixelsy * nMody) + (modGapPixelsy * (nMody - 1));
     // total number of chips
-    int nChipx = nPixelsx / nChipPixelsx;
-    int nChipy = nPixelsy / nChipPixelsy;
+    int const nChipx = nPixelsx / nChipPixelsx;
+    int const nChipy = nPixelsy / nChipPixelsy;
 
-    double bytesPerPixel = (double)dr / 8.00;
-    int imagesize = nTotx * nToty * bytesPerPixel;
+    double const bytesPerPixel = (double)dr / 8.00;
+    int const imagesize = nTotx * nToty * bytesPerPixel;
 
-    int nChipBytesx = nChipPixelsx * bytesPerPixel;         // 1 chip bytes in x
-    int nChipGapBytesx = chipGapPixelsx * bytesPerPixel;    // 2 pixel bytes
-    int nModGapBytesx = modGapPixelsx * bytesPerPixel;      // 8 pixel bytes
-    int nChipBytesy = nChipPixelsy * nTotx * bytesPerPixel; // 1 chip bytes in y
-    int nChipGapBytesy = chipGapPixelsy * nTotx * bytesPerPixel; // 2 lines
-    int nModGapBytesy = modGapPixelsy * nTotx *
+    int const nChipBytesx = nChipPixelsx * bytesPerPixel;         // 1 chip bytes in x
+    int const nChipGapBytesx = chipGapPixelsx * bytesPerPixel;    // 2 pixel bytes
+    int const nModGapBytesx = modGapPixelsx * bytesPerPixel;      // 8 pixel bytes
+    int const nChipBytesy = nChipPixelsy * nTotx * bytesPerPixel; // 1 chip bytes in y
+    int const nChipGapBytesy = chipGapPixelsy * nTotx * bytesPerPixel; // 2 lines
+    int const nModGapBytesy = modGapPixelsy * nTotx *
                         bytesPerPixel; // 36 lines
                                        // 4 bit mode, its 1 byte (because for 4
                                        // bit mode, we handle 1 byte at a time)
-    int pixel1 = (int)(ceil(bytesPerPixel));
-    int row1Bytes = nTotx * bytesPerPixel;
+    int const pixel1 = (int)(ceil(bytesPerPixel));
+    int const row1Bytes = nTotx * bytesPerPixel;
     int nMod1TotPixelsx = nMod1Pixelsx + nMod1GapPixelsx;
     if (dr == 4) {
         nMod1TotPixelsx /= 2;
@@ -811,7 +811,7 @@ int DetectorImpl::insertGapPixels(char *image, char *&gpImage, bool quadEnable,
     // eiger requires inter chip gap pixels are halved
     // jungfrau/moench prefers same inter chip gap pixels as the boundary pixels
     int divisionValue = 2;
-    slsDetectorDefs::detectorType detType = shm()->detType;
+    slsDetectorDefs::detectorType const detType = shm()->detType;
     if (detType == JUNGFRAU || detType == MOENCH) {
         divisionValue = 1;
     }
@@ -1053,7 +1053,7 @@ int DetectorImpl::getClientStreamingHwm() const {
     for (auto &it : zmqSocket) {
         result.push_back(it->GetReceiveHighWaterMark());
     }
-    int res = result.tsquash("Inconsistent zmq receive hwm values");
+    int const res = result.tsquash("Inconsistent zmq receive hwm values");
     return res;
 }
 
@@ -1110,7 +1110,7 @@ int DetectorImpl::acquire() {
         struct timespec begin, end;
         clock_gettime(CLOCK_REALTIME, &begin);
 
-        bool receiver = Parallel(&Module::getUseReceiverFlag, {}).squash(false);
+        bool const receiver = Parallel(&Module::getUseReceiverFlag, {}).squash(false);
 
         if (dataReady == nullptr) {
             setJoinThreadFlag(false);
@@ -1172,7 +1172,7 @@ int DetectorImpl::acquire() {
 
             // progress
             auto a = Parallel(&Module::getReceiverProgress, {});
-            double progress = (*std::max_element(a.begin(), a.end()));
+            double const progress = (*std::max_element(a.begin(), a.end()));
 
             // callback
             acquisition_finished(progress, static_cast<int>(status),
@@ -1340,7 +1340,7 @@ void DetectorImpl::processData(bool receiver) {
                     }
                 }
                 // get and print progress
-                double temp =
+                double const temp =
                     (double)Parallel(&Module::getReceiverProgress, {0})
                         .squash();
                 if (temp != progress) {
@@ -1365,12 +1365,12 @@ void DetectorImpl::processData(bool receiver) {
 }
 
 bool DetectorImpl::getJoinThreadFlag() const {
-    std::lock_guard<std::mutex> lock(mp);
+    std::lock_guard<std::mutex> const lock(mp);
     return jointhread;
 }
 
 void DetectorImpl::setJoinThreadFlag(bool value) {
-    std::lock_guard<std::mutex> lock(mp);
+    std::lock_guard<std::mutex> const lock(mp);
     jointhread = value;
 }
 
@@ -1430,11 +1430,11 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
     }
 
     // get srcSize to print progress
-    ssize_t srcSize = getFileSize(src, "Program FPGA");
+    ssize_t const srcSize = getFileSize(src, "Program FPGA");
 
     // create temp destination file
     char destfname[] = "/tmp/SLS_DET_MCB.XXXXXX";
-    int dst = mkstemp(destfname); // create temporary file and open it in r/w
+    int const dst = mkstemp(destfname); // create temporary file and open it in r/w
     if (dst == -1) {
         fclose(src);
         throw RuntimeError(std::string("Could not create destination file "
@@ -1466,7 +1466,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
         int oldProgress = 0;
         while (!feof(src)) {
             // print progress
-            int progress = (int)(((double)(dstFilePos) / srcSize) * 100);
+            int const progress = (int)(((double)(dstFilePos) / srcSize) * 100);
             if (oldProgress != progress) {
                 printf("%d%%\r", progress);
                 fflush(stdout);
@@ -1477,7 +1477,7 @@ std::vector<char> DetectorImpl::readProgrammingFile(const std::string &fname) {
                 break;
             }
             // read source
-            int s = fgetc(src);
+            int const s = fgetc(src);
             if (s < 0) {
                 break;
             }
@@ -1547,13 +1547,13 @@ DetectorImpl::verifyUniqueDetHost(const std::string &name) {
     // extract port
     // C++17 could be auto [hostname, port] = ParseHostPort(name);
     auto res = ParseHostPort(name);
-    std::string hostname = res.first;
+    std::string const hostname = res.first;
     uint16_t port = res.second;
     if (port == 0) {
         port = DEFAULT_TCP_CNTRL_PORTNO;
     }
 
-    int detSize = size();
+    int const detSize = size();
     // mod not yet added
     std::vector<std::pair<std::string, uint16_t>> hosts(detSize + 1);
     hosts[detSize].first = hostname;
@@ -1573,8 +1573,8 @@ DetectorImpl::verifyUniqueRxHost(const std::string &name,
     // extract port
     // C++17 could be auto [hostname, port] = ParseHostPort(name);
     auto res = ParseHostPort(name);
-    std::string hostname = res.first;
-    uint16_t port = res.second;
+    std::string const hostname = res.first;
+    uint16_t const port = res.second;
 
     // hostname and port for given positions
     if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
@@ -1669,7 +1669,7 @@ void DetectorImpl::validateROIs(const std::vector<defs::ROI> &rois) {
         if (roi.noRoi()) {
             throw RuntimeError("Invalid Roi of size 0. Roi: " + ToString(roi));
         }
-        bool is2D = (modules[0]->getNumberOfChannels().y > 1 ? true : false);
+        bool const is2D = (modules[0]->getNumberOfChannels().y > 1 ? true : false);
         if (roi.completeRoi()) {
             std::ostringstream oss;
             oss << "Did you mean the clear roi command (API: clearRxROI, cmd: "
@@ -1730,9 +1730,9 @@ defs::xy DetectorImpl::getPortGeometry() const {
 }
 
 defs::xy DetectorImpl::calculatePosition(int moduleIndex) const {
-    int maxYMods = shm()->numberOfModules.y;
-    int y = (moduleIndex % maxYMods);
-    int x = (moduleIndex / maxYMods);
+    int const maxYMods = shm()->numberOfModules.y;
+    int const y = (moduleIndex % maxYMods);
+    int const x = (moduleIndex / maxYMods);
     return defs::xy{x, y};
 }
 
@@ -1771,13 +1771,13 @@ void DetectorImpl::convertGlobalRoiToPortLevel(
         defs::ROI portRoi = moduleRoi;
         // Recalculate port ROI boundaries (split vertically or horizontally)
         if (portGeometry.x == 2) {
-            int midX = (moduleRoi.xmin + moduleRoi.xmax) / 2;
+            int const midX = (moduleRoi.xmin + moduleRoi.xmax) / 2;
             if (port == 0)
                 portRoi.xmax = midX;
             else
                 portRoi.xmin = midX + 1;
         } else if (portGeometry.y == 2) {
-            int midY = (moduleRoi.ymin + moduleRoi.ymax) / 2;
+            int const midY = (moduleRoi.ymin + moduleRoi.ymax) / 2;
             if (port == 0)
                 portRoi.ymax = midY;
             else
@@ -1823,7 +1823,7 @@ void DetectorImpl::setRxROI(const std::vector<defs::ROI> &args) {
     }
 
     validateROIs(args);
-    int nPortsPerModule =
+    int const nPortsPerModule =
         Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
             .tsquash("Inconsistent number of udp ports set up per module");
 
@@ -1845,7 +1845,7 @@ void DetectorImpl::setRxROI(const std::vector<defs::ROI> &args) {
 }
 
 void DetectorImpl::clearRxROI() {
-    int nPortsPerModule =
+    int const nPortsPerModule =
         Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
             .tsquash("Inconsistent number of udp ports set up per module");
     for (size_t iModule = 0; iModule < modules.size(); ++iModule) {
@@ -1890,7 +1890,7 @@ void DetectorImpl::getBadChannels(const std::string &fname,
 }
 
 void DetectorImpl::setBadChannels(const std::string &fname, Positions pos) {
-    std::vector<int> list = sls::getChannelsFromFile(fname);
+    std::vector<int> const list = sls::getChannelsFromFile(fname);
     if (list.empty()) {
         throw RuntimeError("Bad channel file is empty.");
     }
@@ -1913,8 +1913,8 @@ void DetectorImpl::setBadChannels(const std::vector<int> list, Positions pos) {
                                    std::to_string(badchannel) +
                                    " out of bounds.");
             }
-            int ch = badchannel % nchan;
-            size_t imod = badchannel / nchan;
+            int const ch = badchannel % nchan;
+            size_t const imod = badchannel / nchan;
             if (imod >= modules.size()) {
                 throw RuntimeError("Invalid bad channel list. " +
                                    std::to_string(badchannel) +
@@ -1935,317 +1935,86 @@ void DetectorImpl::setBadChannels(const std::vector<int> list, Positions pos) {
 }
 
 std::vector<std::string> DetectorImpl::getCtbDacNames() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named DACs only for CTB");
     return ctb_shm()->getDacNames();
 }
 
 void DetectorImpl::setCtbDacNames(const std::vector<std::string> &names) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named DACs only for CTB");
     ctb_shm()->setDacNames(names);
 }
 
 std::string DetectorImpl::getCtbDacName(defs::dacIndex i) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named DACs only for CTB");
     return ctb_shm()->getDacName(static_cast<int>(i));
 }
 
 void DetectorImpl::setCtbDacName(const defs::dacIndex index,
                                  const std::string &name) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named DACs only for CTB");
     ctb_shm()->setDacName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbAdcNames() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named ADCs only for CTB");
     return ctb_shm()->getAdcNames();
 }
 
 void DetectorImpl::setCtbAdcNames(const std::vector<std::string> &names) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named ADCs only for CTB");
     ctb_shm()->setAdcNames(names);
 }
 
 std::string DetectorImpl::getCtbAdcName(const int i) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named ADCs only for CTB");
     return ctb_shm()->getAdcName(i);
 }
 
 void DetectorImpl::setCtbAdcName(const int index, const std::string &name) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named ADCs only for CTB");
     ctb_shm()->setAdcName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbSignalNames() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named signals only for CTB");
     return ctb_shm()->getSignalNames();
 }
 
 void DetectorImpl::setCtbSignalNames(const std::vector<std::string> &names) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named signals only for CTB");
     ctb_shm()->setSignalNames(names);
 }
 
 std::string DetectorImpl::getCtbSignalName(const int i) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named signals only for CTB");
     return ctb_shm()->getSignalName(i);
 }
 
 void DetectorImpl::setCtbSignalName(const int index, const std::string &name) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named signals only for CTB");
     ctb_shm()->setSignalName(index, name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbPowerNames() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Powers only for CTB");
     return ctb_shm()->getPowerNames();
 }
 
 void DetectorImpl::setCtbPowerNames(const std::vector<std::string> &names) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Powers only for CTB");
     ctb_shm()->setPowerNames(names);
 }
 
 std::string DetectorImpl::getCtbPowerName(const defs::dacIndex i) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Powers only for CTB");
     return ctb_shm()->getPowerName(static_cast<int>(i - defs::V_POWER_A));
 }
 
 void DetectorImpl::setCtbPowerName(const defs::dacIndex index,
                                    const std::string &name) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Powers only for CTB");
     ctb_shm()->setPowerName(static_cast<int>(index - defs::V_POWER_A), name);
 }
 
 std::vector<std::string> DetectorImpl::getCtbSlowADCNames() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Slow ADCs only for CTB");
     return ctb_shm()->getSlowADCNames();
 }
 
 void DetectorImpl::setCtbSlowADCNames(const std::vector<std::string> &names) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Slow ADCs only for CTB");
     ctb_shm()->setSlowADCNames(names);
 }
 
 std::string DetectorImpl::getCtbSlowADCName(const defs::dacIndex i) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Slow ADCs only for CTB");
     return ctb_shm()->getSlowADCName(static_cast<int>(i - defs::SLOW_ADC0));
 }
 
 void DetectorImpl::setCtbSlowADCName(const defs::dacIndex index,
                                      const std::string &name) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Named Slow ADCs only for CTB");
     ctb_shm()->setSlowADCName(static_cast<int>(index - defs::SLOW_ADC0), name);
 }
 
-int DetectorImpl::getRegisterDefinitionsCount() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->getRegisterNamesCount();
-}
-
-void DetectorImpl::setRegisterDefinition(const std::string &name,
-                                         RegisterAddress addr) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    ctb_shm()->setRegisterName(name, addr);
-}
-
-bool DetectorImpl::hasRegisterDefinition(const std::string &name) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->hasRegisterName(name);
-}
-
-bool DetectorImpl::hasRegisterDefinition(RegisterAddress addr) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->hasRegisterAddress(addr);
-}
-
-RegisterAddress
-DetectorImpl::getRegisterAddress(const std::string &name) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->getRegisterAddress(name);
-}
-
-std::string DetectorImpl::getRegisterName(RegisterAddress addr) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->getRegisterName(addr);
-}
-
-void DetectorImpl::clearRegisterDefinitions() {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    ctb_shm()->clearRegisterNames();
-}
-
-void DetectorImpl::setRegisterDefinitions(
-    const std::map<std::string, RegisterAddress> &list) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    ctb_shm()->setRegisterNames(list);
-}
-
-std::map<std::string, RegisterAddress>
-DetectorImpl::getRegisterDefinitions() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Register Definitions only for CTB");
-    return ctb_shm()->getRegisterNames();
-}
-
-int DetectorImpl::getBitDefinitionsCount() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->getBitNamesCount();
-}
-
-void DetectorImpl::setBitDefinition(const std::string &name, BitAddress addr) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    ctb_shm()->setBitName(name, addr);
-}
-
-bool DetectorImpl::hasBitDefinition(const std::string &name) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->hasBitName(name);
-}
-
-bool DetectorImpl::hasBitDefinition(BitAddress addr) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->hasBitAddress(addr);
-}
-
-std::string DetectorImpl::toRegisterNameBitString(BitAddress addr) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->toRegisterNameBitString(addr);
-}
-
-BitAddress DetectorImpl::getBitAddress(const std::string &name) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->getBitAddress(name);
-}
-
-std::string DetectorImpl::getBitName(BitAddress addr) const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->getBitName(addr);
-}
-
-void DetectorImpl::clearBitDefinitions() {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    ctb_shm()->clearBitNames();
-}
-
-void DetectorImpl::setBitDefinitions(
-    const std::map<std::string, BitAddress> &list) {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    ctb_shm()->setBitNames(list);
-}
-
-std::map<std::string, BitAddress> DetectorImpl::getBitDefinitions() const {
-    if (!isChipTestBoard())
-        throw RuntimeError("Bit Definitions only for CTB");
-    return ctb_shm()->getBitNames();
-}
-
-Result<RegisterValue> DetectorImpl::readRegister(const std::string &reg_name,
-                                                 Positions pos) const {
-    if (!isChipTestBoard()) {
-        throw RuntimeError("Register Definitions only for CTB. Use hard coded "
-                           "values instead.");
-    }
-    auto addr = getRegisterAddress(reg_name);
-    return readRegister(addr, pos);
-}
-
-void DetectorImpl::writeRegister(const std::string &reg_name, RegisterValue val,
-                                 bool validate, Positions pos) {
-    if (!isChipTestBoard()) {
-        throw RuntimeError("Register Definitions only for CTB. Use hard coded "
-                           "values instead.");
-    }
-    auto addr = getRegisterAddress(reg_name);
-    writeRegister(addr, val, validate, pos);
-}
-
-void DetectorImpl::setBit(const std::string &bit_name, bool validate,
-                          Positions pos) {
-    if (!isChipTestBoard()) {
-        throw RuntimeError(
-            "Bit Definitions only for CTB. Use hard coded values instead.");
-    }
-    auto addr = getBitAddress(bit_name);
-    setBit(addr, validate, pos);
-}
-
-void DetectorImpl::clearBit(const std::string &bit_name, bool validate,
-                            Positions pos) {
-    if (!isChipTestBoard()) {
-        throw RuntimeError(
-            "Bit Definitions only for CTB. Use hard coded values instead.");
-    }
-    auto addr = getBitAddress(bit_name);
-    clearBit(addr, validate, pos);
-}
-
-Result<int> DetectorImpl::getBit(const std::string &bit_name,
-                                 Positions pos) const {
-    if (!isChipTestBoard()) {
-        throw RuntimeError(
-            "Bit Definitions only for CTB. Use hard coded values instead.");
-    }
-    auto addr = getBitAddress(bit_name);
-    return getBit(addr, pos);
-}
-
-Result<RegisterValue> DetectorImpl::readRegister(RegisterAddress addr,
-                                                 Positions pos) const {
-    return Parallel(&Module::readRegister, pos, addr);
-}
-
-void DetectorImpl::writeRegister(RegisterAddress addr, RegisterValue val,
-                                 bool validate, Positions pos) {
-    Parallel(&Module::writeRegister, pos, addr, val, validate);
-}
-
-void DetectorImpl::setBit(BitAddress addr, bool validate, Positions pos) {
-    Parallel(&Module::setBit, pos, addr, validate);
-}
-
-void DetectorImpl::clearBit(BitAddress addr, bool validate, Positions pos) {
-    Parallel(&Module::clearBit, pos, addr, validate);
-}
-
-Result<int> DetectorImpl::getBit(BitAddress addr, Positions pos) const {
-    return Parallel(&Module::getBit, pos, addr);
-}
-
 } // namespace sls

slsDetectorSoftware/src/DetectorImpl.h

@@ -90,7 +90,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<RT>> futures;
         futures.reserve(positions.size());
-        for (size_t i : positions) {
+        for (const size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -118,7 +118,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<RT>> futures;
         futures.reserve(positions.size());
-        for (size_t i : positions) {
+        for (const size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -145,7 +145,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<void>> futures;
         futures.reserve(positions.size());
-        for (size_t i : positions) {
+        for (const size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -170,7 +170,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
         }
         std::vector<std::future<void>> futures;
         futures.reserve(positions.size());
-        for (size_t i : positions) {
+        for (const size_t i : positions) {
             if (i >= modules.size())
                 throw RuntimeError("Module out of range");
             futures.push_back(std::async(std::launch::async, somefunc,
@@ -183,11 +183,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     bool isAllPositions(Positions pos) const;
 
-    inline bool isChipTestBoard() const {
-        return (shm()->detType == defs::CHIPTESTBOARD ||
-                shm()->detType == defs::XILINX_CHIPTESTBOARD);
-    }
-
     /** set acquiring flag in shared memory */
     void setAcquiringFlag(bool flag);
 
@@ -333,43 +328,6 @@ class DetectorImpl : public virtual slsDetectorDefs {
     void setCtbSlowADCNames(const std::vector<std::string> &names);
     void setCtbSlowADCName(const defs::dacIndex index, const std::string &name);
 
-    int getRegisterDefinitionsCount() const;
-    void setRegisterDefinition(const std::string &name, RegisterAddress addr);
-    bool hasRegisterDefinition(const std::string &name) const;
-    bool hasRegisterDefinition(RegisterAddress addr) const;
-    RegisterAddress getRegisterAddress(const std::string &name) const;
-    std::string getRegisterName(RegisterAddress addr) const;
-    void clearRegisterDefinitions();
-    void
-    setRegisterDefinitions(const std::map<std::string, RegisterAddress> &list);
-    std::map<std::string, RegisterAddress> getRegisterDefinitions() const;
-    int getBitDefinitionsCount() const;
-    void setBitDefinition(const std::string &name, BitAddress addr);
-    bool hasBitDefinition(const std::string &name) const;
-    bool hasBitDefinition(BitAddress addr) const;
-    std::string toRegisterNameBitString(BitAddress addr) const;
-    BitAddress getBitAddress(const std::string &name) const;
-    std::string getBitName(BitAddress addr) const;
-    void clearBitDefinitions();
-    void setBitDefinitions(const std::map<std::string, BitAddress> &list);
-    std::map<std::string, BitAddress> getBitDefinitions() const;
-
-    Result<RegisterValue> readRegister(const std::string &reg_name,
-                                       Positions pos) const;
-    void writeRegister(const std::string &reg_name, RegisterValue val,
-                       bool validate, Positions pos);
-    void setBit(const std::string &bit_name, bool validate, Positions pos);
-    void clearBit(const std::string &bit_name, bool validate, Positions pos);
-    Result<int> getBit(const std::string &bit_name, Positions pos) const;
-
-    Result<RegisterValue> readRegister(RegisterAddress addr,
-                                       Positions pos = {}) const;
-    void writeRegister(RegisterAddress addr, RegisterValue val,
-                       bool validate = false, Positions pos = {});
-    void setBit(BitAddress addr, bool validate = false, Positions pos = {});
-    void clearBit(BitAddress addr, bool validate = false, Positions pos = {});
-    Result<int> getBit(BitAddress addr, Positions pos = {}) const;
-
   private:
     /**
      * Creates/open shared memory, initializes detector structure and members

slsDetectorSoftware/src/MapOnStack.h

@@ -1,218 +0,0 @@
-#pragma once
-
-// #include "sls/StaticVector.h"
-#include "sls/string_utils.h"
-
-#include <algorithm>
-#include <map>
-#include <optional>
-#include <stdexcept>
-#include <string>
-
-namespace sls {
-
-template <size_t N> struct FixedString {
-    char data_[N]{};
-    constexpr FixedString() noexcept { memset(data_, 0, N); }
-    FixedString(const char (&s)[N]) {
-        if (N <= 1) {
-            throw std::runtime_error("FixedString cannot be empty");
-        }
-        strcpy_checked<N>(data_, s);
-    }
-    FixedString(const std::string &s) {
-        if (s.size() <= 1) {
-            throw std::runtime_error("FixedString cannot be empty");
-        }
-        strcpy_checked<N>(data_, s);
-    }
-    bool operator==(const FixedString &other) const noexcept {
-        return std::strncmp(data_, other.data_, N) == 0;
-    }
-    bool operator<(const FixedString &other) const noexcept {
-        return std::strncmp(data_, other.data_, N) < 0;
-    }
-    std::string str() const { return std::string(data_); }
-};
-
-template <typename Key, typename Value, size_t Capacity, bool Unique_Values>
-
-class MapOnStack {
-    // for shared memory use only trivially copyable types
-    static_assert(std::is_trivially_copyable_v<Key>);
-    static_assert(std::is_trivially_copyable_v<Value>);
-    static_assert(std::is_standard_layout_v<Key>);
-    static_assert(std::is_standard_layout_v<Value>);
-    static_assert(!std::is_pointer_v<Key>);
-    static_assert(!std::is_pointer_v<Value>);
-
-  public:
-    constexpr MapOnStack() noexcept = default;
-
-    constexpr size_t size() const noexcept { return current_size_; }
-    constexpr size_t capacity() const noexcept { return Capacity; }
-    constexpr bool empty() const noexcept { return current_size_ == 0; }
-    void clear() noexcept { current_size_ = 0; }
-
-    bool containsKey(const Key &key) const {
-        return lookupEntryByKey(key).has_value();
-    }
-
-    bool hasValue(const Value &value) const {
-        return lookupEntryByValue(value).has_value();
-    }
-
-    void addKeyOrSetValue(const Key &key, const Value &value) {
-        if (auto entry = findEntryByKey(key)) {
-            (*entry)->setValue(value);
-            return;
-        }
-        addEntry(key, value);
-    }
-
-    void addKey(const Key &key, const Value &value) { addEntry(key, value); }
-
-    void setValue(const Key &key, const Value &value) {
-        if (auto entry = findEntryByKey(key)) {
-            (*entry)->setValue(value);
-            return;
-        }
-        throw std::runtime_error("Key not found. Cannot set value.");
-    }
-
-    Value getValue(const Key &key) const {
-        auto val = lookupEntryByKey(key);
-        if (!val.has_value()) {
-            throw std::runtime_error("No entry found for key");
-        }
-        return val.value();
-    }
-
-    Key getKey(const Value &value) const {
-        auto key = lookupEntryByValue(value);
-        if (!key.has_value()) {
-            throw std::runtime_error("No entry found for value");
-        }
-        return key.value();
-    }
-
-    void setMap(const std::map<Key, Value> &list) {
-        if (list.size() >= Capacity) {
-            throw std::runtime_error("List size exceeds maximum Capacity");
-        }
-        clear();
-        for (const auto &[key, value] : list) {
-            addEntry(key, value);
-        }
-    }
-
-    std::map<Key, Value> getMap() const {
-        std::map<Key, Value> list;
-        for (size_t i = 0; i != current_size_; ++i)
-            list[data_[i].key()] = data_[i].value();
-        return list;
-    }
-
-  private:
-    struct Entry {
-        Key key_{};
-        Value value_{};
-        constexpr Entry() noexcept = default;
-        constexpr Entry(const Key &key, const Value &value)
-            : key_(key), value_(value) {}
-        constexpr Key key() const noexcept { return key_; }
-        constexpr Value value() const noexcept { return value_; }
-        constexpr void setValue(Value value) noexcept { value_ = value; }
-    };
-
-    Entry data_[Capacity];
-    size_t current_size_{0};
-    // StaticVector<Entry, Capacity> entries_;
-
-    std::optional<Entry *> findEntryByKey(const Key &key) {
-        auto it = std::find_if(data_, data_ + current_size_,
-                               [&key](Entry &e) { return (e.key() == key); });
-        if (it != data_ + current_size_)
-            return it;
-        return std::nullopt;
-    }
-
-    std::optional<const Entry *> findEntryByKey(const Key &key) const {
-        auto it =
-            std::find_if(data_, data_ + current_size_,
-                         [&key](const Entry &e) { return (e.key() == key); });
-        if (it != data_ + current_size_)
-            return it;
-        return std::nullopt;
-    }
-
-    std::optional<Entry *> findEntryByValue(Value value) {
-        if (!Unique_Values) {
-            throw std::runtime_error(
-                "Cannot lookup by value when unique values are not enforced.");
-        }
-        auto it =
-            std::find_if(data_, data_ + current_size_,
-                         [&value](Entry &e) { return e.value() == value; });
-        if (it != data_ + current_size_)
-            return it;
-        return std::nullopt;
-    }
-
-    std::optional<const Entry *> findEntryByValue(Value value) const {
-        if (!Unique_Values) {
-            throw std::runtime_error(
-                "Cannot lookup by value when unique values are not enforced.");
-        }
-        auto it = std::find_if(
-            data_, data_ + current_size_,
-            [&value](const Entry &e) { return e.value() == value; });
-        if (it != data_ + current_size_)
-            return it;
-        return std::nullopt;
-    }
-
-    std::optional<const Value> lookupEntryByKey(const Key &key) const {
-        auto entry = findEntryByKey(key);
-        return (entry ? std::optional<Value>((*entry)->value()) : std::nullopt);
-    }
-
-    std::optional<Key> lookupEntryByValue(Value value) const {
-        auto entry = findEntryByValue(value);
-        return (entry ? std::optional<Key>((*entry)->key()) : std::nullopt);
-    }
-
-    void checkDuplicateKey(const Key &key) const {
-        if (auto entry = findEntryByKey(key)) {
-            throw std::runtime_error(
-                "Key already exists. Cannot have duplicate keys.");
-        }
-    }
-
-    void checkDuplicateValue(Value value) const {
-        if (Unique_Values) {
-            if (auto entry = findEntryByValue(value)) {
-                throw std::runtime_error(
-                    "Value already assigned to another key '" +
-                    (*entry)->key().str() + "'. Cannot assign it again.");
-            }
-        }
-    }
-
-    void checkSize() const {
-        if (current_size_ >= Capacity) {
-            throw std::runtime_error("Maximum capacity reached");
-        }
-    }
-
-    void addEntry(const Key &key, const Value &value) {
-        checkSize();
-        checkDuplicateKey(key);
-        checkDuplicateValue(value);
-
-        data_[current_size_] = Entry(key, value);
-        ++(current_size_);
-    }
-};
-
-} // namespace sls

slsDetectorSoftware/src/Module.cpp

@@ -86,7 +86,7 @@ std::string Module::getControlServerLongVersion() const {
     }
     // throw with old server version (sends 8 bytes)
     catch (RuntimeError &e) {
-        std::string emsg = std::string(e.what());
+        std::string const emsg = std::string(e.what());
         if (emsg.find(F_GET_SERVER_VERSION) && emsg.find("8 bytes")) {
             throwDeprecatedServerVersion();
         }
@@ -95,7 +95,7 @@ std::string Module::getControlServerLongVersion() const {
 }
 
 void Module::throwDeprecatedServerVersion() const {
-    uint64_t res = sendToDetectorStop<int64_t>(F_GET_SERVER_VERSION);
+    uint64_t const res = sendToDetectorStop<int64_t>(F_GET_SERVER_VERSION);
     std::cout << std::endl;
     std::ostringstream os;
     os << "Detector Server (Control) version (0x" << std::hex << res
@@ -110,7 +110,7 @@ std::string Module::getStopServerLongVersion() const {
 }
 
 std::string Module::getDetectorServerVersion() const {
-    Version v(getControlServerLongVersion());
+    Version const v(getControlServerLongVersion());
     return v.concise();
 }
 
@@ -139,7 +139,7 @@ std::string Module::getReceiverLongVersion() const {
 }
 
 std::string Module::getReceiverSoftwareVersion() const {
-    Version v(getReceiverLongVersion());
+    Version const v(getReceiverLongVersion());
     return v.concise();
 }
 
@@ -183,7 +183,7 @@ slsDetectorDefs::xy Module::getNumberOfChannels() const {
 
 void Module::updateNumberOfModule(slsDetectorDefs::xy det) {
     shm()->numberOfModule = det;
-    int args[2] = {shm()->numberOfModule.y, moduleIndex};
+    int const args[2] = {shm()->numberOfModule.y, moduleIndex};
     sendToDetector(F_SET_POSITION, args, nullptr);
 }
 
@@ -218,14 +218,14 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
         throw RuntimeError("This energy " + std::to_string(e_eV) +
                            " not defined for this module!");
     }
-    bool interpolate =
+    bool const interpolate =
         std::all_of(shm()->trimEnergies.begin(), shm()->trimEnergies.end(),
                     [e_eV](const int &e) { return e != e_eV; });
 
     sls_detector_module myMod{shm()->detType};
 
     if (!interpolate) {
-        std::string settingsfname = getTrimbitFilename(isettings, e_eV);
+        std::string const settingsfname = getTrimbitFilename(isettings, e_eV);
         LOG(logDEBUG1) << "Settings File is " << settingsfname;
         myMod = readSettingsFile(settingsfname, trimbits);
     } else {
@@ -238,8 +238,8 @@ void Module::setThresholdEnergy(int e_eV, detectorSettings isettings,
                 break;
             }
         }
-        std::string settingsfname1 = getTrimbitFilename(isettings, trim1);
-        std::string settingsfname2 = getTrimbitFilename(isettings, trim2);
+        std::string const settingsfname1 = getTrimbitFilename(isettings, trim1);
+        std::string const settingsfname2 = getTrimbitFilename(isettings, trim2);
         LOG(logDEBUG1) << "Settings Files are " << settingsfname1 << " and "
                        << settingsfname2;
         auto myMod1 = readSettingsFile(settingsfname1, trimbits);
@@ -291,17 +291,17 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
     std::vector<sls_detector_module> myMods;
     for (size_t i = 0; i < energy.size(); ++i) {
         if (energy[i] == -1) {
-            sls_detector_module mod = getModule();
+            sls_detector_module const mod = getModule();
             myMods.push_back(mod);
             continue;
         }
 
-        sls_detector_module mod{shm()->detType};
+        sls_detector_module const mod{shm()->detType};
         myMods.push_back(mod);
 
         // don't interpolate
         if (shm()->trimEnergies.anyEqualTo(energy[i])) {
-            std::string settingsfname =
+            std::string const settingsfname =
                 getTrimbitFilename(isettings, energy[i]);
             LOG(logDEBUG1) << "Settings File is " << settingsfname;
             myMods[i] = readSettingsFile(settingsfname, trimbits);
@@ -335,8 +335,8 @@ void Module::setAllThresholdEnergy(std::array<int, 3> e_eV,
             LOG(logINFO) << "e_eV:" << energy[i] << " [" << trim1 << ", "
                          << trim2 << "]";
 
-            std::string settingsfname1 = getTrimbitFilename(isettings, trim1);
-            std::string settingsfname2 = getTrimbitFilename(isettings, trim2);
+            std::string const settingsfname1 = getTrimbitFilename(isettings, trim1);
+            std::string const settingsfname2 = getTrimbitFilename(isettings, trim2);
             LOG(logDEBUG1) << "Settings Files are " << settingsfname1 << " and "
                            << settingsfname2;
             auto myMod1 = readSettingsFile(settingsfname1, trimbits);
@@ -755,17 +755,17 @@ int Module::getClockDivider(int clkIndex) const {
 }
 
 void Module::setClockDivider(int clkIndex, int value) {
-    int args[]{clkIndex, value};
+    int const args[]{clkIndex, value};
     sendToDetector(F_SET_CLOCK_DIVIDER, args, nullptr);
 }
 
 int Module::getClockPhase(int clkIndex, bool inDegrees) const {
-    int args[]{clkIndex, static_cast<int>(inDegrees)};
+    int const args[]{clkIndex, static_cast<int>(inDegrees)};
     return sendToDetector<int>(F_GET_CLOCK_PHASE, args);
 }
 
 void Module::setClockPhase(int clkIndex, int value, bool inDegrees) {
-    int args[]{clkIndex, value, static_cast<int>(inDegrees)};
+    int const args[]{clkIndex, value, static_cast<int>(inDegrees)};
     sendToDetector(F_SET_CLOCK_PHASE, args, nullptr);
 }
 
@@ -778,22 +778,22 @@ int Module::getClockFrequency(int clkIndex) const {
 }
 
 void Module::setClockFrequency(int clkIndex, int value) {
-    int args[]{clkIndex, value};
+    int const args[]{clkIndex, value};
     sendToDetector(F_SET_CLOCK_FREQUENCY, args, nullptr);
 }
 
 int Module::getDAC(dacIndex index, bool mV) const {
-    int args[]{static_cast<int>(index), static_cast<int>(mV), GET_FLAG};
+    int const args[]{static_cast<int>(index), static_cast<int>(mV), GET_FLAG};
     return sendToDetector<int>(F_SET_DAC, args);
 }
 int Module::getDefaultDac(slsDetectorDefs::dacIndex index,
                           slsDetectorDefs::detectorSettings sett) {
-    int args[]{static_cast<int>(index), static_cast<int>(sett)};
+    int const args[]{static_cast<int>(index), static_cast<int>(sett)};
     return sendToDetector<int>(F_GET_DEFAULT_DAC, args);
 }
 void Module::setDefaultDac(slsDetectorDefs::dacIndex index, int defaultValue,
                            defs::detectorSettings sett) {
-    int args[]{static_cast<int>(index), static_cast<int>(sett), defaultValue};
+    int const args[]{static_cast<int>(index), static_cast<int>(sett), defaultValue};
     return sendToDetector(F_SET_DEFAULT_DAC, args, nullptr);
 }
 
@@ -803,7 +803,7 @@ void Module::resetToDefaultDacs(const bool hardReset) {
 }
 
 void Module::setDAC(int val, dacIndex index, bool mV) {
-    int args[]{static_cast<int>(index), static_cast<int>(mV), val};
+    int const args[]{static_cast<int>(index), static_cast<int>(mV), val};
     sendToDetector<int>(F_SET_DAC, args);
 }
 
@@ -844,13 +844,13 @@ int Module::getADC(dacIndex index) const {
 }
 
 int Module::getOnChipDAC(slsDetectorDefs::dacIndex index, int chipIndex) const {
-    int args[]{static_cast<int>(index), chipIndex};
+    int const args[]{static_cast<int>(index), chipIndex};
     return sendToDetector<int>(F_GET_ON_CHIP_DAC, args);
 }
 
 void Module::setOnChipDAC(slsDetectorDefs::dacIndex index, int chipIndex,
                           int value) {
-    int args[]{static_cast<int>(index), chipIndex, value};
+    int const args[]{static_cast<int>(index), chipIndex, value};
     sendToDetector(F_SET_ON_CHIP_DAC, args, nullptr);
 }
 
@@ -861,7 +861,7 @@ Module::getExternalSignalFlags(int signalIndex) const {
 }
 
 void Module::setExternalSignalFlags(int signalIndex, externalSignalFlag type) {
-    int args[]{signalIndex, static_cast<int>(type)};
+    int const args[]{signalIndex, static_cast<int>(type)};
     sendToDetector(F_SET_EXTERNAL_SIGNAL_FLAG, args, nullptr);
 }
 
@@ -1483,7 +1483,7 @@ void Module::setPartialFramesPadding(bool padding) {
 }
 
 int Module::getReceiverUDPSocketBufferSize() const {
-    int arg = GET_FLAG;
+    int const arg = GET_FLAG;
     return sendToReceiver<int>(F_RECEIVER_UDP_SOCK_BUF_SIZE, arg);
 }
 
@@ -1809,7 +1809,7 @@ int64_t Module::getRateCorrection() const {
 }
 
 void Module::setDefaultRateCorrection() {
-    int64_t arg = -1;
+    int64_t const arg = -1;
     sendToDetector(F_SET_RATE_CORRECT, arg, nullptr);
 }
 
@@ -1860,7 +1860,7 @@ bool Module::getActivate() const {
 }
 
 void Module::setActivate(const bool enable) {
-    int arg = static_cast<int>(enable);
+    int const arg = static_cast<int>(enable);
     auto retval = sendToDetector<int>(F_ACTIVATE, arg);
     sendToDetectorStop<int>(F_ACTIVATE, arg);
     if (shm()->useReceiverFlag) {
@@ -1894,7 +1894,7 @@ void Module::pulseChip(int n_pulses) {
 bool Module::getQuad() const { return sendToDetector<int>(F_GET_QUAD) != 0; }
 
 void Module::setQuad(const bool enable) {
-    int value = enable ? 1 : 0;
+    int const value = enable ? 1 : 0;
     sendToDetector(F_SET_QUAD, value, nullptr);
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_SET_RECEIVER_QUAD, value, nullptr);
@@ -1906,7 +1906,7 @@ bool Module::getDataStream(const portPosition port) const {
 }
 
 void Module::setDataStream(const portPosition port, const bool enable) {
-    int args[]{static_cast<int>(port), static_cast<int>(enable)};
+    int const args[]{static_cast<int>(port), static_cast<int>(enable)};
     sendToDetector(F_SET_DATASTREAM, args, nullptr);
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_RECEIVER_SET_DATASTREAM, args, nullptr);
@@ -2076,7 +2076,7 @@ std::array<int, 2> Module::getInjectChannel() const {
 
 void Module::setInjectChannel(const int offsetChannel,
                               const int incrementChannel) {
-    int args[]{offsetChannel, incrementChannel};
+    int const args[]{offsetChannel, incrementChannel};
     sendToDetector(F_SET_INJECT_CHANNEL, args, nullptr);
 }
 
@@ -2331,18 +2331,18 @@ slsDetectorDefs::vetoAlgorithm Module::getVetoAlgorithm(
 void Module::setVetoAlgorithm(
     const slsDetectorDefs::vetoAlgorithm alg,
     const slsDetectorDefs::streamingInterface interface) {
-    int args[]{static_cast<int>(alg), static_cast<int>(interface)};
+    int const args[]{static_cast<int>(alg), static_cast<int>(interface)};
     sendToDetector(F_SET_VETO_ALGORITHM, args, nullptr);
 }
 
 int Module::getADCConfiguration(const int chipIndex, const int adcIndex) const {
-    int args[]{chipIndex, adcIndex};
+    int const args[]{chipIndex, adcIndex};
     return sendToDetector<int>(F_GET_ADC_CONFIGURATION, args);
 }
 
 void Module::setADCConfiguration(const int chipIndex, const int adcIndex,
                                  int value) {
-    int args[]{chipIndex, adcIndex, value};
+    int const args[]{chipIndex, adcIndex, value};
     sendToDetector(F_SET_ADC_CONFIGURATION, args, nullptr);
 }
 
@@ -2417,7 +2417,7 @@ bool Module::getInterpolation() const {
 
 void Module::setInterpolation(const bool enable) {
     sendToDetector(F_SET_INTERPOLATION, static_cast<int>(enable), nullptr);
-    int mask = getCounterMask();
+    int const mask = getCounterMask();
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_RECEIVER_SET_COUNTER_MASK, mask, nullptr);
     }
@@ -2575,11 +2575,10 @@ void Module::setReceiverDbitList(std::vector<int> list) {
         }
     }
     auto r = stableRemoveDuplicates(list);
-    if (r) {
+    if(r)
         LOG(logWARNING) << "Removed duplicated from receiver dbit list";
-    }
 
-    StaticVector<int, MAX_RX_DBIT> arg = list;
+    StaticVector<int, MAX_RX_DBIT> const arg = list;
     sendToReceiver(F_SET_RECEIVER_DBIT_LIST, arg, nullptr);
 }
 
@@ -2601,7 +2600,7 @@ void Module::setReceiverDbitReorder(bool reorder) {
 }
 
 void Module::setDigitalIODelay(uint64_t pinMask, int delay) {
-    uint64_t args[]{pinMask, static_cast<uint64_t>(delay)};
+    uint64_t const args[]{pinMask, static_cast<uint64_t>(delay)};
     sendToDetector(F_DIGITAL_IO_DELAY, args, nullptr);
 }
 
@@ -2658,57 +2657,57 @@ void Module::setPatternIOControl(uint64_t word) {
 }
 
 uint64_t Module::getPatternWord(int addr) const {
-    uint64_t args[]{static_cast<uint64_t>(addr),
+    uint64_t const args[]{static_cast<uint64_t>(addr),
                     static_cast<uint64_t>(GET_FLAG)};
     return sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
 }
 
 void Module::setPatternWord(int addr, uint64_t word) {
-    uint64_t args[]{static_cast<uint64_t>(addr), word};
+    uint64_t const args[]{static_cast<uint64_t>(addr), word};
     sendToDetector<uint64_t>(F_SET_PATTERN_WORD, args);
 }
 
 std::array<int, 2> Module::getPatternLoopAddresses(int level) const {
-    int args[]{level, GET_FLAG, GET_FLAG};
+    int const args[]{level, GET_FLAG, GET_FLAG};
     std::array<int, 2> retvals{};
     sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
     return retvals;
 }
 
 void Module::setPatternLoopAddresses(int level, int start, int stop) {
-    int args[]{level, start, stop};
+    int const args[]{level, start, stop};
     std::array<int, 2> retvals{};
     sendToDetector(F_SET_PATTERN_LOOP_ADDRESSES, args, retvals);
 }
 
 int Module::getPatternLoopCycles(int level) const {
-    int args[]{level, GET_FLAG};
+    int const args[]{level, GET_FLAG};
     return sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
 }
 
 void Module::setPatternLoopCycles(int level, int n) {
-    int args[]{level, n};
+    int const args[]{level, n};
     sendToDetector<int>(F_SET_PATTERN_LOOP_CYCLES, args);
 }
 
 int Module::getPatternWaitAddr(int level) const {
-    int args[]{level, GET_FLAG};
+    int const args[]{level, GET_FLAG};
     return sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
 }
 
 void Module::setPatternWaitAddr(int level, int addr) {
-    int args[]{level, addr};
+    int const args[]{level, addr};
     sendToDetector<int>(F_SET_PATTERN_WAIT_ADDR, args);
 }
 
 uint64_t Module::getPatternWaitClocks(int level) const {
-    uint64_t args[]{static_cast<uint64_t>(level),
+    uint64_t const args[]{static_cast<uint64_t>(level),
                     static_cast<uint64_t>(GET_FLAG)};
     return sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_CLOCKS, args);
 }
 
 void Module::setPatternWaitClocks(int level, uint64_t t) {
-    uint64_t args[]{static_cast<uint64_t>(level), t};
+    uint64_t const args[]{static_cast<uint64_t>(level), t};
     sendToDetector<uint64_t>(F_SET_PATTERN_WAIT_CLOCKS, args);
 }
 
@@ -2716,7 +2715,7 @@ uint64_t Module::getPatternWaitInterval(int level) const {
     return sendToDetector<uint64_t>(F_GET_PATTERN_WAIT_INTERVAL, level);
 }
 void Module::setPatternWaitInterval(int level, uint64_t t) {
-    uint64_t args[]{static_cast<uint64_t>(level), t};
+    uint64_t const args[]{static_cast<uint64_t>(level), t};
     sendToDetector(F_SET_PATTERN_WAIT_INTERVAL, args, nullptr);
 }
 
@@ -2915,30 +2914,29 @@ void Module::setUpdateMode(const bool updatemode) {
                  << "): Update Mode set to " << updatemode << "!";
 }
 
-RegisterValue Module::readRegister(RegisterAddress addr) const {
-    return sendToDetectorStop<RegisterValue>(F_READ_REGISTER, addr.value());
+uint32_t Module::readRegister(uint32_t addr) const {
+    return sendToDetectorStop<uint32_t>(F_READ_REGISTER, addr);
 }
 
-void Module::writeRegister(RegisterAddress addr, RegisterValue val,
-                           bool validate) {
-    uint32_t args[]{addr.value(), val.value(), static_cast<uint32_t>(validate)};
+void Module::writeRegister(uint32_t addr, uint32_t val, bool validate) {
+    uint32_t const args[]{addr, val, static_cast<uint32_t>(validate)};
     return sendToDetectorStop(F_WRITE_REGISTER, args, nullptr);
 }
 
-void Module::setBit(BitAddress bitAddr, bool validate) {
-    uint32_t args[] = {bitAddr.address().value(), bitAddr.bitPosition(),
+void Module::setBit(uint32_t addr, int n, bool validate) {
+    uint32_t const args[] = {addr, static_cast<uint32_t>(n),
                        static_cast<uint32_t>(validate)};
     sendToDetectorStop(F_SET_BIT, args, nullptr);
 }
 
-void Module::clearBit(BitAddress bitAddr, bool validate) {
-    uint32_t args[] = {bitAddr.address().value(), bitAddr.bitPosition(),
+void Module::clearBit(uint32_t addr, int n, bool validate) {
+    uint32_t const args[] = {addr, static_cast<uint32_t>(n),
                        static_cast<uint32_t>(validate)};
     sendToDetectorStop(F_CLEAR_BIT, args, nullptr);
 }
 
-int Module::getBit(BitAddress bitAddr) const {
-    uint32_t args[2] = {bitAddr.address().value(), bitAddr.bitPosition()};
+int Module::getBit(uint32_t addr, int n) {
+    uint32_t const args[2] = {addr, static_cast<uint32_t>(n)};
     return sendToDetectorStop<int>(F_GET_BIT, args);
 }
 
@@ -2947,7 +2945,7 @@ void Module::executeFirmwareTest() { sendToDetector(F_SET_FIRMWARE_TEST); }
 void Module::executeBusTest() { sendToDetector(F_SET_BUS_TEST); }
 
 void Module::writeAdcRegister(uint32_t addr, uint32_t val) {
-    uint32_t args[]{addr, val};
+    uint32_t const args[]{addr, val};
     sendToDetector(F_WRITE_ADC_REG, args, nullptr);
 }
 
@@ -3451,7 +3449,7 @@ void Module::initializeModuleStructure(detectorType type) {
     shm()->stoppedFlag = false;
 
     // get the Module parameters based on type
-    detParameters parameters{type};
+    detParameters const parameters{type};
     shm()->nChan.x = parameters.nChanX;
     shm()->nChan.y = parameters.nChanY;
     shm()->nChip.x = parameters.nChipX;
@@ -3465,12 +3463,12 @@ void Module::initialDetectorServerChecks() {
 }
 
 void Module::checkDetectorVersionCompatibility() {
-    std::string detServers[2] = {getControlServerLongVersion(),
+    std::string const detServers[2] = {getControlServerLongVersion(),
                                  getStopServerLongVersion()};
     for (int i = 0; i != 2; ++i) {
         // det and client (sem. versioning)
-        Version det(detServers[i]);
-        Version client(APILIB);
+        Version const det(detServers[i]);
+        Version const client(APILIB);
         if (det.hasSemanticVersioning() && client.hasSemanticVersioning()) {
             if (!det.isBackwardCompatible(client)) {
                 std::ostringstream oss;
@@ -3484,7 +3482,7 @@ void Module::checkDetectorVersionCompatibility() {
         }
         // comparing dates(exact match to expected)
         else {
-            Version expectedDetector(getDetectorAPI());
+            Version const expectedDetector(getDetectorAPI());
             if (det != expectedDetector) {
                 std::ostringstream oss;
                 oss << "Detector (" << (i == 0 ? "Control" : "Stop")
@@ -3523,8 +3521,8 @@ const std::string Module::getDetectorAPI() const {
 
 void Module::checkReceiverVersionCompatibility() {
     // rxr and client (sem. versioning)
-    Version rxr(getReceiverLongVersion());
-    Version client(APILIB);
+    Version const rxr(getReceiverLongVersion());
+    Version const client(APILIB);
     if (rxr.hasSemanticVersioning() && client.hasSemanticVersioning()) {
         if (!rxr.isBackwardCompatible(client)) {
             std::ostringstream oss;
@@ -3537,7 +3535,7 @@ void Module::checkReceiverVersionCompatibility() {
     }
     // comparing dates(exact match to expected)
     else {
-        Version expectedReceiver(APIRECEIVER);
+        Version const expectedReceiver(APIRECEIVER);
         if (rxr != expectedReceiver) {
             std::ostringstream oss;
             oss << "Receiver version (" << rxr.getDate()
@@ -3668,7 +3666,7 @@ void Module::sendModule(sls_detector_module *myMod, ClientSocket &client) {
     ts += n;
     LOG(level) << "channels sent. " << n << " bytes";
 
-    int expectedBytesSent = sizeof(sls_detector_module) - sizeof(myMod->dacs) -
+    int const expectedBytesSent = sizeof(sls_detector_module) - sizeof(myMod->dacs) -
                             sizeof(myMod->chanregs) +
                             (myMod->ndac * sizeof(int)) +
                             (myMod->nchan * sizeof(int));
@@ -3734,7 +3732,7 @@ sls_detector_module Module::interpolateTrim(sls_detector_module *a,
             "Interpolation of Trim values not implemented for this detector!");
     }
 
-    sls_detector_module myMod{shm()->detType};
+    sls_detector_module const myMod{shm()->detType};
 
     // create copy and interpolate dac lists
     std::vector<int> dacs_to_copy, dacs_to_interpolate;
@@ -3880,7 +3878,7 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     // mythen3 (dacs, trimbits)
     else if (shm()->detType == MYTHEN3) {
-        int expected_size = sizeof(int) * myMod.ndac +
+        int const expected_size = sizeof(int) * myMod.ndac +
                             sizeof(int) * myMod.nchan + sizeof(myMod.reg);
         if (file_size != expected_size) {
             throw RuntimeError("The size of the settings file: " + fname +
@@ -3959,7 +3957,7 @@ void Module::sendProgram(bool blackfin, std::vector<char> buffer,
     client.Send(filesize);
 
     // send checksum
-    std::string checksum = md5_calculate_checksum(buffer.data(), filesize);
+    std::string const checksum = md5_calculate_checksum(buffer.data(), filesize);
     LOG(logDEBUG1) << "Checksum:" << checksum;
     char cChecksum[MAX_STR_LENGTH] = {0};
     strcpy(cChecksum, checksum.c_str());

slsDetectorSoftware/src/Module.h

@@ -5,7 +5,6 @@
 #include "sls/ClientSocket.h"
 #include "sls/Pattern.h"
 #include "sls/StaticVector.h"
-#include "sls/bit_utils.h"
 #include "sls/logger.h"
 #include "sls/network_utils.h"
 #include "sls/sls_detector_defs.h"
@@ -580,11 +579,11 @@ class Module : public virtual slsDetectorDefs {
     void rebootController();
     bool getUpdateMode() const;
     void setUpdateMode(const bool updatemode);
-    RegisterValue readRegister(RegisterAddress addr) const;
-    void writeRegister(RegisterAddress addr, RegisterValue val, bool validate);
-    void setBit(BitAddress bitAddr, bool validate);
-    void clearBit(BitAddress bitAddr, bool validate);
-    int getBit(BitAddress bitAddr) const;
+    uint32_t readRegister(uint32_t addr) const;
+    void writeRegister(uint32_t addr, uint32_t val, bool validate);
+    void setBit(uint32_t addr, int n, bool validate);
+    void clearBit(uint32_t addr, int n, bool validate);
+    int getBit(uint32_t addr, int n);
     void executeFirmwareTest();
     void executeBusTest();
     void writeAdcRegister(uint32_t addr, uint32_t val);

slsDetectorSoftware/src/Pattern.cpp

@@ -114,14 +114,14 @@ size_t Pattern::load(const std::string &fname) {
                 it, std::istream_iterator<std::string>());
 
             std::string cmd = args[0];
-            int nargs = args.size() - 1;
+            int const nargs = args.size() - 1;
 
             if (cmd == "patword") {
                 if (nargs != 2) {
                     throw RuntimeError("Invalid arguments for " +
                                        ToString(args));
                 }
-                uint32_t addr = StringTo<uint32_t>(args[1]);
+                uint32_t const addr = StringTo<uint32_t>(args[1]);
                 if (addr >= MAX_PATTERN_LENGTH) {
                     throw RuntimeError("Invalid address for " + ToString(args));
                 }
@@ -162,8 +162,8 @@ size_t Pattern::load(const std::string &fname) {
                     throw RuntimeError("Invalid Pattern level. Options 0-" +
                                        std::to_string(MAX_PATTERN_LEVELS - 1));
                 }
-                int loop1 = StringTo<uint32_t>(args[iArg++]);
-                int loop2 = StringTo<uint32_t>(args[iArg++]);
+                int const loop1 = StringTo<uint32_t>(args[iArg++]);
+                int const loop2 = StringTo<uint32_t>(args[iArg++]);
                 pat->startloop[level] = loop1;
                 pat->stoploop[level] = loop2;
             } else if (cmd == "patnloop0" || cmd == "patnloop1" ||

slsDetectorSoftware/src/SharedMemory.h

@@ -28,26 +28,25 @@
 // ********************** Defines for shared memory. **********************
 // WARNING! before chaning these search the codebase for their usage!
 
-// date when IsValid boolean introduced into every shm structure
-// (to look out for shm that still exists due to other mapped resources)
 #define SHM_IS_VALID_CHECK_VERSION 0x250820
 
-// Max shared memory name length in macOS is 31 characters
+//Max shared memory name length in macOS is 31 characters
 #ifdef __APPLE__
-#define SHM_DETECTOR_PREFIX "/sls_"
-#define SHM_MODULE_PREFIX   "_mod_"
+#define SHM_DETECTOR_PREFIX        "/sls_"
+#define SHM_MODULE_PREFIX          "_mod_"
 #else
-#define SHM_DETECTOR_PREFIX "/slsDetectorPackage_detector_"
-#define SHM_MODULE_PREFIX   "_module_"
+#define SHM_DETECTOR_PREFIX        "/slsDetectorPackage_detector_"
+#define SHM_MODULE_PREFIX          "_module_"
 #endif
 
-#define SHM_ENV_NAME "SLSDETNAME"
+#define SHM_ENV_NAME               "SLSDETNAME"
 // ************************************************************************
 
 namespace sls {
 
 class CtbConfig;
 
+
 template <typename T, typename U> constexpr bool is_type() {
     return std::is_same_v<std::decay_t<U>, T>;
 }
@@ -95,16 +94,17 @@ template <typename T> class SharedMemory {
             unmapSharedMemory();
     }
 
-    /** memory is valid if it has the IsValid flag and is true */
     bool memoryHasValidFlag() const {
         if (shared_struct == nullptr) {
             throw SharedMemoryError(
                 "Shared memory not mapped. Cannot check validity.");
         }
-        // CtbConfig also works (shmversion didnt exist prior, but it would read
-        // "20" = length size) so shmversion should always be >= isValid
-        // introduced date (0x250820)
-        if (shared_struct->shmversion >= SHM_IS_VALID_CHECK_VERSION) {
+        // CtbConfig did not have shmversion before, so exact value check
+        if constexpr (is_type<CtbConfig, T>()) {
+            if (shared_struct->shmversion == SHM_IS_VALID_CHECK_VERSION) {
+                return true;
+            }
+        } else if (shared_struct->shmversion >= SHM_IS_VALID_CHECK_VERSION) {
             return true;
         }
         return false;
@@ -154,7 +154,7 @@ template <typename T> class SharedMemory {
     std::string getName() const { return name; }
 
     bool exists() {
-        int tempfd = shm_open(name.c_str(), O_RDWR, 0);
+        const int tempfd = shm_open(name.c_str(), O_RDWR, 0);
         if ((tempfd < 0) && (errno == ENOENT)) {
             return false;
         }
@@ -163,7 +163,7 @@ template <typename T> class SharedMemory {
     }
 
     void createSharedMemory() {
-        int fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
+        const int fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR,
                           S_IRUSR | S_IWUSR);
         if (fd < 0) {
             std::string msg =
@@ -184,9 +184,9 @@ template <typename T> class SharedMemory {
     }
 
     void openSharedMemory(bool verifySize) {
-        int fd = shm_open(name.c_str(), O_RDWR, 0);
+        const int fd = shm_open(name.c_str(), O_RDWR, 0);
         if (fd < 0) {
-            std::string msg = "Open existing shared memory " + name +
+            const std::string msg = "Open existing shared memory " + name +
                               " failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -198,7 +198,7 @@ template <typename T> class SharedMemory {
     void unmapSharedMemory() {
         if (shared_struct != nullptr) {
             if (munmap(shared_struct, sizeof(T)) < 0) {
-                std::string msg = "Unmapping shared memory " + name +
+                const std::string msg = "Unmapping shared memory " + name +
                                   " failed: " + strerror(errno);
                 throw SharedMemoryError(msg);
             }
@@ -213,7 +213,7 @@ template <typename T> class SharedMemory {
             // silent exit if shm did not exist anyway
             if (errno == ENOENT)
                 return;
-            std::string msg =
+            const std::string msg =
                 "Free Shared Memory " + name + " Failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -244,7 +244,7 @@ template <typename T> class SharedMemory {
 
         std::string shm_name = ss.str();
         if (shm_name.length() > NAME_MAX_LENGTH) {
-            std::string msg =
+            const std::string msg =
                 "Shared memory initialization failed. " + shm_name + " has " +
                 std::to_string(shm_name.length()) + " characters. \n" +
                 "Maximum is " + std::to_string(NAME_MAX_LENGTH) +
@@ -262,7 +262,7 @@ template <typename T> class SharedMemory {
             mmap(nullptr, sizeof(T), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
         close(fd);
         if (addr == MAP_FAILED) {
-            std::string msg =
+            const std::string msg =
                 "Mapping shared memory " + name + " failed: " + strerror(errno);
             throw SharedMemoryError(msg);
         }
@@ -272,23 +272,22 @@ template <typename T> class SharedMemory {
     void checkSize(int fd) {
         struct stat sb;
         if (fstat(fd, &sb) < 0) {
-            std::string msg = "Could not verify existing shared memory " +
+            const std::string msg = "Could not verify existing shared memory " +
                               name + " size match " +
                               "(could not fstat): " + strerror(errno);
             close(fd);
             throw SharedMemoryError(msg);
         }
 
-#ifdef __APPLE__
-        // On macOS, fstat returns the allocated size and not the requested
-        // size. This means we can't check for size since we always get for
-        // example 16384 bytes.
+        #ifdef __APPLE__
+        // On macOS, fstat returns the allocated size and not the requested size.
+        // This means we can't check for size since we always get for example 16384 bytes.
         return;
-#endif
+        #endif
         auto actual_size = static_cast<size_t>(sb.st_size);
         auto expected_size = sizeof(T);
         if (actual_size != expected_size) {
-            std::string msg =
+            const std::string msg =
                 "Existing shared memory " + name + " size does not match. " +
                 "Expected " + std::to_string(expected_size) + ", found " +
                 std::to_string(actual_size) +

slsDetectorSoftware/src/inferAction.cpp

@@ -400,10 +400,6 @@ int InferAction::chipversion() {
 
 int InferAction::clearbit() {
 
-    if (args.size() == 1) {
-        return slsDetectorDefs::PUT_ACTION;
-    }
-
     if (args.size() == 2) {
         return slsDetectorDefs::PUT_ACTION;
     }
@@ -792,66 +788,6 @@ int InferAction::defaultpattern() {
     }
 }
 
-int InferAction::define_bit() {
-
-    if (args.size() == 1) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
-    if (args.size() == 2) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
-    if (args.size() == 3) {
-        return slsDetectorDefs::PUT_ACTION;
-    }
-
-    else {
-
-        throw RuntimeError("Could not infer action: Wrong number of arguments");
-    }
-}
-
-int InferAction::define_reg() {
-
-    if (args.size() == 1) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
-    if (args.size() == 2) {
-        return slsDetectorDefs::PUT_ACTION;
-    }
-
-    else {
-
-        throw RuntimeError("Could not infer action: Wrong number of arguments");
-    }
-}
-
-int InferAction::definelist_bit() {
-
-    if (args.size() == 0) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
-    else {
-
-        throw RuntimeError("Could not infer action: Wrong number of arguments");
-    }
-}
-
-int InferAction::definelist_reg() {
-
-    if (args.size() == 0) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
-    else {
-
-        throw RuntimeError("Could not infer action: Wrong number of arguments");
-    }
-}
-
 int InferAction::delay() {
 
     if (args.size() == 0) {
@@ -1562,10 +1498,6 @@ int InferAction::gates() {
 
 int InferAction::getbit() {
 
-    if (args.size() == 1) {
-        return slsDetectorDefs::GET_ACTION;
-    }
-
     if (args.size() == 2) {
         return slsDetectorDefs::GET_ACTION;
     }
@@ -3123,10 +3055,6 @@ int InferAction::serialnumber() {
 
 int InferAction::setbit() {
 
-    if (args.size() == 1) {
-        return slsDetectorDefs::PUT_ACTION;
-    }
-
     if (args.size() == 2) {
         return slsDetectorDefs::PUT_ACTION;
     }

slsDetectorSoftware/src/inferAction.h

@@ -62,10 +62,6 @@ class InferAction {
     int dbitpipeline();
     int defaultdac();
     int defaultpattern();
-    int define_bit();
-    int define_reg();
-    int definelist_bit();
-    int definelist_reg();
     int delay();
     int delayl();
     int detectorserverversion();
@@ -398,10 +394,6 @@ class InferAction {
         {"dbitpipeline", &InferAction::dbitpipeline},
         {"defaultdac", &InferAction::defaultdac},
         {"defaultpattern", &InferAction::defaultpattern},
-        {"define_bit", &InferAction::define_bit},
-        {"define_reg", &InferAction::define_reg},
-        {"definelist_bit", &InferAction::definelist_bit},
-        {"definelist_reg", &InferAction::definelist_reg},
         {"delay", &InferAction::delay},
         {"delayl", &InferAction::delayl},
         {"detectorserverversion", &InferAction::detectorserverversion},

slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp

@@ -29,18 +29,18 @@ TEST_CASE("jungfrau_or_moench_acquire_check_file_size",
         auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
             "inconsistent number of udp interfaces");
 
-        int num_frames_to_acquire = 2;
+        int const num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters par(det_type);
-            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            detParameters const par(det_type);
+            int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
             // if 2 udp interfaces, data split into half
-            size_t expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
+            size_t const expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
                                           par.nChipY * bytes_per_pixel) /
                                          num_udp_interfaces;
-            testFileInfo test_file_info;
+            testFileInfo const test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -55,23 +55,23 @@ TEST_CASE("eiger_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::EIGER) {
 
-        int dynamic_range = det.getDynamicRange().squash();
+        int const dynamic_range = det.getDynamicRange().squash();
         if (dynamic_range != 16) {
             throw RuntimeError(
                 "Eiger detector must have dynamic range 16 to test");
         }
-        int num_frames_to_acquire = 2;
+        int const num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters par(det_type);
+            detParameters const par(det_type);
             // data split into half due to 2 udp interfaces per half module
-            int num_chips = (par.nChipX / 2);
-            int bytes_per_pixel = (dynamic_range / 8);
-            size_t expected_image_size =
+            int const num_chips = (par.nChipX / 2);
+            int const bytes_per_pixel = (dynamic_range / 8);
+            size_t const expected_image_size =
                 par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
-            testFileInfo test_file_info;
+            testFileInfo const test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -86,25 +86,25 @@ TEST_CASE("mythen3_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::MYTHEN3) {
 
-        int dynamic_range = det.getDynamicRange().squash();
-        int counter_mask = det.getCounterMask().squash();
+        int const dynamic_range = det.getDynamicRange().squash();
+        int const counter_mask = det.getCounterMask().squash();
         if (dynamic_range != 16 && counter_mask != 0x3) {
             throw RuntimeError("Mythen3 detector must have dynamic range 16 "
                                "and counter mask 0x3 to test");
         }
-        int num_counters = __builtin_popcount(counter_mask);
-        int num_frames_to_acquire = 2;
+        int const num_counters = __builtin_popcount(counter_mask);
+        int const num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters par(det_type);
-            int bytes_per_pixel = dynamic_range / 8;
-            int num_channels_per_counter = par.nChanX / 3;
-            size_t expected_image_size = num_channels_per_counter *
+            detParameters const par(det_type);
+            int const bytes_per_pixel = dynamic_range / 8;
+            int const num_channels_per_counter = par.nChanX / 3;
+            size_t const expected_image_size = num_channels_per_counter *
                                          num_counters * par.nChipX *
                                          bytes_per_pixel;
-            testFileInfo test_file_info;
+            testFileInfo const test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -119,16 +119,16 @@ TEST_CASE("gotthard2_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::GOTTHARD2) {
 
-        int num_frames_to_acquire = 2;
+        int const num_frames_to_acquire = 2;
         create_files_for_acquire(det, caller, num_frames_to_acquire);
 
         // check file size (assuming local pc)
         {
-            detParameters par(det_type);
-            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
-            size_t expected_image_size =
+            detParameters const par(det_type);
+            int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            size_t const expected_image_size =
                 par.nChanX * par.nChipX * bytes_per_pixel;
-            testFileInfo test_file_info;
+            testFileInfo const test_file_info;
             test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
                                           expected_image_size);
         }
@@ -143,9 +143,9 @@ void test_ctb_file_size_with_acquire(Detector &det, Caller &caller,
     create_files_for_acquire(det, caller, num_frames, test_info);
 
     // check file size (assuming local pc)
-    uint64_t expected_image_size =
+    uint64_t const expected_image_size =
         calculate_ctb_image_size(test_info, isXilinxCtb).first;
-    testFileInfo test_file_info;
+    testFileInfo const test_file_info;
     REQUIRE_NOTHROW(test_acquire_binary_file_size(test_file_info, num_frames,
                                                   expected_image_size));
 }
@@ -158,8 +158,8 @@ TEST_CASE("ctb_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        bool isXilinxCtb = (det_type == defs::XILINX_CHIPTESTBOARD);
-        int num_frames_to_acquire = 2;
+        bool const isXilinxCtb = (det_type == defs::XILINX_CHIPTESTBOARD);
+        int const num_frames_to_acquire = 2;
         // all the test cases
         {
             testCtbAcquireInfo test_ctb_config{};

slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp

@@ -26,8 +26,8 @@ TEST_CASE("dacname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2);
-        std::string str_dac_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2);
+        std::string const str_dac_index = "2";
         auto prev = det.getDacName(ind);
 
         // 1 arg throw
@@ -61,8 +61,8 @@ TEST_CASE("dacindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2);
-        std::string str_dac_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2);
+        std::string const str_dac_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("dacindex", {"2", "2"}, -1, PUT));
@@ -120,8 +120,8 @@ TEST_CASE("adcname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int ind = 2;
-        std::string str_adc_index = "2";
+        int const ind = 2;
+        std::string const str_adc_index = "2";
         auto prev = det.getAdcName(ind);
 
         // 1 arg throw
@@ -155,8 +155,8 @@ TEST_CASE("adcindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int ind = 2;
-        std::string str_adc_index = "2";
+        int const ind = 2;
+        std::string const str_adc_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("adcindex", {"2", "2"}, -1, PUT));
@@ -214,8 +214,8 @@ TEST_CASE("signalname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int ind = 2;
-        std::string str_signal_index = "2";
+        int const ind = 2;
+        std::string const str_signal_index = "2";
         auto prev = det.getSignalName(ind);
 
         // 1 arg throw
@@ -249,8 +249,8 @@ TEST_CASE("signalindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        int ind = 2;
-        std::string str_signal_index = "2";
+        int const ind = 2;
+        std::string const str_signal_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("signalindex", {"2", "2"}, -1, PUT));
@@ -309,8 +309,8 @@ TEST_CASE("powername", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
-        std::string str_power_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
+        std::string const str_power_index = "2";
         auto prev = det.getPowerName(ind);
 
         // 1 arg throw
@@ -344,8 +344,8 @@ TEST_CASE("powerindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
-        std::string str_power_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
+        std::string const str_power_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("powerindex", {"2", "2"}, -1, PUT));
@@ -430,8 +430,8 @@ TEST_CASE("slowadcname", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
-        std::string str_slowadc_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
+        std::string const str_slowadc_index = "2";
         auto prev = det.getSlowADCName(ind);
 
         // 1 arg throw
@@ -466,8 +466,8 @@ TEST_CASE("slowadcindex", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD) {
-        defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
-        std::string str_slowadc_index = "2";
+        defs::dacIndex const ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
+        std::string const str_slowadc_index = "2";
 
         // 1 arg throw
         REQUIRE_THROWS(caller.call("slowadcindex", {"2", "2"}, -1, PUT));
@@ -1030,41 +1030,37 @@ TEST_CASE("v_abcd", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
+    std::vector<std::string> cmds{"v_a", "v_b", "v_c", "v_d"};
+    std::vector<defs::dacIndex> indices{defs::V_POWER_A, defs::V_POWER_B,
+                                        defs::V_POWER_C, defs::V_POWER_D};
+
     if (det.isVirtualDetectorServer().tsquash("Inconsistent virtual servers")) {
+        cmds.push_back("v_io");
+        indices.push_back(defs::V_POWER_IO);
+    }
 
-        std::vector<std::string> cmds{"v_a", "v_b", "v_c", "v_d", "v_io"};
-        std::vector<defs::dacIndex> indices{defs::V_POWER_A, defs::V_POWER_B,
-                                            defs::V_POWER_C, defs::V_POWER_D,
-                                            defs::V_POWER_IO};
-
-        for (size_t i = 0; i < cmds.size(); ++i) {
-            if (det_type == defs::CHIPTESTBOARD ||
-                det_type == defs::XILINX_CHIPTESTBOARD) {
-                auto prev_val = det.getPower(indices[i]);
-                {
-                    std::ostringstream oss;
-                    caller.call(cmds[i], {"0"}, -1, PUT, oss);
-                    REQUIRE(oss.str() == cmds[i] + " 0\n");
-                }
-                {
-                    std::ostringstream oss1, oss2;
-                    caller.call(cmds[i], {"1200"}, -1, PUT, oss1);
-                    REQUIRE(oss1.str() == cmds[i] + " 1200\n");
-                    caller.call(cmds[i], {}, -1, GET, oss2);
-                    REQUIRE(oss2.str() == cmds[i] + " 1200\n");
-                }
-                for (int i = 0; i != det.size(); ++i) {
-                    if (det_type == defs::XILINX_CHIPTESTBOARD &&
-                        prev_val[i] == -100) {
-                        prev_val[i] = 0;
-                        continue;
-                    }
-                    det.setPower(indices[i], prev_val[i], {i});
-                }
-
-            } else {
-                REQUIRE_THROWS(caller.call(cmds[i], {}, -1, GET));
+    for (size_t i = 0; i < cmds.size(); ++i) {
+        if (det_type == defs::CHIPTESTBOARD ||
+            det_type == defs::XILINX_CHIPTESTBOARD) {
+            auto prev_val = det.getPower(indices[i]);
+            {
+                std::ostringstream oss;
+                caller.call(cmds[i], {"0"}, -1, PUT, oss);
+                REQUIRE(oss.str() == cmds[i] + " 0\n");
             }
+            {
+                std::ostringstream oss1, oss2;
+                caller.call(cmds[i], {"1200"}, -1, PUT, oss1);
+                REQUIRE(oss1.str() == cmds[i] + " 1200\n");
+                caller.call(cmds[i], {}, -1, GET, oss2);
+                REQUIRE(oss2.str() == cmds[i] + " 1200\n");
+            }
+            for (int i = 0; i != det.size(); ++i) {
+                det.setPower(indices[i], prev_val[i], {i});
+            }
+
+        } else {
+            REQUIRE_THROWS(caller.call(cmds[i], {}, -1, GET));
         }
     }
 }
@@ -1334,366 +1330,4 @@ TEST_CASE("led", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("define_reg", "[.cmdcall][.definecmds]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-
-        auto prev_reg_defines = det.getRegisterDefinitions();
-        auto prev_bit_defines = det.getBitDefinitions();
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-
-        {
-            // invalid puts
-            // missing arg
-            REQUIRE_THROWS(caller.call("define_reg", {}, -1, GET));
-            // missing arg
-            REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG"}, -1, PUT));
-            // invalid module id
-            REQUIRE_THROWS(
-                caller.call("define_reg", {"TEST_REG", "0x201"}, 0, PUT));
-
-            // valid put
-            REQUIRE_NOTHROW(
-                caller.call("define_reg", {"TEST_REG", "0x200"}, -1, PUT));
-            // modify reg
-            REQUIRE_NOTHROW(
-                caller.call("define_reg", {"TEST_REG", "0x201"}, -1, PUT));
-            REQUIRE_NOTHROW(
-                caller.call("define_reg", {"TEST_REG2", "0x202"}, -1, PUT));
-
-            // invalid puts
-            // existing reg addr
-            REQUIRE_THROWS(
-                caller.call("define_reg", {"TEST_REG3", "0x201"}, -1, PUT));
-
-            // valid gets
-            {
-                // get by name
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("define_reg", {"TEST_REG"}, -1, GET, oss));
-                REQUIRE(oss.str() == "define_reg 0x201\n");
-            }
-            {
-                // get by addr
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("define_reg", {"0x201"}, -1, GET, oss));
-                REQUIRE(oss.str() == "define_reg TEST_REG\n");
-            }
-
-            // invalid gets
-            // doesnt exist
-            REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG3"}, -1, GET));
-            REQUIRE_THROWS(caller.call("define_reg", {"0x203"}, -1, GET));
-            // ensure correct exception message
-            try {
-                caller.call("define_reg", {"0x203"}, -1, GET);
-            } catch (const std::exception &e) {
-                REQUIRE(std::string(e.what()).find(
-                            "No entry found for value") != std::string::npos);
-            }
-        }
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-
-        det.setRegisterDefinitions(prev_reg_defines);
-        det.setBitDefinitions(prev_bit_defines);
-
-    } else {
-        REQUIRE_THROWS(
-            caller.call("define_reg", {"TEST_REG", "0x200"}, -1, PUT));
-        REQUIRE_THROWS(caller.call("define_reg", {"TEST_REG"}, -1, GET));
-    }
-}
-
-TEST_CASE("define_bit", "[.cmdcall][.definecmds]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-
-        auto prev_reg_defines = det.getRegisterDefinitions();
-        auto prev_bit_defines = det.getBitDefinitions();
-
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
-        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
-
-        {
-            // invalid puts
-            // skipped register
-            REQUIRE_THROWS(
-                caller.call("define_bit", {"TEST_BIT", "1"}, -1, PUT));
-            // named register doesnt exist
-            REQUIRE_THROWS(caller.call(
-                "define_bit", {"TEST_BIT", "RANDOM_REG", "1"}, -1, PUT));
-            // invalid bit position
-            REQUIRE_THROWS(
-                caller.call("define", {"TEST_BIT", "TEST_REG", "32"}, -1, PUT));
-
-            // valid puts
-            REQUIRE_NOTHROW(caller.call(
-                "define_bit", {"TEST_BIT", "TEST_REG2", "1"}, -1, PUT));
-            // modify reg
-            REQUIRE_NOTHROW(caller.call(
-                "define_bit", {"TEST_BIT", "TEST_REG", "1"}, -1, PUT));
-
-            // modify position
-            REQUIRE_NOTHROW(caller.call(
-                "define_bit", {"TEST_BIT", "TEST_REG", "2"}, -1, PUT));
-            // another bit to same reg
-            REQUIRE_NOTHROW(caller.call(
-                "define_bit", {"TEST_BIT2", "TEST_REG", "4"}, -1, PUT));
-            // bit to a different reg
-            REQUIRE_NOTHROW(caller.call(
-                "define_bit", {"TEST_BIT3", "TEST_REG2", "3"}, -1, PUT));
-
-            // valid gets
-            {
-                // get by name
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("define_bit", {"TEST_BIT"}, -1, GET, oss));
-                REQUIRE(oss.str() == "define_bit [TEST_REG, 2]\n");
-            }
-            {
-                // get by addr+pos name
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("define_bit", {"TEST_REG", "2"}, -1, GET, oss));
-                REQUIRE(oss.str() == "define_bit TEST_BIT\n");
-            }
-            {
-                // get by addr val + pos
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("define_bit", {"0x201", "2"}, -1, GET, oss));
-                REQUIRE(oss.str() == "define_bit TEST_BIT\n");
-            }
-
-            // invalid gets
-            // bit doesnt exist
-            REQUIRE_THROWS(
-                caller.call("define_bit", {"TEST_REG", "3"}, -1, GET));
-            // addr doesnt exist
-            REQUIRE_THROWS(
-                caller.call("define_bit", {"TEST_REG3", "2"}, -1, GET));
-            // ensure correct exception message
-            try {
-                caller.call("define_bit", {"TEST_REG", "3"}, -1, GET);
-            } catch (const std::exception &e) {
-                REQUIRE(std::string(e.what()).find(
-                            "No entry found for value") != std::string::npos);
-            }
-        }
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-
-        det.setRegisterDefinitions(prev_reg_defines);
-        det.setBitDefinitions(prev_bit_defines);
-
-    } else {
-        REQUIRE_THROWS(
-            caller.call("define_bit", {"TEST_BIT", "0x200", "2"}, -1, PUT));
-        REQUIRE_THROWS(caller.call("define_bit", {"0x200", "2"}, -1, GET));
-    }
-}
-
-TEST_CASE("using define for reg, setbit, getbit and clearbit",
-          "[.cmdcall][.definecmds]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-
-        if (det.isVirtualDetectorServer().tsquash(
-                "inconsistent virtual values")) {
-
-            auto prev_reg_defines = det.getRegisterDefinitions();
-            auto prev_bit_defines = det.getBitDefinitions();
-
-            det.clearRegisterDefinitions();
-            det.clearBitDefinitions();
-            det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
-            det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
-            det.setBitDefinition("TEST_BIT",
-                                 BitAddress(RegisterAddress(0x201), 2));
-            det.setBitDefinition("TEST_BIT2",
-                                 BitAddress(RegisterAddress(0x201), 4));
-            det.setBitDefinition("TEST_BIT3",
-                                 BitAddress(RegisterAddress(0x202), 3));
-
-            auto prev_val_addr = det.readRegister(RegisterAddress(0x201));
-            auto prev_val_addr2 = det.readRegister(RegisterAddress(0x202));
-
-            // invalid puts
-            // doesnt exist addr
-            REQUIRE_THROWS(
-                caller.call("reg", {"RANDOM_REG", "0xf00"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("clearbit", {"RANDOM_REG", "TEST_BIT"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("setbit", {"RANDOM_REG", "TEST_BIT"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("getbit", {"RANDOM_REG", "TEST_BIT"}, -1, GET));
-            // using bit name for reg (only hardcoded values allowed)
-            REQUIRE_THROWS(
-                caller.call("reg", {"TEST_REG", "TEST_BIT"}, -1, PUT));
-            // using bit name and reg (only bit names or both reg and bit
-            // hardcoded allowed)
-            REQUIRE_THROWS(
-                caller.call("clearbit", {"TEST_REG", "TEST_BIT"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("setbit", {"TEST_REG", "TEST_BIT"}, -1, PUT));
-            REQUIRE_THROWS(
-                caller.call("getbit", {"TEST_REG", "TEST_BIT"}, -1, GET));
-
-            // valid puts and gets
-            {
-                // reg hard coded value of 0
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("reg", {"TEST_REG", "0x0"}, -1, PUT));
-                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
-                REQUIRE(oss.str() == "reg 0x0\n");
-            }
-            {
-                // reg hard coded value
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(
-                    caller.call("reg", {"TEST_REG", "0x10"}, -1, PUT));
-                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
-                REQUIRE(oss.str() == "reg 0x10\n");
-            }
-            {
-                // set bit
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(caller.call("setbit", {"TEST_BIT"}, -1, PUT));
-                REQUIRE_NOTHROW(
-                    caller.call("setbit", {"TEST_REG", "2"}, -1, PUT));
-                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
-                REQUIRE(oss.str() == "reg 0x14\n");
-            }
-            {
-                // get bit
-                std::ostringstream oss, oss2;
-                REQUIRE_NOTHROW(
-                    caller.call("getbit", {"TEST_REG", "2"}, -1, GET, oss));
-                REQUIRE(oss.str() == "getbit 1\n");
-                REQUIRE_NOTHROW(
-                    caller.call("getbit", {"TEST_BIT"}, -1, GET, oss2));
-                REQUIRE(oss2.str() == "getbit 1\n");
-            }
-            {
-                // clear bit
-                std::ostringstream oss;
-                REQUIRE_NOTHROW(caller.call("clearbit", {"TEST_BIT"}, -1, PUT));
-                REQUIRE_NOTHROW(
-                    caller.call("clearbit", {"TEST_REG", "2"}, -1, PUT));
-                REQUIRE_NOTHROW(caller.call("reg", {"TEST_REG"}, -1, GET, oss));
-                REQUIRE(oss.str() == "reg 0x10\n");
-            }
-            for (int i = 0; i != det.size(); ++i) {
-                det.writeRegister(RegisterAddress(0x201),
-                                  RegisterValue(prev_val_addr[i]), false, {i});
-                det.writeRegister(RegisterAddress(0x202),
-                                  RegisterValue(prev_val_addr2[i]), false, {i});
-            }
-            det.clearRegisterDefinitions();
-            det.clearBitDefinitions();
-
-            det.setRegisterDefinitions(prev_reg_defines);
-            det.setBitDefinitions(prev_bit_defines);
-        }
-
-    } else {
-        REQUIRE_THROWS(caller.call("reg", {"TEST_REG", "0x200"}, -1, PUT));
-        REQUIRE_THROWS(caller.call("reg", {"TEST_REG"}, -1, GET));
-    }
-}
-
-TEST_CASE("definelist_reg", "[.cmdcall][.definecmds]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-
-        auto prev_reg_defines = det.getRegisterDefinitions();
-
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
-        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
-
-        // invalid
-        // cannot put
-        REQUIRE_THROWS(
-            caller.call("definelist_reg", {"TEST_REG", "0x201"}, -1, PUT));
-        // too many args
-        REQUIRE_THROWS(caller.call("definelist_reg", {"TEST_MACRO"}, -1, GET));
-
-        // valid
-        REQUIRE_NOTHROW(caller.call("definelist_reg", {}, -1, GET));
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-
-        det.setRegisterDefinitions(prev_reg_defines);
-    } else {
-        REQUIRE_THROWS(caller.call("definelist_reg", {}, -1, GET));
-    }
-}
-
-TEST_CASE("definelist_bit", "[.cmdcall][.definecmds]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type = det.getDetectorType().squash();
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-
-        auto prev_reg_defines = det.getRegisterDefinitions();
-        auto prev_bit_defines = det.getBitDefinitions();
-
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-        det.setRegisterDefinition("TEST_REG", RegisterAddress(0x201));
-        det.setRegisterDefinition("TEST_REG2", RegisterAddress(0x202));
-        det.setBitDefinition("TEST_BIT", BitAddress(RegisterAddress(0x201), 2));
-        det.setBitDefinition("TEST_BIT2",
-                             BitAddress(RegisterAddress(0x201), 4));
-        det.setBitDefinition("TEST_BIT3",
-                             BitAddress(RegisterAddress(0x202), 3));
-
-        // invalid
-        // cannot put
-        REQUIRE_THROWS(
-            caller.call("definelist_bit", {"TEST_BIT", "0x201", "2"}, -1, PUT));
-        // too many args
-        REQUIRE_THROWS(caller.call("definelist_bit", {"TEST_BIT"}, -1, GET));
-
-        // valid
-        REQUIRE_NOTHROW(caller.call("definelist_bit", {}, -1, GET));
-        det.clearRegisterDefinitions();
-        det.clearBitDefinitions();
-
-        det.setRegisterDefinitions(prev_reg_defines);
-        det.setBitDefinitions(prev_bit_defines);
-    } else {
-        REQUIRE_THROWS(caller.call("definelist_bit", {}, -1, GET));
-    }
-}
-
 } // namespace sls

slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp

@@ -27,7 +27,7 @@ TEST_CASE("temp_fpgaext", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgaext", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_fpgaext "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_fpgaext "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgaext", {}, -1, GET));
@@ -42,7 +42,7 @@ TEST_CASE("temp_10ge", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_10ge", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_10ge", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_10ge "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_10ge "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_10ge", {}, -1, GET));
@@ -57,7 +57,7 @@ TEST_CASE("temp_dcdc", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_dcdc", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_dcdc "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_dcdc "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_dcdc", {}, -1, GET));
@@ -72,7 +72,7 @@ TEST_CASE("temp_sodl", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_sodl", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_sodl", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_sodl "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_sodl "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_sodl", {}, -1, GET));
@@ -87,7 +87,7 @@ TEST_CASE("temp_sodr", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_sodr", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_sodr", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_sodr "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_sodr "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_sodr", {}, -1, GET));
@@ -102,7 +102,7 @@ TEST_CASE("temp_fpgafl", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgafl", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_fpgafl "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_fpgafl "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgafl", {}, -1, GET));
@@ -117,7 +117,7 @@ TEST_CASE("temp_fpgafr", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpgafr", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_fpgafr "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_fpgafr "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpgafr", {}, -1, GET));
@@ -421,7 +421,7 @@ TEST_CASE("measuredperiod", "[.cmdcall]") {
         } else {
             s = st.erase(0, strlen("measuredperiod "));
         }
-        double val = std::stod(s);
+        double const val = std::stod(s);
         // REQUIRE(val >= 1.0);
         REQUIRE(val < 2.0);
         for (int i = 0; i != det.size(); ++i) {
@@ -460,7 +460,7 @@ TEST_CASE("measuredsubperiod", "[.cmdcall]") {
         } else {
             s = st.erase(0, strlen("measuredsubperiod "));
         }
-        double val = std::stod(s);
+        double const val = std::stod(s);
         REQUIRE(val >= 0);
         REQUIRE(val < 1000);
         for (int i = 0; i != det.size(); ++i) {

slsDetectorSoftware/tests/Caller/test-Caller-global.cpp

@@ -22,9 +22,9 @@ void test_valid_port_caller(const std::string &command,
     if (arg.empty())
         arg.push_back("0");
 
-    int test_values[3] = {77797, -1, 0};
+    int const test_values[3] = {77797, -1, 0};
     for (int i = 0; i != 3; ++i) {
-        int port_number = test_values[i];
+        int const port_number = test_values[i];
         arg[arg.size() - 1] = std::to_string(port_number);
         REQUIRE_THROWS(caller.call(command, arg, detector_id, action));
         /*REQUIRE_THROWS_WITH(proxy.Call(command, arguments, detector_id,
@@ -72,7 +72,7 @@ void test_onchip_dac_caller(defs::dacIndex index, const std::string &dacname,
     REQUIRE_THROWS(
         caller.call(dacname, {"-1", "0x400"}, -1, PUT)); // max val is 0x3ff
 
-    int chipIndex = -1; // for now, it is -1 only
+    int const chipIndex = -1; // for now, it is -1 only
     auto prev_val = det.getOnChipDAC(index, chipIndex);
     auto dacValueStr = ToStringHex(dacvalue);
     auto chipIndexStr = std::to_string(chipIndex);
@@ -115,10 +115,10 @@ void test_acquire_binary_file_size(const testFileInfo &file_info,
                                    uint64_t num_frames_to_acquire,
                                    uint64_t expected_image_size) {
     assert(file_info.file_format == defs::BINARY);
-    std::string fname = file_info.file_path + "/" + file_info.file_prefix +
+    std::string const fname = file_info.file_path + "/" + file_info.file_prefix +
                         "_d0_f0_" + std::to_string(file_info.file_acq_index) +
                         ".raw";
-    uint64_t expected_file_size =
+    uint64_t const expected_file_size =
         num_frames_to_acquire *
         (expected_image_size + sizeof(defs::sls_receiver_header));
     auto actual_file_size = std::filesystem::file_size(fname);
@@ -136,7 +136,7 @@ void test_acquire_with_receiver(Caller &caller, const Detector &det) {
     REQUIRE_NOTHROW(caller.call("start", {}, -1, PUT));
     bool idle = false;
     while (!idle) {
-        std::ostringstream oss;
+        std::ostringstream const oss;
         REQUIRE_NOTHROW(caller.call("status", {}, -1, GET));
         auto statusList = det.getDetectorStatus();
         if (statusList.any(defs::ERROR)) {
@@ -154,7 +154,7 @@ void create_files_for_acquire(
     const std::optional<testCtbAcquireInfo> &test_info) {
 
     // save previous state
-    testFileInfo prev_file_info = get_file_state(det);
+    testFileInfo const prev_file_info = get_file_state(det);
     auto prev_num_frames = det.getNumberOfFrames().tsquash(
         "Inconsistent number of frames to acquire");
     std::optional<testCtbAcquireInfo> prev_ctb_config_info{};
@@ -163,7 +163,7 @@ void create_files_for_acquire(
     }
 
     // set state for acquire
-    testFileInfo test_file_info;
+    testFileInfo const test_file_info;
     set_file_state(det, test_file_info);
     det.setNumberOfFrames(num_frames);
     if (test_info) {
@@ -265,10 +265,10 @@ calculate_ctb_image_size(const testCtbAcquireInfo &test_info,
     inputs.dbitList = test_info.dbit_list;
 
     auto out = computeCtbImageSize(inputs);
-    uint64_t image_size =
+    uint64_t const image_size =
         out.nAnalogBytes + out.nDigitalBytes + out.nTransceiverBytes;
     LOG(logDEBUG1) << "Expected image size: " << image_size;
-    int npixelx = out.nPixelsX;
+    int const npixelx = out.nPixelsX;
     LOG(logDEBUG1) << "Expected number of pixels in x: " << npixelx;
     return std::make_pair(image_size, npixelx);
 }

slsDetectorSoftware/tests/Caller/test-Caller-jungfrau.cpp

@@ -580,9 +580,9 @@ TEST_CASE("pedestalmode", "[.cmdcall]") {
             REQUIRE(oss.str() == "pedestalmode [disabled]\n");
         }
 
-        uint8_t pedestalFrames = 50;
-        uint16_t pedestalLoops = 100;
-        int64_t expNumFrames = pedestalFrames * pedestalLoops * 2;
+        uint8_t const pedestalFrames = 50;
+        uint16_t const pedestalLoops = 100;
+        int64_t const expNumFrames = pedestalFrames * pedestalLoops * 2;
         auto origFrames = det.getNumberOfFrames().squash(-1);
         auto origTriggers = det.getNumberOfTriggers().squash(-1);
 

slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp

@@ -183,7 +183,7 @@ void read_from_json(const Document &doc, const std::string &name,
     }
     int index = 0;
     for (const auto &item : json_values) {
-        std::string sval = item.GetString();
+        std::string const sval = item.GetString();
         retval[index++] = StringTo<sls::ns>(sval);
     }
 }
@@ -330,7 +330,7 @@ void test_master_file_version(const Detector &det,
     // different values for json and hdf5
     // hdf5 version in atttribute and not dataset
     double retval{};
-    std::string name = MasterAttributes::N_VERSION.data();
+    std::string const name = MasterAttributes::N_VERSION.data();
     if (doc.has_value()) {
         const auto &d = *doc;
         REQUIRE(d.HasMember(MasterAttributes::N_VERSION.data()));
@@ -381,14 +381,14 @@ void test_master_file_image_size(const Detector &det,
 
     auto det_type =
         det.getDetectorType().tsquash("Inconsistent detector types to test");
-    int bytes_per_pixel = det.getDynamicRange().squash() / 8;
-    detParameters par(det_type);
+    int const bytes_per_pixel = det.getDynamicRange().squash() / 8;
+    detParameters const par(det_type);
 
     int image_size = 0;
     switch (det_type) {
 
     case defs::EIGER: {
-        int num_chips = (par.nChipX / 2);
+        int const num_chips = (par.nChipX / 2);
         image_size = par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
     } break;
 
@@ -402,9 +402,9 @@ void test_master_file_image_size(const Detector &det,
     } break;
 
     case defs::MYTHEN3: {
-        int counter_mask = det.getCounterMask().squash();
-        int num_counters = __builtin_popcount(counter_mask);
-        int num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS;
+        int const counter_mask = det.getCounterMask().squash();
+        int const num_counters = __builtin_popcount(counter_mask);
+        int const num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS;
         image_size = num_channels_per_counter * num_counters * par.nChipX *
                      bytes_per_pixel;
     } break;
@@ -415,7 +415,7 @@ void test_master_file_image_size(const Detector &det,
 
     case defs::CHIPTESTBOARD:
     case defs::XILINX_CHIPTESTBOARD: {
-        testCtbAcquireInfo test_info{};
+        testCtbAcquireInfo const test_info{};
         image_size = calculate_ctb_image_size(
                          test_info, (det_type == defs::XILINX_CHIPTESTBOARD))
                          .first;
@@ -439,14 +439,14 @@ void test_master_file_det_size(const Detector &det,
     // m3 assumes all counters enabled when getting num channels from client
     // TODO: in future, remove assumption
     if (det_type == defs::MYTHEN3) {
-        int nchan = portSize.x / MAX_NUM_COUNTERS;
+        int const nchan = portSize.x / MAX_NUM_COUNTERS;
         auto counter_mask = det.getCounterMask().tsquash(
             "Inconsistent counter mask for Mythen3 detector");
-        int num_counters = __builtin_popcount(counter_mask);
+        int const num_counters = __builtin_popcount(counter_mask);
         portSize.x = nchan * num_counters;
     } else if (det_type == defs::CHIPTESTBOARD ||
                det_type == defs::XILINX_CHIPTESTBOARD) {
-        testCtbAcquireInfo test_info{};
+        testCtbAcquireInfo const test_info{};
         portSize.x = calculate_ctb_image_size(
                          test_info, det_type == defs::XILINX_CHIPTESTBOARD)
                          .second;
@@ -534,7 +534,7 @@ void test_master_file_total_frames(const Detector &det,
             det.getNumberOfAdditionalStorageCells().tsquash(
                 "Inconsistent number of additional storage cells");
     }
-    uint64_t total_frames =
+    uint64_t const total_frames =
         numFrames * repeats * (int64_t)(numAdditionalStorageCells + 1);
 
     REQUIRE_NOTHROW(check_master_file<uint64_t>(
@@ -549,14 +549,14 @@ void test_master_file_rois(const Detector &det,
         det.getDetectorType().tsquash("Inconsistent detector types to test");
     // compensate for m3 channel size and counter mask mess
     if (det_type == defs::MYTHEN3) {
-        int nchan = detsize.x / MAX_NUM_COUNTERS;
+        int const nchan = detsize.x / MAX_NUM_COUNTERS;
         auto counter_mask = det.getCounterMask().tsquash(
             "Inconsistent counter mask for Mythen3 detector");
-        int num_counters = __builtin_popcount(counter_mask);
+        int const num_counters = __builtin_popcount(counter_mask);
         detsize.x = nchan * num_counters;
     }
     // replace -1 for complete ROI
-    bool is2D = (detsize.y > 1);
+    bool const is2D = (detsize.y > 1);
     for (auto &roi : rois) {
         if (roi.completeRoi()) {
             roi.xmin = 0;
@@ -751,7 +751,7 @@ void test_master_file_burst_mode(const Detector &det,
 
 void test_master_file_adc_mask(const Detector &det,
                                const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_ctb_config{};
+    testCtbAcquireInfo const test_ctb_config{};
     auto adc_mask = test_ctb_config.adc_enable_10g;
     auto det_type = det.getDetectorType().squash();
     if (det_type == defs::CHIPTESTBOARD) {
@@ -766,7 +766,7 @@ void test_master_file_adc_mask(const Detector &det,
 
 void test_master_file_analog_flag(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto romode = test_info.readout_mode;
     auto analog = static_cast<int>(
         (romode == defs::ANALOG_ONLY || romode == defs::ANALOG_AND_DIGITAL));
@@ -777,7 +777,7 @@ void test_master_file_analog_flag(const Detector &det,
 
 void test_master_file_analog_samples(const Detector &det,
                                      const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto analog_samples = test_info.num_adc_samples;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -786,7 +786,7 @@ void test_master_file_analog_samples(const Detector &det,
 
 void test_master_file_digital_flag(const Detector &det,
                                    const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto romode = test_info.readout_mode;
     auto digital = static_cast<int>(romode == defs::DIGITAL_ONLY ||
                                     romode == defs::ANALOG_AND_DIGITAL ||
@@ -798,7 +798,7 @@ void test_master_file_digital_flag(const Detector &det,
 
 void test_master_file_digital_samples(const Detector &det,
                                       const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto digital_samples = test_info.num_dbit_samples;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -807,7 +807,7 @@ void test_master_file_digital_samples(const Detector &det,
 
 void test_master_file_dbit_offset(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto dbit_offset = test_info.dbit_offset;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -816,7 +816,7 @@ void test_master_file_dbit_offset(const Detector &det,
 
 void test_master_file_dbit_reorder(const Detector &det,
                                    const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto dbit_reorder = test_info.dbit_reorder;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -825,7 +825,7 @@ void test_master_file_dbit_reorder(const Detector &det,
 
 void test_master_file_dbit_bitset(const Detector &det,
                                   const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     uint64_t dbit_bitset = 0;
     for (auto &i : test_info.dbit_list) {
         dbit_bitset |= (static_cast<uint64_t>(1) << i);
@@ -837,7 +837,7 @@ void test_master_file_dbit_bitset(const Detector &det,
 
 void test_master_file_transceiver_mask(const Detector &det,
                                        const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto trans_mask = test_info.transceiver_mask;
 
     REQUIRE_NOTHROW(check_master_file<int>(
@@ -846,7 +846,7 @@ void test_master_file_transceiver_mask(const Detector &det,
 
 void test_master_file_transceiver_flag(const Detector &det,
                                        const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto romode = test_info.readout_mode;
     auto trans = static_cast<int>(romode == defs::DIGITAL_AND_TRANSCEIVER ||
                                   romode == defs::TRANSCEIVER_ONLY);
@@ -857,7 +857,7 @@ void test_master_file_transceiver_flag(const Detector &det,
 
 void test_master_file_transceiver_samples(const Detector &det,
                                           const std::optional<Document> &doc) {
-    testCtbAcquireInfo test_info{};
+    testCtbAcquireInfo const test_info{};
     auto trans_samples = test_info.num_trans_samples;
     REQUIRE_NOTHROW(check_master_file<int>(
         doc, MasterAttributes::N_TRANSCEIVER_SAMPLES.data(), trans_samples));
@@ -1005,17 +1005,17 @@ Document parse_binary_master_attributes(std::string file_path) {
     REQUIRE(file.is_open());
     std::stringstream buffer;
     buffer << file.rdbuf();
-    std::string json_str = buffer.str();
+    std::string const json_str = buffer.str();
 
     Document doc;
-    ParseResult result = doc.Parse(json_str.c_str());
+    ParseResult const result = doc.Parse(json_str.c_str());
     if (result == 0) {
         std::cout << "JSON parse error: " << GetParseError_En(result.Code())
                   << " (at offset " << result.Offset() << ")" << std::endl;
 
         // Optional: Show problematic snippet
-        size_t offset = result.Offset();
-        std::string context =
+        size_t const offset = result.Offset();
+        std::string const context =
             json_str.substr(std::max(0, (int)offset - 20), 40);
         std::cout << "Context around error: \"" << context << "\"" << std::endl;
     }
@@ -1039,7 +1039,7 @@ TEST_CASE("check_master_file_attributes", "[.cmdcall][.cmdacquire][.cmdattr]") {
     auto det_type =
         det.getDetectorType().tsquash("Inconsistent detector types to test");
 
-    int64_t num_frames = 1;
+    int64_t const num_frames = 1;
     switch (det_type) {
     case defs::EIGER:
     case defs::JUNGFRAU:
@@ -1057,11 +1057,11 @@ TEST_CASE("check_master_file_attributes", "[.cmdcall][.cmdacquire][.cmdattr]") {
         throw sls::RuntimeError("Unsupported detector type for this test");
     }
 
-    testFileInfo file_info;
-    std::string master_file_prefix = file_info.getMasterFileNamePrefix();
+    testFileInfo const file_info;
+    std::string const master_file_prefix = file_info.getMasterFileNamePrefix();
 
     // binary
-    std::string fname =
+    std::string const fname =
         master_file_prefix + ".json"; // /tmp/sls_test_master_0.json
     auto doc = std::make_optional(parse_binary_master_attributes(fname));
     test_master_file_metadata(det, doc);

slsDetectorSoftware/tests/Caller/test-Caller-mythen3.cpp

@@ -509,11 +509,11 @@ TEST_CASE("interpolation", "[.cmdcall]") {
         auto prev_mask = det.getCounterMask();
         auto prev_vth3DacVal = det.getDAC(defs::VTH3, 0, {});
 
-        int disabledDacValue = 2800;
+        int const disabledDacValue = 2800;
         auto fixedVth3DacVal = 1000;
         det.setDAC(defs::VTH3, fixedVth3DacVal, 0, {});
         // mask with counter 3 disabled and enabled(to test vth3)
-        uint32_t fixedMask[2] = {0x2, 0x4};
+        uint32_t const fixedMask[2] = {0x2, 0x4};
         for (int i = 0; i != 2; ++i) {
             det.setCounterMask(fixedMask[i]);
             {
@@ -532,7 +532,7 @@ TEST_CASE("interpolation", "[.cmdcall]") {
                 REQUIRE(oss.str() == "interpolation 0\n");
                 REQUIRE(det.getCounterMask().tsquash(
                             "inconsistent counter mask") == fixedMask[i]);
-                int expectedVth3DacVal =
+                int const expectedVth3DacVal =
                     (fixedMask[i] & 0x4 ? fixedVth3DacVal : disabledDacValue);
                 REQUIRE(det.getDAC(defs::VTH3, 0, {0})
                             .tsquash("inconsistent vth3 dac value") ==
@@ -566,13 +566,13 @@ TEST_CASE("pumpprobe", "[.cmdcall]") {
         auto prev_vth2DacVal = det.getDAC(defs::VTH2, 0, {});
         auto prev_vth3DacVal = det.getDAC(defs::VTH3, 0, {});
 
-        int disabledDacValue = 2800;
+        int const disabledDacValue = 2800;
         auto fixedVthDacVal = 1000;
         det.setDAC(defs::VTH1, fixedVthDacVal, 0, {});
         det.setDAC(defs::VTH2, fixedVthDacVal, 0, {});
         det.setDAC(defs::VTH3, fixedVthDacVal, 0, {});
         // mask with counter 2 disabled and enabled(to test vth2)
-        uint32_t fixedMask[2] = {0x4, 0x3};
+        uint32_t const fixedMask[2] = {0x4, 0x3};
         for (int i = 0; i != 2; ++i) {
             std::cout << "i:" << i << std::endl;
             det.setCounterMask(fixedMask[i]);

slsDetectorSoftware/tests/Caller/test-Caller-pattern.cpp

@@ -114,8 +114,8 @@ TEST_CASE("patword", "[.cmdcall]") {
 
     if (det_type == defs::CHIPTESTBOARD ||
         det_type == defs::XILINX_CHIPTESTBOARD || det_type == defs::MYTHEN3) {
-        int addr = 0x23;
-        std::string saddr = ToStringHex(addr, 4);
+        int const addr = 0x23;
+        std::string const saddr = ToStringHex(addr, 4);
         auto prev_val = det.getPatternWord(addr);
         {
             std::ostringstream oss;
@@ -189,9 +189,9 @@ TEST_CASE("patloop", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternLoopAddresses(iLoop);
-            std::string sLoop = ToString(iLoop);
+            std::string const sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string deprecatedCmd = "patloop" + sLoop;
+                std::string const deprecatedCmd = "patloop" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"0x20", "0x5c"}, -1, PUT, oss);
@@ -238,9 +238,9 @@ TEST_CASE("patnloop", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternLoopCycles(iLoop);
-            std::string sLoop = ToString(iLoop);
+            std::string const sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string deprecatedCmd = "patnloop" + sLoop;
+                std::string const deprecatedCmd = "patnloop" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"5"}, -1, PUT, oss);
@@ -284,9 +284,9 @@ TEST_CASE("patwait", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternWaitAddr(iLoop);
-            std::string sLoop = ToString(iLoop);
+            std::string const sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string deprecatedCmd = "patwait" + sLoop;
+                std::string const deprecatedCmd = "patwait" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"0x5c"}, -1, PUT, oss);
@@ -330,9 +330,9 @@ TEST_CASE("patwaittime", "[.cmdcall]") {
                 continue;
             }
             auto prev_val = det.getPatternWaitClocks(iLoop);
-            std::string sLoop = ToString(iLoop);
+            std::string const sLoop = ToString(iLoop);
             if (iLoop < 3) {
-                std::string deprecatedCmd = "patwaittime" + sLoop;
+                std::string const deprecatedCmd = "patwaittime" + sLoop;
                 { // deprecated
                     std::ostringstream oss;
                     caller.call(deprecatedCmd, {"8589936640"}, -1, PUT, oss);

slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp

@@ -30,7 +30,7 @@ TEST_CASE("rx_version", "[.cmdcall][.rx]") {
     Caller caller(&det);
     std::ostringstream oss;
     caller.call("rx_version", {}, -1, GET, oss);
-    sls::Version v(APIRECEIVER);
+    sls::Version const v(APIRECEIVER);
     std::ostringstream vs;
     vs << "rx_version " << v.concise() << '\n';
     REQUIRE(oss.str() == vs.str());
@@ -365,9 +365,9 @@ TEST_CASE("rx_padding", "[.cmdcall][.rx]") {
 TEST_CASE("rx_udpsocksize", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
-    int64_t prev_val = det.getRxUDPSocketBufferSize().tsquash(
+    int64_t const prev_val = det.getRxUDPSocketBufferSize().tsquash(
         "Need same udp socket buffer size to test");
-    std::string s_new_val = std::to_string(prev_val);
+    std::string const s_new_val = std::to_string(prev_val);
     /*std::string s_new_val = std::to_string(prev_val - 1000);
     { Need permissions
         std::ostringstream oss;
@@ -389,14 +389,14 @@ TEST_CASE("rx_realudpsocksize", "[.cmdcall][.rx]") {
     {
         std::ostringstream oss;
         caller.call("rx_udpsocksize", {}, -1, GET, oss);
-        std::string s = (oss.str()).erase(0, strlen("rx_udpsocksize "));
+        std::string const s = (oss.str()).erase(0, strlen("rx_udpsocksize "));
         val = std::stol(s);
     }
     {
         std::ostringstream oss;
         caller.call("rx_realudpsocksize", {}, -1, GET, oss);
-        std::string s = (oss.str()).erase(0, strlen("rx_realudpsocksize "));
-        uint64_t rval = std::stol(s);
+        std::string const s = (oss.str()).erase(0, strlen("rx_realudpsocksize "));
+        uint64_t const rval = std::stol(s);
         REQUIRE(rval >= val * 2);
     }
 }
@@ -476,10 +476,10 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         REQUIRE_THROWS(caller.call("rx_roi", {"5", "10"}, -1, PUT));
     } else {
         auto prev_val = det.getRxROI();
-        defs::xy detsize = det.getDetectorSize();
+        defs::xy const detsize = det.getDetectorSize();
         auto portSize = det.getPortSize()[0];
-        int delta = 50;
-        int numinterfaces = det.getNumberofUDPInterfaces().tsquash(
+        int const delta = 50;
+        int const numinterfaces = det.getNumberofUDPInterfaces().tsquash(
             "inconsistent number of interfaces");
 
         // 1d
@@ -757,11 +757,11 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         // TODO: check roi in master file
         {
             REQUIRE_NOTHROW(create_files_for_acquire(det, caller));
-            testFileInfo file_info;
-            std::string master_file_prefix =
+            testFileInfo const file_info;
+            std::string const master_file_prefix =
                 file_info.getMasterFileNamePrefix();
 
-            std::string fname = master_file_prefix + ".json";
+            std::string const fname = master_file_prefix + ".json";
             REQUIRE(std::filesystem::exists(fname) == true);
 #ifdef HDF5C
             fname = master_file_prefix + ".h5";

slsDetectorSoftware/tests/Caller/test-Caller.cpp

@@ -24,7 +24,7 @@ TEST_CASE("Calling help doesn't throw or cause segfault") {
     // Dont add [.cmdcall] tag this should run with normal tests
     Caller caller(nullptr);
     std::ostringstream os;
-    for (std::string cmd : caller.getAllCommands())
+    for (std::string const& cmd : caller.getAllCommands())
         REQUIRE_NOTHROW(
             caller.call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os));
 }
@@ -291,7 +291,7 @@ TEST_CASE("threshold", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string senergy = std::to_string(prev_energies[0]);
+            std::string const senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("threshold", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() == "threshold [" + senergy + ", standard]\n");
@@ -319,15 +319,15 @@ TEST_CASE("threshold", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string senergy = std::to_string(prev_energies[0]);
+            std::string const senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("threshold", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() == "threshold [" + senergy + ", standard]\n");
             caller.call("threshold", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "threshold [" + senergy + ", " + senergy +
                                       ", " + senergy + "]\n");
-            std::string senergy2 = std::to_string(prev_energies[1]);
-            std::string senergy3 = std::to_string(prev_energies[2]);
+            std::string const senergy2 = std::to_string(prev_energies[1]);
+            std::string const senergy3 = std::to_string(prev_energies[2]);
             std::ostringstream oss3, oss4;
             caller.call("threshold", {senergy, senergy2, senergy3, "standard"},
                         -1, PUT, oss3);
@@ -370,7 +370,7 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string senergy = std::to_string(prev_energies[0]);
+            std::string const senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("thresholdnotb", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() ==
@@ -398,7 +398,7 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
         auto prev_energies =
             det.getTrimEnergies().tsquash("inconsistent trim energies to test");
         if (!prev_energies.empty()) {
-            std::string senergy = std::to_string(prev_energies[0]);
+            std::string const senergy = std::to_string(prev_energies[0]);
             std::ostringstream oss1, oss2;
             caller.call("thresholdnotb", {senergy, "standard"}, -1, PUT, oss1);
             REQUIRE(oss1.str() ==
@@ -406,8 +406,8 @@ TEST_CASE("thresholdnotb", "[.cmdcall]") {
             caller.call("threshold", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "threshold [" + senergy + ", " + senergy +
                                       ", " + senergy + "]\n");
-            std::string senergy2 = std::to_string(prev_energies[1]);
-            std::string senergy3 = std::to_string(prev_energies[2]);
+            std::string const senergy2 = std::to_string(prev_energies[1]);
+            std::string const senergy3 = std::to_string(prev_energies[2]);
             std::ostringstream oss3, oss4;
             caller.call("thresholdnotb",
                         {senergy, senergy2, senergy3, "standard"}, -1, PUT,
@@ -528,8 +528,8 @@ TEST_CASE("gappixels", "[.cmdcall]") {
     if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH)
         gapPixelTest = true;
     else if (det_type == defs::EIGER) {
-        bool quad = det.getQuad().squash(false);
-        bool fullModule = (det.getModuleGeometry().y % 2 == 0);
+        bool const quad = det.getQuad().squash(false);
+        bool const fullModule = (det.getModuleGeometry().y % 2 == 0);
         if (quad || fullModule) {
             gapPixelTest = true;
         }
@@ -658,9 +658,9 @@ TEST_CASE("badchannels", "[.cmdcall]") {
 
         REQUIRE_THROWS(caller.call("badchannels", {}, -1, GET));
 
-        std::string fname_put =
+        std::string const fname_put =
             getAbsolutePathFromCurrentProcess(TEST_FILE_NAME_BAD_CHANNELS);
-        std::string fname_get = "/tmp/sls_test_channels.txt";
+        std::string const fname_get = "/tmp/sls_test_channels.txt";
 
         REQUIRE_NOTHROW(caller.call("badchannels", {fname_put}, 0, PUT));
         REQUIRE_NOTHROW(caller.call("badchannels", {fname_get}, 0, GET));
@@ -976,7 +976,7 @@ TEST_CASE("dr", "[.cmdcall]") {
     auto det_type = det.getDetectorType().squash();
     if (det_type == defs::EIGER) {
         auto dr = det.getDynamicRange().squash();
-        std::array<int, 4> vals{4, 8, 16, 32};
+        std::array<int, 4> const vals{4, 8, 16, 32};
         for (const auto val : vals) {
             std::ostringstream oss1, oss2;
             caller.call("dr", {std::to_string(val)}, -1, PUT, oss1);
@@ -988,7 +988,7 @@ TEST_CASE("dr", "[.cmdcall]") {
     } else if (det_type == defs::MYTHEN3) {
         auto dr = det.getDynamicRange().squash();
         // not updated in firmware to support dr 1
-        std::array<int, 3> vals{8, 16, 32};
+        std::array<int, 3> const vals{8, 16, 32};
         for (const auto val : vals) {
             std::ostringstream oss1, oss2;
             caller.call("dr", {std::to_string(val)}, -1, PUT, oss1);
@@ -1542,7 +1542,7 @@ TEST_CASE("powerchip", "[.cmdcall]") {
                 "Inconsistent virtual detector "
                 "server to test powerchip command")) {
             det.setPowerChip(1);
-            int hv = det.getHighVoltage().tsquash(
+            int const hv = det.getHighVoltage().tsquash(
                 "Inconsistent high voltage to test "
                 "powerchip command");
 
@@ -1976,7 +1976,7 @@ TEST_CASE("temp_adc", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_adc", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_adc", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_adc "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_adc "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_adc", {}, -1, GET));
@@ -1991,7 +1991,7 @@ TEST_CASE("temp_fpga", "[.cmdcall]") {
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, 0, GET, oss));
-        std::string s = (oss.str()).erase(0, strlen("temp_fpga "));
+        std::string const s = (oss.str()).erase(0, strlen("temp_fpga "));
         REQUIRE(std::stoi(s) != -1);
     } else {
         REQUIRE_THROWS(caller.call("temp_fpga", {}, -1, GET));
@@ -2075,7 +2075,7 @@ TEST_CASE("defaultdac", "[.cmdcall]") {
             }
         }
         if (det_type == defs::JUNGFRAU) {
-            std::vector<defs::dacIndex> daclist = {
+            std::vector<defs::dacIndex> const daclist = {
                 defs::VREF_PRECH, defs::VREF_DS, defs::VREF_COMP};
             for (auto it : daclist) {
                 auto dacname = ToString(it);
@@ -2955,7 +2955,7 @@ TEST_CASE("txdelay_frame", "[.cmdcall]") {
             det_type == defs::MYTHEN3) {
             val = 5;
         }
-        std::string sval = std::to_string(val);
+        std::string const sval = std::to_string(val);
         {
             std::ostringstream oss1, oss2;
             caller.call("txdelay_frame", {sval}, -1, PUT, oss1);
@@ -2983,8 +2983,8 @@ TEST_CASE("txdelay", "[.cmdcall]") {
              det_type == defs::MYTHEN3) &&
             (det.size() < 2)) {
             REQUIRE_THROWS(caller.call("txdelay", {}, -1, GET));
-            int val = 5;
-            std::string sval = std::to_string(val);
+            int const val = 5;
+            std::string const sval = std::to_string(val);
             {
                 std::ostringstream oss1;
                 caller.call("txdelay", {sval}, -1, PUT, oss1);
@@ -3006,7 +3006,7 @@ TEST_CASE("txdelay", "[.cmdcall]") {
                 det_type == defs::MYTHEN3) {
                 val = 5;
             }
-            std::string sval = std::to_string(val);
+            std::string const sval = std::to_string(val);
             {
                 std::ostringstream oss1, oss2;
                 caller.call("txdelay", {sval}, -1, PUT, oss1);
@@ -3267,7 +3267,7 @@ TEST_CASE("update", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("reg", "[.cmdcall][.definecmds]") {
+TEST_CASE("reg", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3279,19 +3279,19 @@ TEST_CASE("reg", "[.cmdcall][.definecmds]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string saddr = ToStringHex(addr);
+        std::string const saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2;
             caller.call("reg", {saddr, "0x6", "--validate"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "reg " + saddr + " 0x6\n");
+            REQUIRE(oss1.str() == "reg [" + saddr + ", 0x6]\n");
             caller.call("reg", {saddr}, -1, GET, oss2);
             REQUIRE(oss2.str() == "reg 0x6\n");
         }
         {
             std::ostringstream oss1, oss2;
             caller.call("reg", {saddr, "0x5"}, -1, PUT, oss1);
-            REQUIRE(oss1.str() == "reg " + saddr + " 0x5\n");
+            REQUIRE(oss1.str() == "reg [" + saddr + ", 0x5]\n");
             caller.call("reg", {saddr}, -1, GET, oss2);
             REQUIRE(oss2.str() == "reg 0x5\n");
         }
@@ -3326,7 +3326,7 @@ TEST_CASE("adcreg", "[.cmdcall]") {
     }
 }
 
-TEST_CASE("setbit", "[.cmdcall][.definecmds]") {
+TEST_CASE("setbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3338,7 +3338,7 @@ TEST_CASE("setbit", "[.cmdcall][.definecmds]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string saddr = ToStringHex(addr);
+        std::string const saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2, oss3;
@@ -3356,7 +3356,7 @@ TEST_CASE("setbit", "[.cmdcall][.definecmds]") {
     }
 }
 
-TEST_CASE("clearbit", "[.cmdcall][.definecmds]") {
+TEST_CASE("clearbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3368,7 +3368,7 @@ TEST_CASE("clearbit", "[.cmdcall][.definecmds]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string saddr = ToStringHex(addr);
+        std::string const saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2, oss3;
@@ -3386,7 +3386,7 @@ TEST_CASE("clearbit", "[.cmdcall][.definecmds]") {
     }
 }
 
-TEST_CASE("getbit", "[.cmdcall][.definecmds]") {
+TEST_CASE("getbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
@@ -3398,7 +3398,7 @@ TEST_CASE("getbit", "[.cmdcall][.definecmds]") {
         if (det_type == defs::GOTTHARD2) {
             addr = 0x298;
         }
-        std::string saddr = ToStringHex(addr);
+        std::string const saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
         {
             std::ostringstream oss1, oss2;

slsDetectorSoftware/tests/test-CmdParser.cpp

@@ -15,7 +15,7 @@ using vs = std::vector<std::string>;
 
 SCENARIO("Construction", "[support]") {
     GIVEN("A default constructed CmdParser") {
-        CmdParser p;
+        CmdParser const p;
         THEN("The state of the object is valid") {
             REQUIRE(p.detector_id() == -1);
             REQUIRE(p.multi_id() == 0);
@@ -31,7 +31,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
     GIVEN("A CmdParser") {
         CmdParser p;
         WHEN("Parsing an empty string") {
-            std::string s;
+            std::string const s;
             p.Parse(s);
             THEN("command and arguments are empty") {
                 REQUIRE(p.detector_id() == -1);
@@ -42,7 +42,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
             }
         }
         WHEN("Parsing a string with a single command") {
-            std::string s = "vrf";
+            std::string const s = "vrf";
             p.Parse(s);
             THEN("command is assigned and id's remain default") {
                 REQUIRE(p.command() == "vrf");
@@ -53,7 +53,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
             }
         }
         WHEN("Parsing a string with command and value") {
-            std::string s = "vthreshold 1500";
+            std::string const s = "vthreshold 1500";
             p.Parse(s);
             THEN("cmd and value are assigned and id's remain default") {
                 REQUIRE(p.command() == "vthreshold");
@@ -98,7 +98,7 @@ SCENARIO("Parsing a string with the command line parser", "[support]") {
         }
 
         WHEN("Parsing string with cmd and multiple arguments") {
-            std::string s = "trimen 5000 6000 7000";
+            std::string const s = "trimen 5000 6000 7000";
             p.Parse(s);
             THEN("cmd and args are correct") {
                 REQUIRE(p.command() == "trimen");
@@ -115,7 +115,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
     GIVEN("A parser") {
         CmdParser p;
         WHEN("Parsing a string with a command and help ") {
-            std::string s = "-h list";
+            std::string const s = "-h list";
 
             THEN("the command is correct and isHelp is set") {
                 p.Parse(s);
@@ -128,7 +128,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
             }
         }
         WHEN("Parsing a string with -h at a different position") {
-            std::string s = "list -h something";
+            std::string const s = "list -h something";
             THEN("its also done right") {
                 p.Parse(s);
                 REQUIRE(p.isHelp());
@@ -138,7 +138,7 @@ SCENARIO("Parsing strings with -h or --help", "[support]") {
             }
         }
         WHEN("Parsing a string with -help at a different position") {
-            std::string s = "list --help something";
+            std::string const s = "list --help something";
             THEN("its also done right") {
                 p.Parse(s);
                 REQUIRE(p.isHelp());
@@ -186,7 +186,7 @@ TEST_CASE("Parse with no arguments results in no command and default id",
           "[support]") {
     // build up argc and argv
     // first argument is the command used to call the binary
-    int argc = 1;
+    int const argc = 1;
     const char *const argv[]{"call"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -200,7 +200,7 @@ TEST_CASE("Parse with no arguments results in no command and default id",
 TEST_CASE(
     "Parse a command without client id and detector id results in default",
     "[support]") {
-    int argc = 2;
+    int const argc = 2;
     const char *const argv[]{"caller", "vrf"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -213,7 +213,7 @@ TEST_CASE(
 
 TEST_CASE("Parse a command with value but without client or detector id",
           "[support]") {
-    int argc = 3;
+    int const argc = 3;
     const char *const argv[]{"caller", "vrf", "3000"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -226,7 +226,7 @@ TEST_CASE("Parse a command with value but without client or detector id",
 }
 
 TEST_CASE("Decodes position") {
-    int argc = 2;
+    int const argc = 2;
     const char *const argv[]{"caller", "7:vrf"};
 
     CmdParser p;
@@ -239,7 +239,7 @@ TEST_CASE("Decodes position") {
 }
 
 TEST_CASE("Decodes double digit position", "[support]") {
-    int argc = 2;
+    int const argc = 2;
     const char *const argv[]{"caller", "73:vcmp"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -251,7 +251,7 @@ TEST_CASE("Decodes double digit position", "[support]") {
 }
 
 TEST_CASE("Decodes position and id", "[support]") {
-    int argc = 2;
+    int const argc = 2;
     const char *const argv[]{"caller", "5-8:vrf"};
     CmdParser p;
     p.Parse(argc, argv);
@@ -263,7 +263,7 @@ TEST_CASE("Decodes position and id", "[support]") {
 }
 
 TEST_CASE("Double digit id", "[support]") {
-    int argc = 2;
+    int const argc = 2;
     const char *const argv[]{"caller", "56-8:vrf"};
     CmdParser p;
     p.Parse(argc, argv);

slsDetectorSoftware/tests/test-CtbConfig.cpp

@@ -6,18 +6,15 @@
 #include "CtbConfig.h"
 #include "SharedMemory.h"
 #include <fstream>
-#include <set>
 
 namespace sls {
 
 TEST_CASE("Default construction") {
-    /*TODO static_assert(sizeof(CtbConfig) ==
-                      (2 * sizeof(int) + (18 + 32 + 64 + 5 + 8) * 32) +
-                        (sizeof(size_t) * 2) + ((sizeof(uint32_t) + 32) * 64) +
-       ((32 + sizeof(uint32_t) + sizeof(int)) * 64), "Size of CtbConfig does not
-       match "); //8952 (8696)*/
+    static_assert(sizeof(CtbConfig) ==
+                      (2 * sizeof(int) + (18 + 32 + 64 + 5 + 8) * 20),
+                  "Size of CtbConfig does not match ");
 
-    CtbConfig c;
+    CtbConfig const c;
     auto dacnames = c.getDacNames();
     REQUIRE(dacnames.size() == 18);
     REQUIRE(dacnames[0] == "DAC0");
@@ -49,16 +46,6 @@ TEST_CASE("Default construction") {
     REQUIRE(sensenames[1] == "SLOWADC1");
     REQUIRE(sensenames[2] == "SLOWADC2");
     REQUIRE(sensenames[3] == "SLOWADC3");
-    auto regisernames = c.getRegisterNames();
-    REQUIRE(regisernames.size() == 0);
-    auto bitnames = c.getBitNames();
-    REQUIRE(bitnames.size() == 0);
-    REQUIRE(c.getRegisterNamesCount() == 0);
-    auto registerNames = c.getRegisterNames();
-    REQUIRE(registerNames.size() == 0);
-    REQUIRE(c.getBitNamesCount() == 0);
-    auto bitNames = c.getBitNames();
-    REQUIRE(bitNames.size() == 0);
 }
 
 TEST_CASE("Set and get a single dac name") {
@@ -94,168 +81,8 @@ TEST_CASE("Copy a CTB config") {
 TEST_CASE("Move CtbConfig ") {
     CtbConfig c1;
     c1.setDacName(3, "yetanothername");
-    CtbConfig c2(std::move(c1));
+    CtbConfig const c2(std::move(c1));
     REQUIRE(c2.getDacName(3) == "yetanothername");
 }
 
-TEST_CASE("Add or modify a register name", "[.reg]") {
-    CtbConfig c;
-    auto addr = RegisterAddress(100);
-    auto addr1 = RegisterAddress(300);
-
-    REQUIRE(c.getRegisterNamesCount() == 0);
-    REQUIRE_THROWS(
-        c.setRegisterName("reg1_with_a_really_long_name_to_crash", addr));
-    // add an entry
-    REQUIRE_NOTHROW(c.setRegisterName("reg1", addr));
-    REQUIRE(c.getRegisterName(addr) == "reg1");
-    REQUIRE(c.getRegisterAddress("reg1") == addr);
-    REQUIRE(c.getRegisterNamesCount() == 1);
-    // modify an entry
-    REQUIRE_NOTHROW(c.setRegisterName("reg1", addr1));
-    REQUIRE(c.getRegisterAddress("reg1") == addr1);
-    REQUIRE(c.getRegisterName(addr1) == "reg1");
-    // clear all entries
-    REQUIRE_NOTHROW(c.clearRegisterNames());
-    REQUIRE(c.getRegisterNamesCount() == 0);
-    REQUIRE_THROWS(c.getRegisterName(addr));
-    REQUIRE_THROWS(c.getRegisterAddress("reg1"));
-    REQUIRE_THROWS(c.getRegisterName(addr1));
-}
-
-TEST_CASE("Add a register list", "[.reg]") {
-    CtbConfig c;
-    REQUIRE(c.getRegisterNamesCount() == 0);
-
-    // add a list
-    std::map<std::string, RegisterAddress> list = {
-        {"reg1", RegisterAddress(0x100)},
-        {"reg2", RegisterAddress(0x200)},
-        {"reg3", RegisterAddress(0x300)}};
-    REQUIRE_NOTHROW(c.setRegisterNames(list));
-    REQUIRE(c.getRegisterNamesCount() == static_cast<int>(list.size()));
-    auto names = c.getRegisterNames();
-    REQUIRE(names.size() == 3);
-
-    // TODO std::set<RegisterAddress> seen_values;
-    for (const auto &[key, val] : list) {
-        // check for duplicate keys, and key-value match
-        REQUIRE(names.count(key) == 1);
-        REQUIRE(names.at(key) == val);
-
-        // check for duplicate values
-        // TODO REQUIRE(seen_values.count(val) == 0);
-        // TODO seen_values.insert(val);
-    }
-
-    // clear all entries
-    REQUIRE_NOTHROW(c.clearRegisterNames());
-    REQUIRE(c.getRegisterNames().size() == 0);
-}
-
-TEST_CASE("Finding a regiser name or address", "[.reg]") {
-    CtbConfig c;
-    RegisterAddress addr1(0x100);
-    RegisterAddress addr2(0x200);
-    RegisterAddress addr3(0x300);
-
-    // find nothing
-    REQUIRE(c.getRegisterNamesCount() == 0);
-    REQUIRE_THROWS(c.getRegisterName(addr1));
-    REQUIRE_THROWS(c.getRegisterAddress("reg1"));
-
-    std::map<std::string, RegisterAddress> list = {
-        {"reg1", addr1}, {"reg2", addr2}, {"reg3", addr3}};
-    REQUIRE_NOTHROW(c.setRegisterNames(list));
-
-    // find
-    REQUIRE(c.getRegisterName(addr1) == "reg1");
-    REQUIRE(c.getRegisterName(addr2) == "reg2");
-    REQUIRE(c.getRegisterAddress("reg3") == addr3);
-}
-
-TEST_CASE("Add or modify a bit name", "[.reg]") {
-    CtbConfig c;
-    RegisterAddress addr(0x100);
-    BitAddress pos(addr, 2);
-    BitAddress pos1(addr, 5);
-
-    REQUIRE(c.getBitNamesCount() == 0);
-
-    REQUIRE_THROWS(c.setBitName("bit1_with_a_really_long_name_to_crash",
-                                BitAddress(addr, 100)));
-    REQUIRE_THROWS(c.setBitName("bit1", BitAddress(addr, 32)));
-    REQUIRE_THROWS(c.setBitName("bit1", BitAddress(addr, -1)));
-
-    // add an entry
-    REQUIRE_NOTHROW(c.setBitName("bit1", pos));
-    REQUIRE(c.getBitName(pos) == "bit1");
-    REQUIRE(c.getBitAddress("bit1") == pos);
-    REQUIRE(c.getBitNamesCount() == 1);
-    // modify an entry
-    REQUIRE_NOTHROW(c.setBitName("bit1", pos1));
-    REQUIRE(c.getBitAddress("bit1") == pos1);
-    REQUIRE(c.getBitName(pos1) == "bit1");
-    // clear all entries
-    REQUIRE_NOTHROW(c.clearBitNames());
-    REQUIRE(c.getBitNamesCount() == 0);
-    REQUIRE_THROWS(c.getBitName(pos));
-    REQUIRE_THROWS(c.getBitAddress("bit1"));
-    REQUIRE_THROWS(c.getBitName(pos1));
-}
-
-TEST_CASE("Add a bit list", "[.reg]") {
-    CtbConfig c;
-    REQUIRE(c.getBitNamesCount() == 0);
-
-    RegisterAddress addr(0x100);
-    BitAddress pos1(addr, 2);
-    BitAddress pos2(addr, 21);
-
-    BitAddress pos3(addr, 31);
-
-    // add a list
-    std::map<std::string, BitAddress> list = {
-        {"bit1", pos1}, {"bit2", pos2}, {"bit3", pos3}};
-    REQUIRE_NOTHROW(c.setBitNames(list));
-    REQUIRE(c.getBitNamesCount() == 3);
-    auto names = c.getBitNames();
-    REQUIRE(names.size() == 3);
-
-    // TODO std::set<BitAddress> seen_values;
-    for (const auto &[key, val] : list) {
-        // check for duplicate keys, and key-value match
-        REQUIRE(names.count(key) == 1);
-        REQUIRE(names.at(key) == val);
-
-        // check for duplicate values
-        // TODO REQUIRE(seen_values.count(val) == 0);
-        // TODO seen_values.insert(val);
-    }
-
-    // clear all entries
-    REQUIRE_NOTHROW(c.clearBitNames());
-    REQUIRE(c.getBitNames().size() == 0);
-}
-
-TEST_CASE("Finding a bit value", "[.reg]") {
-    CtbConfig c;
-    RegisterAddress addr(0x100);
-    BitAddress pos(addr, 2);
-    BitAddress pos1(addr, 21);
-    BitAddress pos2(addr, 31);
-
-    // find nothing
-    REQUIRE(c.getBitNamesCount() == 0);
-    REQUIRE_THROWS(c.getBitAddress("bit"));
-
-    std::map<std::string, BitAddress> list = {
-        {"bit0", pos}, {"bit1", pos1}, {"bit2", pos2}};
-    REQUIRE_NOTHROW(c.setBitNames(list));
-
-    // find
-    REQUIRE(c.getBitAddress("bit2") == pos2);
-    REQUIRE(c.getBitName(pos1) == "bit1");
-}
-
 } // namespace sls

slsDetectorSoftware/tests/test-MapOnStack.cpp

@@ -1,133 +0,0 @@
-#include "MapOnStack.h"
-#include "catch.hpp"
-#include "sls/bit_utils.h"
-
-#include <string>
-
-namespace sls {
-
-using Key = FixedString<32>;
-
-TEST_CASE("MapOnStack with int values") {
-    MapOnStack<Key, int, 64, true> map;
-
-    map.addKey("bit0", 55);
-    map.addKeyOrSetValue("bit1", 66);
-    REQUIRE(map.size() == 2);
-    REQUIRE(map.capacity() == 64);
-    REQUIRE(map.empty() == false);
-
-    REQUIRE(map.getValue("bit0") == 55);
-    REQUIRE(map.getValue("bit1") == 66);
-
-    // Duplicate key throws
-    REQUIRE_THROWS(map.addKey("bit0", 77));
-    // Duplicate value throws
-    REQUIRE_THROWS(map.addKey("bit2", 66));
-
-    // modifies
-    map.addKeyOrSetValue("bit0", 77);
-    REQUIRE(map.getValue("bit0") == 77);
-
-    // containsKey / hasValue
-    REQUIRE(map.containsKey("bit1"));
-    REQUIRE(map.hasValue(77));
-
-    // Clear map
-    map.clear();
-    REQUIRE(map.empty());
-    REQUIRE(map.size() == 0);
-    REQUIRE(map.capacity() == 64);
-}
-
-TEST_CASE("MapOnStack with BitAddress values") {
-    MapOnStack<Key, BitAddress, 64, true> map;
-
-    RegisterAddress addr0(0x100);
-    RegisterAddress addr1(0x200);
-    BitAddress b0(addr0, 0);
-    BitAddress b1(addr0, 1);
-    BitAddress b2(addr1, 0);
-
-    map.addKey("bit0", b0);
-    map.addKeyOrSetValue("bit1", b1);
-    REQUIRE(map.size() == 2);
-    REQUIRE(map.capacity() == 64);
-    REQUIRE(map.empty() == false);
-
-    REQUIRE(map.getValue("bit0") == b0);
-    REQUIRE(map.getValue("bit1") == b1);
-
-    // Duplicate key throws
-    REQUIRE_THROWS(map.addKey("bit0", b2));
-    // Duplicate value throws
-    REQUIRE_THROWS(map.addKey("bit2", b1));
-
-    // modifies
-    map.addKeyOrSetValue("bit0", b2);
-    REQUIRE(map.getValue("bit0") == b2);
-
-    // containsKey / hasValue
-    REQUIRE(map.containsKey("bit1"));
-    REQUIRE(map.hasValue(b2));
-
-    // Clear map
-    map.clear();
-    REQUIRE(map.empty());
-    REQUIRE(map.size() == 0);
-    REQUIRE(map.capacity() == 64);
-}
-
-TEST_CASE("Set and get a single entry") {
-    MapOnStack<Key, RegisterAddress, 64, true> map;
-    RegisterAddress addr0(0x100);
-
-    map.addKey("bit0", addr0);
-    auto entries = map.getMap();
-    REQUIRE(entries.size() == 1);
-
-    REQUIRE(map.getValue("bit0") == addr0);
-    REQUIRE(entries["bit0"] == addr0);
-}
-
-TEST_CASE("Set a name that is too large throws") {
-    MapOnStack<Key, int, 64, true> map;
-    REQUIRE_THROWS(map.addKey("somestringthatisreallytolongforadatac", 12));
-}
-
-TEST_CASE("Length of dac name cannot be 0") {
-    MapOnStack<Key, int, 64, true> map;
-    REQUIRE_THROWS(map.addKey("", 12));
-}
-
-TEST_CASE("Copy a MapOnStack") {
-    MapOnStack<Key, int, 64, true> m1;
-    m1.addKey("key1", 12);
-
-    auto m2 = m1;
-    // change the first object
-    // to detecto shallow copy
-    m1.setValue("key1", 34);
-    REQUIRE(m2.getValue("key1") == 12);
-}
-
-TEST_CASE("Move MapOnStack ") {
-    MapOnStack<Key, int, 64, true> m1;
-    m1.addKey("key1", 12);
-    MapOnStack<Key, int, 64, true> m2(std::move(m1));
-    REQUIRE(m1.size() == 0);
-    REQUIRE(m2.size() == 1);
-}
-
-TEST_CASE("Set map from std::map") {
-    MapOnStack<Key, int, 64, true> map;
-    std::map<Key, int> m1 = {{"key1", 11}, {"key2", 22}, {"key3", 33}};
-    map.setMap(m1);
-    REQUIRE(map.size() == 3);
-    REQUIRE(map.getValue("key2") == 22);
-
-    auto retrieved_map = map.getMap();
-    REQUIRE(retrieved_map.size() == 3);
-    REQUIRE(retrieved_map["key3"] == 33);
-
-} // namespace sls

slsDetectorSoftware/tests/test-Module.cpp

@@ -10,7 +10,7 @@ namespace sls {
 using dt = slsDetectorDefs::detectorType;
 TEST_CASE("Construction with a defined detector type") {
     freeSharedMemory(0, 0); // clean up to start test
-    Module m(dt::EIGER);
+    Module const m(dt::EIGER);
     REQUIRE(m.getDetectorType() == dt::EIGER);
     freeSharedMemory(0, 0); // clean up
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -19,10 +19,10 @@ TEST_CASE("Construction with a defined detector type") {
 
 TEST_CASE("Read back detector type from shm") {
     // Create specific detector in order to create shm
-    Module m(dt::JUNGFRAU);
+    Module const m(dt::JUNGFRAU);
 
     // New detector that reads type from shm
-    Module m2;
+    Module const m2;
     REQUIRE(m2.getDetectorType() == dt::JUNGFRAU);
 
     // Now both objects point to the same shm so we can only
@@ -33,7 +33,7 @@ TEST_CASE("Read back detector type from shm") {
 }
 
 TEST_CASE("Is shm fixed pattern shm compatible") {
-    Module m(dt::JUNGFRAU);
+    Module const m(dt::JUNGFRAU);
 
     // Should be true since we just created the shm
     REQUIRE(m.isFixedPatternSharedMemoryCompatible() == true);
@@ -53,7 +53,7 @@ TEST_CASE("Is shm fixed pattern shm compatible") {
 }
 
 TEST_CASE("Get default control port") {
-    Module m(dt::MYTHEN3);
+    Module const m(dt::MYTHEN3);
     REQUIRE(m.getControlPort() == 1952);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -61,7 +61,7 @@ TEST_CASE("Get default control port") {
 }
 
 TEST_CASE("Get default stop port") {
-    Module m(dt::GOTTHARD2);
+    Module const m(dt::GOTTHARD2);
     REQUIRE(m.getStopPort() == 1953);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);
@@ -69,7 +69,7 @@ TEST_CASE("Get default stop port") {
 }
 
 TEST_CASE("Get default receiver TCP port") {
-    Module m(dt::MYTHEN3);
+    Module const m(dt::MYTHEN3);
     REQUIRE(m.getReceiverPort() == 1954);
     freeSharedMemory(0, 0);
     SharedMemory<sharedModule> moduleShm(0, 0);

slsDetectorSoftware/tests/test-Pattern.cpp

@@ -20,7 +20,7 @@ TEST_CASE("Copy construct pattern") {
 }
 
 TEST_CASE("Compare patterns") {
-    Pattern p;
+    Pattern const p;
     Pattern p1;
     REQUIRE(p == p1);
 

slsDetectorSoftware/tests/test-Result.cpp

@@ -13,7 +13,7 @@ TEST_CASE("Result looks and behaves like a standard container") {
 }
 
 TEST_CASE("Default construction is possible and gives an empty result") {
-    Result<int> res;
+    Result<int> const res;
     REQUIRE(res.size() == 0);
     REQUIRE(res.empty() == true);
 }
@@ -38,7 +38,7 @@ TEST_CASE("Like vector it can be constructed from size and value") {
 }
 
 TEST_CASE("Result can be iterated using modern syntax") {
-    Result<int> res{0, 1, 2, 3, 4, 5};
+    Result<int> const res{0, 1, 2, 3, 4, 5};
 
     int i = 0;
     for (const auto &r : res)
@@ -46,28 +46,28 @@ TEST_CASE("Result can be iterated using modern syntax") {
 }
 
 TEST_CASE("Calling squash on an empty Result produces default value") {
-    Result<double> res;
+    Result<double> const res;
     REQUIRE(res.squash() == 0.);
 
-    Result<unsigned> res2;
+    Result<unsigned> const res2;
     REQUIRE(res2.squash() == 0u);
 
-    Result<std::string> res3;
+    Result<std::string> const res3;
     REQUIRE(res3.squash() == "");
 }
 
 TEST_CASE("When equal squash gives the front value") {
-    Result<int> res{3, 3, 3};
+    Result<int> const res{3, 3, 3};
     REQUIRE(res.squash() == 3);
 }
 
 TEST_CASE("When elements are not equal squash gives default value") {
-    Result<int> res{3, 3, 3, 5};
+    Result<int> const res{3, 3, 3, 5};
     REQUIRE(res.squash() == 0);
 }
 
 TEST_CASE("String compare with squash") {
-    Result<std::string> res{"hej", "hej", "hej"};
+    Result<std::string> const res{"hej", "hej", "hej"};
     REQUIRE(res.squash() == "hej");
 }
 
@@ -113,13 +113,13 @@ TEST_CASE("Check if elements are equal") {
 
 TEST_CASE("Result can be converted to std::vector") {
     Result<short> res{1, 2, 3, 4, 5};
-    std::vector<short> vec{1, 2, 3, 4, 5};
-    std::vector<short> vec2 = res;
+    std::vector<short> const vec{1, 2, 3, 4, 5};
+    std::vector<short> const vec2 = res;
     REQUIRE(vec2 == vec);
 }
 
 TEST_CASE("Result can be printed using <<") {
-    Result<int> res{1, 2, 3};
+    Result<int> const res{1, 2, 3};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[1, 2, 3]");
@@ -139,8 +139,8 @@ TEST_CASE("Convert from Result<int> to Result<ns>") {
 
 TEST_CASE("Result of vectors") {
     using VecVec = std::vector<std::vector<int>>;
-    VecVec vecvec{{1, 2, 3}, {4, 5, 6}};
-    Result<VecVec> res{vecvec};
+    VecVec const vecvec{{1, 2, 3}, {4, 5, 6}};
+    Result<VecVec> const res{vecvec};
 }
 
 TEST_CASE("Free function begin end") {
@@ -159,30 +159,30 @@ TEST_CASE("Sorting a Result") {
 }
 
 TEST_CASE("Printing Result<std::string>") {
-    Result<std::string> res{"ein", "zwei", "drei"};
+    Result<std::string> const res{"ein", "zwei", "drei"};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[ein, zwei, drei]");
 }
 
 TEST_CASE("Printing Result<int>") {
-    Result<int> res{1, 2, 3};
+    Result<int> const res{1, 2, 3};
     std::ostringstream os;
     os << res;
     REQUIRE(os.str() == "[1, 2, 3]");
 }
 
 TEST_CASE("String conversions") {
-    Result<int> res{1, 2, 3};
+    Result<int> const res{1, 2, 3};
     REQUIRE(ToString(res) == "[1, 2, 3]");
 
-    Result<std::string> res2{"one", "two", "three"};
+    Result<std::string> const res2{"one", "two", "three"};
     REQUIRE(ToString(res2) == "[one, two, three]");
 
     using Smap = std::map<std::string, std::string>;
     Smap m;
     m["one"] = "1";
-    Result<Smap> res3{m, m, m};
+    Result<Smap> const res3{m, m, m};
     REQUIRE(res3.size() == 3);
     REQUIRE(ToString(res3) == "[{one: 1}, {one: 1}, {one: 1}]");
 
@@ -191,25 +191,25 @@ TEST_CASE("String conversions") {
     m2["two"] = "2";
     m2["three"] = "3";
 
-    Result<Smap> res4{m, m2, m};
+    Result<Smap> const res4{m, m2, m};
     REQUIRE(ToString(res4) ==
             "[{one: 1}, {one: 1, three: 3, two: 2}, {one: 1}]");
 }
 
 TEST_CASE("Any element is equal") {
-    Result<int> r{1, 2, 3, 4, 5};
+    Result<int> const r{1, 2, 3, 4, 5};
     REQUIRE(r.any(3));
     REQUIRE_FALSE(r.any(9));
 }
 
 TEST_CASE("Result contains only the specified elements") {
-    Result<int> r{1, 1, 1};
+    Result<int> const r{1, 1, 1};
     REQUIRE(r.contains_only(1));
     REQUIRE(r.contains_only(1, 1));
 }
 
 TEST_CASE("Only with multiple values") {
-    Result<int> r{1, 1, 2, 1, 2, 1, 1};
+    Result<int> const r{1, 1, 2, 1, 2, 1, 1};
     REQUIRE_FALSE(r.contains_only(1));
     REQUIRE_FALSE(r.contains_only(2));
     REQUIRE(r.contains_only(1, 2));

slsDetectorSoftware/tests/test-SharedMemory.cpp

@@ -39,13 +39,15 @@ void freeShm(const int dindex, const int mIndex) {
 
 constexpr int shm_id = 10;
 
-// macOS does not expose shm in the filesystem
+//macOS does not expose shm in the filesystem
 #ifndef __APPLE__
 
 const std::string file_path =
     std::string("/dev/shm/slsDetectorPackage_detector_") +
     std::to_string(shm_id);
 
+
+
 TEST_CASE("Free obsolete (without isValid)", "[detector][shm]") {
 
     // ensure its clean to start
@@ -103,9 +105,9 @@ TEST_CASE("Create SharedMemory read and write", "[detector][shm]") {
     shm.createSharedMemory();
 
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
-    CHECK(shm.getName() ==
-          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
+    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
+    CHECK(shm.getName() == std::string(SHM_DETECTOR_PREFIX) +
+                               std::to_string(shm_id) + env_name);
     shm()->x = 3;
     shm()->y = 5.7;
     strcpy_safe(shm()->mess, "Some string");
@@ -175,11 +177,11 @@ TEST_CASE("Open two shared memories to the same place", "[detector][shm]") {
 
 TEST_CASE("Move SharedMemory", "[detector][shm]") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
 
     SharedMemory<Data> shm(shm_id, -1);
-    CHECK(shm.getName() ==
-          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
+    CHECK(shm.getName() == std::string(SHM_DETECTOR_PREFIX) +
+                               std::to_string(shm_id) + env_name);
     shm.createSharedMemory();
     shm()->x = 9;
 
@@ -189,14 +191,14 @@ TEST_CASE("Move SharedMemory", "[detector][shm]") {
     CHECK(shm2()->x == 9);
     REQUIRE_THROWS(
         shm()); // trying to access should throw instead of returning a nullptr
-    CHECK(shm2.getName() ==
-          std::string(SHM_DETECTOR_PREFIX) + std::to_string(shm_id) + env_name);
+    CHECK(shm2.getName() == std::string(SHM_DETECTOR_PREFIX) +
+                                std::to_string(shm_id) + env_name);
     shm2.removeSharedMemory();
 }
 
 TEST_CASE("Create several shared memories", "[detector][shm]") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
 
     constexpr int N = 5;
     std::vector<SharedMemory<Data>> v;
@@ -223,9 +225,9 @@ TEST_CASE("Create several shared memories", "[detector][shm]") {
 
 TEST_CASE("Create create a shared memory with a tag") {
     const char *env_p = std::getenv(SHM_ENV_NAME);
-    std::string env_name = env_p ? ("_" + std::string(env_p)) : "";
+    std::string const env_name = env_p ? ("_" + std::string(env_p)) : "";
 
-    SharedMemory<Data> shm(0, -1, "ctbdacs");
+    SharedMemory<Data> const shm(0, -1, "ctbdacs");
     REQUIRE(shm.getName() ==
             std::string(SHM_DETECTOR_PREFIX) + "0" + env_name + "_ctbdacs");
 }
@@ -240,9 +242,8 @@ TEST_CASE("Create create a shared memory with a tag when SLSDETNAME is set") {
     unsetenv(SHM_ENV_NAME);
     setenv(SHM_ENV_NAME, "myprefix", 1);
 
-    SharedMemory<Data> shm(0, -1, "ctbdacs");
-    REQUIRE(shm.getName() ==
-            std::string(SHM_DETECTOR_PREFIX) + "0_myprefix_ctbdacs");
+    SharedMemory<Data> const shm(0, -1, "ctbdacs");
+    REQUIRE(shm.getName() == std::string(SHM_DETECTOR_PREFIX) + "0_myprefix_ctbdacs");
 
     // Clean up after us
     if (old_slsdetname.empty())

slsReceiverSoftware/src/Arping.cpp

@@ -38,7 +38,7 @@ void Arping::SetInterfacesAndIps(const int index, const std::string &interface,
     // create commands to arping
     std::ostringstream os;
     os << "arping -c 1 -U -I " << interface << " " << ip;
-    std::string cmd = os.str();
+    std::string const cmd = os.str();
     commands[index] = cmd;
 }
 
@@ -84,7 +84,7 @@ void Arping::StopProcess() {
 
 void Arping::ProcessExecution() {
     while (true) {
-        std::string error = ExecuteCommands();
+        std::string const error = ExecuteCommands();
         // just print (was already tested at Process start)
         if (!error.empty()) {
             LOG(logERROR) << error;
@@ -101,7 +101,7 @@ void Arping::TestForErrors() {
             "Could not arping. Interface not set up in arping Process");
     }
     // test if arping commands throw an error
-    std::string error = ExecuteCommands();
+    std::string const error = ExecuteCommands();
     if (!error.empty()) {
         throw RuntimeError(error);
     }

slsReceiverSoftware/src/ClientInterface.cpp

@@ -57,14 +57,14 @@ std::string ClientInterface::getReceiverVersion() { return APIRECEIVER; }
 /***callback functions***/
 void ClientInterface::registerCallBackStartAcquisition(
     void (*func)(const startCallbackHeader, void *), void *arg) {
-    std::lock_guard<std::mutex> lock(callbackMutex);
+    std::lock_guard<std::mutex> const lock(callbackMutex);
     startAcquisitionCallBack = func;
     pStartAcquisition = arg;
 }
 
 void ClientInterface::registerCallBackAcquisitionFinished(
     void (*func)(const endCallbackHeader, void *), void *arg) {
-    std::lock_guard<std::mutex> lock(callbackMutex);
+    std::lock_guard<std::mutex> const lock(callbackMutex);
     acquisitionFinishedCallBack = func;
     pAcquisitionFinished = arg;
 }
@@ -73,7 +73,7 @@ void ClientInterface::registerCallBackRawDataReady(
     void (*func)(sls_receiver_header &, dataCallbackHeader, char *, size_t &,
                  void *),
     void *arg) {
-    std::lock_guard<std::mutex> lock(callbackMutex);
+    std::lock_guard<std::mutex> const lock(callbackMutex);
     rawDataReadyCallBack = func;
     pRawDataReady = arg;
 }
@@ -338,15 +338,15 @@ int ClientInterface::setup_receiver(Interface &socket) {
         // udp setup
         // update retvals only if detmac is not the same as in detector
         if (arg.udp_dstip != 0) {
-            MacAddr r = setUdpIp(IpAddr(arg.udp_dstip));
-            MacAddr detMac{arg.udp_dstmac};
+            MacAddr const r = setUdpIp(IpAddr(arg.udp_dstip));
+            MacAddr const detMac{arg.udp_dstmac};
             if (detMac != r) {
                 retvals[0] = r;
             }
         }
         if (arg.udp_dstip2 != 0) {
-            MacAddr r = setUdpIp2(IpAddr(arg.udp_dstip2));
-            MacAddr detMac{arg.udp_dstmac2};
+            MacAddr const r = setUdpIp2(IpAddr(arg.udp_dstip2));
+            MacAddr const detMac{arg.udp_dstmac2};
             if (detMac != r) {
                 retvals[1] = r;
             }
@@ -467,7 +467,7 @@ void ClientInterface::setDetectorType(detectorType arg) {
     }
     // callbacks after (in setdetectortype, the object is reinitialized)
     {
-        std::lock_guard<std::mutex> lock(callbackMutex);
+        std::lock_guard<std::mutex> const lock(callbackMutex);
         if (startAcquisitionCallBack != nullptr)
             impl()->registerCallBackStartAcquisition(startAcquisitionCallBack,
                                                      pStartAcquisition);
@@ -586,8 +586,8 @@ int ClientInterface::set_num_digital_samples(Interface &socket) {
 int ClientInterface::set_exptime(Interface &socket) {
     int64_t args[2]{-1, -1};
     socket.Receive(args);
-    int gateIndex = static_cast<int>(args[0]);
-    ns value = std::chrono::nanoseconds(args[1]);
+    int const gateIndex = static_cast<int>(args[0]);
+    ns const value = std::chrono::nanoseconds(args[1]);
     LOG(logDEBUG1) << "Setting exptime to " << ToString(value)
                    << " (gateIndex: " << gateIndex << ")";
     switch (gateIndex) {
@@ -635,7 +635,7 @@ int ClientInterface::set_period(Interface &socket) {
 int ClientInterface::set_subexptime(Interface &socket) {
     auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
     LOG(logDEBUG1) << "Setting period to " << ToString(value);
-    ns subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
+    ns const subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
     impl()->setSubExpTime(value);
     impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime);
     return socket.Send(OK);
@@ -780,7 +780,7 @@ int ClientInterface::get_file_dir(Interface &socket) {
 }
 
 int ClientInterface::set_file_name(Interface &socket) {
-    std::string fname = socket.Receive(MAX_STR_LENGTH);
+    std::string const fname = socket.Receive(MAX_STR_LENGTH);
     if (fname.empty()) {
         throw RuntimeError("Cannot set empty file name");
     }
@@ -1115,7 +1115,7 @@ int ClientInterface::set_additional_json_header(Interface &socket) {
 }
 
 int ClientInterface::get_additional_json_header(Interface &socket) {
-    std::map<std::string, std::string> json = impl()->getAdditionalJsonHeader();
+    std::map<std::string, std::string> const json = impl()->getAdditionalJsonHeader();
     LOG(logDEBUG1) << "additional json header:" << ToString(json);
     std::ostringstream oss;
     for (auto &it : json) {
@@ -1319,7 +1319,7 @@ int ClientInterface::set_quad_type(Interface &socket) {
                                std::string(e.what()) + ']');
         }
     }
-    int retval = impl()->getQuad() ? 1 : 0;
+    int const retval = impl()->getQuad() ? 1 : 0;
     validate(quadEnable, retval, "set quad", DEC);
     LOG(logDEBUG1) << "quad retval:" << retval;
     return socket.Send(OK);
@@ -1336,7 +1336,7 @@ int ClientInterface::set_read_n_rows(Interface &socket) {
         LOG(logDEBUG1) << "Setting number of rows:" << arg;
         impl()->setReadNRows(arg);
     }
-    int retval = impl()->getReadNRows();
+    int const retval = impl()->getReadNRows();
     validate(arg, retval, "set number of rows", DEC);
     LOG(logDEBUG1) << "read number of rows:" << retval;
     return socket.Send(OK);
@@ -1516,7 +1516,7 @@ int ClientInterface::set_additional_json_parameter(Interface &socket) {
 }
 
 int ClientInterface::get_additional_json_parameter(Interface &socket) {
-    std::string key = socket.Receive(SHORT_STR_LENGTH);
+    std::string const key = socket.Receive(SHORT_STR_LENGTH);
     std::string value = impl()->getAdditionalJsonParameter(key);
     value.resize(SHORT_STR_LENGTH);
     return socket.sendResult(value);
@@ -1541,7 +1541,7 @@ int ClientInterface::set_num_gates(Interface &socket) {
 int ClientInterface::set_gate_delay(Interface &socket) {
     int64_t args[2]{-1, -1};
     socket.Receive(args);
-    int gateIndex = static_cast<int>(args[0]);
+    int const gateIndex = static_cast<int>(args[0]);
     auto value = std::chrono::nanoseconds(args[1]);
     LOG(logDEBUG1) << "Setting gate delay to " << ToString(value)
                    << " (gateIndex: " << gateIndex << ")";
@@ -1657,7 +1657,7 @@ int ClientInterface::set_all_threshold(Interface &socket) {
 int ClientInterface::set_detector_datastream(Interface &socket) {
     int args[2]{-1, -1};
     socket.Receive(args);
-    portPosition port = static_cast<portPosition>(args[0]);
+    portPosition const port = static_cast<portPosition>(args[0]);
     switch (port) {
     case LEFT:
     case RIGHT:
@@ -1665,7 +1665,7 @@ int ClientInterface::set_detector_datastream(Interface &socket) {
     default:
         throw RuntimeError("Invalid port type");
     }
-    bool enable = static_cast<int>(args[1]);
+    bool const enable = static_cast<int>(args[1]);
     LOG(logDEBUG1) << "Setting datastream (" << ToString(port) << ") to "
                    << ToString(enable);
     if (detType != EIGER)

slsReceiverSoftware/src/CommandLineOptions.cpp

@@ -21,7 +21,7 @@ ParsedOptions CommandLineOptions::parse(const std::vector<std::string> &args) {
     for (const auto &arg : args) {
         argv.push_back(const_cast<char *>(arg.c_str()));
     }
-    int argc = static_cast<int>(argv.size());
+    int const argc = static_cast<int>(argv.size());
     return parse(argc, argv.data());
 }
 
@@ -76,7 +76,7 @@ ParsedOptions CommandLineOptions::parse(int argc, char *argv[]) {
         }
 
         // parse deprecated arguments
-        std::vector<std::string> args(argv, argv + argc);
+        std::vector<std::string> const args(argv, argv + argc);
         auto [p, n, o] = ParseDeprecated(args);
         // set options
         base.port = p;
@@ -251,7 +251,7 @@ void CommandLineOptions::handleAppSpecificOption(int opt, const char *optarg,
 std::tuple<uint16_t, uint16_t, bool>
 CommandLineOptions::ParseDeprecated(const std::vector<std::string> &args) {
 
-    size_t nargs = args.size();
+    size_t const nargs = args.size();
     if (nargs != 1 && nargs != 3 && nargs != 4) {
         throw sls::RuntimeError("Invalid number of arguments.");
     }
@@ -266,8 +266,8 @@ CommandLineOptions::ParseDeprecated(const std::vector<std::string> &args) {
     }
 
     // parse deprecated arguments
-    uint16_t p = parsePort(args[1].c_str());
-    uint16_t n = parseNumReceivers(args[2].c_str());
+    uint16_t const p = parsePort(args[1].c_str());
+    uint16_t const n = parseNumReceivers(args[2].c_str());
     bool o = false;
     if (nargs == 4) {
         try {

slsReceiverSoftware/src/DataProcessor.cpp

@@ -93,7 +93,7 @@ void DataProcessor::SetNumberofTotalFrames(uint64_t value) {
 
 void DataProcessor::SetAdditionalJsonHeader(
     const std::map<std::string, std::string> &json) {
-    std::lock_guard<std::mutex> lock(additionalJsonMutex);
+    std::lock_guard<std::mutex> const lock(additionalJsonMutex);
     additionalJsonHeader = json;
     isAdditionalJsonUpdated = true;
 }
@@ -254,7 +254,7 @@ std::string DataProcessor::CreateMasterFile(
 
     attr->framesInFile = numFramesCaught;
 
-    std::unique_ptr<File> masterFile{nullptr};
+    std::unique_ptr<File> const masterFile{nullptr};
     switch (fileFormatType) {
 #ifdef HDF5C
     case HDF5:
@@ -325,11 +325,11 @@ void DataProcessor::StopProcessing(char *buf) {
 void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
                                    size_t &firstImageIndex, char *data) {
 
-    uint64_t fnum = header.detHeader.frameNumber;
+    uint64_t const fnum = header.detHeader.frameNumber;
     LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
     currentFrameIndex = fnum;
     numFramesCaught++;
-    uint32_t nump = header.detHeader.packetNumber;
+    uint32_t const nump = header.detHeader.packetNumber;
 
     if (!startedFlag) {
         RecordFirstIndex(fnum);
@@ -390,16 +390,16 @@ void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
         // callbacks
         if (rawDataReadyCallBack != nullptr) {
 
-            uint64_t frameIndex = fnum - firstIndex;
+            uint64_t const frameIndex = fnum - firstIndex;
             // update local copy only if it was updated (to prevent locking each
             // time)
             if (isAdditionalJsonUpdated) {
-                std::lock_guard<std::mutex> lock(additionalJsonMutex);
+                std::lock_guard<std::mutex> const lock(additionalJsonMutex);
                 localAdditionalJsonHeader = additionalJsonHeader;
                 isAdditionalJsonUpdated = false;
             }
 
-            dataCallbackHeader callbackHeader = {
+            dataCallbackHeader const callbackHeader = {
                 udpPortNumber,
                 {static_cast<int>(generalData->nPixelsX),
                  static_cast<int>(generalData->nPixelsY)},
@@ -446,7 +446,7 @@ bool DataProcessor::CheckTimer() {
 
     auto elapsed_s = (end.tv_sec - timerbegin.tv_sec) +
                      (end.tv_nsec - timerbegin.tv_nsec) / 1e9;
-    double timer_s = streamingTimerInMs / 1e3;
+    double const timer_s = streamingTimerInMs / 1e3;
 
     LOG(logDEBUG1) << index << " Timer elapsed time:" << elapsed_s
                    << " seconds";
@@ -480,7 +480,7 @@ void DataProcessor::registerCallBackRawDataReady(
 void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
     LOG(logDEBUG) << index << ": Padding Missing Packets";
 
-    uint32_t pperFrame = generalData->packetsPerFrame;
+    uint32_t const pperFrame = generalData->packetsPerFrame;
 
     uint32_t nmissing = pperFrame - header.detHeader.packetNumber;
     sls_bitset pmask = header.packetsMask;
@@ -489,7 +489,7 @@ void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
     if (generalData->detType == GOTTHARD2 && index != 0) {
         dsize = generalData->vetoDataSize;
     }
-    uint32_t corrected_dsize =
+    uint32_t const corrected_dsize =
         dsize - ((pperFrame * dsize) - generalData->imageSize);
     LOG(logDEBUG1) << "bitmask: " << pmask.to_string();
 
@@ -571,7 +571,7 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
     const auto ctbDbitList = generalData->ctbDbitList;
 
     // TODO! (Erik) Refactor and add tests
-    int ctbDigitalDataBytes = nDigitalDataBytes - ctbDbitOffset;
+    int const ctbDigitalDataBytes = nDigitalDataBytes - ctbDbitOffset;
 
     // no digital data
     if (ctbDigitalDataBytes == 0) {
@@ -618,13 +618,13 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
                 ++dest;
             }
 
-            uint8_t byte_index = bi / 8;
+            uint8_t const byte_index = bi / 8;
 
             // loop through the frame digital data
             for (auto *ptr = source + byte_index;
                  ptr < (source + 8 * numDigitalSamples); ptr += 8) {
                 // get selected bit from each 8 bit
-                uint8_t bit = (*ptr >> bi % 8) & 1;
+                uint8_t const bit = (*ptr >> bi % 8) & 1;
                 *dest |= bit << bitoffset; // stored as least significant
                 ++bitoffset;
                 // extract destination in 8 bit batches
@@ -648,9 +648,9 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
             // loop through digital bit enable vector
             for (auto bi : ctbDbitList) {
                 // get selected bit from each 64 bit
-                uint8_t byte_index = bi / 8;
+                uint8_t const byte_index = bi / 8;
 
-                uint8_t bit = (*(ptr + byte_index) >> (bi % 8)) & 1;
+                uint8_t const bit = (*(ptr + byte_index) >> (bi % 8)) & 1;
                 *dest |= bit << bitoffset;
                 ++bitoffset;
                 // extract destination in 8 bit batches
@@ -684,12 +684,12 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
 
 void DataProcessor::CropImage(size_t &size, char *data) {
     LOG(logDEBUG1) << "Cropping Image to ROI " << ToString(portRoi);
-    int nPixelsX = generalData->nPixelsX;
-    int xmin = portRoi.xmin;
-    int xmax = portRoi.xmax;
+    int const nPixelsX = generalData->nPixelsX;
+    int const xmin = portRoi.xmin;
+    int const xmax = portRoi.xmax;
     int ymin = portRoi.ymin;
-    int ymax = portRoi.ymax;
-    int xwidth = xmax - xmin + 1;
+    int const ymax = portRoi.ymax;
+    int const xwidth = xmax - xmin + 1;
     int ywidth = ymax - ymin + 1;
     if (ymin == -1 || ymax == -1) {
         ywidth = 1;
@@ -697,11 +697,11 @@ void DataProcessor::CropImage(size_t &size, char *data) {
     }
 
     // calculate total roi size
-    double bytesPerPixel = generalData->dynamicRange / 8.00;
-    int startOffset = (int)((nPixelsX * ymin + xmin) * bytesPerPixel);
+    double const bytesPerPixel = generalData->dynamicRange / 8.00;
+    int const startOffset = (int)((nPixelsX * ymin + xmin) * bytesPerPixel);
 
     // write size into memory
-    std::size_t roiImageSize = xwidth * ywidth * bytesPerPixel;
+    std::size_t const roiImageSize = xwidth * ywidth * bytesPerPixel;
     LOG(logDEBUG) << "roiImageSize:" << roiImageSize;
     size = roiImageSize;
 

slsReceiverSoftware/src/DataStreamer.cpp

@@ -48,7 +48,7 @@ void DataStreamer::SetNumberofTotalFrames(uint64_t value) {
 
 void DataStreamer::SetAdditionalJsonHeader(
     const std::map<std::string, std::string> &json) {
-    std::lock_guard<std::mutex> lock(additionalJsonMutex);
+    std::lock_guard<std::mutex> const lock(additionalJsonMutex);
     additionalJsonHeader = json;
     isAdditionalJsonUpdated = true;
 }
@@ -77,7 +77,7 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, size_t firstImageIndex) {
 }
 
 void DataStreamer::CreateZmqSockets(uint16_t port, int hwm) {
-    uint16_t portnum = port + index;
+    uint16_t const portnum = port + index;
     try {
         zmqSocket = new ZmqSocket(portnum);
 
@@ -149,7 +149,7 @@ void DataStreamer::StopProcessing(char *buf) {
 void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size,
                                   char *data) {
 
-    uint64_t fnum = header.frameNumber;
+    uint64_t const fnum = header.frameNumber;
     LOG(logDEBUG1) << "DataStreamer " << index << ": fnum:" << fnum;
 
     if (!SendDataHeader(header, size, generalData->nPixelsX,
@@ -177,8 +177,8 @@ int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
     zHeader.data = true;
     zHeader.jsonversion = SLS_DETECTOR_JSON_HEADER_VERSION;
 
-    uint64_t frameIndex = header.frameNumber - firstIndex;
-    uint64_t acquisitionIndex = header.frameNumber;
+    uint64_t const frameIndex = header.frameNumber - firstIndex;
+    uint64_t const acquisitionIndex = header.frameNumber;
 
     zHeader.dynamicRange = generalData->dynamicRange;
     zHeader.fileIndex = fileIndex;
@@ -212,7 +212,7 @@ int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
 
     // update local copy only if it was updated (to prevent locking each time)
     if (isAdditionalJsonUpdated) {
-        std::lock_guard<std::mutex> lock(additionalJsonMutex);
+        std::lock_guard<std::mutex> const lock(additionalJsonMutex);
         localAdditionalJsonHeader = additionalJsonHeader;
         isAdditionalJsonUpdated = false;
     }

slsReceiverSoftware/src/Fifo.cpp

@@ -41,13 +41,13 @@ void Fifo::CreateFifos(size_t fifoItemSize) {
     fifoFree = new CircularFifo<char>(fifoDepth);
     fifoStream = new CircularFifo<char>(fifoDepth);
     // allocate memory
-    size_t mem_len = fifoItemSize * (size_t)fifoDepth * sizeof(char);
+    size_t const mem_len = fifoItemSize * (size_t)fifoDepth * sizeof(char);
     memory = (char *)malloc(mem_len);
     if (memory == nullptr) {
         throw RuntimeError("Could not allocate memory for fifos");
     }
     memset(memory, 0, mem_len);
-    int pagesize = getpagesize();
+    int const pagesize = getpagesize();
     for (size_t i = 0; i < mem_len; i += pagesize) {
         strcpy(memory + i, "memory");
     }
@@ -84,14 +84,14 @@ void Fifo::DestroyFifos() {
 void Fifo::FreeAddress(char *&address) { fifoFree->push(address); }
 
 void Fifo::GetNewAddress(char *&address) {
-    int temp = fifoFree->getDataValue();
+    int const temp = fifoFree->getDataValue();
     if (temp < status_fifoFree)
         status_fifoFree = temp;
     fifoFree->pop(address);
 }
 
 void Fifo::PushAddress(char *&address) {
-    int temp = fifoBound->getDataValue();
+    int const temp = fifoBound->getDataValue();
     if (temp > status_fifoBound)
         status_fifoBound = temp;
     while (!fifoBound->push(address))
@@ -108,13 +108,13 @@ void Fifo::PushAddressToStream(char *&address) { fifoStream->push(address); }
 void Fifo::PopAddressToStream(char *&address) { fifoStream->pop(address); }
 
 int Fifo::GetMaxLevelForFifoBound() {
-    int temp = status_fifoBound;
+    int const temp = status_fifoBound;
     status_fifoBound = 0;
     return temp;
 }
 
 int Fifo::GetMinLevelForFifoFree() {
-    int temp = status_fifoFree;
+    int const temp = status_fifoFree;
     status_fifoFree = fifoDepth;
     return temp;
 }

slsReceiverSoftware/src/FrameSynchronizerApp.cpp

@@ -65,7 +65,7 @@ FrameStatus *global_frame_status = nullptr;
 
 void cleanup() {
     if (global_frame_status) {
-        std::lock_guard<std::mutex> lock(global_frame_status->mtx);
+        std::lock_guard<std::mutex> const lock(global_frame_status->mtx);
         for (auto &outer_pair : global_frame_status->frames) {
             for (auto &inner_pair : outer_pair.second) {
                 for (zmq_msg_t *msg : inner_pair.second) {
@@ -146,11 +146,11 @@ std::set<uint64_t> get_valid_fnums(const PortFrameMap &port_frame_map) {
 }
 
 int zmq_send_multipart(void *socket, const ZmqMsgList &messages) {
-    size_t num_messages = messages.size();
+    size_t const num_messages = messages.size();
     for (size_t i = 0; i != num_messages; ++i) {
         zmq_msg_t *msg = messages[i];
         // determine flags: ZMQ_SNDMORE for all messages except the last
-        int flags = (i == num_messages - 1) ? 0 : ZMQ_SNDMORE;
+        int const flags = (i == num_messages - 1) ? 0 : ZMQ_SNDMORE;
         if (zmq_msg_send(msg, socket, flags) == -1) {
             LOG(sls::logERROR)
                 << "Error sending message: " << zmq_strerror(zmq_errno());
@@ -164,7 +164,7 @@ void Correlate(FrameStatus *stat) {
     void *context = zmq_ctx_new();
 
     void *socket = zmq_socket(context, ZMQ_PUSH);
-    int rc = zmq_bind(socket, "tcp://*:5555");
+    int const rc = zmq_bind(socket, "tcp://*:5555");
     if (rc != 0) {
         LOG(sls::logERROR) << "failed to bind";
     }
@@ -172,7 +172,7 @@ void Correlate(FrameStatus *stat) {
     while (true) {
         sem_wait(&(stat->available));
         {
-            std::lock_guard<std::mutex> lock(stat->mtx);
+            std::lock_guard<std::mutex> const lock(stat->mtx);
 
             if (stat->terminate) {
                 break;
@@ -304,10 +304,10 @@ void StartAcquisitionCallback(
     }
     oss << "}\n";
 
-    std::string message = oss.str();
+    std::string const message = oss.str();
     LOG(sls::logDEBUG) << "Start Acquisition message:" << std::endl << message;
 
-    int length = message.length();
+    int const length = message.length();
     char *hdata = new char[length];
     memcpy(hdata, message.c_str(), length);
     zmq_msg_t *hmsg = new zmq_msg_t;
@@ -316,7 +316,7 @@ void StartAcquisitionCallback(
     // push zmq msg into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> lock(stat->mtx);
+        std::lock_guard<std::mutex> const lock(stat->mtx);
         stat->headers.push_back(hmsg);
         stat->starting = true;
         // clean up old frames
@@ -355,8 +355,8 @@ void AcquisitionFinishedCallback(
         << sls::ToString(callbackHeader.completeFrames)
         << ", \"lastFrameIndex\":"
         << sls::ToString(callbackHeader.lastFrameIndex) << "}\n";
-    std::string message = oss.str();
-    int length = message.length();
+    std::string const message = oss.str();
+    int const length = message.length();
     LOG(sls::logDEBUG) << "Acquisition Finished message:" << std::endl
                        << message;
 
@@ -368,7 +368,7 @@ void AcquisitionFinishedCallback(
     // push zmq msg into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> lock(stat->mtx);
+        std::lock_guard<std::mutex> const lock(stat->mtx);
         stat->ends.push_back(hmsg);
     }
     sem_post(&stat->available);
@@ -379,7 +379,7 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
                      char *dataPointer, size_t &imageSize,
                      void *objectPointer) {
 
-    slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
+    slsDetectorDefs::sls_detector_header const detectorHeader = header.detHeader;
 
     if (printHeadersLevel < sls::logDEBUG) {
         // print in different color for each udp port
@@ -468,11 +468,11 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
         oss << " } ";
     }
     oss << "}\n";
-    std::string message = oss.str();
+    std::string const message = oss.str();
     LOG(sls::logDEBUG) << "Data message:" << std::endl << message;
 
     // creating header part of data packet
-    int length = message.length();
+    int const length = message.length();
     char *hdata = new char[length];
     memcpy(hdata, message.c_str(), length);
     zmq_msg_t *hmsg = new zmq_msg_t;
@@ -486,7 +486,7 @@ void GetDataCallback(slsDetectorDefs::sls_receiver_header &header,
     // push both parts into stat to be processed
     FrameStatus *stat = static_cast<FrameStatus *>(objectPointer);
     {
-        std::lock_guard<std::mutex> lock(stat->mtx);
+        std::lock_guard<std::mutex> const lock(stat->mtx);
         stat->frames[callbackHeader.udpPort][header.detHeader.frameNumber]
             .push_back(hmsg);
         stat->frames[callbackHeader.udpPort][header.detHeader.frameNumber]
@@ -544,7 +544,7 @@ int main(int argc, char *argv[]) {
 
     std::exception_ptr threadException = nullptr;
     for (int i = 0; i != f.numReceivers; ++i) {
-        uint16_t port = f.port + i;
+        uint16_t const port = f.port + i;
         sem_t *semaphore = &semaphores[i];
         threads.emplace_back(
             [i, semaphore, port, user_data, &threadException]() {
@@ -581,7 +581,7 @@ int main(int argc, char *argv[]) {
     cleanup();
 
     {
-        std::lock_guard<std::mutex> lock(stat.mtx);
+        std::lock_guard<std::mutex> const lock(stat.mtx);
         stat.terminate = true;
         sem_post(&stat.available);
     }

slsReceiverSoftware/src/Implementation.cpp

@@ -238,9 +238,9 @@ const slsDetectorDefs::xy Implementation::GetPortGeometry() const {
 }
 
 void Implementation::setDetectorSize(const slsDetectorDefs::xy size) {
-    xy portGeometry = GetPortGeometry();
+    xy const portGeometry = GetPortGeometry();
 
-    std::string log_message = "Detector Size (ports): (";
+    std::string const log_message = "Detector Size (ports): (";
     numModules = size;
     numPorts.x = portGeometry.x * numModules.x;
     numPorts.y = portGeometry.y * numModules.y;
@@ -262,7 +262,7 @@ void Implementation::setModulePositionId(const int id) {
     LOG(logINFO) << "Module Position Id:" << modulePos;
 
     // update zmq port
-    xy portGeometry = GetPortGeometry();
+    xy const portGeometry = GetPortGeometry();
     streamingPort = DEFAULT_ZMQ_RX_PORTNO + modulePos * portGeometry.x;
 
     assert(numModules.y != 0);
@@ -285,14 +285,14 @@ void Implementation::setModulePositionId(const int id) {
 
 void Implementation::setRow(const int value) {
     for (unsigned int i = 0; i < listener.size(); ++i) {
-        int col = listener[i]->GetHardCodedPosition().second;
+        int const col = listener[i]->GetHardCodedPosition().second;
         listener[i]->SetHardCodedPosition(value, col);
     }
 }
 
 void Implementation::setColumn(const int value) {
     for (unsigned int i = 0; i < listener.size(); ++i) {
-        int row = listener[i]->GetHardCodedPosition().first;
+        int const row = listener[i]->GetHardCodedPosition().first;
         listener[i]->SetHardCodedPosition(row, value);
     }
 }
@@ -405,16 +405,16 @@ std::vector<slsDetectorDefs::ROI> Implementation::getPortROIs() const {
 }
 
 void Implementation::ResetRois() {
-    int numports = generalData->numUDPInterfaces;
-    std::vector<ROI> rois(numports);
-    std::vector<ROI> multiRoi(1);
+    int const numports = generalData->numUDPInterfaces;
+    std::vector<ROI> const rois(numports);
+    std::vector<ROI> const multiRoi(1);
     setPortROIs(rois);
     setMultiROIMetadata(multiRoi);
 }
 
 void Implementation::setPortROIs(const std::vector<defs::ROI> &args) {
-    int nx = static_cast<int>(generalData->nPixelsX);
-    int ny = static_cast<int>(generalData->nPixelsY);
+    int const nx = static_cast<int>(generalData->nPixelsX);
+    int const ny = static_cast<int>(generalData->nPixelsY);
     // validate rois
     for (auto &it : args) {
         if (it.completeRoi() || it.noRoi()) {
@@ -614,7 +614,7 @@ double Implementation::getProgress() const {
 std::vector<int64_t> Implementation::getNumMissingPackets() const {
     std::vector<int64_t> mp(generalData->numUDPInterfaces);
     for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
-        int np = generalData->packetsPerFrame;
+        int const np = generalData->packetsPerFrame;
         uint64_t totnp = np;
         // ReadNRows
         if (readNRows != (int)generalData->maxRowsPerReadout) {
@@ -646,7 +646,7 @@ void Implementation::startReceiver() {
             for (size_t i = 0; i != listener.size(); ++i) {
                 udpPort.push_back(udpPortNum[i]);
             }
-            startCallbackHeader callbackHeader = {
+            startCallbackHeader const callbackHeader = {
                 udpPort,
                 generalData->dynamicRange,
                 numPorts,
@@ -731,7 +731,7 @@ void Implementation::stopReceiver() {
         // print summary
         uint64_t tot = 0;
         for (int i = 0; i < generalData->numUDPInterfaces; i++) {
-            int nf = listener[i]->GetNumCompleteFramesCaught();
+            int const nf = listener[i]->GetNumCompleteFramesCaught();
             tot += nf;
             std::string mpMessage = std::to_string(mp[i]);
             if (mp[i] < 0) {
@@ -756,7 +756,7 @@ void Implementation::stopReceiver() {
                 summary = os.str();
             }
 
-            TLogLevel lev = ((mp[i]) > 0) ? logINFORED : logINFOGREEN;
+            TLogLevel const lev = ((mp[i]) > 0) ? logINFORED : logINFOGREEN;
             LOG(lev) << "Summary of Port " << udpPortNum[i] << " (" << eth[i]
                      << ')' << summary;
         }
@@ -774,7 +774,7 @@ void Implementation::stopReceiver() {
                     lastFrameIndexCaught.push_back(
                         listener[i]->GetLastFrameIndexCaught());
                 }
-                endCallbackHeader callHeader = {udpPort, completeFramesCaught,
+                endCallbackHeader const callHeader = {udpPort, completeFramesCaught,
                                                 lastFrameIndexCaught};
                 acquisitionFinishedCallBack(callHeader, pAcquisitionFinished);
             } catch (const std::exception &e) {
@@ -852,7 +852,7 @@ void Implementation::ResetParametersforNewAcquisition() {
     if (dataStreamEnable) {
         std::ostringstream os;
         os << filePath << '/' << fileName;
-        std::string fnametostream = os.str();
+        std::string const fnametostream = os.str();
         for (const auto &it : dataStreamer)
             it->ResetParametersforNewAcquisition(fnametostream);
     }
@@ -884,7 +884,7 @@ void Implementation::SetupWriter() {
             std::ostringstream os;
             os << filePath << "/" << fileName << "_d"
                << (modulePos * generalData->numUDPInterfaces + i);
-            std::string fileNamePrefix = os.str();
+            std::string const fileNamePrefix = os.str();
             dataProcessor[i]->CreateFirstFiles(fileNamePrefix, fileIndex,
                                                overwriteEnable, silentMode,
                                                detectorDataStream[i]);
@@ -919,8 +919,8 @@ void Implementation::StartMasterWriter() {
             // complete ROI (for each port TODO?)
             if (multiRoiMetadata.size() == 1 &&
                 multiRoiMetadata[0].completeRoi()) {
-                int nTotalPixelsX = (generalData->nPixelsX * numPorts.x);
-                int nTotalPixelsY = (generalData->nPixelsY * numPorts.y);
+                int const nTotalPixelsX = (generalData->nPixelsX * numPorts.x);
+                int const nTotalPixelsY = (generalData->nPixelsY * numPorts.y);
                 if (nTotalPixelsY == 1) {
                     masterAttributes.rois.push_back(ROI{0, nTotalPixelsX - 1});
                 } else {
@@ -1180,7 +1180,7 @@ int Implementation::getUDPSocketBufferSize() const {
 }
 
 void Implementation::setUDPSocketBufferSize(const int s) {
-    size_t listSize = listener.size();
+    size_t const listSize = listener.size();
     if ((generalData->detType == JUNGFRAU || generalData->detType == MOENCH ||
          generalData->detType == GOTTHARD2) &&
         (int)listSize != generalData->numUDPInterfaces) {
@@ -1572,7 +1572,7 @@ void Implementation::setCounterMask(const uint32_t i) {
         SetupFifoStructure();
     }
     LOG(logINFO) << "Counter mask: " << ToStringHex(generalData->counterMask);
-    int ncounters = __builtin_popcount(generalData->counterMask);
+    int const ncounters = __builtin_popcount(generalData->counterMask);
     LOG(logINFO) << "Number of counters: " << ncounters;
 }
 
@@ -1661,13 +1661,13 @@ void Implementation::setActivate(bool enable) {
 }
 
 bool Implementation::getDetectorDataStream(const portPosition port) const {
-    int index = (port == LEFT ? 0 : 1);
+    int const index = (port == LEFT ? 0 : 1);
     return detectorDataStream[index];
 }
 
 void Implementation::setDetectorDataStream(const portPosition port,
                                            const bool enable) {
-    int index = (port == LEFT ? 0 : 1);
+    int const index = (port == LEFT ? 0 : 1);
     detectorDataStream10GbE[index] = enable;
     LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port)
                  << " Port): " << ToString(detectorDataStream10GbE[index]);

slsReceiverSoftware/src/Listener.cpp

@@ -193,10 +193,10 @@ void Listener::DeleteUDPSocket() {
 void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize) {
     // custom setup (s != 0)
     // default setup at startup (s = 0)
-    int size = (s == 0 ? generalData->udpSocketBufferSize : s);
+    int const size = (s == 0 ? generalData->udpSocketBufferSize : s);
     LOG(logINFO) << "Testing UDP Socket Buffer size " << size
                  << " with test port " << udpPortNumber;
-    int previousSize = generalData->udpSocketBufferSize;
+    int const previousSize = generalData->udpSocketBufferSize;
     generalData->udpSocketBufferSize = size;
 
     if (disabledPort) {
@@ -217,7 +217,7 @@ void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize) {
         std::string ip;
         if (eth.length() > 0)
             ip = InterfaceNameToIp(eth).str();
-        UdpRxSocket g(udpPortNumber, packetSize,
+        UdpRxSocket const g(udpPortNumber, packetSize,
                       (ip.empty() ? nullptr : ip.c_str()),
                       generalData->udpSocketBufferSize);
 
@@ -268,7 +268,7 @@ void Listener::ThreadExecution() {
 
     // reset header and size and get data
     memset(memImage, 0, IMAGE_STRUCTURE_HEADER_SIZE);
-    int rc = ListenToAnImage(memImage->header, memImage->data);
+    int const rc = ListenToAnImage(memImage->header, memImage->data);
 
     // end of acquisition or discarding image
     if (rc <= 0) {
@@ -320,9 +320,9 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header &dstHeader,
         hsize = generalData->vetoHsize;
         standardHeader = false;
     }
-    uint32_t pperFrame = generalData->packetsPerFrame;
+    uint32_t const pperFrame = generalData->packetsPerFrame;
     bool isHeaderEmpty = true;
-    uint32_t corrected_dsize = dsize - ((pperFrame * dsize) - imageSize);
+    uint32_t const corrected_dsize = dsize - ((pperFrame * dsize) - imageSize);
     sls_detector_header *srcDetHeader = nullptr;
 
     // carry over packet
@@ -516,9 +516,9 @@ void Listener::PrintFifoStatistics() {
                    << " packetsperframe:" << generalData->packetsPerFrame;
 
     // calculate packet loss
-    int64_t totalP = numFramesStatistic * (generalData->packetsPerFrame);
-    int64_t loss = totalP - numPacketsStatistic;
-    int lossPercent = ((double)loss / (double)totalP) * 100.00;
+    int64_t const totalP = numFramesStatistic * (generalData->packetsPerFrame);
+    int64_t const loss = totalP - numPacketsStatistic;
+    int const lossPercent = ((double)loss / (double)totalP) * 100.00;
     numPacketsStatistic = 0;
     numFramesStatistic = 0;
 

slsReceiverSoftware/src/MasterAttributes.cpp

@@ -756,7 +756,7 @@ void MasterAttributes::WriteHDF5Version(H5::H5File *fd) {
 #endif
 
 void MasterAttributes::WriteBinaryTimestamp(writer *w) {
-    time_t t = std::time(nullptr);
+    time_t const t = std::time(nullptr);
     std::string sTime(ctime(&t));
     std::replace(sTime.begin(), sTime.end(), '\n', '\0');
     WriteBinary(w, N_TIMESTAMP.data(), sTime);

slsReceiverSoftware/src/MultiReceiverApp.cpp

@@ -76,7 +76,7 @@ void GetData(slsDetectorDefs::sls_receiver_header &header,
              slsDetectorDefs::dataCallbackHeader callbackHeader,
              char *dataPointer, size_t &imageSize, void *objectPointer) {
 
-    slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
+    slsDetectorDefs::sls_detector_header const detectorHeader = header.detHeader;
 
     PRINT_IN_COLOR(
         (callbackHeader.udpPort % 10),
@@ -169,7 +169,7 @@ int main(int argc, char *argv[]) {
     for (int i = 0; i < m.numReceivers; ++i) {
 
         /**	- fork process to create child process */
-        pid_t pid = fork();
+        pid_t const pid = fork();
 
         /**	- if fork failed, raise SIGINT and properly destroy all child
          * processes */
@@ -185,7 +185,7 @@ int main(int argc, char *argv[]) {
                 << "Child process " << i << " [ Tid: " << gettid() << ']';
 
             try {
-                uint16_t port = m.port + i;
+                uint16_t const port = m.port + i;
                 sls::Receiver receiver(port);
 
                 /**	- register callbacks. remember to set file write enable
@@ -236,7 +236,7 @@ int main(int argc, char *argv[]) {
     /** - Parent process waits for all child processes to exit */
     for (;;) {
         int status;
-        pid_t childPid = waitpid(-1, &status, 0);
+        pid_t const childPid = waitpid(-1, &status, 0);
 
         // no child closed
         if (childPid == -1) {

slsReceiverSoftware/src/ReceiverApp.cpp

@@ -54,7 +54,7 @@ int main(int argc, char *argv[]) {
     sem_init(&semaphore, 1, 0);
 
     try {
-        sls::Receiver r(o.port);
+        sls::Receiver const r(o.port);
         LOG(sls::logINFO) << "[ Press \'Ctrl+c\' to exit ]";
         sem_wait(&semaphore);
         sem_destroy(&semaphore);

slsReceiverSoftware/tests/test-Apps.cpp

@@ -14,19 +14,19 @@ template <typename T, typename U> constexpr bool is_type() {
 }
 
 TEST_CASE("CommandLineOption construction", "[detector]") {
-    CommandLineOptions s(AppType::SingleReceiver);
+    CommandLineOptions const s(AppType::SingleReceiver);
     REQUIRE(s.getTypeString() == "slsReceiver");
     REQUIRE(s.getVersion() ==
             std::string("slsReceiver Version: ") + APIRECEIVER);
     REQUIRE_NOTHROW(s.getHelpMessage());
 
-    CommandLineOptions m(AppType::MultiReceiver);
+    CommandLineOptions const m(AppType::MultiReceiver);
     REQUIRE(m.getTypeString() == "slsMultiReceiver");
     REQUIRE(m.getVersion() ==
             std::string("slsMultiReceiver Version: ") + APIRECEIVER);
     REQUIRE_NOTHROW(m.getHelpMessage());
 
-    CommandLineOptions f(AppType::FrameSynchronizer);
+    CommandLineOptions const f(AppType::FrameSynchronizer);
     REQUIRE(f.getTypeString() == "slsFrameSynchronizer");
     REQUIRE(f.getVersion() ==
             std::string("slsFrameSynchronizer Version: ") + APIRECEIVER);
@@ -49,7 +49,7 @@ TEST_CASE("Parse Help", "[detector]") {
 }
 
 TEST_CASE("Validate common options", "[detector]") {
-    std::string uidStr = std::to_string(getuid());
+    std::string const uidStr = std::to_string(getuid());
 
     for (auto app : {AppType::SingleReceiver, AppType::MultiReceiver,
                      AppType::FrameSynchronizer}) {
@@ -65,7 +65,7 @@ TEST_CASE("Validate common options", "[detector]") {
 }
 
 TEST_CASE("Validate specific options", "[detector]") {
-    std::string uidStr = std::to_string(getuid());
+    std::string const uidStr = std::to_string(getuid());
 
     CommandLineOptions s(AppType::SingleReceiver);
     REQUIRE_NOTHROW(s.parse({"", "-t", "1955"}));
@@ -141,19 +141,20 @@ TEST_CASE("Parse version and help", "[detector]") {
 // TODO: fails on gitea CI due to uid issue, fix later
 TEST_CASE("Parse port and uid", "[.failsongitea][detector]") {
     uid_t uid = getuid();
-    std::string uidStr = std::to_string(uid);
-    uid_t invalidUid = uid + 1000;
-    std::string invalidUidStr = std::to_string(invalidUid);
+    std::string const uidStr = std::to_string(uid);
+    uid_t const invalidUid = uid + 1000;
+    std::string const invalidUidStr = std::to_string(invalidUid);
 
     for (auto app : {AppType::SingleReceiver, AppType::MultiReceiver,
                      AppType::FrameSynchronizer}) {
         CommandLineOptions s(app);
 
-        // TODO! This test fails on gitea CI probably because the user can set
-        // the uid commenting it out for now. Revisit later. REQUIRE_THROWS(
+        // TODO! This test fails on gitea CI probably because the user can set the uid
+        // commenting it out for now. Revisit later.
+        // REQUIRE_THROWS(
         //     s.parse({"", "-p", "1234", "-u", invalidUidStr})); // invalid uid
 
-        REQUIRE_THROWS(s.parse({"", "-p", "500"})); // invalid port
+        REQUIRE_THROWS(s.parse({"", "-p", "500"}));            // invalid port
 
         auto opts = s.parse({"", "-p", "1234", "-u", uidStr});
         std::visit(

slsReceiverSoftware/tests/test-ArrangeDataBasedOnBitList.cpp

@@ -109,9 +109,9 @@ class DataProcessorTestFixture {
 
     void set_data(const std::bitset<8> pattern = 0xFF) {
         delete[] data;
-        uint64_t max_bytes_per_bit =
+        uint64_t const max_bytes_per_bit =
             num_samples % 8 == 0 ? num_samples / 8 : num_samples / 8 + 1;
-        uint64_t reserved_size =
+        uint64_t const reserved_size =
             get_size() - num_digital_bytes + max_bytes_per_bit * 64;
         data = new char[reserved_size];
 
@@ -148,7 +148,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Remove Trailing Bits",
 
     generaldata->SetCtbDbitOffset(num_random_offset_bytes);
 
-    size_t expected_size = get_size() - num_random_offset_bytes;
+    size_t const expected_size = get_size() - num_random_offset_bytes;
 
     char *expected_data = new char[expected_size];
     memset(expected_data, dummy_value, num_analog_bytes); // set to 125
@@ -287,7 +287,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder false",
     set_num_samples(num_samples);
     set_data(0b01010101); // set digital data to 0x55 to have alternating bits
 
-    size_t expected_size =
+    size_t const expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data
@@ -343,7 +343,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture, "Arrange bitlist with reorder true",
     set_num_samples(num_samples);
     set_data(0b01010101);
 
-    size_t expected_size =
+    size_t const expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data
@@ -371,8 +371,8 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
                  "Arrange bitlist and remove trailing bits",
                  "[.dataprocessor][.retrievebitlist]") {
 
-    size_t num_random_offset_bytes = 3;
-    std::vector<int> bitlist{1, 4, 5};
+    size_t const num_random_offset_bytes = 3;
+    std::vector<int> const bitlist{1, 4, 5};
 
     set_random_offset_bytes(num_random_offset_bytes);
     set_data();
@@ -386,7 +386,7 @@ TEST_CASE_METHOD(DataProcessorTestFixture,
     std::vector<uint8_t> expected_digital_part{0b00000111};
     const size_t expected_num_digital_bytes = 5;
 
-    size_t expected_size =
+    size_t const expected_size =
         num_analog_bytes + num_transceiver_bytes + expected_num_digital_bytes;
 
     // create expected data

slsSupportLib/CMakeLists.txt

@@ -17,7 +17,6 @@ set(SOURCES
     src/sls_detector_exceptions.cpp
     src/md5_helper.cpp
     src/Version.cpp
-    src/bit_utils.cpp
 )
 
 # Header files to install as a part of the library
@@ -30,7 +29,6 @@ set(PUBLICHEADERS
     include/sls/ToString.h
     include/sls/TypeTraits.h
     include/sls/TimeHelper.h
-    include/sls/bit_utils.h
 )
 
 # Additional headers to be installed if SLS_DEVEL_HEADERS

slsSupportLib/include/sls/ToString.h

@@ -11,7 +11,6 @@
 
 #include "sls/TimeHelper.h"
 #include "sls/TypeTraits.h"
-#include "sls/bit_utils.h"
 #include "sls/sls_detector_defs.h"
 #include "sls/sls_detector_exceptions.h"
 #include "sls/string_utils.h"
@@ -66,7 +65,6 @@ std::ostream &operator<<(std::ostream &os,
 std::string ToString(const slsDetectorDefs::pedestalParameters &r);
 std::ostream &operator<<(std::ostream &os,
                          const slsDetectorDefs::pedestalParameters &r);
-
 const std::string &ToString(const std::string &s);
 
 /** Convert std::chrono::duration with specified output unit */
@@ -326,8 +324,6 @@ template <> defs::gainMode StringTo(const std::string &s);
 template <> defs::polarity StringTo(const std::string &s);
 template <> defs::timingInfoDecoder StringTo(const std::string &s);
 template <> defs::collectionMode StringTo(const std::string &s);
-template <> RegisterAddress StringTo(const std::string &s);
-template <> RegisterValue StringTo(const std::string &s);
 
 template <> uint8_t StringTo(const std::string &s);
 template <> uint16_t StringTo(const std::string &s);

slsSupportLib/include/sls/bit_utils.h

@@ -3,7 +3,6 @@
 #pragma once
 
 #include <bitset>
-#include <cstdint>
 #include <vector>
 namespace sls {
 template <typename T> std::vector<int> getSetBits(T val) {
@@ -19,87 +18,4 @@ template <typename T> std::vector<int> getSetBits(T val) {
     }
     return set_bits;
 }
-
-class RegisterAddress {
-  private:
-    uint32_t value_{0};
-
-  public:
-    constexpr RegisterAddress() noexcept = default;
-    constexpr explicit RegisterAddress(uint32_t value) : value_(value) {}
-    std::string str() const;
-    constexpr uint32_t value() const noexcept { return value_; }
-
-    constexpr bool operator==(const RegisterAddress &other) const {
-        return (value_ == other.value_);
-    }
-    constexpr bool operator!=(const RegisterAddress &other) const {
-        return (value_ != other.value_);
-    }
-};
-
-class BitAddress {
-  private:
-    RegisterAddress addr_{0};
-    uint32_t bitPos_{0};
-
-  public:
-    constexpr BitAddress() noexcept = default;
-    BitAddress(RegisterAddress address, uint32_t bitPosition);
-    std::string str() const;
-    constexpr RegisterAddress address() const noexcept { return addr_; }
-    constexpr uint32_t bitPosition() const noexcept { return bitPos_; }
-
-    constexpr bool operator==(const BitAddress &other) const {
-        return (addr_ == other.addr_ && bitPos_ == other.bitPos_);
-    }
-    constexpr bool operator!=(const BitAddress &other) const {
-        return !(*this == other);
-    }
-};
-
-class RegisterValue {
-  private:
-    uint32_t value_{0};
-
-  public:
-    constexpr RegisterValue() noexcept = default;
-    explicit constexpr RegisterValue(uint32_t value) noexcept : value_(value) {}
-    std::string str() const;
-    constexpr uint32_t value() const noexcept { return value_; }
-
-    constexpr RegisterValue &operator|=(const RegisterValue &rhs) noexcept {
-        value_ |= rhs.value();
-        return *this;
-    }
-
-    constexpr RegisterValue operator|(const RegisterValue &rhs) const noexcept {
-        RegisterValue tmp(*this);
-        tmp |= rhs;
-        return tmp;
-    }
-
-    constexpr RegisterValue &operator|=(uint32_t rhs) noexcept {
-        value_ |= rhs;
-        return *this;
-    }
-
-    constexpr RegisterValue operator|(uint32_t rhs) const noexcept {
-        RegisterValue tmp(*this);
-        tmp |= rhs;
-        return tmp;
-    }
-
-    constexpr bool operator==(const RegisterValue &other) const noexcept {
-        return value_ == other.value_;
-    }
-    constexpr bool operator!=(const RegisterValue &other) const noexcept {
-        return value_ != other.value_;
-    }
-};
-
-std::ostream &operator<<(std::ostream &os, const RegisterAddress &r);
-std::ostream &operator<<(std::ostream &os, const BitAddress &r);
-std::ostream &operator<<(std::ostream &os, const RegisterValue &r);
-
 } // namespace sls

slsSupportLib/include/sls/container_utils.h

@@ -181,18 +181,20 @@ typename std::enable_if<is_container<T>::value, bool>::type
 stableRemoveDuplicates(T &c) {
     auto containerSize = c.size();
     std::set<typename T::value_type> seen;
-    c.erase(std::remove_if(
-                c.begin(), c.end(),
-                [&](const typename T::value_type &val) {
-                    return !seen.insert(val).second; // erase if already seen
-                }),
-            c.end());
+    c.erase(
+        std::remove_if(c.begin(), c.end(),
+            [&](const typename T::value_type& val) {
+                return !seen.insert(val).second;  // erase if already seen
+            }),
+        c.end()
+    );
     if (c.size() != containerSize) {
         return true;
     }
     return false;
 }
 
+
 } // namespace sls
 
 #endif // CONTAINER_UTILS_H

slsSupportLib/include/sls/sls_detector_defs.h

@@ -788,9 +788,9 @@ typedef struct {
 
     explicit sls_detector_module(slsDetectorDefs::detectorType type)
         : sls_detector_module() {
-        detParameters parameters{type};
-        int nch = parameters.nChanX * parameters.nChanY;
-        int nc = parameters.nChipX * parameters.nChipY;
+        const detParameters parameters{type}; //used to initialize
+        const int nch = parameters.nChanX * parameters.nChanY;
+        const int nc = parameters.nChipX * parameters.nChipY;
         ndac = parameters.nDacs;
         nchip = nc;
         nchan = nch * nc;
@@ -804,8 +804,6 @@ typedef struct {
     }
 
     sls_detector_module &operator=(const sls_detector_module &other) {
-        if (this == &other)
-            return *this;
         delete[] dacs;
         delete[] chanregs;
         serialnumber = other.serialnumber;

slsSupportLib/include/sls/string_utils.h

@@ -5,7 +5,6 @@
 #include <cassert>
 #include <cstdint>
 #include <cstring>
-#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,35 +33,6 @@ void strcpy_safe(char (&destination)[array_size], const std::string &source) {
     destination[array_size - 1] = '\0';
 }
 
-// Runtime-checked variant — throws if it won't fit
-template <size_t array_size>
-void strcpy_checked(char (&destination)[array_size], const char *source) {
-    if (!source)
-        throw std::runtime_error("Null source pointer in strcpy_checked");
-
-    size_t len = std::strlen(source);
-    if (len >= (array_size - 1)) {
-        throw std::runtime_error("String length (" + std::to_string(len) +
-                                 ") should be less than " +
-                                 std::to_string(array_size - 1) + " chars");
-    }
-    std::strncpy(destination, source, array_size - 1);
-    destination[array_size - 1] = '\0';
-}
-
-template <size_t array_size>
-void strcpy_checked(char (&destination)[array_size],
-                    const std::string &source) {
-    if (source.size() >= (array_size - 1)) {
-        throw std::runtime_error("String length (" +
-                                 std::to_string(source.size()) +
-                                 ") should be less than " +
-                                 std::to_string(array_size - 1) + " chars");
-    }
-    std::strncpy(destination, source.c_str(), array_size - 1);
-    destination[array_size - 1] = '\0';
-}
-
 /*
 Removes all occurrences of the specified char from a c string
 Templated on array size to ensure no access after buffer limits.
@@ -88,8 +58,6 @@ std::vector<std::string> split(const std::string &strToSplit, char delimeter);
 std::string RemoveUnit(std::string &str);
 
 bool is_int(const std::string &s);
-/** '0x200' is also an int here */
-bool is_hex_or_dec_uint(const std::string &s);
 
 bool replace_first(std::string *s, const std::string &substr,
                    const std::string &repl);

slsSupportLib/include/sls/versionAPI.h

@@ -7,6 +7,6 @@
 #define APIGOTTHARD2 "0.0.0 0x250909"
 #define APIMOENCH    "0.0.0 0x250909"
 #define APIEIGER     "0.0.0 0x250909"
-#define APIXILINXCTB "0.0.0 0x260106"
+#define APIXILINXCTB "0.0.0 0x251015"
 #define APIJUNGFRAU  "0.0.0 0x250909"
 #define APIMYTHEN3   "0.0.0 0x250922"

slsSupportLib/src/ClientSocket.cpp

@@ -24,7 +24,7 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host,
     hints.ai_flags |= AI_CANONNAME;
 
     if (getaddrinfo(host.c_str(), nullptr, &hints, &result) != 0) {
-        std::string msg = "ClientSocket cannot decode host:" + host +
+        std::string const msg = "ClientSocket cannot decode host:" + host +
                           " on port " + std::to_string(port) + "\n";
         throw SocketError(msg);
     }
@@ -40,7 +40,7 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host,
     if (::connect(getSocketId(), (struct sockaddr *)&serverAddr,
                   sizeof(serverAddr)) != 0) {
         freeaddrinfo(result);
-        std::string msg = "ClientSocket: Cannot connect to " + socketType +
+        std::string const msg = "ClientSocket: Cannot connect to " + socketType +
                           ":" + host + " on port " + std::to_string(port) +
                           "\n";
         throw SocketError(msg);
@@ -54,7 +54,7 @@ ClientSocket::ClientSocket(std::string sType, struct sockaddr_in addr)
     if (::connect(getSocketId(), (struct sockaddr *)&addr, sizeof(addr)) != 0) {
         char address[INET_ADDRSTRLEN];
         inet_ntop(AF_INET, &addr.sin_addr, address, INET_ADDRSTRLEN);
-        std::string msg = "ClientSocket: Cannot connect to " + socketType +
+        std::string const msg = "ClientSocket: Cannot connect to " + socketType +
                           ":" + address + " on port " +
                           std::to_string(addr.sin_port) + "\n";
         throw SocketError(msg);
@@ -77,7 +77,7 @@ void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) {
     try {
         Receive(&ret, sizeof(ret));
         if (ret == slsDetectorDefs::FAIL) {
-            std::string mess = readErrorMessage();
+            std::string const mess = readErrorMessage();
             // Do we need to know hostname here?
             // In that case save it???
             if (socketType == "Receiver") {

slsSupportLib/src/DataSocket.cpp

@@ -48,7 +48,7 @@ void DataSocket::setFnum(const int fnum) { fnum_ = fnum; }
 
 int DataSocket::Receive(void *buffer, size_t size) {
     // TODO!(Erik) Add sleep? how many reties?
-    int bytes_expected = static_cast<int>(size); // signed size
+    int const bytes_expected = static_cast<int>(size); // signed size
     int bytes_read = 0;
     while (bytes_read < bytes_expected) {
         auto this_read =
@@ -79,7 +79,7 @@ std::string DataSocket::Receive(size_t length) {
 }
 int DataSocket::Send(const void *buffer, size_t size) {
     int bytes_sent = 0;
-    int data_size = static_cast<int>(size); // signed size
+    int const data_size = static_cast<int>(size); // signed size
     while (bytes_sent < (data_size)) {
         auto this_send = ::write(getSocketId(), buffer, size);
         if (this_send <= 0)

slsSupportLib/src/ServerSocket.cpp

@@ -47,7 +47,7 @@ ServerInterface ServerSocket::accept() {
     lastClient = thisClient; // update from previous connection
     struct sockaddr_in clientAddr;
     socklen_t addr_size = sizeof clientAddr;
-    int newSocket =
+    int const newSocket =
         ::accept(getSocketId(), (struct sockaddr *)&clientAddr, &addr_size);
     if (newSocket == -1) {
         throw SocketError("Server ERROR: socket accept failed\n");

slsSupportLib/src/ToString.cpp

@@ -614,7 +614,7 @@ std::string ToString(const defs::portPosition s) {
 
 std::string ToString(const defs::streamingInterface s) {
     std::ostringstream os;
-    std::string rs;
+    std::string const rs;
     switch (s) {
     case defs::streamingInterface::NONE:
         return std::string("none");
@@ -1128,8 +1128,8 @@ template <> defs::collectionMode StringTo(const std::string &s) {
 }
 
 template <> uint8_t StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
-    int value = std::stoi(s, nullptr, base);
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const value = std::stoi(s, nullptr, base);
     if (value < std::numeric_limits<uint8_t>::min() ||
         value > std::numeric_limits<uint8_t>::max()) {
         throw RuntimeError("Cannot scan uint8_t from string '" + s +
@@ -1139,8 +1139,8 @@ template <> uint8_t StringTo(const std::string &s) {
 }
 
 template <> uint16_t StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
-    int value = std::stoi(s, nullptr, base);
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const value = std::stoi(s, nullptr, base);
     if (value < std::numeric_limits<uint16_t>::min() ||
         value > std::numeric_limits<uint16_t>::max()) {
         throw RuntimeError("Cannot scan uint16_t from string '" + s +
@@ -1150,22 +1150,22 @@ template <> uint16_t StringTo(const std::string &s) {
 }
 
 template <> uint32_t StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoul(s, nullptr, base);
 }
 
 template <> uint64_t StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoull(s, nullptr, base);
 }
 
 template <> int StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoi(s, nullptr, base);
 }
 
 template <> bool StringTo(const std::string &s) {
-    int i = std::stoi(s, nullptr, 10);
+    int const i = std::stoi(s, nullptr, 10);
     switch (i) {
     case 0:
         return false;
@@ -1177,7 +1177,7 @@ template <> bool StringTo(const std::string &s) {
 }
 
 template <> int64_t StringTo(const std::string &s) {
-    int base = s.find("0x") != std::string::npos ? 16 : 10;
+    int const base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stol(s, nullptr, base);
 }
 

slsSupportLib/src/ZmqSocket.cpp

@@ -305,8 +305,8 @@ int ZmqSocket::SendHeader(int index, zmqHeader header) {
     oss << ", \"rx_roi\":[" << header.rx_roi[0] << ", " << header.rx_roi[1]
         << ", " << header.rx_roi[2] << ", " << header.rx_roi[3] << "]";
     oss << "}\n";
-    std::string message = oss.str();
-    int length = message.length();
+    std::string const message = oss.str();
+    int const length = message.length();
 #ifdef ZMQ_DETAIL
     // if(!index)
     LOG(logINFOBLUE) << index << " : Streamer: buf: " << message;
@@ -436,7 +436,7 @@ int ZmqSocket::ParseHeader(const int index, int length, char *buff,
 int ZmqSocket::ReceiveData(const int index, char *buf, const int size) {
     zmq_msg_t message;
     zmq_msg_init(&message);
-    int length = ReceiveMessage(index, message);
+    int const length = ReceiveMessage(index, message);
     if (length == size) {
         memcpy(buf, (char *)zmq_msg_data(&message), size);
     } else if (length < size) {
@@ -453,7 +453,7 @@ int ZmqSocket::ReceiveData(const int index, char *buf, const int size) {
 }
 
 int ZmqSocket::ReceiveMessage(const int index, zmq_msg_t &message) {
-    int length = zmq_msg_recv(&message, sockfd.socketDescriptor, 0);
+    int const length = zmq_msg_recv(&message, sockfd.socketDescriptor, 0);
     if (length == -1) {
         PrintError();
         LOG(logERROR) << "Could not read header for socket " << index;

slsSupportLib/src/bit_utils.cpp

@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-other
-// Copyright (C) 2021 Contributors to the SLS Detector Package
-#include "sls/bit_utils.h"
-#include "sls/ToString.h"
-#include "sls/sls_detector_exceptions.h"
-
-namespace sls {
-
-std::string RegisterAddress::str() const { return ToStringHex(value_); }
-
-BitAddress::BitAddress(RegisterAddress address, uint32_t bitPosition)
-    : addr_(address) {
-    if (bitPosition > 31) {
-        throw RuntimeError("Bit position must be between 0 and 31.");
-    }
-    bitPos_ = bitPosition;
-}
-
-std::string BitAddress::str() const {
-    std::ostringstream os;
-    os << '[' << addr_.str() << ", " << ToString(bitPos_) << ']';
-    return os.str();
-}
-
-std::string RegisterValue::str() const { return ToStringHex(value_); }
-
-std::ostream &operator<<(std::ostream &os, const RegisterAddress &r) {
-    os << r.str();
-    return os;
-}
-
-std::ostream &operator<<(std::ostream &os, const BitAddress &r) {
-    os << r.str();
-    return os;
-}
-
-std::ostream &operator<<(std::ostream &os, const RegisterValue &r) {
-    os << r.str();
-    return os;
-}
-
-} // namespace sls

slsSupportLib/src/file_utils.cpp

@@ -52,7 +52,7 @@ int readDataFile(std::ifstream &infile, short int *data, int nch, int offset) {
 int readDataFile(std::string fname, short int *data, int nch) {
     std::ifstream infile;
     int iline = 0;
-    std::string str;
+    std::string const str;
     infile.open(fname.c_str(), std::ios_base::in);
     if (infile.is_open()) {
         iline = readDataFile(infile, data, nch, 0);
@@ -80,7 +80,7 @@ std::vector<char> readBinaryFile(const std::string &fname,
     }
 
     // get file size to print progress
-    ssize_t filesize = getFileSize(fp, errorPrefix);
+    ssize_t const filesize = getFileSize(fp, errorPrefix);
 
     std::vector<char> buffer(filesize, 0);
     if ((ssize_t)fread(buffer.data(), sizeof(char), filesize, fp) != filesize) {
@@ -142,14 +142,14 @@ void mkdir_p(const std::string &path, std::string dir) {
 int getFileSize(std::ifstream &ifs) {
     auto current_pos = ifs.tellg();
     ifs.seekg(0, std::ios::end);
-    int file_size = ifs.tellg();
+    int const file_size = ifs.tellg();
     ifs.seekg(current_pos);
     return file_size;
 }
 
 std::string getFileNameFromFilePath(const std::string &fpath) {
     std::string fname(fpath);
-    std::size_t slashPos = fpath.rfind('/');
+    std::size_t const slashPos = fpath.rfind('/');
     if (slashPos != std::string::npos) {
         fname = fpath.substr(slashPos + 1, fpath.size() - 1);
     }
@@ -161,7 +161,7 @@ ssize_t getFileSize(FILE *fd, const std::string &prependErrorString) {
         throw RuntimeError(prependErrorString +
                            std::string(" (Seek error in src file)"));
     }
-    size_t fileSize = ftell(fd);
+    size_t const fileSize = ftell(fd);
     if (fileSize <= 0) {
         throw RuntimeError(
             prependErrorString +
@@ -181,7 +181,7 @@ getChannelsFromStringList(const std::vector<std::string> list) {
             begin(line), end(line), [](char c) { return (c == ','); }, ' ');
 
         // split line (delim space)
-        std::vector<std::string> vec = split(line, ' ');
+        std::vector<std::string> const vec = split(line, ' ');
 
         // for every channel separated by space
         for (auto it : vec) {
@@ -189,8 +189,8 @@ getChannelsFromStringList(const std::vector<std::string> list) {
             auto result = it.find(':');
             if (result != std::string::npos) {
                 try {
-                    int istart = StringTo<int>(it.substr(0, result));
-                    int istop = StringTo<int>(
+                    int const istart = StringTo<int>(it.substr(0, result));
+                    int const istop = StringTo<int>(
                         it.substr(result + 1, it.length() - result - 1));
                     LOG(logDEBUG1) << "istart:" << istart << " istop:" << istop;
                     std::vector<int> range(istop - istart);
@@ -256,11 +256,12 @@ std::string getAbsolutePathFromCurrentProcess(const std::string &fname) {
         return fname;
     }
 
-    // in case PATH_MAX defines the longest possible path on linux and macOS
-    // use string instead of char array to avoid overflow
+    //in case PATH_MAX defines the longest possible path on linux and macOS
+    //use string instead of char array to avoid overflow
     std::string path(PATH_MAX, '\0'); 
 
-#if defined(__APPLE__)
+
+    #if defined(__APPLE__)
     uint32_t size = PATH_MAX;
     if (_NSGetExecutablePath(path.data(), &size) != 0) {
         throw std::runtime_error("Failed to get executable path");
@@ -271,15 +272,16 @@ std::string getAbsolutePathFromCurrentProcess(const std::string &fname) {
         throw std::runtime_error("realpath failed for executable");
     }
     path = resolved;
-#else
+    #else
 
-    ssize_t len = readlink("/proc/self/exe", path.data(), PATH_MAX - 1);
+
+    ssize_t const len = readlink("/proc/self/exe", path.data(), PATH_MAX - 1);
     if (len < 0) {
         throw RuntimeError("Could not get absolute path for " + fname);
     }
     path[len] = '\0';
 
-#endif
+    #endif
 
     // get dir path and attach file name
     std::string absPath = (std::string(dirname(path.data())) + '/' + fname);

slsSupportLib/src/network_utils.cpp

@@ -115,7 +115,7 @@ IpAddr HostnameToIp(const char *hostname) {
         throw RuntimeError("Could not convert hostname (" +
                            std::string(hostname) + ") to ip");
     }
-    uint32_t ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
+    uint32_t const ip = ((sockaddr_in *)result->ai_addr)->sin_addr.s_addr;
     freeaddrinfo(result);
     return IpAddr(ip);
 }
@@ -179,7 +179,8 @@ IpAddr InterfaceNameToIp(const std::string &ifn) {
 MacAddr InterfaceNameToMac(const std::string &inf) {
 
 #ifdef __APPLE__
-    throw RuntimeError("InterfaceNameToMac not implemented on macOS yet");
+    throw RuntimeError(
+        "InterfaceNameToMac not implemented on macOS yet");
 #else
 
     // TODO! Copied from genericSocket needs to be refactored!
@@ -188,7 +189,7 @@ MacAddr InterfaceNameToMac(const std::string &inf) {
     const int mac_len = sizeof(mac);
     memset(mac, 0, mac_len);
 
-    int sock = socket(PF_INET, SOCK_STREAM, 0);
+    int const sock = socket(PF_INET, SOCK_STREAM, 0);
     strncpy(ifr.ifr_name, inf.c_str(), sizeof(ifr.ifr_name) - 1);
     ifr.ifr_name[sizeof(ifr.ifr_name) - 1] = '\0';
 

slsSupportLib/src/string_utils.cpp

@@ -43,15 +43,6 @@ bool is_int(const std::string &s) {
                          }) == s.end();
 }
 
-bool is_hex_or_dec_uint(const std::string &s) {
-    try {
-        StringTo<uint32_t>(s);
-        return true;
-    } catch (...) {
-    }
-    return false;
-}
-
 bool replace_first(std::string *s, const std::string &substr,
                    const std::string &repl) {
     auto pos = s->find(substr);

slsSupportLib/tests/test-StaticVector.cpp

@@ -15,9 +15,9 @@ TEST_CASE("StaticVector is a container") {
 }
 
 TEST_CASE("Comparing StaticVector containers") {
-    StaticVector<int, 5> a{0, 1, 2};
-    StaticVector<int, 5> b{0, 1, 2};
-    StaticVector<int, 5> c{0, 1, 2, 4};
+    StaticVector<int, 5> const a{0, 1, 2};
+    StaticVector<int, 5> const b{0, 1, 2};
+    StaticVector<int, 5> const c{0, 1, 2, 4};
 
     REQUIRE(a == b);
     REQUIRE_FALSE(a != b);
@@ -29,9 +29,9 @@ TEST_CASE("Comparing StaticVector containers") {
 }
 
 TEST_CASE("Compare array and fixed capacity container") {
-    std::array<int, 3> arr{1, 2, 3};
-    std::array<int, 3> arr2{1, 7, 3};
-    StaticVector<int, 7> fcc{1, 2, 3};
+    std::array<int, 3> const arr{1, 2, 3};
+    std::array<int, 3> const arr2{1, 7, 3};
+    StaticVector<int, 7> const fcc{1, 2, 3};
     REQUIRE(fcc == arr);
     REQUIRE(arr == fcc);
     REQUIRE_FALSE(fcc != arr);
@@ -41,9 +41,9 @@ TEST_CASE("Compare array and fixed capacity container") {
 }
 
 TEST_CASE("Compare vector and fixed capacity container") {
-    std::vector<int> vec{1, 2, 3};
-    std::vector<int> vec2{10, 2, 3};
-    StaticVector<int, 7> fcc{1, 2, 3};
+    std::vector<int> const vec{1, 2, 3};
+    std::vector<int> const vec2{10, 2, 3};
+    StaticVector<int, 7> const fcc{1, 2, 3};
     REQUIRE(fcc == vec);
     REQUIRE(vec == fcc);
     REQUIRE_FALSE(fcc != vec);
@@ -53,46 +53,46 @@ TEST_CASE("Compare vector and fixed capacity container") {
 }
 
 TEST_CASE("Construct from vector") {
-    std::vector<int> vec{1, 2, 3};
-    StaticVector<int, 5> fcc{vec};
+    std::vector<int> const vec{1, 2, 3};
+    StaticVector<int, 5> const fcc{vec};
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Copy construct from vector") {
-    std::vector<int> vec{1, 2, 3};
-    StaticVector<int, 5> fcc = vec;
+    std::vector<int> const vec{1, 2, 3};
+    StaticVector<int, 5> const fcc = vec;
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Copy assignment from vector") {
-    std::vector<int> vec{1, 2, 3};
+    std::vector<int> const vec{1, 2, 3};
     StaticVector<int, 5> fcc;
     fcc = vec;
     REQUIRE(fcc == vec);
 }
 
 TEST_CASE("Construct from array") {
-    std::array<int, 3> arr{1, 2, 3};
-    StaticVector<int, 5> fcc{arr};
+    std::array<int, 3> const arr{1, 2, 3};
+    StaticVector<int, 5> const fcc{arr};
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Copy assign from array") {
-    std::array<int, 3> arr{1, 2, 3};
+    std::array<int, 3> const arr{1, 2, 3};
     StaticVector<int, 5> fcc;
     fcc = arr;
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Copy construct from array") {
-    std::array<int, 3> arr{1, 2, 3};
-    StaticVector<int, 5> fcc = arr;
+    std::array<int, 3> const arr{1, 2, 3};
+    StaticVector<int, 5> const fcc = arr;
     REQUIRE(fcc == arr);
 }
 
 TEST_CASE("Construct from a smaller StaticVector") {
-    StaticVector<int, 3> sv{1, 2, 3};
-    StaticVector<int, 5> sv2{sv};
+    StaticVector<int, 3> const sv{1, 2, 3};
+    StaticVector<int, 5> const sv2{sv};
     REQUIRE(sv == sv2);
 }
 
@@ -183,7 +183,7 @@ SCENARIO("StaticVectors can be sized and resized", "[support]") {
     }
 
     GIVEN("An std::vector of size 3") {
-        std::vector<int> standard_vector{5, 2, 1};
+        std::vector<int> const standard_vector{5, 2, 1};
         WHEN("we construct a fixed capacity container from it") {
             StaticVector<int, 5> vec(standard_vector);
             THEN("size and data matches") {
@@ -202,7 +202,7 @@ SCENARIO("StaticVectors can be sized and resized", "[support]") {
 SCENARIO("Comparison of StaticVectors", "[support]") {
     GIVEN("Two containers containers that are equal at the start") {
         StaticVector<int, 5> a{0, 1, 2};
-        StaticVector<int, 5> b{0, 1, 2};
+        StaticVector<int, 5> const b{0, 1, 2};
         REQUIRE(a == b);
         REQUIRE_FALSE(a != b);
 
@@ -211,7 +211,7 @@ SCENARIO("Comparison of StaticVectors", "[support]") {
             THEN("they are not equal anymore") { REQUIRE(a != b); }
         }
         WHEN("Compared to a StaticVector with different capacity") {
-            StaticVector<int, 8> c{0, 1, 2};
+            StaticVector<int, 8> const c{0, 1, 2};
             THEN("The comparison still holds") {
                 REQUIRE(a == c);
                 REQUIRE_FALSE(a != c);
@@ -316,7 +316,7 @@ SCENARIO("Converting to vector", "[support]") {
     GIVEN("a StaticVector") {
         StaticVector<int, 5> a{1, 2, 3};
         WHEN("Converted into a vector") {
-            std::vector<int> b(a);
+            std::vector<int> const b(a);
             THEN("Data and size matches") {
                 REQUIRE(a == b);
                 REQUIRE(a.size() == b.size());

slsSupportLib/tests/test-ToString.cpp

@@ -59,7 +59,7 @@ TEST_CASE("conversion from duration to string", "[support]") {
 }
 
 TEST_CASE("Convert vector of time", "[support]") {
-    std::vector<ns> vec{ns(150), us(10), ns(600)};
+    std::vector<ns> const vec{ns(150), us(10), ns(600)};
     REQUIRE(ToString(vec) == "[150ns, 10us, 600ns]");
     REQUIRE(ToString(vec, "ns") == "[150ns, 10000ns, 600ns]");
 }
@@ -93,26 +93,26 @@ TEST_CASE("Vector of double", "[support]") {
 }
 
 TEST_CASE("Array") {
-    std::array<int, 3> arr{1, 2, 3};
+    std::array<int, 3> const arr{1, 2, 3};
     REQUIRE(ToString(arr) == "[1, 2, 3]");
 }
 
 TEST_CASE("Convert types with str method") {
-    IpAddr addr;
+    IpAddr const addr;
     REQUIRE(ToString(addr) == "0.0.0.0");
     REQUIRE(ToString(IpAddr{}) == "0.0.0.0");
 }
 
 TEST_CASE("String to string", "[support]") {
-    std::string s = "hej";
+    std::string const s = "hej";
     REQUIRE(ToString(s) == "hej");
 }
 
 TEST_CASE("vector of strings") {
-    std::vector<std::string> vec{"5", "s"};
+    std::vector<std::string> const vec{"5", "s"};
     REQUIRE(ToString(vec) == "[5, s]");
 
-    std::vector<std::string> vec2{"some", "strange", "words", "75"};
+    std::vector<std::string> const vec2{"some", "strange", "words", "75"};
     REQUIRE(ToString(vec2) == "[some, strange, words, 75]");
 }
 
@@ -150,7 +150,7 @@ TEST_CASE("string to detectorType") {
 
 TEST_CASE("vec") {
     using rs = slsDetectorDefs::runStatus;
-    std::vector<rs> vec{rs::ERROR, rs::IDLE};
+    std::vector<rs> const vec{rs::ERROR, rs::IDLE};
     REQUIRE(ToString(vec) == "[error, idle]");
 }
 
@@ -232,25 +232,25 @@ TEST_CASE("Detector type") {
 }
 
 TEST_CASE("Formatting slsDetectorDefs::ROI") {
-    slsDetectorDefs::ROI roi(5, 159);
+    slsDetectorDefs::ROI const roi(5, 159);
     REQUIRE(ToString(roi) == "[5, 159]");
-    slsDetectorDefs::ROI roi1(5, 159, 6, 170);
+    slsDetectorDefs::ROI const roi1(5, 159, 6, 170);
     REQUIRE(ToString(roi1) == "[5, 159, 6, 170]");
 }
 
 TEST_CASE("Streaming of slsDetectorDefs::ROI") {
     using namespace sls;
-    slsDetectorDefs::ROI roi(-10, 1);
+    slsDetectorDefs::ROI const roi(-10, 1);
     std::ostringstream oss, oss1;
     oss << roi;
     REQUIRE(oss.str() == "[-10, 1]");
-    slsDetectorDefs::ROI roi1(-10, 1, 5, 11);
+    slsDetectorDefs::ROI const roi1(-10, 1, 5, 11);
     oss1 << roi1;
     REQUIRE(oss1.str() == "[-10, 1, 5, 11]");
 }
 
 TEST_CASE("std::array") {
-    std::array<int, 3> arr{4, 6, 7};
+    std::array<int, 3> const arr{4, 6, 7};
     REQUIRE(ToString(arr) == "[4, 6, 7]");
 }
 
@@ -267,14 +267,14 @@ TEST_CASE("dac index to string") {
 }
 
 TEST_CASE("convert vector of strings to dac index") {
-    std::vector<std::string> dacs{"vcassh", "vth2", "vrshaper"};
-    std::vector<defs::dacIndex> daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
+    std::vector<std::string> const dacs{"vcassh", "vth2", "vrshaper"};
+    std::vector<defs::dacIndex> const daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
     auto r = StringTo<defs::dacIndex>(dacs);
     REQUIRE(r == daci);
 }
 
 TEST_CASE("vector of dac index to string") {
-    std::vector<defs::dacIndex> daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
+    std::vector<defs::dacIndex> const daci{defs::VCASSH, defs::VTH2, defs::VRSHAPER};
     auto r = ToString(daci);
     REQUIRE(r == "[vcassh, vth2, vrshaper]");
 }
@@ -284,7 +284,7 @@ TEST_CASE("int or uin64_t to a string in hex") {
     REQUIRE(ToStringHex(65535, 8) == "0x0000ffff");
     REQUIRE(ToStringHex(8927748192) == "0x21422a060");
     REQUIRE(ToStringHex(8927748192, 16) == "0x000000021422a060");
-    std::vector<int> temp{244, 65535, 1638582};
+    std::vector<int> const temp{244, 65535, 1638582};
     auto r = ToStringHex(temp);
     REQUIRE(r == "[0xf4, 0xffff, 0x1900b6]");
     r = ToStringHex(temp, 8);
@@ -294,20 +294,20 @@ TEST_CASE("int or uin64_t to a string in hex") {
 TEST_CASE("Streaming of slsDetectorDefs::scanParameters") {
     using namespace sls;
     {
-        defs::scanParameters t{};
+        defs::scanParameters const t{};
         std::ostringstream oss;
         oss << t;
         REQUIRE(oss.str() == "[disabled]");
     }
     {
-        defs::scanParameters t{defs::VTH2, 500, 1500, 500};
+        defs::scanParameters const t{defs::VTH2, 500, 1500, 500};
         std::ostringstream oss;
         oss << t;
         REQUIRE(oss.str() == "[enabled\ndac vth2\nstart 500\nstop 1500\nstep "
                              "500\nsettleTime 1ms\n]");
     }
     {
-        defs::scanParameters t{defs::VTH2, 500, 1500, 500,
+        defs::scanParameters const t{defs::VTH2, 500, 1500, 500,
                                std::chrono::milliseconds{500}};
         std::ostringstream oss;
         oss << t;
@@ -317,17 +317,17 @@ TEST_CASE("Streaming of slsDetectorDefs::scanParameters") {
 }
 
 TEST_CASE("Printing c style arrays of int") {
-    int arr[]{3, 5};
+    int const arr[]{3, 5};
     REQUIRE(ToString(arr) == "[3, 5]");
 }
 
 TEST_CASE("Printing c style arrays of uint8") {
-    uint8_t arr[]{1, 2, 3, 4, 5};
+    uint8_t const arr[]{1, 2, 3, 4, 5};
     REQUIRE(ToString(arr) == "[1, 2, 3, 4, 5]");
 }
 
 TEST_CASE("Printing c style arrays of double") {
-    double arr[]{3.4, 5.3, 6.2};
+    double const arr[]{3.4, 5.3, 6.2};
     REQUIRE(ToString(arr) == "[3.4, 5.3, 6.2]");
 }