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 Fragment::sequence_id_t sequence_id_t;
00035
00036 run_id_t run_id;
00037 subrun_id_t subrun_id;
00038 sequence_id_t sequence_id;
00039 bool is_complete;
00040
00047 RawEventHeader(run_id_t run,
00048 subrun_id_t subrun,
00049 sequence_id_t event) :
00050 run_id(run)
00051 , subrun_id(subrun)
00052 , sequence_id(event)
00053 , is_complete(false) { }
00054 };
00055
00056
00064 class RawEvent
00065 {
00066 public:
00067 typedef detail::RawEventHeader::run_id_t run_id_t;
00068 typedef detail::RawEventHeader::subrun_id_t subrun_id_t;
00069 typedef detail::RawEventHeader::sequence_id_t sequence_id_t;
00070
00077 RawEvent(run_id_t run, subrun_id_t subrun, sequence_id_t event);
00078
00083 explicit RawEvent(detail::RawEventHeader hdr);
00084
00085 #if HIDE_FROM_ROOT
00086
00095 void insertFragment(FragmentPtr&& pfrag);
00096
00100 void markComplete();
00101
00106 size_t numFragments() const;
00107
00112 size_t wordCount() const;
00113
00118 run_id_t runID() const;
00119
00124 subrun_id_t subrunID() const;
00125
00130 sequence_id_t sequenceID() const;
00131
00136 bool isComplete() const;
00137
00142 void print(std::ostream& os) const;
00143
00152 std::unique_ptr<Fragments> releaseProduct();
00153
00158 void fragmentTypes(std::vector<Fragment::type_t>& type_list);
00159
00172 std::unique_ptr<Fragments> releaseProduct(Fragment::type_t type);
00173
00174 #endif
00175
00176 private:
00177 detail::RawEventHeader header_;
00178 FragmentPtrs fragments_;
00179 };
00180
00181 typedef std::shared_ptr<RawEvent> RawEvent_ptr;
00182
00183 inline
00184 RawEvent::RawEvent(run_id_t run, subrun_id_t subrun, sequence_id_t event) :
00185 header_(run, subrun, event)
00186 , fragments_() { }
00187
00188 inline RawEvent::RawEvent(detail::RawEventHeader hdr) : header_(hdr), fragments_()
00189 {}
00190
00191 #if HIDE_FROM_ROOT
00192 inline
00193 void RawEvent::insertFragment(FragmentPtr&& pfrag)
00194 {
00195 if (pfrag == nullptr)
00196 {
00197 throw cet::exception("LogicError")
00198 << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
00199 }
00200 fragments_.emplace_back(std::move(pfrag));
00201 }
00202
00203 inline void RawEvent::markComplete() { header_.is_complete = true; }
00204
00205 inline
00206 size_t RawEvent::numFragments() const
00207 {
00208 return fragments_.size();
00209 }
00210
00211 inline
00212 size_t RawEvent::wordCount() const
00213 {
00214 size_t sum = 0;
00215 for (auto const& frag : fragments_) { sum += frag->size(); }
00216 return sum;
00217 }
00218
00219 inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
00220 inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
00221 inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
00222 inline bool RawEvent::isComplete() const { return header_.is_complete; }
00223
00224 inline
00225 std::unique_ptr<Fragments> RawEvent::releaseProduct()
00226 {
00227 std::unique_ptr<Fragments> result(new Fragments);
00228 result->reserve(fragments_.size());
00229
00230
00231 for (auto& i : fragments_)
00232 {
00233 result->emplace_back(std::move(*i));
00234 }
00235
00236
00237
00238 fragments_.clear();
00239 return result;
00240 }
00241
00242 inline
00243 void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
00244 {
00245
00246
00247 for (auto& i : fragments_)
00248 {
00249 auto fragType = i->type();
00250 if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end())
00251 {
00252 type_list.push_back(fragType);
00253 }
00254 }
00255
00256
00257 }
00258
00259 inline
00260 std::unique_ptr<Fragments>
00261 RawEvent::releaseProduct(Fragment::type_t fragment_type)
00262 {
00263 std::unique_ptr<Fragments> result(new Fragments);
00264 FragmentPtrs::iterator iter = fragments_.begin();
00265 do
00266 {
00267 if ((*iter)->type() == fragment_type)
00268 {
00269 result->push_back(std::move(*(*iter)));
00270 iter = fragments_.erase(iter);
00271 }
00272 else
00273 {
00274 ++iter;
00275 }
00276 }
00277 while (iter != fragments_.end());
00278 return result;
00279 }
00280
00287 inline
00288 std::ostream& operator<<(std::ostream& os, RawEvent const& ev)
00289 {
00290 ev.print(os);
00291 return os;
00292 }
00293
00294 #endif
00295 }
00296
00297 #endif