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/Fragments.hh"
00006
00007 #include "cetlib/exception.h"
00008
00009 #include <iosfwd>
00010 #include <memory>
00011 #include <algorithm>
00012
00013 namespace artdaq {
00014
00015
00016
00017
00018
00019
00020
00021
00022 namespace detail { struct RawEventHeader; }
00023
00024 struct detail::RawEventHeader {
00025 typedef uint32_t run_id_t;
00026 typedef uint32_t subrun_id_t;
00027 typedef Fragment::sequence_id_t sequence_id_t;
00028
00029 run_id_t run_id;
00030 subrun_id_t subrun_id;
00031 sequence_id_t sequence_id;
00032 bool is_complete;
00033
00034 RawEventHeader(run_id_t run,
00035 subrun_id_t subrun,
00036 sequence_id_t event) :
00037 run_id(run),
00038 subrun_id(subrun),
00039 sequence_id(event),
00040 is_complete(false)
00041 { }
00042
00043 };
00044
00045
00046
00047
00048
00049 class RawEvent {
00050 public:
00051 typedef detail::RawEventHeader::run_id_t run_id_t;
00052 typedef detail::RawEventHeader::subrun_id_t subrun_id_t;
00053 typedef detail::RawEventHeader::sequence_id_t sequence_id_t;
00054
00055 RawEvent(run_id_t run, subrun_id_t subrun, sequence_id_t event);
00056
00057
00058
00059
00060 #if HIDE_FROM_ROOT
00061 void insertFragment(FragmentPtr && pfrag);
00062
00063
00064 void markComplete();
00065
00066
00067 size_t numFragments() const;
00068
00069
00070 size_t wordCount() const;
00071
00072
00073 run_id_t runID() const;
00074 subrun_id_t subrunID() const;
00075 sequence_id_t sequenceID() const;
00076 bool isComplete() const;
00077
00078
00079 void print(std::ostream & os) const;
00080
00081
00082
00083
00084 std::unique_ptr<std::vector<Fragment>> releaseProduct();
00085
00086
00087 void fragmentTypes(std::vector<Fragment::type_t>& type_list);
00088
00089
00090
00091
00092
00093
00094
00095 std::unique_ptr<std::vector<Fragment>> releaseProduct(Fragment::type_t);
00096
00097 #endif
00098
00099 private:
00100 detail::RawEventHeader header_;
00101 FragmentPtrs fragments_;
00102 };
00103
00104 typedef std::shared_ptr<RawEvent> RawEvent_ptr;
00105
00106 inline
00107 RawEvent::RawEvent(run_id_t run, subrun_id_t subrun, sequence_id_t event) :
00108 header_(run, subrun, event),
00109 fragments_()
00110 { }
00111
00112 #if HIDE_FROM_ROOT
00113 inline
00114 void RawEvent::insertFragment(FragmentPtr && pfrag)
00115 {
00116 if (pfrag == nullptr) {
00117 throw cet::exception("LogicError")
00118 << "Attempt to insert a null FragmentPtr into a RawEvent detected.\n";
00119 }
00120 fragments_.emplace_back(std::move(pfrag));
00121 }
00122
00123 inline void RawEvent::markComplete() { header_.is_complete = true; }
00124
00125 inline
00126 size_t RawEvent::numFragments() const
00127 {
00128 return fragments_.size();
00129 }
00130
00131 inline
00132 size_t RawEvent::wordCount() const
00133 {
00134 size_t sum = 0;
00135 for (auto const & frag : fragments_) { sum += frag->size(); }
00136 return sum;
00137 }
00138
00139 inline RawEvent::run_id_t RawEvent::runID() const { return header_.run_id; }
00140 inline RawEvent::subrun_id_t RawEvent::subrunID() const { return header_.subrun_id; }
00141 inline RawEvent::sequence_id_t RawEvent::sequenceID() const { return header_.sequence_id; }
00142 inline bool RawEvent::isComplete() const { return header_.is_complete; }
00143
00144 inline
00145 std::unique_ptr<std::vector<Fragment>> RawEvent::releaseProduct()
00146 {
00147 std::unique_ptr<std::vector<Fragment>> result(new std::vector<Fragment>);
00148 result->reserve(fragments_.size());
00149
00150
00151 for (auto & i : fragments_) {
00152 result->emplace_back(std::move(*i));
00153 }
00154
00155
00156
00157 fragments_.clear();
00158 return result;
00159 }
00160
00161 inline
00162 void RawEvent::fragmentTypes(std::vector<Fragment::type_t>& type_list)
00163 {
00164
00165
00166 for (auto& i : fragments_) {
00167 Fragment::type_t fragType = i->type();
00168 if (std::find(type_list.begin(), type_list.end(), fragType) == type_list.end()) {
00169 type_list.push_back(fragType);
00170 }
00171 }
00172
00173
00174 }
00175
00176 inline
00177 std::unique_ptr<std::vector<Fragment>>
00178 RawEvent::releaseProduct(Fragment::type_t fragment_type)
00179 {
00180 std::unique_ptr<std::vector<Fragment>> result(new std::vector<Fragment>);
00181 FragmentPtrs::iterator iter = fragments_.begin();
00182 do {
00183 if ((*iter)->type() == fragment_type) {
00184 result->push_back(std::move(*(*iter)));
00185 iter = fragments_.erase(iter);
00186 }
00187 else {
00188 ++iter;
00189 }
00190 } while (iter != fragments_.end());
00191 return result;
00192 }
00193
00194 inline
00195 std::ostream & operator<<(std::ostream & os, RawEvent const & ev)
00196 {
00197 ev.print(os);
00198 return os;
00199 }
00200
00201 #endif
00202 }
00203
00204 #endif