00001 #ifndef artdaq_core_Data_RawEvent_hh
00002 #define artdaq_core_Data_RawEvent_hh
00003
00004 #include "artdaq-core/Data/dictionarycontrol.hh"
00005 #include "artdaq-core/Data/Fragment.hh"
00006
00007 #include "cetlib_except/exception.h"
00008
00009 #include <iosfwd>
00010 #include <memory>
00011 #include <algorithm>
00012
00013 namespace artdaq
00014 {
00018 namespace detail
00019 {
00020 struct RawEventHeader;
00021 }
00022
00030 struct detail::RawEventHeader
00031 {
00032 typedef uint32_t run_id_t;
00033 typedef uint32_t subrun_id_t;
00034 typedef uint32_t event_id_t;
00035 typedef Fragment::sequence_id_t sequence_id_t;
00036
00037 run_id_t run_id;
00038 subrun_id_t subrun_id;
00039 event_id_t event_id;
00040 sequence_id_t sequence_id;
00041 bool is_complete;
00042
00050 RawEventHeader(run_id_t run,
00051 subrun_id_t subrun,
00052 event_id_t event,
00053 sequence_id_t seq) :
00054 run_id(run)
00055 , subrun_id(subrun)
00056 , event_id(event)
00057 , sequence_id(seq)
00058 , is_complete(false) { }
00059 };
00060
00061
00069 class RawEvent
00070 {
00071 public:
00072 typedef detail::RawEventHeader::run_id_t run_id_t;
00073 typedef detail::RawEventHeader::subrun_id_t subrun_id_t;
00074 typedef detail::RawEventHeader::event_id_t event_id_t;
00075 typedef detail::RawEventHeader::sequence_id_t sequence_id_t;
00076
00084 RawEvent(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq);
00085
00090 explicit RawEvent(detail::RawEventHeader hdr);
00091
00092 #if HIDE_FROM_ROOT
00093
00102 void insertFragment(FragmentPtr&& pfrag);
00103
00107 void markComplete();
00108
00113 size_t numFragments() const;
00114
00119 size_t wordCount() const;
00120
00125 run_id_t runID() const;
00126
00131 subrun_id_t subrunID() const;
00132
00137 event_id_t eventID() const;
00138
00143 sequence_id_t sequenceID() const;
00144
00149 bool isComplete() const;
00150
00155 void print(std::ostream& os) const;
00156
00165 std::unique_ptr<Fragments> releaseProduct();
00166
00171 void fragmentTypes(std::vector<Fragment::type_t>& type_list);
00172
00185 std::unique_ptr<Fragments> releaseProduct(Fragment::type_t type);
00186
00187 #endif
00188
00189 private:
00190 detail::RawEventHeader header_;
00191 FragmentPtrs fragments_;
00192 };
00193
00194 typedef std::shared_ptr<RawEvent> RawEvent_ptr;
00195
00196 inline
00197 RawEvent::RawEvent(run_id_t run, subrun_id_t subrun, event_id_t event, sequence_id_t seq) :
00198 header_(run, subrun, event, seq)
00199 , fragments_() { }
00200
00201 inline RawEvent::RawEvent(detail::RawEventHeader hdr) : header_(hdr), fragments_()
00202 {}
00203
00204 #if HIDE_FROM_ROOT
00205 inline
00206 void RawEvent::insertFragment(FragmentPtr&& pfrag)
00207 {
00208 if (pfrag == nullptr)
00209 {
00210 throw cet::exception("LogicError")
00211 << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
00212 }
00213 fragments_.emplace_back(std::move(pfrag));
00214 }
00215
00216 inline void RawEvent::markComplete() { header_.is_complete = true; }
00217
00218 inline
00219 size_t RawEvent::numFragments() const
00220 {
00221 return fragments_.size();
00222 }
00223
00224 inline
00225 size_t RawEvent::wordCount() const
00226 {
00227 size_t sum = 0;
00228 for (auto const& frag : fragments_) { sum += frag->size(); }
00229 return sum;
00230 }
00231
00232 inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
00233 inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
00234 inline RawEvent::event_id_t RawEvent::eventID() const { return header_.event_id; }
00235 inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
00236 inline bool RawEvent::isComplete() const { return header_.is_complete; }
00237
00238 inline
00239 std::unique_ptr<Fragments> RawEvent::releaseProduct()
00240 {
00241 std::unique_ptr<Fragments> result(new Fragments);
00242 result->reserve(fragments_.size());
00243
00244
00245 for (auto& i : fragments_)
00246 {
00247 result->emplace_back(std::move(*i));
00248 }
00249
00250
00251
00252 fragments_.clear();
00253 return result;
00254 }
00255
00256 inline
00257 void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
00258 {
00259
00260
00261 for (auto& i : fragments_)
00262 {
00263 auto fragType = i->type();
00264 if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end())
00265 {
00266 type_list.push_back(fragType);
00267 }
00268 }
00269
00270
00271 }
00272
00273 inline
00274 std::unique_ptr<Fragments>
00275 RawEvent::releaseProduct(Fragment::type_t fragment_type)
00276 {
00277 std::unique_ptr<Fragments> result(new Fragments);
00278 FragmentPtrs::iterator iter = fragments_.begin();
00279 do
00280 {
00281 if ((*iter)->type() == fragment_type)
00282 {
00283 result->push_back(std::move(*(*iter)));
00284 iter = fragments_.erase(iter);
00285 }
00286 else
00287 {
00288 ++iter;
00289 }
00290 }
00291 while (iter != fragments_.end());
00292 return result;
00293 }
00294
00301 inline
00302 std::ostream& operator<<(std::ostream& os, RawEvent const& ev)
00303 {
00304 ev.print(os);
00305 return os;
00306 }
00307
00308 #endif
00309 }
00310
00311 #endif