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/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
00079 #if HIDE_FROM_ROOT
00080
00089 void insertFragment(FragmentPtr&& pfrag);
00090
00094 void markComplete();
00095
00100 size_t numFragments() const;
00101
00106 size_t wordCount() const;
00107
00112 run_id_t runID() const;
00113
00118 subrun_id_t subrunID() const;
00119
00124 sequence_id_t sequenceID() const;
00125
00130 bool isComplete() const;
00131
00136 void print(std::ostream& os) const;
00137
00146 std::unique_ptr<Fragments> releaseProduct();
00147
00152 void fragmentTypes(std::vector<Fragment::type_t>& type_list);
00153
00166 std::unique_ptr<Fragments> releaseProduct(Fragment::type_t type);
00167
00168 #endif
00169
00170 private:
00171 detail::RawEventHeader header_;
00172 FragmentPtrs fragments_;
00173 };
00174
00175 typedef std::shared_ptr<RawEvent> RawEvent_ptr;
00176
00177 inline
00178 RawEvent::RawEvent(run_id_t run, subrun_id_t subrun, sequence_id_t event) :
00179 header_(run, subrun, event)
00180 , fragments_() { }
00181
00182 #if HIDE_FROM_ROOT
00183 inline
00184 void RawEvent::insertFragment(FragmentPtr&& pfrag)
00185 {
00186 if (pfrag == nullptr)
00187 {
00188 throw cet::exception("LogicError")
00189 << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
00190 }
00191 fragments_.emplace_back(std::move(pfrag));
00192 }
00193
00194 inline void RawEvent::markComplete() { header_.is_complete = true; }
00195
00196 inline
00197 size_t RawEvent::numFragments() const
00198 {
00199 return fragments_.size();
00200 }
00201
00202 inline
00203 size_t RawEvent::wordCount() const
00204 {
00205 size_t sum = 0;
00206 for (auto const& frag : fragments_) { sum += frag->size(); }
00207 return sum;
00208 }
00209
00210 inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
00211 inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
00212 inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
00213 inline bool RawEvent::isComplete() const { return header_.is_complete; }
00214
00215 inline
00216 std::unique_ptr<Fragments> RawEvent::releaseProduct()
00217 {
00218 std::unique_ptr<Fragments> result(new Fragments);
00219 result->reserve(fragments_.size());
00220
00221
00222 for (auto& i : fragments_)
00223 {
00224 result->emplace_back(std::move(*i));
00225 }
00226
00227
00228
00229 fragments_.clear();
00230 return result;
00231 }
00232
00233 inline
00234 void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
00235 {
00236
00237
00238 for (auto& i : fragments_)
00239 {
00240 auto fragType = i->type();
00241 if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end())
00242 {
00243 type_list.push_back(fragType);
00244 }
00245 }
00246
00247
00248 }
00249
00250 inline
00251 std::unique_ptr<Fragments>
00252 RawEvent::releaseProduct(Fragment::type_t fragment_type)
00253 {
00254 std::unique_ptr<Fragments> result(new Fragments);
00255 FragmentPtrs::iterator iter = fragments_.begin();
00256 do
00257 {
00258 if ((*iter)->type() == fragment_type)
00259 {
00260 result->push_back(std::move(*(*iter)));
00261 iter = fragments_.erase(iter);
00262 }
00263 else
00264 {
00265 ++iter;
00266 }
00267 }
00268 while (iter != fragments_.end());
00269 return result;
00270 }
00271
00278 inline
00279 std::ostream& operator<<(std::ostream& os, RawEvent const& ev)
00280 {
00281 ev.print(os);
00282 return os;
00283 }
00284
00285 #endif
00286 }
00287
00288 #endif