artdaq_core  v3_04_02
Fragment.hh
1 #ifndef artdaq_core_Data_Fragment_hh
2 #define artdaq_core_Data_Fragment_hh
3 
4 #include <algorithm>
5 //#include <cassert>
6 #include <cstddef>
7 #include <iosfwd>
8 #include <iterator>
9 #include <vector>
10 #include <list>
11 #include <memory>
12 #include <map>
13 #include <cmath>
14 #include <stdint.h>
15 #include <string.h>
16 
17 #include "artdaq-core/Data/detail/RawFragmentHeader.hh"
18 #include "artdaq-core/Data/detail/RawFragmentHeaderV0.hh"
19 #include "artdaq-core/Data/dictionarycontrol.hh"
20 #include "artdaq-core/Core/QuickVec.hh"
21 #include <iostream>
22 #if HIDE_FROM_ROOT
23 #include "trace.h" // TRACE
24 #endif
25 
29 namespace artdaq {
30 # define DATAVEC_T QuickVec<RawDataType>
31  //#define DATAVEC_T std::vector<RawDataType>
32 
40 
41  class Fragment;
45  typedef std::vector<Fragment> Fragments;
46 
53  typedef std::unique_ptr<Fragment> FragmentPtr;
54 
58  typedef std::list<FragmentPtr> FragmentPtrs;
59 
67 
74  std::ostream& operator<<(std::ostream& os, Fragment const& f);
75 }
76 
85 {
86 public:
90  Fragment();
91 
99  typedef uint8_t byte_t;
100 
101  // Hide most things from ROOT.
102 #if HIDE_FROM_ROOT
103 
104  // http://stackoverflow.com/questions/33939687
105  // This should generate an exception if artdaq::Fragment is not move-constructible
110  Fragment(const Fragment&) = default;
118  Fragment(Fragment&&) noexcept;
124  Fragment& operator=(const Fragment&) = default;
133  Fragment& operator=(Fragment&&) noexcept;
134 
135  typedef detail::RawFragmentHeader::version_t version_t;
136  typedef detail::RawFragmentHeader::type_t type_t;
137  typedef detail::RawFragmentHeader::sequence_id_t sequence_id_t;
138  typedef detail::RawFragmentHeader::fragment_id_t fragment_id_t;
139  typedef detail::RawFragmentHeader::timestamp_t timestamp_t;
140 
141  static constexpr version_t InvalidVersion = detail::RawFragmentHeader::InvalidVersion;
142  static constexpr sequence_id_t InvalidSequenceID = detail::RawFragmentHeader::InvalidSequenceID;
143  static constexpr fragment_id_t InvalidFragmentID = detail::RawFragmentHeader::InvalidFragmentID;
144  static constexpr timestamp_t InvalidTimestamp = detail::RawFragmentHeader::InvalidTimestamp;
145 
146  static constexpr type_t InvalidFragmentType = detail::RawFragmentHeader::InvalidFragmentType;
147  static constexpr type_t EndOfDataFragmentType = detail::RawFragmentHeader::EndOfDataFragmentType;
148  static constexpr type_t DataFragmentType = detail::RawFragmentHeader::DataFragmentType;
149  static constexpr type_t InitFragmentType = detail::RawFragmentHeader::InitFragmentType;
150  static constexpr type_t EndOfRunFragmentType = detail::RawFragmentHeader::EndOfRunFragmentType;
151  static constexpr type_t EndOfSubrunFragmentType = detail::RawFragmentHeader::EndOfSubrunFragmentType;
152  static constexpr type_t ShutdownFragmentType = detail::RawFragmentHeader::ShutdownFragmentType;
153  static constexpr type_t FirstUserFragmentType = detail::RawFragmentHeader::FIRST_USER_TYPE;
154  static constexpr type_t EmptyFragmentType = detail::RawFragmentHeader::EmptyFragmentType;
155  static constexpr type_t ContainerFragmentType = detail::RawFragmentHeader::ContainerFragmentType;
156  static constexpr type_t ErrorFragmentType = detail::RawFragmentHeader::ErrorFragmentType;
157 
163  static constexpr bool isUserFragmentType(type_t fragmentType);
164 
170  static constexpr bool isSystemFragmentType(type_t fragmentType);
171 
176  static std::map<type_t, std::string> MakeSystemTypeMap()
177  {
179  }
180 
181  typedef DATAVEC_T::reference reference;
182  typedef DATAVEC_T::iterator iterator;
183  typedef DATAVEC_T::const_iterator const_iterator;
184  typedef DATAVEC_T::value_type value_type;
185  typedef DATAVEC_T::difference_type difference_type;
186  typedef DATAVEC_T::size_type size_type;
187 
193  explicit Fragment(std::size_t n);
194 
201  static FragmentPtr FragmentBytes(std::size_t nbytes)
202  {
203  RawDataType nwords = ceil(nbytes / static_cast<double>(sizeof(RawDataType)));
204  return FragmentPtr(new Fragment(nwords));
205  }
206 
217  template <class T>
218  Fragment(std::size_t payload_size, sequence_id_t sequence_id,
219  fragment_id_t fragment_id, type_t type, const T& metadata,
221 
235  template <class T>
236  static FragmentPtr FragmentBytes(std::size_t payload_size_in_bytes,
237  sequence_id_t sequence_id,
238  fragment_id_t fragment_id,
239  type_t type, const T& metadata,
241  {
242  RawDataType nwords = ceil(payload_size_in_bytes /
243  static_cast<double>(sizeof(RawDataType)));
244  return FragmentPtr(new Fragment(nwords, sequence_id, fragment_id, type, metadata, timestamp));
245  }
246 
255  fragment_id_t fragID,
258 
263  void print(std::ostream& os) const;
264 
269  std::size_t size() const;
270 
275  version_t version() const;
276 
281  type_t type() const;
282 
287  std::string typeString() const;
288 
293  sequence_id_t sequenceID() const;
294 
299  fragment_id_t fragmentID() const;
300 
305  timestamp_t timestamp() const;
306 
311  void setUserType(type_t utype);
312 
317  void setSystemType(type_t stype);
318 
323  void setSequenceID(sequence_id_t sequence_id);
324 
329  void setFragmentID(fragment_id_t fragment_id);
330 
336 
341  std::size_t sizeBytes() const { return sizeof(RawDataType) * size(); }
342 
348  std::size_t dataSize() const;
349 
350 
356  std::size_t dataSizeBytes() const
357  {
358  return sizeof(RawDataType) * dataSize();
359  }
360 
365  bool hasMetadata() const;
366 
374  template <class T>
375  T* metadata();
376 
384  template <class T>
385  T const* metadata() const;
386 
395  template <class T>
396  void setMetadata(const T& md);
397 
405  template <class T>
406  void updateMetadata(const T& md);
407 
412  void resize(std::size_t sz);
413 
419  void resize(std::size_t sz, RawDataType val);
420 
427  void resizeBytes(std::size_t szbytes);
428 
436  void resizeBytes(std::size_t szbytes, byte_t val);
437 
441  void autoResize();
442 
448 
453  iterator dataEnd();
454 
474  template <typename T>
476  {
477  T newpointer = reinterpret_cast<T>(in);
478 
479  if (static_cast<const void*>(newpointer) != static_cast<const void*>(in))
480  {
481  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
482  }
483 
484  return newpointer;
485  }
486 
502  template <typename T>
504  {
505  T newpointer = reinterpret_cast<T>(in);
506 
507  if (static_cast<void*>(newpointer) != static_cast<void*>(in))
508  {
509  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
510  }
511 
512  return newpointer;
513  }
514 
523  byte_t* dataBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* dataBegin()); }
524 
533  byte_t* dataEndBytes() { return reinterpret_cast_checked<byte_t*>(&* dataEnd()); }
534 
541 
546  byte_t* headerBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* headerBegin()); }
547 
552  const_iterator dataBegin() const;
553 
558  const_iterator dataEnd() const;
559 
568  const byte_t* dataBeginBytes() const
569  {
570  return reinterpret_cast_checked<const byte_t*>(&* dataBegin());
571  }
572 
581  const byte_t* dataEndBytes() const
582  {
583  return reinterpret_cast_checked<const byte_t*>(&* dataEnd());
584  }
585 
591  const_iterator headerBegin() const; // See note for non-const, above.
592 
597  const byte_t* headerBeginBytes() const
598  {
599  return reinterpret_cast_checked<const byte_t*>(&* headerBegin());
600  }
601 
605  void clear();
606 
611  bool empty();
612 
617  void reserve(std::size_t cap);
618 
623  void swap(Fragment& other) noexcept;
624 
631  void swap(DATAVEC_T& other) noexcept { vals_.swap(other); };
632 
638 
651 
657  static FragmentPtr eodFrag(size_t nFragsToExpect);
658 
670  template<class InputIterator> static FragmentPtr dataFrag(sequence_id_t sequenceID,
671  fragment_id_t fragID,
672  InputIterator i,
673  InputIterator e)
674  {
675  FragmentPtr result(new Fragment(sequenceID, fragID));
676  result->vals_.reserve(std::distance(i, e) + detail::RawFragmentHeader::num_words());
677  std::copy(i, e, std::back_inserter(result->vals_));
678  result->updateFragmentHeaderWC_();
679  return result;
680  }
681 
692  fragment_id_t fragID,
693  RawDataType const* dataPtr,
694  size_t dataSize,
696 #endif
697 
698 private:
699  template <typename T>
700  static std::size_t validatedMetadataSize_();
701 
702  void updateFragmentHeaderWC_();
703 
704  DATAVEC_T vals_;
705 
706 #if HIDE_FROM_ROOT
707  detail::RawFragmentHeader* fragmentHeader();
708 
709  detail::RawFragmentHeader const* fragmentHeader() const;
710 #endif
711 };
712 
713 #if HIDE_FROM_ROOT
714 
715 
716 // http://stackoverflow.com/questions/33939687
717 // This should generate an exception if artdaq::Fragment is not move-constructible
718 inline artdaq::Fragment::Fragment(artdaq::Fragment&&) noexcept = default;
719 inline artdaq::Fragment& artdaq::Fragment::operator=(artdaq::Fragment&&) noexcept = default;
720 
721 inline
722 bool
723 constexpr
724 artdaq::Fragment::
725 isUserFragmentType(type_t fragmentType)
726 {
727  return fragmentType >= detail::RawFragmentHeader::FIRST_USER_TYPE &&
728  fragmentType <= detail::RawFragmentHeader::LAST_USER_TYPE;
729 }
730 
731 inline
732 bool
733 constexpr
736 {
737  return fragmentType >= detail::RawFragmentHeader::FIRST_SYSTEM_TYPE;
738 }
739 
740 template <typename T>
741 std::size_t
742 artdaq::Fragment::
743 validatedMetadataSize_()
744 {
745  // Make sure a size_t is big enough to hold the maximum metadata
746  // size. This *should* always be true, but it is a compile-time check
747  // and therefore cheap.
748  static_assert(sizeof(size_t) >=
749  sizeof(decltype(std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max())),
750  "metadata_word_count_t is too big!");
751 
752  static size_t constexpr max_md_wc =
753  std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max();
754  size_t requested_md_wc =
755  std::ceil(sizeof(T) / static_cast<double>(sizeof(artdaq::RawDataType)));
756  if (requested_md_wc > max_md_wc)
757  {
758  throw cet::exception("InvalidRequest")
759  << "The requested metadata structure is too large: "
760  << "requested word count = " << requested_md_wc
761  << ", maximum word count = " << max_md_wc;
762  }
763  return requested_md_wc;
764 }
765 
766 template <class T>
768 Fragment(std::size_t payload_size, sequence_id_t sequence_id,
769  fragment_id_t fragment_id,
770  type_t type, const T& metadata, timestamp_t timestamp) :
771  vals_((artdaq::detail::RawFragmentHeader::num_words() + // Header
772  validatedMetadataSize_<T>() + // Metadata
773  payload_size) // User data
774  )
775 {
776  TRACEN( "Fragment", 50, "Fragment ctor num_word()=%zu MetadataSize_=%zu payload_size=%zu"
777  ,artdaq::detail::RawFragmentHeader::num_words(), validatedMetadataSize_<T>(), payload_size );
778  // vals ctor w/o init val is used; make sure header is ALL initialized.
779  for (iterator ii = vals_.begin();
780  ii != (vals_.begin() + detail::RawFragmentHeader::num_words()); ++ii) {
781  *ii = -1;
782  }
784  updateFragmentHeaderWC_();
785  fragmentHeader()->sequence_id = sequence_id;
786  fragmentHeader()->fragment_id = fragment_id;
787  fragmentHeader()->timestamp = timestamp;
788  fragmentHeader()->type = type;
789 
790  fragmentHeader()->metadata_word_count =
791  vals_.size() -
792  (fragmentHeader()->num_words() + payload_size);
793 
794  memcpy(metadataAddress(), &metadata, sizeof(T));
795 }
796 
797 inline
798 std::size_t
800 {
801  return fragmentHeader()->word_count;
802 }
803 
804 inline
807 {
808  return fragmentHeader()->version;
809 }
810 
811 inline
814 {
815  return static_cast<type_t>(fragmentHeader()->type);
816 }
817 
818 inline
819 std::string
821 {
822  return std::to_string(type()) + (isSystemFragmentType(type()) ? " (" + detail::RawFragmentHeader::SystemTypeToString(type()) + ")" : "");
823 }
824 
825 inline
828 {
829  return fragmentHeader()->sequence_id;
830 }
831 
832 inline
835 {
836  return fragmentHeader()->fragment_id;
837 }
838 
839 inline
842 {
843  return fragmentHeader()->timestamp;
844 }
845 
846 inline
847 void
849 {
850  fragmentHeader()->setUserType(static_cast<uint8_t>(type));
851 }
852 
853 inline
854 void
856 {
857  fragmentHeader()->setSystemType(static_cast<uint8_t>(type));
858 }
859 
860 inline
861 void
863 {
864  assert(sequence_id <= detail::RawFragmentHeader::InvalidSequenceID);
865  fragmentHeader()->sequence_id = sequence_id;
866 }
867 
868 inline
869 void
871 {
872  fragmentHeader()->fragment_id = fragment_id;
873 }
874 
875 inline
876 void
878 {
879  fragmentHeader()->timestamp = timestamp;
880 }
881 
882 inline
883 void
884 artdaq::Fragment::updateFragmentHeaderWC_()
885 {
886  // Make sure vals_.size() fits inside 32 bits. Left-shift here should
887  // match bitfield size of word_count in RawFragmentHeader.
888  assert(vals_.size() < (1ULL << 32));
889  TRACEN( "Fragment", 50, "Fragment::updateFragmentHeaderWC_ adjusting fragmentHeader()->word_count from %u to %zu", (unsigned)(fragmentHeader()->word_count), vals_.size() );
890  fragmentHeader()->word_count = vals_.size();
891 }
892 
893 inline
894 std::size_t
896 {
897  return vals_.size() - fragmentHeader()->num_words() -
898  fragmentHeader()->metadata_word_count;
899 }
900 
901 inline
902 bool
904 {
905  return fragmentHeader()->metadata_word_count != 0;
906 }
907 
908 template <class T>
909 T*
911 {
912  if (fragmentHeader()->metadata_word_count == 0)
913  {
914  throw cet::exception("InvalidRequest")
915  << "No metadata has been stored in this Fragment.";
916  }
917 
918  return reinterpret_cast_checked<T *>
919  (&vals_[fragmentHeader()->num_words()]);
920 }
921 
922 template <class T>
923 T const*
925 {
926  if (fragmentHeader()->metadata_word_count == 0)
927  {
928  throw cet::exception("InvalidRequest")
929  << "No metadata has been stored in this Fragment.";
930  }
931  return reinterpret_cast_checked<T const *>
932  (&vals_[fragmentHeader()->num_words()]);
933 }
934 
935 template <class T>
936 void
938 {
939  if (fragmentHeader()->metadata_word_count != 0)
940  {
941  throw cet::exception("InvalidRequest")
942  << "Metadata has already been stored in this Fragment.";
943  }
944  auto const mdSize = validatedMetadataSize_<T>();
945  vals_.insert(dataBegin(), mdSize, 0);
946  updateFragmentHeaderWC_();
947  fragmentHeader()->metadata_word_count = mdSize;
948 
949  memcpy(metadataAddress(), &metadata, sizeof(T));
950 }
951 
952 template <class T>
953 void
955 {
956  if (fragmentHeader()->metadata_word_count == 0)
957  {
958  throw cet::exception("InvalidRequest")
959  << "No metadata in fragment; please use Fragment::setMetadata instead of Fragment::updateMetadata";
960  }
961 
962  auto const mdSize = validatedMetadataSize_<T>();
963 
964  if (fragmentHeader()->metadata_word_count != mdSize)
965  {
966  throw cet::exception("InvalidRequest")
967  << "Mismatch between type of metadata struct passed to updateMetadata and existing metadata struct";
968  }
969 
970  memcpy(metadataAddress(), &metadata, sizeof(T));
971 }
972 
973 inline void
975 {
976  vals_.resize(sz + fragmentHeader()->metadata_word_count +
977  fragmentHeader()->num_words());
978  updateFragmentHeaderWC_();
979 }
980 
981 inline
982 void
984 {
985  vals_.resize(sz + fragmentHeader()->metadata_word_count +
986  fragmentHeader()->num_words(), v);
987  updateFragmentHeaderWC_();
988 }
989 
990 inline void
991 artdaq::Fragment::resizeBytes(std::size_t szbytes)
992 {
993  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
994  resize(nwords);
995 }
996 
997 inline
998 void
999 artdaq::Fragment::resizeBytes(std::size_t szbytes, byte_t v)
1000 {
1001  RawDataType defaultval;
1002  byte_t* ptr = reinterpret_cast_checked<byte_t*>(&defaultval);
1003 
1004  for (uint8_t i = 0; i < sizeof(RawDataType); ++i)
1005  {
1006  *ptr = v;
1007  ptr++;
1008  }
1009 
1010  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
1011 
1012  resize(nwords, defaultval);
1013 }
1014 
1015 
1016 inline
1017 void
1019 {
1020  vals_.resize(fragmentHeader()->word_count);
1021  updateFragmentHeaderWC_();
1022 }
1023 
1024 inline
1027 {
1028  return vals_.begin() + fragmentHeader()->num_words() +
1029  fragmentHeader()->metadata_word_count;
1030 }
1031 
1032 inline
1035 {
1036  return vals_.end();
1037 }
1038 
1039 inline
1042 {
1043  return vals_.begin();
1044 }
1045 
1046 inline
1049 {
1050  return vals_.begin() + fragmentHeader()->num_words() +
1051  fragmentHeader()->metadata_word_count;
1052 }
1053 
1054 inline
1057 {
1058  return vals_.end();
1059 }
1060 
1061 inline
1064 {
1065  return vals_.begin();
1066 }
1067 
1068 
1069 inline
1070 void
1072 {
1073  vals_.erase(dataBegin(), dataEnd());
1074  updateFragmentHeaderWC_();
1075 }
1076 
1077 inline
1078 bool
1080 {
1081  return (vals_.size() - fragmentHeader()->num_words() -
1082  fragmentHeader()->metadata_word_count) == 0;
1083 }
1084 
1085 inline
1086 void
1088 {
1089  vals_.reserve(cap + fragmentHeader()->num_words() +
1090  fragmentHeader()->metadata_word_count);
1091 }
1092 
1093 inline
1094 void
1096 {
1097  vals_.swap(other.vals_);
1098 }
1099 
1100 inline
1103 {
1104  return &vals_[0] + fragmentHeader()->num_words() +
1105  fragmentHeader()->metadata_word_count;
1106 }
1107 
1108 inline
1111 {
1112  if (fragmentHeader()->metadata_word_count == 0)
1113  {
1114  throw cet::exception("InvalidRequest")
1115  << "No metadata has been stored in this Fragment.";
1116  }
1117  return &vals_[0] + fragmentHeader()->num_words();
1118 }
1119 
1120 inline
1123 {
1124  return &vals_[0];
1125 }
1126 
1127 inline
1129 artdaq::Fragment::fragmentHeader()
1130 {
1131  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader *>(&vals_[0]);
1132  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1133  {
1134  switch (hdr->version)
1135  {
1136  case 0xFFFF:
1137  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1138  break;
1139  case 0:
1140  {
1141  std::cout << "Upgrading RawFragmentHeaderV0 (non const)" << std::endl;
1142  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 *>(&vals_[0]);
1143  auto new_hdr = old_hdr->upgrade();
1144 
1145  auto szDiff = hdr->num_words() - old_hdr->num_words();
1146  if (szDiff > 0) vals_.insert(vals_.begin(), szDiff, 0);
1147  memcpy(&vals_[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1148  }
1149  break;
1150  default:
1151  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1152  break;
1153  }
1154  }
1155  return hdr;
1156 }
1157 
1158 inline
1160 artdaq::Fragment::fragmentHeader() const
1161 {
1162  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader const*>(&vals_[0]);
1163  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1164  {
1165  switch (hdr->version)
1166  {
1167  case 0xFFFF:
1168  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1169  break;
1170  case 0:
1171  {
1172  std::cout << "Upgrading RawFragmentHeaderV0 (const)" << std::endl;
1173  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 const*>(&vals_[0]);
1174  auto new_hdr = old_hdr->upgrade();
1175 
1176  auto szDiff = hdr->num_words() - old_hdr->num_words();
1177  auto vals_nc = const_cast<DATAVEC_T*>(&vals_);
1178  if (szDiff > 0) vals_nc->insert(vals_nc->begin(), szDiff, 0);
1179  memcpy(&(*vals_nc)[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1180  }
1181  break;
1182  default:
1183  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1184  break;
1185  }
1186  }
1187  return hdr;
1188 }
1189 
1190 inline
1191 void
1192 swap(artdaq::Fragment& x, artdaq::Fragment& y) noexcept
1193 {
1194  x.swap(y);
1195 }
1196 
1197 inline
1198 std::ostream&
1199 artdaq::operator<<(std::ostream& os, artdaq::Fragment const& f)
1200 {
1201  f.print(os);
1202  return os;
1203 }
1204 #endif/* HIDE_FROM_ROOT */
1205 
1206 #endif /* artdaq_core_Data_Fragment_hh */
std::unique_ptr< Fragment > FragmentPtr
A std::unique_ptr to a Fragment object.
Definition: Fragment.hh:53
void reserve(std::size_t cap)
Reserves enough memory to hold cap RawDataType words in the Fragment payload.
Definition: Fragment.hh:1087
detail::RawFragmentHeader::timestamp_t timestamp_t
typedef for timestamp_t from RawFragmentHeader
Definition: Fragment.hh:139
RawDataType metadata_word_count
The number of RawDataType words in the user-defined metadata.
static const sequence_id_t InvalidSequenceID
The sequence_id field is currently 48-bits.
static constexpr type_t FIRST_SYSTEM_TYPE
The first system type.
std::size_t dataSizeBytes() const
Return the number of bytes in the data payload. This does not include the number of bytes in the head...
Definition: Fragment.hh:356
RawDataType type
The type of the fragment, either system or user-defined.
static constexpr type_t InvalidFragmentType
Copy InvalidFragmentType from RawFragmentHeader.
Definition: Fragment.hh:146
T reinterpret_cast_checked(const RawDataType *in) const
Wrapper around reinterpret_cast.
Definition: Fragment.hh:475
QuickVec< RawDataType >::difference_type difference_type
Alias difference_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:185
void setSequenceID(sequence_id_t sequence_id)
Sets the Sequence ID of the Fragment.
Definition: Fragment.hh:862
void setSystemType(type_t stype)
Sets the type of the Fragment, checking that it is a valid system type.
Definition: Fragment.hh:855
static std::map< type_t, std::string > MakeSystemTypeMap()
Returns a map of the most-commonly used system types.
std::vector< Fragment > Fragments
A std::vector of Fragment objects.
Definition: Fragment.hh:41
std::size_t size() const
Gets the size of the Fragment, from the Fragment header.
Definition: Fragment.hh:799
static constexpr type_t EndOfDataFragmentType
Copy EndOfDataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:147
static constexpr timestamp_t InvalidTimestamp
Copy InvalidTimestamp from RawFragmentHeader.
Definition: Fragment.hh:144
void updateMetadata(const T &md)
Updates existing metadata with a new metadata object.
Definition: Fragment.hh:954
static constexpr type_t EmptyFragmentType
Copy EmptyFragmentType from RawFragmentHeader.
Definition: Fragment.hh:154
bool fragmentSequenceIDCompare(Fragment i, Fragment j)
Comparator for Fragment objects, based on their sequence_id.
Definition: Fragment.cc:8
const byte_t * dataEndBytes() const
Return const Fragment::byte_t* pointing at the end of the payload.
Definition: Fragment.hh:581
static constexpr bool isUserFragmentType(type_t fragmentType)
Returns whether the given type is in the range of user types.
Definition: Fragment.hh:725
detail::RawFragmentHeader::fragment_id_t fragment_id_t
typedef for fragment_id_t from RawFragmentHeader
Definition: Fragment.hh:138
std::size_t sizeBytes() const
Size of vals_ vector ( header + (optional) metadata + payload) in bytes.
Definition: Fragment.hh:341
byte_t * dataBeginBytes()
Return Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:523
static constexpr std::size_t num_words()
Returns the number of RawDataType words present in the header.
The RawFragmentHeader class contains the basic fields used by artdaq for routing Fragment objects thr...
detail::RawFragmentHeader::type_t type_t
typedef for type_t from RawFragmentHeader
Definition: Fragment.hh:136
void resizeBytes(std::size_t szbytes)
Resize the data payload to hold szbytes bytes (padded by the 8-byte RawDataTypes, so...
Definition: Fragment.hh:991
static FragmentPtr dataFrag(sequence_id_t sequenceID, fragment_id_t fragID, InputIterator i, InputIterator e)
Creates a Fragment, copying data from given location. 12-Apr-2013, KAB - this method is deprecated...
Definition: Fragment.hh:670
RawDataType timestamp
The 64-bit timestamp field is the output of a user-defined clock used for building time-correlated ev...
RawDataType sequence_id
The 48-bit sequence_id uniquely identifies events within the artdaq system.
sequence_id_t sequenceID() const
Sequence ID of the Fragment, from the Fragment header.
Definition: Fragment.hh:827
timestamp_t timestamp() const
Timestamp of the Fragment, from the Fragment header.
Definition: Fragment.hh:841
static constexpr type_t DataFragmentType
Copy DataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:148
QuickVec< RawDataType >::const_iterator const_iterator
Alias const_iterator type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:183
uint8_t byte_t
For byte representation.
Definition: Fragment.hh:99
void resize(std::size_t sz)
Resize the data payload to hold sz RawDataType words.
Definition: Fragment.hh:974
RawDataType version
The version of the fragment.
void autoResize()
Resize the fragment to hold the number of words indicated by the header.
Definition: Fragment.hh:1018
static constexpr type_t EndOfRunFragmentType
Copy EndOfRunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:150
static constexpr fragment_id_t InvalidFragmentID
Copy InvalidFragmentID from RawFragmentHeader.
Definition: Fragment.hh:143
RawDataType fragment_id
The fragment_id uniquely identifies a particular piece of hardware within the artdaq system...
size_t size() const
Accesses the current size of the QuickVec.
Definition: QuickVec.hh:381
static constexpr type_t InitFragmentType
Copy InitFragmentType from RawFragmentHeader.
Definition: Fragment.hh:149
QuickVec< RawDataType >::reference reference
Alias reference type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:181
byte_t * headerBeginBytes()
Return a Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:546
static FragmentPtr FragmentBytes(std::size_t payload_size_in_bytes, sequence_id_t sequence_id, fragment_id_t fragment_id, type_t type, const T &metadata, timestamp_t timestamp=Fragment::InvalidTimestamp)
Create a Fragment with the given header values. Uses static factory function instead of constructor t...
Definition: Fragment.hh:236
static constexpr type_t ErrorFragmentType
Copy ErrorFragmentType from RawFragmentHeader.
Definition: Fragment.hh:156
detail::RawFragmentHeader::version_t version_t
typedef for version_t from RawFragmentHeader
Definition: Fragment.hh:135
void setTimestamp(timestamp_t timestamp)
Sets the Timestamp of the Fragment.
Definition: Fragment.hh:877
iterator headerBegin()
Return an iterator to the beginning of the header (should be used for serialization only: use setters...
Definition: Fragment.hh:1041
T reinterpret_cast_checked(RawDataType *in)
Wrapper around reinterpret_cast.
Definition: Fragment.hh:503
byte_t * dataEndBytes()
Return Fragment::byte_t* pointing at the end of the payload.
Definition: Fragment.hh:533
static constexpr version_t InvalidVersion
Copy InvalidVersion from RawFragmentHeader.
Definition: Fragment.hh:141
iterator dataBegin()
Return an iterator to the beginning of the data payload (after header and metadata) ...
Definition: Fragment.hh:1026
bool empty()
Determines if the Fragment contains no data.
Definition: Fragment.hh:1079
static constexpr sequence_id_t InvalidSequenceID
Copy InvalidSequenceID from RawFragmentHeader.
Definition: Fragment.hh:142
QuickVec< RawDataType >::value_type value_type
Alias value_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:184
static FragmentPtr eodFrag(size_t nFragsToExpect)
Creates an EndOfData Fragment.
Definition: Fragment.cc:74
void setUserType(type_t utype)
Sets the type of the Fragment, checking that it is a valid user type.
Definition: Fragment.hh:848
static constexpr type_t ContainerFragmentType
Copy ContainerFragmentType from RawFragmentHeader.
Definition: Fragment.hh:155
static std::map< type_t, std::string > MakeSystemTypeMap()
Returns a map of the most commonly-used system types.
Definition: Fragment.hh:176
std::ostream & operator<<(std::ostream &os, Fragment const &f)
Prints the given Fragment to the stream.
Definition: Fragment.hh:1199
void swap(QuickVec &other) noexcept
Exchanges references to two QuickVec objects.
Definition: QuickVec.hh:501
void setMetadata(const T &md)
Set the metadata in the Fragment to the contents of the specified structure. This throws an exception...
Definition: Fragment.hh:937
const byte_t * dataBeginBytes() const
Return const Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:568
type_t type() const
Type of the Fragment, from the Fragment header.
Definition: Fragment.hh:813
RawDataType * dataAddress()
Returns a RawDataType pointer to the beginning of the payload.
Definition: Fragment.hh:1102
void print(std::ostream &os) const
Print out summary information for this Fragment to the given stream.
Definition: Fragment.cc:65
unsigned long long RawDataType
The RawDataType (currently a 64-bit integer) is the basic unit of data representation within artdaq ...
T * metadata()
Return a pointer to the metadata. This throws an exception if the Fragment contains no metadata...
Definition: Fragment.hh:910
iterator dataEnd()
Return an iterator to the end of the data payload.
Definition: Fragment.hh:1034
static FragmentPtr FragmentBytes(std::size_t nbytes)
Create a Fragment using a static factory function rather than a constructor to allow for the function...
Definition: Fragment.hh:201
static constexpr type_t ShutdownFragmentType
Copy ShutdownFragmentType from RawFragmentHeader.
Definition: Fragment.hh:152
static constexpr type_t FirstUserFragmentType
Copy FIRST_USER_TYPE from RawFragmentHeader.
Definition: Fragment.hh:153
std::string typeString() const
Print the type of the Fragment.
Definition: Fragment.hh:820
detail::RawFragmentHeader::RawDataType RawDataType
The RawDataType (currently a 64-bit integer) is the basic unit of data representation within artdaq ...
Definition: Fragment.hh:39
RawDataType * metadataAddress()
Get the address of the metadata. For internal use only, use metadata() instead.
Definition: Fragment.hh:1110
std::list< FragmentPtr > FragmentPtrs
A std::list of FragmentPtrs.
Definition: Fragment.hh:58
Fragment()
Create a Fragment with all header values zeroed.
Definition: Fragment.cc:13
void clear()
Removes all elements from the payload section of the Fragment.
Definition: Fragment.hh:1071
static constexpr bool isSystemFragmentType(type_t fragmentType)
Returns whether the given type is in the range of system types.
Definition: Fragment.hh:735
static const version_t CurrentVersion
The CurrentVersion field should be incremented whenever the RawFragmentHeader changes.
QuickVec< RawDataType >::iterator iterator
Alias iterator type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:182
bool hasMetadata() const
Test whether this Fragment has metadata.
Definition: Fragment.hh:903
QuickVec< RawDataType >::size_type size_type
Alias size_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:186
const byte_t * headerBeginBytes() const
Return a const Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:597
static std::string SystemTypeToString(type_t type)
Print a system type&#39;s string name.
void setFragmentID(fragment_id_t fragment_id)
Sets the Fragment ID of the Fragment.
Definition: Fragment.hh:870
A Fragment contains the data from one piece of the DAQ system for one event The artdaq::Fragment is t...
Definition: Fragment.hh:84
void swap(Fragment &other) noexcept
Swaps two Fragment objects.
Definition: Fragment.hh:1095
static constexpr type_t EndOfSubrunFragmentType
Copy EndOfSubrunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:151
std::size_t dataSize() const
Return the number of RawDataType words in the data payload. This does not include the number of words...
Definition: Fragment.hh:895
iterator begin()
Gets an iterator to the beginning of the QuickVec.
Definition: QuickVec.hh:387
void swap(QuickVec< RawDataType > &other) noexcept
Swaps two Fragment data vectors.
Definition: Fragment.hh:631
detail::RawFragmentHeader::sequence_id_t sequence_id_t
typedef for sequence_id_t from RawFragmentHeader
Definition: Fragment.hh:137
fragment_id_t fragmentID() const
Fragment ID of the Fragment, from the Fragment header.
Definition: Fragment.hh:834
RawDataType * headerAddress()
Gets the address of the header.
Definition: Fragment.hh:1122
version_t version() const
Version of the Fragment, from the Fragment header.
Definition: Fragment.hh:806