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

42.31

/src/DataManager/utils/TableView/computers/IntervalOverlapComputer.cpp

#include "IntervalOverlapComputer.h"

#include <algorithm>
#include <limits>
#include <stdexcept>
#include <iostream> // Added for debug output


bool intervalsOverlap(const TimeFrameInterval& a, const TimeFrameInterval& b) {
    // Two intervals overlap if: a.start <= b.end && b.start <= a.end
    return a.start.getValue() <= b.end.getValue() && b.start.getValue() <= a.end.getValue();
}

bool intervalsOverlapInAbsoluteTime(const TimeFrameInterval& rowInterval,
                                   const Interval& columnInterval,
                                   const TimeFrame* sourceTimeFrame,
                                   const TimeFrame* destinationTimeFrame) {
    // Convert row interval to absolute time coordinates
    auto destination_start = destinationTimeFrame->getTimeAtIndex(rowInterval.start);
    auto destination_end = destinationTimeFrame->getTimeAtIndex(rowInterval.end);
    
    // Convert column interval to absolute time coordinates
    auto source_start = sourceTimeFrame->getTimeAtIndex(TimeFrameIndex(columnInterval.start));
    auto source_end = sourceTimeFrame->getTimeAtIndex(TimeFrameIndex(columnInterval.end));
    
    // Check overlap using absolute time coordinates
    // Two intervals overlap if: source_start <= destination_end && destination_start <= source_end
    return source_start <= destination_end && destination_start <= source_end;
}

int64_t findContainingInterval(const TimeFrameInterval& rowInterval,
                              const std::vector<Interval>& columnIntervals) {
    for (size_t i = 0; i < columnIntervals.size(); ++i) {
        const auto& colInterval = columnIntervals[i];
        
        // Check if column interval contains the row interval
        // Column interval contains row interval if: colInterval.start <= rowInterval.start && rowInterval.end <= colInterval.end
        if (colInterval.start <= rowInterval.start.getValue() && rowInterval.end.getValue() <= colInterval.end) {
            return static_cast<int64_t>(i);
        }
    }
    return -1; // No containing interval found
}

int64_t countOverlappingIntervals(const TimeFrameInterval& rowInterval,
                                 const std::vector<Interval>& columnIntervals,
                                 const TimeFrame* sourceTimeFrame,
                                 const TimeFrame* destinationTimeFrame) {
    int64_t count = 0;
    
    for (const auto& colInterval : columnIntervals) {
        if (intervalsOverlapInAbsoluteTime(rowInterval, colInterval, sourceTimeFrame, destinationTimeFrame)) {
            ++count;
        }
    }
    
    return count;
}

std::pair<int64_t, std::vector<EntityId>> countOverlappingIntervalsWithIds(const TimeFrameInterval& rowInterval,
                                                                           const std::vector<IntervalWithId>& columnIntervalsWithIds,
                                                                           const TimeFrame* sourceTimeFrame,
                                                                           const TimeFrame* destinationTimeFrame) {
    int64_t count = 0;
    std::vector<EntityId> overlappingEntityIds;
    
    for (const auto& colIntervalWithId : columnIntervalsWithIds) {
        if (intervalsOverlapInAbsoluteTime(rowInterval, colIntervalWithId.interval, sourceTimeFrame, destinationTimeFrame)) {
            ++count;
            overlappingEntityIds.push_back(colIntervalWithId.entity_id);
        }
    }
    
    return {count, overlappingEntityIds};
}

// Template specialization for size_t
template<>
std::pair<std::vector<size_t>, ColumnEntityIds> IntervalOverlapComputer<size_t>::compute(const ExecutionPlan& plan) const {
    if (m_operation != IntervalOverlapOperation::CountOverlaps) {
        throw std::runtime_error("IntervalOverlapComputer<size_t> can only be used with CountOverlaps operation");
    }
    
    if (!plan.hasIntervals()) {
        throw std::runtime_error("IntervalOverlapComputer requires an ExecutionPlan with intervals");
    }
    
    auto rowIntervals = plan.getIntervals();
    auto destinationTimeFrame = plan.getTimeFrame();
    auto sourceTimeFrame = m_source->getTimeFrame();
    
    std::vector<size_t> results;
    results.reserve(rowIntervals.size());
    std::vector<std::vector<EntityId>> entity_ids;
    // Get all column intervals from the source
    // Use a reasonable range that covers the entire time frame
    auto columnIntervals = m_source->getIntervalsInRange(
        TimeFrameIndex(0),
        TimeFrameIndex(1000000), // Use a large but reasonable upper bound
        destinationTimeFrame.get()
    );
    
    std::cout << "DEBUG: Retrieved " << columnIntervals.size() << " column intervals" << std::endl;
    for (size_t i = 0; i < columnIntervals.size(); ++i) {
        const auto& interval = columnIntervals[i];
        std::cout << "DEBUG: Column interval " << i << ": [" << interval.start << ", " << interval.end << "]" << std::endl;
    }
    
    for (const auto& rowInterval : rowIntervals) {
        int64_t count = countOverlappingIntervals(rowInterval, columnIntervals, sourceTimeFrame.get(), destinationTimeFrame.get());
        results.push_back(static_cast<size_t>(count));
    }
    
    return {results, entity_ids};
}

// Template specializations for different data types
template std::pair<std::vector<int64_t>, ColumnEntityIds> IntervalOverlapComputer<int64_t>::compute(ExecutionPlan const & plan) const;
template std::pair<std::vector<size_t>, ColumnEntityIds> IntervalOverlapComputer<size_t>::compute(ExecutionPlan const & plan) const;
template std::pair<std::vector<double>, ColumnEntityIds> IntervalOverlapComputer<double>::compute(ExecutionPlan const & plan) const;

1	#include "IntervalOverlapComputer.h"
2
3	#include <algorithm>
4	#include <limits>
5	#include <stdexcept>
6	#include <iostream> // Added for debug output
7
8
9	bool intervalsOverlap(const TimeFrameInterval& a, const TimeFrameInterval& b) {	3✔
10	// Two intervals overlap if: a.start <= b.end && b.start <= a.end
11	return a.start.getValue() <= b.end.getValue() && b.start.getValue() <= a.end.getValue();	3✔
12	}
13
14	bool intervalsOverlapInAbsoluteTime(const TimeFrameInterval& rowInterval,	53✔
15	const Interval& columnInterval,
16	const TimeFrame* sourceTimeFrame,
17	const TimeFrame* destinationTimeFrame) {
18	// Convert row interval to absolute time coordinates
19	auto destination_start = destinationTimeFrame->getTimeAtIndex(rowInterval.start);	53✔
20	auto destination_end = destinationTimeFrame->getTimeAtIndex(rowInterval.end);	53✔
21
22	// Convert column interval to absolute time coordinates
23	auto source_start = sourceTimeFrame->getTimeAtIndex(TimeFrameIndex(columnInterval.start));	53✔
24	auto source_end = sourceTimeFrame->getTimeAtIndex(TimeFrameIndex(columnInterval.end));	53✔
25
26	// Check overlap using absolute time coordinates
27	// Two intervals overlap if: source_start <= destination_end && destination_start <= source_end
28	return source_start <= destination_end && destination_start <= source_end;	53✔
29	}
30
31	int64_t findContainingInterval(const TimeFrameInterval& rowInterval,	1✔
32	const std::vector<Interval>& columnIntervals) {
33	for (size_t i = 0; i < columnIntervals.size(); ++i) {	2✔
34	const auto& colInterval = columnIntervals[i];	2✔
35
36	// Check if column interval contains the row interval
37	// Column interval contains row interval if: colInterval.start <= rowInterval.start && rowInterval.end <= colInterval.end
38	if (colInterval.start <= rowInterval.start.getValue() && rowInterval.end.getValue() <= colInterval.end) {	2✔
39	return static_cast<int64_t>(i);	1✔
40	}
41	}
UNCOV 42	return -1; // No containing interval found	×
43	}
44
UNCOV 45	int64_t countOverlappingIntervals(const TimeFrameInterval& rowInterval,	×
46	const std::vector<Interval>& columnIntervals,
47	const TimeFrame* sourceTimeFrame,
48	const TimeFrame* destinationTimeFrame) {
UNCOV 49	int64_t count = 0;	×
50
UNCOV 51	for (const auto& colInterval : columnIntervals) {	×
UNCOV 52	if (intervalsOverlapInAbsoluteTime(rowInterval, colInterval, sourceTimeFrame, destinationTimeFrame)) {	×
UNCOV 53	++count;	×
54	}
55	}
56
57	return count;	×
58	}
59
60	std::pair<int64_t, std::vector<EntityId>> countOverlappingIntervalsWithIds(const TimeFrameInterval& rowInterval,	51✔
61	const std::vector<IntervalWithId>& columnIntervalsWithIds,
62	const TimeFrame* sourceTimeFrame,
63	const TimeFrame* destinationTimeFrame) {
64	int64_t count = 0;	51✔
65	std::vector<EntityId> overlappingEntityIds;	51✔
66
67	for (const auto& colIntervalWithId : columnIntervalsWithIds) {	104✔
68	if (intervalsOverlapInAbsoluteTime(rowInterval, colIntervalWithId.interval, sourceTimeFrame, destinationTimeFrame)) {	53✔
69	++count;	52✔
70	overlappingEntityIds.push_back(colIntervalWithId.entity_id);	52✔
71	}
72	}
73
74	return {count, overlappingEntityIds};	102✔
75	}	51✔
76
77	// Template specialization for size_t
78	template<>
79	std::pair<std::vector<size_t>, ColumnEntityIds> IntervalOverlapComputer<size_t>::compute(const ExecutionPlan& plan) const {	×
80	if (m_operation != IntervalOverlapOperation::CountOverlaps) {	×
81	throw std::runtime_error("IntervalOverlapComputer<size_t> can only be used with CountOverlaps operation");	×
82	}
83
UNCOV 84	if (!plan.hasIntervals()) {	×
85	throw std::runtime_error("IntervalOverlapComputer requires an ExecutionPlan with intervals");	×
86	}
87
UNCOV 88	auto rowIntervals = plan.getIntervals();	×
UNCOV 89	auto destinationTimeFrame = plan.getTimeFrame();	×
90	auto sourceTimeFrame = m_source->getTimeFrame();	×
91
UNCOV 92	std::vector<size_t> results;	×
UNCOV 93	results.reserve(rowIntervals.size());	×
UNCOV 94	std::vector<std::vector<EntityId>> entity_ids;	×
95	// Get all column intervals from the source
96	// Use a reasonable range that covers the entire time frame
UNCOV 97	auto columnIntervals = m_source->getIntervalsInRange(	×
98	TimeFrameIndex(0),
99	TimeFrameIndex(1000000), // Use a large but reasonable upper bound
UNCOV 100	destinationTimeFrame.get()	×
UNCOV 101	);	×
102
UNCOV 103	std::cout << "DEBUG: Retrieved " << columnIntervals.size() << " column intervals" << std::endl;	×
UNCOV 104	for (size_t i = 0; i < columnIntervals.size(); ++i) {	×
UNCOV 105	const auto& interval = columnIntervals[i];	×
UNCOV 106	std::cout << "DEBUG: Column interval " << i << ": [" << interval.start << ", " << interval.end << "]" << std::endl;	×
107	}
108
UNCOV 109	for (const auto& rowInterval : rowIntervals) {	×
UNCOV 110	int64_t count = countOverlappingIntervals(rowInterval, columnIntervals, sourceTimeFrame.get(), destinationTimeFrame.get());	×
UNCOV 111	results.push_back(static_cast<size_t>(count));	×
112	}
113
UNCOV 114	return {results, entity_ids};	×
UNCOV 115	}	×
116
117	// Template specializations for different data types
118	template std::pair<std::vector<int64_t>, ColumnEntityIds> IntervalOverlapComputer<int64_t>::compute(ExecutionPlan const & plan) const;
119	template std::pair<std::vector<size_t>, ColumnEntityIds> IntervalOverlapComputer<size_t>::compute(ExecutionPlan const & plan) const;
120	template std::pair<std::vector<double>, ColumnEntityIds> IntervalOverlapComputer<double>::compute(ExecutionPlan const & plan) const;

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