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