Streamlined the setup process in the GitHub Actions workflow by
combining system updates and package installations into a single step.
Removed the action for setting up CMake, instead directly installing it
along with build requirements, reducing redundancy and improving build
times. These adjustments enhance the efficiency of the continuous
integration process.
artifacts
Transition the project's build system from Autoconf to CMake,
streamlining the build process and conforming to modern C++ project
standards. Autoconf related files like 'configure', 'install-sh', and
'missing' have been removed while CMakeLists and relevant .cmake
configuration files are added to support the new system. This change
addresses the need for a more portable and easier-to-maintain build
system, particularly beneficial for cross-platform development. As a
result, build process customization and dependency management are
expected to be more straightforward.
Additionally, `.gitignore` has been adjusted to accommodate the CMake
build outputs. The new CMake build system introduces `build/` as the
directory for out-of-source builds, replacing the more scattered build
artifacts of the previous system.
Replaced the array parameter in `dumpConfig` function with a vector reference, streamlining parameter passing and enhancing code maintainability. Included `<cstddef>` for `size_t` definition and removed redundant code that copied vector contents to an array, thus improving performance. These changes eliminate the need for manual array sizing and copying, reducing potential errors and improving readability.
Enhanced performance and safety of the LimeDriver by passing `LimeCfg` by reference to `getHDFAttributes`. Additionally, zero-initialized `LimeCfg`, pulse duration, and frequency arrays upon creation to prevent potential use of garbage values and ensure determinate behavior. These changes may reduce memory usage and increase reliability when configuring the Lime hardware.
Replaced inline initialization of HDF attribute structs with getHDFAttributes, a new function isolating HDF configuration setup. This change improves modularity, making the main function cleaner and the codebase easier to maintain. It allows expanding or changing the attribute set without cluttering the main logic. The introduced std::vector further modernizes resource management and supports dynamic attribute collection, followed by a conversion to an array for backward compatibility with existing code.
Corrected the for loop syntax for initializing parameters by removing an extraneous comma that caused a tuple unpacking error when iterating over dictionary keys. This change allows proper parameter initialization without errors.
Simplified the storage of command-line arguments by refactoring how parameters are initialized in the 'limr' class. Removed redundant storage of parameters by opting to keep them as attributes instead of storing them in both attributes and a dictionary. Enhanced the parameter display function by appending the "name" attribute from the parameter dictionary, providing clearer output. This change improves code maintainability and readability, ensuring argument-related data is handled consistently throughout the class.
Resolves confusion around parameter storage as flagged in TODO comment.
Updated the configuration dump function to serialize argument-value pairs into more detailed JSON objects. This now includes the argument's name, data type, value, and dimensions instead of just the value as a string. This richer output format allows for enhanced configuration clarity and downstream data processing. Improved type information and dimension data support handling various data types and array structures without information loss or ambiguity.
Standardized the iteration over dictionary keys in `limr.py` to directly call `.keys()` method for clarity. Additionally, streamlined the output formatting by removing redundant data in `print_params()` method, resulting in cleaner output without extraneous details. This enhances code readability and maintains a tidy console display.
Temporarily retain input arguments in a dictionary within the initialization for potential future use, marked with a TODO for deciding on a singular method of parameter storage. This aims to streamline configuration management and facilitate debugging. Further cleanup is needed to consolidate parameter handling.
Refactored the dumpConfig function in C++ to output valid JSON format by changing brackets and refining the argument-value pair structure. This corrects the previous invalid JSON syntax and ensures compatibility with JSON parsers. In Python, enhanced type safety by explicitly annotating in_arg as a dictionary and streamlined parameter initialization by iterating over items directly. This change improves code readability and reduces potential errors during parameter assignment.
Fixes issue with JSON serialization and parameter handling.
Refactored the limr class to streamline initialization and improve parameter management by directly fetching default parameters from the `limedriver` binary with a `--dump` flag, eliminating manual parsing, leading to more robust and maintainable code. These changes improve the maintainability and extend the functionality of the parameter handling in the limr class, making it easier to scale and adapt for future requirements.
Improved JSON serialization logic in the driver to correctly handle and label special "///" arguments by giving them unique identifiers. This enhancement ensures that the outputted configuration data is not only syntactically correct but also more informative and easier to process programmatically. These changes address potential ambiguities when parsing the JSON output, leading to more reliable configuration management.
Moved compiled binaries to a dedicated 'bin/' directory to streamline output organization, ensuring that all executables are consolidated in a single, standard location. Updated the gitignore to reflect this change, which helps prevent accidental commits of executable files. The Makefile was also adjusted to build the 'limedriver' program within the new directory structure.
Removed the previously tracked binary 'limedriver' to reduce repository clutter and avoid potential merge conflicts with binary files. Now, future compilations will adhere to the new 'bin/' directory convention, improving the project's structure and maintainability.
Setup the initial build system and dependency management using Automake. This includes checks for a C++ compiler, LimeSuite library, and associated header files. Additionally, configured automatic dependency tracking to facilitate smoother development. This system is necessary for ensuring consistent builds across different environments and simplifying the addition of new components and dependencies as development progresses.