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:30

◆ 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:21
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:35

◆ 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}
ERS_HERE
#define ERS_HERE
Definition LocalContext.hpp:127
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
dunedaq::UnexpectedChunk
FELIX Initialization std::string initerror FELIX queue timed std::string queuename UnexpectedChunk
Definition FelixIssues.hpp:29
ers::error
void error(const Issue &issue)
Definition ers.hpp:101

◆ 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 121 of file AvailableParserOperations.hpp.

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

◆ 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 97 of file AvailableParserOperations.hpp.

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

◆ 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 158 of file AvailableParserOperations.hpp.

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

◆ 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 204 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:26

◆ 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 187 of file AvailableParserOperations.hpp.

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

◆ 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.

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