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< std::function< void(TargetStruct &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetStruct >
std::function< void(const felix::packetformat::shortchunk &shortchunk)> fixsizedShortchunkInto (std::shared_ptr< std::function< void(TargetStruct &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetStruct >
std::function< void(const felix::packetformat::chunk &chunk)> fixsizedChunkViaHeap (std::shared_ptr< std::function< void(TargetStruct &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetWithDatafield >
std::function< void(const felix::packetformat::chunk &)> varsizedChunkIntoWithDatafield (std::shared_ptr< std::function< void(TargetWithDatafield &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
template<class TargetWithDatafield >
std::function< void(const felix::packetformat::shortchunk &)> varsizedShortchunkIntoWithDatafield (std::shared_ptr< std::function< void(TargetWithDatafield &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::chunk &chunk)> varsizedChunkIntoWrapper (std::shared_ptr< std::function< void(fdreadoutlibs::types::VariableSizePayloadTypeAdapter &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::shortchunk &shortchunk)> varsizedShortchunkIntoWrapper (std::shared_ptr< std::function< void(fdreadoutlibs::types::VariableSizePayloadTypeAdapter &&)> > &cb, std::chrono::milliseconds timeout=std::chrono::milliseconds(100))
 
std::function< void(const felix::packetformat::chunk &chunk)> errorChunkIntoSink (std::shared_ptr< std::function< void(felix::packetformat::chunk &&)> > &cb, 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< std::function< void(felix::packetformat::chunk &&)> > & cb,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 249 of file AvailableParserOperations.hpp.

251{
252 return [&](const felix::packetformat::chunk& chunk) {
253 try {
254 auto payload = chunk;
255 (*cb)(std::move(payload));
256 } catch (const std::exception &e) {
257 TLOG() << "Caught " << e.what();
258 }
259 };
260}
TLOG
#define TLOG(...)
Definition macro.hpp:22
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< std::function< void(TargetStruct &&)> > & cb,
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 (*cb)(std::move(payload));
88 } catch (const std::exception &e) {
89 TLOG() << "Caught " << e.what();
90 }
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< std::function< void(TargetStruct &&)> > & cb,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 122 of file AvailableParserOperations.hpp.

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

◆ fixsizedShortchunkInto()

template<class TargetStruct >
std::function< void(const felix::packetformat::shortchunk &shortchunk)> dunedaq::flxlibs::parsers::fixsizedShortchunkInto ( std::shared_ptr< std::function< void(TargetStruct &&)> > & cb,
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 (*cb)(std::move(payload));
113 } catch (const std::exception &e) {
114 TLOG() << "Caught " << e.what();
115 }
116 }
117 };
118}

◆ 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< std::function< void(TargetWithDatafield &&)> > & cb,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 159 of file AvailableParserOperations.hpp.

161{
162 return [&](const felix::packetformat::chunk& chunk) {
163 auto subchunk_data = chunk.subchunks();
164 auto subchunk_sizes = chunk.subchunk_lengths();
165 auto n_subchunks = chunk.subchunk_number();
166 TargetWithDatafield twd;
167 twd.get_data().reserve(chunk.length());
168 uint32_t bytes_copied_chunk = 0;
169 for (unsigned i = 0; i< n_subchunks; ++i) {
170 dump_to_buffer(subchunk_data[i],
171 subchunk_sizes[i],
172 static_cast<void*>(twd.get_data().data()),
173 bytes_copied_chunk,
174 chunk.length());
175 bytes_copied_chunk += subchunk_sizes[i];
176 }
177 twd.set_data_size(bytes_copied_chunk);
178 try {
179 (*cb)(std::move(twd));
180 } catch (const std::exception &e) {
181 TLOG() << "Caught " << e.what();
182 }
183 };
184}
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< std::function< void(fdreadoutlibs::types::VariableSizePayloadTypeAdapter &&)> > & cb,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 205 of file AvailableParserOperations.hpp.

207{
208 return [&](const felix::packetformat::chunk& chunk) {
209 auto subchunk_data = chunk.subchunks();
210 auto subchunk_sizes = chunk.subchunk_lengths();
211 auto n_subchunks = chunk.subchunk_number();
212 auto chunk_length = chunk.length();
213
214 char* payload = static_cast<char*>(malloc(chunk_length * sizeof(char)));
215 uint32_t bytes_copied_chunk = 0; // NOLINT(build/unsigned)
216 for (unsigned i = 0; i < n_subchunks; ++i) {
217 dump_to_buffer(
218 subchunk_data[i], subchunk_sizes[i], static_cast<void*>(payload), bytes_copied_chunk, chunk_length);
219 bytes_copied_chunk += subchunk_sizes[i];
220 }
221 fdreadoutlibs::types::VariableSizePayloadTypeAdapter payload_wrapper(chunk_length, payload);
222 try {
223 (*cb)(std::move(payload_wrapper));
224 } catch (const std::exception &e) {
225 TLOG() << "Caught " << e.what();
226 }
227 };
228}
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< std::function< void(TargetWithDatafield &&)> > & cb,
std::chrono::milliseconds timeout = std::chrono::milliseconds(100) )
inline

Definition at line 188 of file AvailableParserOperations.hpp.

190{
191 return [&](const felix::packetformat::shortchunk& shortchunk) {
192 TargetWithDatafield twd;
193 twd.get_data().reserve(shortchunk.length);
194 std::memcpy(static_cast<void*>(twd.get_data().data()), shortchunk.data, shortchunk.length);
195 twd.set_data_size(shortchunk.length);
196 try {
197 (*cb)(std::move(twd));
198 } catch (const std::exception &e) {
199 TLOG() << "Caught " << e.what();
200 }
201 };
202}

◆ varsizedShortchunkIntoWrapper()

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

Definition at line 231 of file AvailableParserOperations.hpp.

233{
234 return [&](const felix::packetformat::shortchunk& shortchunk) {
235 auto shortchunk_length = shortchunk.length;
236 char* payload = static_cast<char*>(malloc(shortchunk_length * sizeof(char)));
237 std::memcpy(payload, shortchunk.data, shortchunk_length);
238 fdreadoutlibs::types::VariableSizePayloadTypeAdapter payload_wrapper(shortchunk_length, payload);
239 try {
240 (*cb)(std::move(payload_wrapper));
241 } catch (const std::exception &e) {
242 TLOG() << "Caught " << e.what();
243 }
244 };
245}
Generated on Sat Apr 4 2026 for DUNE-DAQ by doxygen 1.12.0