28496595030

Committed 01 Jul 2026 05:50AM UTC coverage: 50.727% (-1.6%) from 52.278%

Build # 28496595030

Build Type

Pull #83

github

Committed by

web-flow

Commit Message

Merge 8f1ff4df5 into 2efed6649

Pull Request Pull Request #83: refactor and improve code QoL

Coverage Stats

31872 of 80367 branches covered (39.66%)

Branch coverage included in aggregate %.

770 of 1591 new or added lines in 85 files covered. (48.4%)

5070 existing lines in 182 files now uncovered.

32742 of 47009 relevant lines covered (69.65%)

9887.52 hits per line

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

55.96

/src/dftracer/utils/utilities/reader/internal/reader_c.cpp

#include <dftracer/utils/core/common/logging.h>
#include <dftracer/utils/utilities/reader/internal/reader.h>
#include <dftracer/utils/utilities/reader/internal/reader_factory.h>
#include <dftracer/utils/utilities/reader/internal/stream.h>
#include <dftracer/utils/utilities/reader/internal/stream_type.h>

#include <cstring>

using namespace dftracer::utils::utilities::reader::internal;

static std::shared_ptr<Reader> *cast_reader(dft_reader_handle_t reader) {
    return static_cast<std::shared_ptr<Reader> *>(reader);
}

extern "C" {

// Helper functions for C API
static int validate_handle(dft_reader_handle_t reader) {
    return reader ? 0 : -1;
}

dft_reader_handle_t dft_reader_create(const char *gz_path,
                                      const char *index_path,
                                      size_t index_ckpt_size) {
    if (!gz_path || !index_path) {
        DFTRACER_UTILS_LOG_ERROR("%s",
                                 "Both gz_path and index_path cannot be null");
        return nullptr;
    }

    try {
        auto reader =
            ReaderFactory::create(gz_path, index_path, index_ckpt_size);
        // For C API, we need to transfer ownership - create a new shared_ptr on
        // heap
        return static_cast<dft_reader_handle_t>(
            new std::shared_ptr<Reader>(reader));
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader: %s", e.what());
        return nullptr;
    }
}

dft_reader_handle_t dft_reader_create_with_indexer(
    dft_indexer_handle_t indexer) {
    if (!indexer) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Indexer cannot be null");
        return nullptr;
    }

    DFTRACER_UTILS_LOG_DEBUG("%s", "Creating DFT reader with provided indexer");

    try {
        // Indexer handle is now a shared_ptr<Indexer>*
        auto indexer_ptr = static_cast<std::shared_ptr<
            dftracer::utils::utilities::indexer::internal::Indexer> *>(indexer);
        auto reader = ReaderFactory::create(*indexer_ptr);
        return static_cast<dft_reader_handle_t>(
            new std::shared_ptr<Reader>(reader));
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader with indexer: %s",
                                 e.what());
        return nullptr;
    }
}

void dft_reader_destroy(dft_reader_handle_t reader) {
    if (reader) {
        delete cast_reader(reader);
    }
}

int dft_reader_get_max_bytes(dft_reader_handle_t reader, size_t *max_bytes) {
    if (validate_handle(reader) || !max_bytes) {
        return -1;
    }

    try {
        *max_bytes = (*cast_reader(reader))->get_max_bytes();
        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to get max bytes: %s", e.what());
        return -1;
    }
}

int dft_reader_get_num_lines(dft_reader_handle_t reader, size_t *num_lines) {
    if (validate_handle(reader) || !num_lines) {
        return -1;
    }

    try {
        *num_lines = (*cast_reader(reader))->get_num_lines();
        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to get number of lines: %s", e.what());
        return -1;
    }
}

int dft_reader_read(dft_reader_handle_t reader, size_t start_bytes,
                    size_t end_bytes, char *buffer, size_t buffer_size) {
    if (validate_handle(reader) || !buffer || buffer_size == 0) {
        return -1;
    }

    try {
        size_t bytes_read =
            (*cast_reader(reader))
                ->read(start_bytes, end_bytes, buffer, buffer_size);
        return static_cast<int>(bytes_read);
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read: %s", e.what());
        return -1;
    }
}

int dft_reader_read_line_bytes(dft_reader_handle_t reader, size_t start_bytes,
                               size_t end_bytes, char *buffer,
                               size_t buffer_size) {
    if (validate_handle(reader) || !buffer || buffer_size == 0) {
        return -1;
    }

    try {
        size_t bytes_read =
            (*cast_reader(reader))
                ->read_line_bytes(start_bytes, end_bytes, buffer, buffer_size);
        return static_cast<int>(bytes_read);
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read line bytes: %s", e.what());
        return -1;
    }
}

int dft_reader_read_lines(dft_reader_handle_t reader, size_t start_line,
                          size_t end_line, char *buffer, size_t buffer_size,
                          size_t *bytes_written) {
    if (validate_handle(reader) || !buffer || buffer_size == 0 ||
        !bytes_written) {
        return -1;
    }

    try {
        std::string result =
            (*cast_reader(reader))->read_lines(start_line, end_line);

        size_t result_size = result.size();
        if (result_size >= buffer_size) {
            *bytes_written = result_size;
            return -1;
        }

        std::memcpy(buffer, result.c_str(), result_size);
        buffer[result_size] = '\0';
        *bytes_written = result_size;

        return 0;
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to read lines: %s", e.what());
        *bytes_written = 0;
        return -1;
    }
}

void dft_reader_reset(dft_reader_handle_t reader) {
    if (reader) {
        (*cast_reader(reader))->reset();
    }
}

dft_reader_stream_t dft_reader_stream(dft_reader_handle_t reader,
                                      const dft_stream_config_t *config) {
    if (validate_handle(reader)) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Invalid reader handle");
        return nullptr;
    }

    if (!config) {
        DFTRACER_UTILS_LOG_ERROR("%s", "Invalid config pointer");
        return nullptr;
    }

    try {
        // Convert C config to C++ config
        StreamConfig cpp_config = StreamConfig::from_c(*config);

        // Create stream
        auto stream = (*cast_reader(reader))->stream(cpp_config);

        // Transfer ownership to C API
        return static_cast<dft_reader_stream_t>(stream.release());
    } catch (const std::exception &e) {
        DFTRACER_UTILS_LOG_ERROR("Failed to create stream: %s", e.what());
        return nullptr;
    }
}

}  // extern "C"

1	#include <dftracer/utils/core/common/logging.h>
2	#include <dftracer/utils/utilities/reader/internal/reader.h>
3	#include <dftracer/utils/utilities/reader/internal/reader_factory.h>
4	#include <dftracer/utils/utilities/reader/internal/stream.h>
5	#include <dftracer/utils/utilities/reader/internal/stream_type.h>
6
7	#include <cstring>
8
9	using namespace dftracer::utils::utilities::reader::internal;
10
11	static std::shared_ptr<Reader> *cast_reader(dft_reader_handle_t reader) {	206✔
12	return static_cast<std::shared_ptr<Reader> *>(reader);	206✔
13	}
14
15	extern "C" {
16
17	// Helper functions for C API
18	static int validate_handle(dft_reader_handle_t reader) {	186✔
19	return reader ? 0 : -1;	186✔
20	}
21
22	dft_reader_handle_t dft_reader_create(const char *gz_path,	12✔
23	const char *index_path,
24	size_t index_ckpt_size) {
25	if (!gz_path \|\| !index_path) {	12✔
26	DFTRACER_UTILS_LOG_ERROR("%s",	2!
27	"Both gz_path and index_path cannot be null");
28	return nullptr;	2✔
29	}
30
31	try {
32	auto reader =
33	ReaderFactory::create(gz_path, index_path, index_ckpt_size);	10!
34	// For C API, we need to transfer ownership - create a new shared_ptr on
35	// heap
36	return static_cast<dft_reader_handle_t>(	9✔
37	new std::shared_ptr<Reader>(reader));	9!
38	} catch (const std::exception &e) {	10!
39	DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader: %s", e.what());	1!
40	return nullptr;	1✔
41	}	1!
42	}	13✔
43
44	dft_reader_handle_t dft_reader_create_with_indexer(	22✔
45	dft_indexer_handle_t indexer) {
46	if (!indexer) {	22!
47	DFTRACER_UTILS_LOG_ERROR("%s", "Indexer cannot be null");	×
48	return nullptr;	×
49	}
50
51	DFTRACER_UTILS_LOG_DEBUG("%s", "Creating DFT reader with provided indexer");	22!
52
53	try {
54	// Indexer handle is now a shared_ptr<Indexer>*
55	auto indexer_ptr = static_cast<std::shared_ptr<	22✔
56	dftracer::utils::utilities::indexer::internal::Indexer> *>(indexer);	22✔
57	auto reader = ReaderFactory::create(*indexer_ptr);	22!
58	return static_cast<dft_reader_handle_t>(	22✔
59	new std::shared_ptr<Reader>(reader));	22!
60	} catch (const std::exception &e) {	22!
61	DFTRACER_UTILS_LOG_ERROR("Failed to create DFT reader with indexer: %s",	×
62	e.what());
63	return nullptr;	×
64	}	×
65	}	22✔
66
67	void dft_reader_destroy(dft_reader_handle_t reader) {	31✔
68	if (reader) {	31!
69	delete cast_reader(reader);	31!
70	}	31✔
71	}	31✔
72
73	int dft_reader_get_max_bytes(dft_reader_handle_t reader, size_t *max_bytes) {	6✔
74	if (validate_handle(reader) \|\| !max_bytes) {	6✔
75	return -1;	2✔
76	}
77
78	try {
79	max_bytes = (cast_reader(reader))->get_max_bytes();	4!
80	return 0;	4✔
81	} catch (const std::exception &e) {	×
82	DFTRACER_UTILS_LOG_ERROR("Failed to get max bytes: %s", e.what());	×
83	return -1;	×
84	}	×
85	}	6✔
86
87	int dft_reader_get_num_lines(dft_reader_handle_t reader, size_t *num_lines) {	5✔
88	if (validate_handle(reader) \|\| !num_lines) {	5!
89	return -1;	×
90	}
91
92	try {
93	num_lines = (cast_reader(reader))->get_num_lines();	5!
94	return 0;	5✔
95	} catch (const std::exception &e) {	×
96	DFTRACER_UTILS_LOG_ERROR("Failed to get number of lines: %s", e.what());	×
97	return -1;	×
98	}	×
99	}	5✔
100
101	int dft_reader_read(dft_reader_handle_t reader, size_t start_bytes,	32✔
102	size_t end_bytes, char *buffer, size_t buffer_size) {
103	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0) {	32✔
104	return -1;	5✔
105	}
106
107	try {
108	size_t bytes_read =	22✔
109	(*cast_reader(reader))	27!
110	->read(start_bytes, end_bytes, buffer, buffer_size);	27✔
111	return static_cast<int>(bytes_read);	22✔
112	} catch (const std::exception &e) {	5!
113	DFTRACER_UTILS_LOG_ERROR("Failed to read: %s", e.what());	5!
114	return -1;	5✔
115	}	5!
116	}	37✔
117
118	int dft_reader_read_line_bytes(dft_reader_handle_t reader, size_t start_bytes,	113✔
119	size_t end_bytes, char *buffer,
120	size_t buffer_size) {
121	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0) {	113!
122	return -1;	×
123	}
124
125	try {
126	size_t bytes_read =	113✔
127	(*cast_reader(reader))	113!
128	->read_line_bytes(start_bytes, end_bytes, buffer, buffer_size);	113!
129	return static_cast<int>(bytes_read);	113✔
130	} catch (const std::exception &e) {	×
131	DFTRACER_UTILS_LOG_ERROR("Failed to read line bytes: %s", e.what());	×
132	return -1;	×
133	}	×
134	}	113✔
135
136	int dft_reader_read_lines(dft_reader_handle_t reader, size_t start_line,	14✔
137	size_t end_line, char *buffer, size_t buffer_size,
138	size_t *bytes_written) {
139	if (validate_handle(reader) \|\| !buffer \|\| buffer_size == 0 \|\|	14✔
140	!bytes_written) {	11✔
141	return -1;	4✔
142	}
143
144	try {
145	std::string result =
146	(*cast_reader(reader))->read_lines(start_line, end_line);	10!
147
148	size_t result_size = result.size();	7✔
149	if (result_size >= buffer_size) {	7✔
150	*bytes_written = result_size;	1✔
151	return -1;	1✔
152	}
153
154	std::memcpy(buffer, result.c_str(), result_size);	6✔
155	buffer[result_size] = '\0';	6✔
156	*bytes_written = result_size;	6✔
157
158	return 0;	6✔
159	} catch (const std::exception &e) {	10!
160	DFTRACER_UTILS_LOG_ERROR("Failed to read lines: %s", e.what());	3!
161	*bytes_written = 0;	3✔
162	return -1;	3✔
163	}	3!
164	}	17✔
165
166	void dft_reader_reset(dft_reader_handle_t reader) {	×
167	if (reader) {	×
168	(*cast_reader(reader))->reset();	×
UNCOV 169	}	×
170	}	×
171
172	dft_reader_stream_t dft_reader_stream(dft_reader_handle_t reader,	16✔
173	const dft_stream_config_t *config) {
174	if (validate_handle(reader)) {	16!
175	DFTRACER_UTILS_LOG_ERROR("%s", "Invalid reader handle");	×
176	return nullptr;	×
177	}
178
179	if (!config) {	16!
180	DFTRACER_UTILS_LOG_ERROR("%s", "Invalid config pointer");	×
181	return nullptr;	×
182	}
183
184	try {
185	// Convert C config to C++ config
186	StreamConfig cpp_config = StreamConfig::from_c(*config);	16!
187
188	// Create stream
189	auto stream = (*cast_reader(reader))->stream(cpp_config);	16!
190
191	// Transfer ownership to C API
192	return static_cast<dft_reader_stream_t>(stream.release());	16✔
193	} catch (const std::exception &e) {	16!
194	DFTRACER_UTILS_LOG_ERROR("Failed to create stream: %s", e.what());	×
195	return nullptr;	×
196	}	×
197	}	16✔
198
199	} // extern "C"

llnl / dftracer-utils / 28496595030

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