DUNE-DAQ
DUNE Trigger and Data Acquisition software
Loading...
Searching...
No Matches
Functions
dunedaq::flxlibs::parsers Namespace Reference

Functions

void print_bytes (std::ostream &ostr, const char *title, const unsigned char *data, std::size_t length, bool format=true)
 
void dump_to_buffer (const char *data, std::size_t size, void *buffer, uint32_t buffer_pos, const std::size_t &buffer_size)
 
template<class TargetStruct >
std::function< void(const felix::packetformat::chunk &chunk)> fixsizedChunkInto (std::shared_ptr< iomanager::SenderConcept< TargetStruct > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetStruct >
std::function< void(const felix::packetformat::shortchunk &shortchunk)> fixsizedShortchunkInto (std::shared_ptr< iomanager::SenderConcept< TargetStruct > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetStruct >
std::function< void(const felix::packetformat::chunk &chunk)> fixsizedChunkViaHeap (std::shared_ptr< iomanager::SenderConcept< TargetStruct * > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetWithDatafield >
std::function< void(const felix::packetformat::chunk &)> varsizedChunkIntoWithDatafield (std::shared_ptr< iomanager::SenderConcept< TargetWithDatafield > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetWithDatafield >
std::function< void(const felix::packetformat::shortchunk &)> varsizedShortchunkIntoWithDatafield (std::shared_ptr< iomanager::SenderConcept< TargetWithDatafield > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::chunk &chunk)> varsizedChunkIntoWrapper (std::shared_ptr< iomanager::SenderConcept< fdreadoutlibs::types::VariableSizePayloadTypeAdapter > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::shortchunk &shortchunk)> varsizedShortchunkIntoWrapper (std::shared_ptr< iomanager::SenderConcept< fdreadoutlibs::types::VariableSizePayloadTypeAdapter > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::chunk &chunk)> errorChunkIntoSink (std::shared_ptr< iomanager::SenderConcept< felix::packetformat::chunk > > &sink, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 

Function Documentation

◆ dump_to_buffer()

void dunedaq::flxlibs::parsers::dump_to_buffer ( const char * data,
std::size_t size,
void * buffer,
uint32_t buffer_pos,
const std::size_t & buffer_size )
inline

Definition at line 45 of file AvailableParserOperations.hpp.

50{
51 auto bytes_to_copy = size; // NOLINT
52 while (bytes_to_copy > 0) {
53 auto n = std::min(bytes_to_copy, buffer_size - buffer_pos); // NOLINT
54 std::memcpy(static_cast<char*>(buffer) + buffer_pos, data, n);
55 buffer_pos += n;
56 bytes_to_copy -= n;
57 if (buffer_pos == buffer_size) {
58 buffer_pos = 0;
59 }
60 }
61}
dunedaq::size
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk size
Definition FelixIssues.hpp:28

◆ errorChunkIntoSink()

std::function< void(const felix::packetformat::chunk &chunk)> dunedaq::flxlibs::parsers::errorChunkIntoSink ( std::shared_ptr< iomanager::SenderConcept< felix::packetformat::chunk > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 252 of file AvailableParserOperations.hpp.

254{
255 return [&](const felix::packetformat::chunk& chunk) {
256 try {
257 auto payload = chunk;
258 sink->send(std::move(payload), timeout);
259 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
260 // ers
261 }
262 };
263}
dunedaq::chunk
FELIX Initialization std::string initerror FELIX queue timed std::string queuename Unexpected chunk int ParserOps couldn t push to queue !Failed chunk
Definition FelixIssues.hpp:33

◆ fixsizedChunkInto()

template<class TargetStruct >
std::function< void(const felix::packetformat::chunk &chunk)> dunedaq::flxlibs::parsers::fixsizedChunkInto ( std::shared_ptr< iomanager::SenderConcept< TargetStruct > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 65 of file AvailableParserOperations.hpp.

67{
68 return [&](const felix::packetformat::chunk& chunk) {
69 // Chunk info
70 auto subchunk_data = chunk.subchunks();
71 auto subchunk_sizes = chunk.subchunk_lengths();
72 auto n_subchunks = chunk.subchunk_number();
73 std::size_t target_size = sizeof(TargetStruct);
74
75 // Only dump to buffer if possible
76 if (chunk.length() != target_size) {
77 ers::error(UnexpectedChunk(ERS_HERE, chunk.length(), target_size));
78 } else {
79 TargetStruct payload;
80 uint32_t bytes_copied_chunk = 0; // NOLINT
81 for (unsigned i = 0; i < n_subchunks; i++) {
82 dump_to_buffer(
83 subchunk_data[i], subchunk_sizes[i], static_cast<void*>(&payload.data), bytes_copied_chunk, target_size);
84 bytes_copied_chunk += subchunk_sizes[i];
85 }
86 try {
87 // finally, push to sink
88 sink->send(std::move(payload), timeout);
89 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
90 // ers::error(ParserOperationQueuePushFailure(ERS_HERE, " "));
91 }
92 }
93 };
94}
ERS_HERE
#define ERS_HERE
Definition LocalContext.hpp:130
dunedaq::UnexpectedChunk
FELIX Initialization std::string initerror FELIX queue timed std::string queuename UnexpectedChunk
Definition FelixIssues.hpp:28
ers::error
void error(const Issue &issue)
Definition ers.hpp:81

◆ fixsizedChunkViaHeap()

template<class TargetStruct >
std::function< void(const felix::packetformat::chunk &chunk)> dunedaq::flxlibs::parsers::fixsizedChunkViaHeap ( std::shared_ptr< iomanager::SenderConcept< TargetStruct * > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 123 of file AvailableParserOperations.hpp.

126{
127 return [&](const felix::packetformat::chunk& chunk) {
128 // Chunk info
129 auto subchunk_data = chunk.subchunks();
130 auto subchunk_sizes = chunk.subchunk_lengths();
131 auto n_subchunks = chunk.subchunk_number();
132 auto target_size = sizeof(TargetStruct);
133
134 // Only dump to buffer if possible
135 if (chunk.length() != target_size) {
136 // report? Add custom way of handling unexpected user payloads.
137 // In this case -> not fixed size chunk -> chunk-to-userbuff not possible
138 } else {
139 TargetStruct* payload = new TargetStruct[sizeof(TargetStruct)];
140 // std::unique_ptr<TargetStruct> payload = std::make_unique<TargetStruct>();
141 uint_fast32_t bytes_copied_chunk = 0; // NOLINT
142 for (unsigned i = 0; i < n_subchunks; i++) {
143 dump_to_buffer(subchunk_data[i],
144 subchunk_sizes[i],
145 static_cast<void*>(payload), // static_cast<void*>(&payload_ptr->data),
146 bytes_copied_chunk,
147 target_size);
148 bytes_copied_chunk += subchunk_sizes[i];
149 }
150 try {
151 // finally, push to sink
152 sink->send(std::move(payload), timeout); // std::move(std::make_unique<TargetStruct>(payload)), timeout);
153 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
154 // ers::error(ParserOperationQueuePushFailure(ERS_HERE, " "));
155 }
156 }
157 };
158}

◆ fixsizedShortchunkInto()

template<class TargetStruct >
std::function< void(const felix::packetformat::shortchunk &shortchunk)> dunedaq::flxlibs::parsers::fixsizedShortchunkInto ( std::shared_ptr< iomanager::SenderConcept< TargetStruct > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 98 of file AvailableParserOperations.hpp.

100{
101 return [&](const felix::packetformat::shortchunk& shortchunk) {
102 // Only dump to buffer if possible
103 std::size_t target_size = sizeof(TargetStruct);
104 if (shortchunk.length != target_size) {
105 // report? Add custom way of handling unexpected user payloads.
106 // In this case -> not fixed size shortchunk -> shortchunk-to-userbuff not possible
107 // Can't throw, and can't print as it may flood output
108 } else {
109 TargetStruct payload;
110 std::memcpy(static_cast<char*>(payload), shortchunk.data, target_size);
111 try {
112 // finally, push to sink
113 sink->send(std::move(payload), timeout);
114 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
115 // ers::error(ParserOperationQueuePushFailure(ERS_HERE, " "));
116 }
117 }
118 };
119}

◆ print_bytes()

void dunedaq::flxlibs::parsers::print_bytes ( std::ostream & ostr,
const char * title,
const unsigned char * data,
std::size_t length,
bool format = true )
inline

Definition at line 31 of file AvailableParserOperations.hpp.

32{
33 ostr << title << std::endl;
34 ostr << std::setfill('0');
35 for (size_t i = 0; i < length; ++i) {
36 ostr << std::hex << std::setw(2) << static_cast<int>(data[i]);
37 if (format) {
38 ostr << (((i + 1) % 16 == 0) ? "\n" : " ");
39 }
40 }
41 ostr << std::endl;
42}

◆ varsizedChunkIntoWithDatafield()

template<class TargetWithDatafield >
std::function< void(const felix::packetformat::chunk &)> dunedaq::flxlibs::parsers::varsizedChunkIntoWithDatafield ( std::shared_ptr< iomanager::SenderConcept< TargetWithDatafield > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 162 of file AvailableParserOperations.hpp.

164{
165 return [&](const felix::packetformat::chunk& chunk) {
166 auto subchunk_data = chunk.subchunks();
167 auto subchunk_sizes = chunk.subchunk_lengths();
168 auto n_subchunks = chunk.subchunk_number();
169 TargetWithDatafield twd;
170 twd.get_data().reserve(chunk.length());
171 uint32_t bytes_copied_chunk = 0;
172 for (unsigned i = 0; i< n_subchunks; ++i) {
173 dump_to_buffer(subchunk_data[i],
174 subchunk_sizes[i],
175 static_cast<void*>(twd.get_data().data()),
176 bytes_copied_chunk,
177 chunk.length());
178 bytes_copied_chunk += subchunk_sizes[i];
179 }
180 twd.set_data_size(bytes_copied_chunk);
181 try {
182 sink->send(std::move(twd), timeout);
183 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
184 // ers::error
185 }
186 };
187}
dunedaq::flxlibs::parsers::dump_to_buffer
void dump_to_buffer(const char *data, std::size_t size, void *buffer, uint32_t buffer_pos, const std::size_t &buffer_size)
Definition AvailableParserOperations.hpp:45

◆ varsizedChunkIntoWrapper()

std::function< void(const felix::packetformat::chunk &chunk)> dunedaq::flxlibs::parsers::varsizedChunkIntoWrapper ( std::shared_ptr< iomanager::SenderConcept< fdreadoutlibs::types::VariableSizePayloadTypeAdapter > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 208 of file AvailableParserOperations.hpp.

210{
211 return [&](const felix::packetformat::chunk& chunk) {
212 auto subchunk_data = chunk.subchunks();
213 auto subchunk_sizes = chunk.subchunk_lengths();
214 auto n_subchunks = chunk.subchunk_number();
215 auto chunk_length = chunk.length();
216
217 char* payload = static_cast<char*>(malloc(chunk_length * sizeof(char)));
218 uint32_t bytes_copied_chunk = 0; // NOLINT(build/unsigned)
219 for (unsigned i = 0; i < n_subchunks; ++i) {
220 dump_to_buffer(
221 subchunk_data[i], subchunk_sizes[i], static_cast<void*>(payload), bytes_copied_chunk, chunk_length);
222 bytes_copied_chunk += subchunk_sizes[i];
223 }
224 fdreadoutlibs::types::VariableSizePayloadTypeAdapter payload_wrapper(chunk_length, payload);
225 try {
226 sink->send(std::move(payload_wrapper), timeout);
227 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
228 // ers
229 }
230 };
231}
dunedaq::fdreadoutlibs::types::VariableSizePayloadTypeAdapter
Convencience wrapper to take ownership over char pointers with corresponding allocated memory size.
Definition VariableSizePayloadTypeAdapter.hpp:27

◆ varsizedShortchunkIntoWithDatafield()

template<class TargetWithDatafield >
std::function< void(const felix::packetformat::shortchunk &)> dunedaq::flxlibs::parsers::varsizedShortchunkIntoWithDatafield ( std::shared_ptr< iomanager::SenderConcept< TargetWithDatafield > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 191 of file AvailableParserOperations.hpp.

193{
194 return [&](const felix::packetformat::shortchunk& shortchunk) {
195 TargetWithDatafield twd;
196 twd.get_data().reserve(shortchunk.length);
197 std::memcpy(static_cast<void*>(twd.get_data().data()), shortchunk.data, shortchunk.length);
198 twd.set_data_size(shortchunk.length);
199 try {
200 sink->send(std::move(twd), timeout);
201 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
202 // ers::error
203 }
204 };
205}

◆ varsizedShortchunkIntoWrapper()

std::function< void(const felix::packetformat::shortchunk &shortchunk)> dunedaq::flxlibs::parsers::varsizedShortchunkIntoWrapper ( std::shared_ptr< iomanager::SenderConcept< fdreadoutlibs::types::VariableSizePayloadTypeAdapter > > & sink,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 234 of file AvailableParserOperations.hpp.

236{
237 return [&](const felix::packetformat::shortchunk& shortchunk) {
238 auto shortchunk_length = shortchunk.length;
239 char* payload = static_cast<char*>(malloc(shortchunk_length * sizeof(char)));
240 std::memcpy(payload, shortchunk.data, shortchunk_length);
241 fdreadoutlibs::types::VariableSizePayloadTypeAdapter payload_wrapper(shortchunk_length, payload);
242 try {
243 sink->send(std::move(payload_wrapper), timeout);
244 } catch (const dunedaq::iomanager::TimeoutExpired& excpt) {
245 // ers
246 }
247 };
248}
Generated on Sat Jun 28 2025 for DUNE-DAQ by doxygen 1.12.0