18117112849

Committed 30 Sep 2025 02:44AM UTC coverage: 70.161% (+0.03%) from 70.132%

Build # 18117112849

Build Type

push

github

Committed by

paulmthompson

Commit Message

hungarian algorithm is actually used

Run Details

60 of 77 new or added lines in 2 files covered. (77.92%)

352 existing lines in 12 files now uncovered.

45125 of 64316 relevant lines covered (70.16%)

1116.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.09

/src/DataManager/transforms/ParameterFactory.hpp

#ifndef PARAMETER_FACTORY_HPP
#define PARAMETER_FACTORY_HPP

#include "data_transforms.hpp"

#include "DataManager.hpp"

#include <nlohmann/json.hpp>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <typeinfo>
#include <any>


/**
 * @brief Function signature for parameter setters
 * 
 * @param param_obj Pointer to the parameter object
 * @param json_value JSON value to set
 * @param data_manager Pointer to data manager for resolving data references
 * @return true if parameter was set successfully
 */
using ParameterSetter = std::function<bool(TransformParametersBase* param_obj, 
                                          nlohmann::json const& json_value, 
                                          DataManager* data_manager)>;

/**
 * @brief Registry for parameter setters for different transform types and parameter names
 */
class ParameterFactory {
public:
    /**
     * @brief Register a parameter setter for a specific transform and parameter
     * 
     * @param transform_name Name of the transform
     * @param param_name Name of the parameter
     * @param setter Function to set the parameter value
     */
    void registerParameterSetter(std::string const& transform_name,
                                std::string const& param_name,
                                ParameterSetter setter);

    /**
     * @brief Set a parameter value with automatic type conversion
     * 
     * @param transform_name Name of the transform
     * @param param_obj Parameter object to modify
     * @param param_name Name of the parameter
     * @param json_value JSON value to set
     * @param data_manager Pointer to data manager for resolving references
     * @return true if parameter was set successfully
     */
    bool setParameter(std::string const& transform_name,
                     TransformParametersBase* param_obj,
                     std::string const& param_name,
                     nlohmann::json const& json_value,
                     DataManager* data_manager);

    /**
     * @brief Get the singleton instance of the parameter factory
     * 
     * @return ParameterFactory& Reference to the singleton instance
     */
    static ParameterFactory& getInstance();

    /**
     * @brief Initialize the factory with default parameter setters
     */
    void initializeDefaultSetters();

    /**
     * @brief Register a basic parameter (int, float, bool, string) with automatic type conversion
     * 
     * @tparam ParamClass The parameter class type
     * @tparam ParamType The type of the parameter member
     * @param transform_name Name of the transform
     * @param param_name Name of the parameter
     * @param param_member Pointer to the parameter member
     */
    template<typename ParamClass, typename ParamType>
    void registerBasicParameter(std::string const& transform_name,
                               std::string const& param_name,
                               ParamType ParamClass::* param_member);

    /**
     * @brief Register a data manager parameter (shared_ptr to data objects)
     * 
     * @tparam ParamClass The parameter class type
     * @tparam DataType The data type stored in DataManager
     * @param transform_name Name of the transform
     * @param param_name Name of the parameter
     * @param param_member Pointer to the parameter member
     */
    template<typename ParamClass, typename DataType>
    void registerDataParameter(std::string const& transform_name,
                              std::string const& param_name,
                              std::shared_ptr<DataType> ParamClass::* param_member);

    /**
     * @brief Register an enum parameter with string-to-enum mapping
     * 
     * @tparam ParamClass The parameter class type
     * @tparam EnumType The enum type
     * @param transform_name Name of the transform
     * @param param_name Name of the parameter
     * @param param_member Pointer to the parameter member
     * @param enum_map Map from string names to enum values
     */
    template<typename ParamClass, typename EnumType>
    void registerEnumParameter(std::string const& transform_name,
                              std::string const& param_name,
                              EnumType ParamClass::* param_member,
                              std::unordered_map<std::string, EnumType> const& enum_map);

private:
    std::unordered_map<std::string, std::unordered_map<std::string, ParameterSetter>> setters_;
    
    ParameterFactory() = default;
};

// Template implementations

template<typename ParamClass, typename ParamType>
void ParameterFactory::registerBasicParameter(std::string const& transform_name,
                                             std::string const& param_name,
                                             ParamType ParamClass::* param_member) {
    registerParameterSetter(transform_name, param_name,
        [param_member](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager*) -> bool {
            auto* typed_params = static_cast<ParamClass*>(param_obj);
            
            if constexpr (std::is_arithmetic_v<ParamType> && !std::is_same_v<ParamType, bool>) {
                // Handle numeric types (int, float, double, etc.)
                if (json_value.is_number()) {
                    typed_params->*param_member = static_cast<ParamType>(json_value.get<double>());
                    return true;
                }
            } else if constexpr (std::is_same_v<ParamType, bool>) {
                // Handle boolean type
                if (json_value.is_boolean()) {
                    typed_params->*param_member = json_value.get<bool>();
                    return true;
                }
            } else if constexpr (std::is_same_v<ParamType, std::string>) {
                // Handle string type
                if (json_value.is_string()) {
                    typed_params->*param_member = json_value.get<std::string>();
                    return true;
                }
            }
            return false;
        });
}

template<typename ParamClass, typename DataType>
void ParameterFactory::registerDataParameter(std::string const& transform_name,
                                            std::string const& param_name,
                                            std::shared_ptr<DataType> ParamClass::* param_member) {
    registerParameterSetter(transform_name, param_name,
        [param_member](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager* dm) -> bool {
            if (!json_value.is_string()) {
                return false;
            }
            
            std::string data_key = json_value.get<std::string>();
            auto data = dm->getData<DataType>(data_key);
            if (!data) {
                return false;
            }
            
            auto* typed_params = static_cast<ParamClass*>(param_obj);
            typed_params->*param_member = data;
            return true;
        });
}

template<typename ParamClass, typename EnumType>
void ParameterFactory::registerEnumParameter(std::string const& transform_name,
                                            std::string const& param_name,
                                            EnumType ParamClass::* param_member,
                                            std::unordered_map<std::string, EnumType> const& enum_map) {
    registerParameterSetter(transform_name, param_name,
        [param_member, enum_map](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager*) -> bool {
            if (!json_value.is_string()) {
                return false;
            }
            
            std::string enum_str = json_value.get<std::string>();
            auto it = enum_map.find(enum_str);
            if (it == enum_map.end()) {
                return false;
            }
            
            auto* typed_params = static_cast<ParamClass*>(param_obj);
            typed_params->*param_member = it->second;
            return true;
        });
}

#endif // PARAMETER_FACTORY_HPP

1	#ifndef PARAMETER_FACTORY_HPP
2	#define PARAMETER_FACTORY_HPP
3
4	#include "data_transforms.hpp"
5
6	#include "DataManager.hpp"
7
8	#include <nlohmann/json.hpp>
9	#include <functional>
10	#include <memory>
11	#include <string>
12	#include <unordered_map>
13	#include <typeinfo>
14	#include <any>
15
16
17	/**
18	* @brief Function signature for parameter setters
19	*
20	* @param param_obj Pointer to the parameter object
21	* @param json_value JSON value to set
22	* @param data_manager Pointer to data manager for resolving data references
23	* @return true if parameter was set successfully
24	*/
25	using ParameterSetter = std::function<bool(TransformParametersBase* param_obj,
26	nlohmann::json const& json_value,
27	DataManager* data_manager)>;
28
29	/**
30	* @brief Registry for parameter setters for different transform types and parameter names
31	*/
32	class ParameterFactory {
33	public:
34	/**
35	* @brief Register a parameter setter for a specific transform and parameter
36	*
37	* @param transform_name Name of the transform
38	* @param param_name Name of the parameter
39	* @param setter Function to set the parameter value
40	*/
41	void registerParameterSetter(std::string const& transform_name,
42	std::string const& param_name,
43	ParameterSetter setter);
44
45	/**
46	* @brief Set a parameter value with automatic type conversion
47	*
48	* @param transform_name Name of the transform
49	* @param param_obj Parameter object to modify
50	* @param param_name Name of the parameter
51	* @param json_value JSON value to set
52	* @param data_manager Pointer to data manager for resolving references
53	* @return true if parameter was set successfully
54	*/
55	bool setParameter(std::string const& transform_name,
56	TransformParametersBase* param_obj,
57	std::string const& param_name,
58	nlohmann::json const& json_value,
59	DataManager* data_manager);
60
61	/**
62	* @brief Get the singleton instance of the parameter factory
63	*
64	* @return ParameterFactory& Reference to the singleton instance
65	*/
66	static ParameterFactory& getInstance();
67
68	/**
69	* @brief Initialize the factory with default parameter setters
70	*/
71	void initializeDefaultSetters();
72
73	/**
74	* @brief Register a basic parameter (int, float, bool, string) with automatic type conversion
75	*
76	* @tparam ParamClass The parameter class type
77	* @tparam ParamType The type of the parameter member
78	* @param transform_name Name of the transform
79	* @param param_name Name of the parameter
80	* @param param_member Pointer to the parameter member
81	*/
82	template<typename ParamClass, typename ParamType>
83	void registerBasicParameter(std::string const& transform_name,
84	std::string const& param_name,
85	ParamType ParamClass::* param_member);
86
87	/**
88	* @brief Register a data manager parameter (shared_ptr to data objects)
89	*
90	* @tparam ParamClass The parameter class type
91	* @tparam DataType The data type stored in DataManager
92	* @param transform_name Name of the transform
93	* @param param_name Name of the parameter
94	* @param param_member Pointer to the parameter member
95	*/
96	template<typename ParamClass, typename DataType>
97	void registerDataParameter(std::string const& transform_name,
98	std::string const& param_name,
99	std::shared_ptr<DataType> ParamClass::* param_member);
100
101	/**
102	* @brief Register an enum parameter with string-to-enum mapping
103	*
104	* @tparam ParamClass The parameter class type
105	* @tparam EnumType The enum type
106	* @param transform_name Name of the transform
107	* @param param_name Name of the parameter
108	* @param param_member Pointer to the parameter member
109	* @param enum_map Map from string names to enum values
110	*/
111	template<typename ParamClass, typename EnumType>
112	void registerEnumParameter(std::string const& transform_name,
113	std::string const& param_name,
114	EnumType ParamClass::* param_member,
115	std::unordered_map<std::string, EnumType> const& enum_map);
116
117	private:
118	std::unordered_map<std::string, std::unordered_map<std::string, ParameterSetter>> setters_;
119
120	ParameterFactory() = default;	48✔
121	};
122
123	// Template implementations
124
125	template<typename ParamClass, typename ParamType>
126	void ParameterFactory::registerBasicParameter(std::string const& transform_name,	6,450✔
127	std::string const& param_name,
128	ParamType ParamClass::* param_member) {
129	registerParameterSetter(transform_name, param_name,	19,350✔
130	[param_member](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager*) -> bool {	13,110✔
131	auto* typed_params = static_cast<ParamClass*>(param_obj);	210✔
132
133	if constexpr (std::is_arithmetic_v<ParamType> && !std::is_same_v<ParamType, bool>) {
134	// Handle numeric types (int, float, double, etc.)
135	if (json_value.is_number()) {	188✔
136	typed_params->*param_member = static_cast<ParamType>(json_value.get<double>());	188✔
137	return true;	188✔
138	}
139	} else if constexpr (std::is_same_v<ParamType, bool>) {
140	// Handle boolean type
141	if (json_value.is_boolean()) {	22✔
142	typed_params->*param_member = json_value.get<bool>();	22✔
143	return true;	22✔
144	}
145	} else if constexpr (std::is_same_v<ParamType, std::string>) {
146	// Handle string type
UNCOV 147	if (json_value.is_string()) {	×
UNCOV 148	typed_params->*param_member = json_value.get<std::string>();	×
UNCOV 149	return true;	×
150	}
151	}
152	return false;	×
153	});
154	}	6,450✔
155
156	template<typename ParamClass, typename DataType>
157	void ParameterFactory::registerDataParameter(std::string const& transform_name,	344✔
158	std::string const& param_name,
159	std::shared_ptr<DataType> ParamClass::* param_member) {
160	registerParameterSetter(transform_name, param_name,	1,032✔
161	[param_member](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager* dm) -> bool {	698✔
162	if (!json_value.is_string()) {	10✔
163	return false;	×
164	}
165
166	std::string data_key = json_value.get<std::string>();	10✔
167	auto data = dm->getData<DataType>(data_key);	10✔
168	if (!data) {	10✔
169	return false;	×
170	}
171
172	auto* typed_params = static_cast<ParamClass*>(param_obj);	10✔
173	typed_params->*param_member = data;	10✔
174	return true;	10✔
175	});	10✔
176	}	344✔
177
178	template<typename ParamClass, typename EnumType>
179	void ParameterFactory::registerEnumParameter(std::string const& transform_name,	1,290✔
180	std::string const& param_name,
181	EnumType ParamClass::* param_member,
182	std::unordered_map<std::string, EnumType> const& enum_map) {
183	registerParameterSetter(transform_name, param_name,	3,870✔
184	[param_member, enum_map](TransformParametersBase* param_obj, nlohmann::json const& json_value, DataManager*) -> bool {	2,643✔
185	if (!json_value.is_string()) {	63✔
186	return false;	×
187	}
188
189	std::string enum_str = json_value.get<std::string>();	63✔
190	auto it = enum_map.find(enum_str);	63✔
191	if (it == enum_map.end()) {	63✔
192	return false;	5✔
193	}
194
195	auto* typed_params = static_cast<ParamClass*>(param_obj);	58✔
196	typed_params->*param_member = it->second;	58✔
197	return true;	58✔
198	});	63✔
199	}	1,290✔
200
201	#endif // PARAMETER_FACTORY_HPP

paulmthompson / WhiskerToolbox / 18117112849

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous