17920603410

Committed 22 Sep 2025 03:39PM UTC coverage: 71.97% (-0.05%) from 72.02%

Build # 17920603410

Build Type

push

github

Committed by

paulmthompson

Commit Message

all tests pass

Run Details

277 of 288 new or added lines in 8 files covered. (96.18%)

520 existing lines in 35 files now uncovered.

40275 of 55961 relevant lines covered (71.97%)

1225.8 hits per line

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

22.22

/src/DataManager/utils/TableView/interfaces/IColumnComputer.h

#ifndef ICOLUMN_COMPUTER_H
#define ICOLUMN_COMPUTER_H

#include "Entity/EntityTypes.hpp"
#include "utils/TableView/columns/IColumn.h"
#include "utils/TableView/core/ExecutionPlan.h"

#include <memory>
#include <string>
#include <utility>
#include <variant>
#include <vector>

/**
 * @brief Templated interface for computing column values in a batch operation.
 * 
 * This interface defines the strategy for computing all values in a column
 * in a single batch operation. Different implementations can provide
 * different computation strategies (direct access, interval reductions,
 * transformations, etc.). The template parameter T allows for heterogeneous
 * column types.
 */
template<typename T>
class IColumnComputer {
public:
    virtual ~IColumnComputer() = default;

    // Make this class non-copyable and non-movable since it's a pure interface
    IColumnComputer(IColumnComputer const &) = delete;
    IColumnComputer & operator=(IColumnComputer const &) = delete;
    IColumnComputer(IColumnComputer &&) = delete;
    IColumnComputer & operator=(IColumnComputer &&) = delete;

    /**
     * @brief The core batch computation method.
     * 
     * This method performs the actual computation of all column values
     * based on the provided execution plan. The execution plan contains
     * the cached access patterns (indices or intervals) for the data source.
     * 
     * @param plan The execution plan containing cached access patterns.
     * @return Vector of computed values for the entire column.
     */
    [[nodiscard]] virtual std::pair<std::vector<T>, ColumnEntityIds> compute(ExecutionPlan const & plan) const = 0;

    /**
     * @brief Declares dependencies on other columns.
     * 
     * For transformed columns that depend on other columns, this method
     * returns the names of the columns that must be computed first.
     * 
     * @return Vector of column names this computer depends on.
     */
    [[nodiscard]] virtual std::vector<std::string> getDependencies() const {
        return {};
    }

    /**
     * @brief Declares the required data source.
     * 
     * This method returns the name of the data source that this computer
     * needs to access (e.g., "LFP", "Spikes.x").
     * 
     * @return The name of the required data source.
     */
    [[nodiscard]] virtual std::string getSourceDependency() const = 0;

    /**
     * @brief Gets the EntityID structure type for this computer.
     * 
     * This indicates whether the computer provides no EntityIDs, simple EntityIDs
     * (one per row), or complex EntityIDs (multiple per row).
     * 
     * @return The EntityID structure type for this computer.
     */
    [[nodiscard]] virtual EntityIdStructure getEntityIdStructure() const {
        return EntityIdStructure::None;
    }

    /**
     * @brief Computes all EntityIDs for the column using the high-level variant approach.
     * 
     * The returned variant contains one of:
     * - std::monostate: No EntityIDs available
     * - std::vector<EntityId>: One EntityID per row (simple)
     * - std::vector<std::vector<EntityId>>: Multiple EntityIDs per row (complex)
     * 
     * Note: Shared EntityID collections are typically handled at the Column level
     * for table transforms, not at the computer level.
     * 
     * @param plan The execution plan used for computation.
     * @return ColumnEntityIds variant containing the EntityIDs for this column.
     */
    [[nodiscard]] virtual ColumnEntityIds computeColumnEntityIds(ExecutionPlan const & plan) const {
        (void) plan;
        return std::monostate{};
    }

    /**
     * @brief Computes EntityIDs for a specific row.
     * 
     * This is a convenience method that works across all EntityID structures.
     * 
     * @param plan The execution plan used for computation.
     * @param row_index The row index to get EntityIDs for.
     * @return Vector of EntityIDs for the specified row. Empty if not available.
     */
    [[nodiscard]] virtual std::vector<EntityId> computeCellEntityIds(ExecutionPlan const & plan, size_t row_index) const {
        auto structure = getEntityIdStructure();
        if (structure == EntityIdStructure::None) {
            return {};
        }

        auto column_entities = computeColumnEntityIds(plan);

        switch (structure) {
            case EntityIdStructure::Simple: {
                auto & entities = std::get<std::vector<EntityId>>(column_entities);
                return (row_index < entities.size()) ? std::vector<EntityId>{entities[row_index]} : std::vector<EntityId>{};
            }
            case EntityIdStructure::Complex: {
                auto & entity_matrix = std::get<std::vector<std::vector<EntityId>>>(column_entities);
                return (row_index < entity_matrix.size()) ? entity_matrix[row_index] : std::vector<EntityId>{};
            }
            case EntityIdStructure::Shared:
                // Shared collections not typically used at computer level
                return {};
            case EntityIdStructure::None:
            default:
                return {};
        }
    }

    /**
     * @brief Checks if this computer can provide EntityID information.
     * @return True if EntityIDs are available, false otherwise.
     */
    [[nodiscard]] virtual bool hasEntityIds() const {
        return getEntityIdStructure() != EntityIdStructure::None;
    }

protected:
    // Protected constructor to allow derived classes to construct
    IColumnComputer() = default;
};

#endif// ICOLUMN_COMPUTER_H

1	#ifndef ICOLUMN_COMPUTER_H
2	#define ICOLUMN_COMPUTER_H
3
4	#include "Entity/EntityTypes.hpp"
5	#include "utils/TableView/columns/IColumn.h"
6	#include "utils/TableView/core/ExecutionPlan.h"
7
8	#include <memory>
9	#include <string>
10	#include <utility>
11	#include <variant>
12	#include <vector>
13
14	/**
15	* @brief Templated interface for computing column values in a batch operation.
16	*
17	* This interface defines the strategy for computing all values in a column
18	* in a single batch operation. Different implementations can provide
19	* different computation strategies (direct access, interval reductions,
20	* transformations, etc.). The template parameter T allows for heterogeneous
21	* column types.
22	*/
23	template<typename T>
24	class IColumnComputer {
25	public:
26	virtual ~IColumnComputer() = default;	604✔
27
28	// Make this class non-copyable and non-movable since it's a pure interface
29	IColumnComputer(IColumnComputer const &) = delete;
30	IColumnComputer & operator=(IColumnComputer const &) = delete;
31	IColumnComputer(IColumnComputer &&) = delete;
32	IColumnComputer & operator=(IColumnComputer &&) = delete;
33
34	/**
35	* @brief The core batch computation method.
36	*
37	* This method performs the actual computation of all column values
38	* based on the provided execution plan. The execution plan contains
39	* the cached access patterns (indices or intervals) for the data source.
40	*
41	* @param plan The execution plan containing cached access patterns.
42	* @return Vector of computed values for the entire column.
43	*/
44	[[nodiscard]] virtual std::pair<std::vector<T>, ColumnEntityIds> compute(ExecutionPlan const & plan) const = 0;
45
46	/**
47	* @brief Declares dependencies on other columns.
48	*
49	* For transformed columns that depend on other columns, this method
50	* returns the names of the columns that must be computed first.
51	*
52	* @return Vector of column names this computer depends on.
53	*/
54	[[nodiscard]] virtual std::vector<std::string> getDependencies() const {	307✔
55	return {};	307✔
56	}
57
58	/**
59	* @brief Declares the required data source.
60	*
61	* This method returns the name of the data source that this computer
62	* needs to access (e.g., "LFP", "Spikes.x").
63	*
64	* @return The name of the required data source.
65	*/
66	[[nodiscard]] virtual std::string getSourceDependency() const = 0;
67
68	/**
69	* @brief Gets the EntityID structure type for this computer.
70	*
71	* This indicates whether the computer provides no EntityIDs, simple EntityIDs
72	* (one per row), or complex EntityIDs (multiple per row).
73	*
74	* @return The EntityID structure type for this computer.
75	*/
76	[[nodiscard]] virtual EntityIdStructure getEntityIdStructure() const {	×
UNCOV 77	return EntityIdStructure::None;	×
78	}
79
80	/**
81	* @brief Computes all EntityIDs for the column using the high-level variant approach.
82	*
83	* The returned variant contains one of:
84	* - std::monostate: No EntityIDs available
85	* - std::vector<EntityId>: One EntityID per row (simple)
86	* - std::vector<std::vector<EntityId>>: Multiple EntityIDs per row (complex)
87	*
88	* Note: Shared EntityID collections are typically handled at the Column level
89	* for table transforms, not at the computer level.
90	*
91	* @param plan The execution plan used for computation.
92	* @return ColumnEntityIds variant containing the EntityIDs for this column.
93	*/
UNCOV 94	[[nodiscard]] virtual ColumnEntityIds computeColumnEntityIds(ExecutionPlan const & plan) const {	×
95	(void) plan;
UNCOV 96	return std::monostate{};	×
97	}
98
99	/**
100	* @brief Computes EntityIDs for a specific row.
101	*
102	* This is a convenience method that works across all EntityID structures.
103	*
104	* @param plan The execution plan used for computation.
105	* @param row_index The row index to get EntityIDs for.
106	* @return Vector of EntityIDs for the specified row. Empty if not available.
107	*/
UNCOV 108	[[nodiscard]] virtual std::vector<EntityId> computeCellEntityIds(ExecutionPlan const & plan, size_t row_index) const {	×
UNCOV 109	auto structure = getEntityIdStructure();	×
UNCOV 110	if (structure == EntityIdStructure::None) {	×
UNCOV 111	return {};	×
112	}
113
UNCOV 114	auto column_entities = computeColumnEntityIds(plan);	×
115
UNCOV 116	switch (structure) {	×
UNCOV 117	case EntityIdStructure::Simple: {	×
UNCOV 118	auto & entities = std::get<std::vector<EntityId>>(column_entities);	×
UNCOV 119	return (row_index < entities.size()) ? std::vector<EntityId>{entities[row_index]} : std::vector<EntityId>{};	×
120	}
UNCOV 121	case EntityIdStructure::Complex: {	×
UNCOV 122	auto & entity_matrix = std::get<std::vector<std::vector<EntityId>>>(column_entities);	×
UNCOV 123	return (row_index < entity_matrix.size()) ? entity_matrix[row_index] : std::vector<EntityId>{};	×
124	}
UNCOV 125	case EntityIdStructure::Shared:	×
126	// Shared collections not typically used at computer level
127	return {};	×
UNCOV 128	case EntityIdStructure::None:	×
129	default:
UNCOV 130	return {};	×
131	}
UNCOV 132	}	×
133
134	/**
135	* @brief Checks if this computer can provide EntityID information.
136	* @return True if EntityIDs are available, false otherwise.
137	*/
138	[[nodiscard]] virtual bool hasEntityIds() const {	6✔
139	return getEntityIdStructure() != EntityIdStructure::None;	6✔
140	}
141
142	protected:
143	// Protected constructor to allow derived classes to construct
144	IColumnComputer() = default;	604✔
145	};
146
147	#endif// ICOLUMN_COMPUTER_H

paulmthompson / WhiskerToolbox / 17920603410

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