artdaq_core  v3_04_09
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 
437  void resizeBytesWithCushion(std::size_t szbytes, double growthFactor=1.3);
438 
446  void resizeBytes(std::size_t szbytes, byte_t val);
447 
451  void autoResize();
452 
458 
463  iterator dataEnd();
464 
484  template <typename T>
486  {
487  T newpointer = reinterpret_cast<T>(in);
488 
489  if (static_cast<const void*>(newpointer) != static_cast<const void*>(in))
490  {
491  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
492  }
493 
494  return newpointer;
495  }
496 
512  template <typename T>
514  {
515  T newpointer = reinterpret_cast<T>(in);
516 
517  if (static_cast<void*>(newpointer) != static_cast<void*>(in))
518  {
519  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
520  }
521 
522  return newpointer;
523  }
524 
533  byte_t* dataBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* dataBegin()); }
534 
543  byte_t* dataEndBytes() { return reinterpret_cast_checked<byte_t*>(&* dataEnd()); }
544 
551 
556  byte_t* headerBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* headerBegin()); }
557 
562  const_iterator dataBegin() const;
563 
568  const_iterator dataEnd() const;
569 
578  const byte_t* dataBeginBytes() const
579  {
580  return reinterpret_cast_checked<const byte_t*>(&* dataBegin());
581  }
582 
591  const byte_t* dataEndBytes() const
592  {
593  return reinterpret_cast_checked<const byte_t*>(&* dataEnd());
594  }
595 
601  const_iterator headerBegin() const; // See note for non-const, above.
602 
607  const byte_t* headerBeginBytes() const
608  {
609  return reinterpret_cast_checked<const byte_t*>(&* headerBegin());
610  }
611 
615  void clear();
616 
621  bool empty();
622 
627  void reserve(std::size_t cap);
628 
633  void swap(Fragment& other) noexcept;
634 
641  void swap(DATAVEC_T& other) noexcept { vals_.swap(other); };
642 
648 
661 
667  static FragmentPtr eodFrag(size_t nFragsToExpect);
668 
680  template<class InputIterator> static FragmentPtr dataFrag(sequence_id_t sequenceID,
681  fragment_id_t fragID,
682  InputIterator i,
683  InputIterator e)
684  {
685  FragmentPtr result(new Fragment(sequenceID, fragID));
686  result->vals_.reserve(std::distance(i, e) + detail::RawFragmentHeader::num_words());
687  std::copy(i, e, std::back_inserter(result->vals_));
688  result->updateFragmentHeaderWC_();
689  return result;
690  }
691 
702  fragment_id_t fragID,
703  RawDataType const* dataPtr,
704  size_t dataSize,
706 #endif
707 
708 private:
709  template <typename T>
710  static std::size_t validatedMetadataSize_();
711 
712  void updateFragmentHeaderWC_();
713 
714  DATAVEC_T vals_;
715 
716 #if HIDE_FROM_ROOT
717  detail::RawFragmentHeader* fragmentHeader();
718 
719  detail::RawFragmentHeader const* fragmentHeader() const;
720 #endif
721 };
722 
723 #if HIDE_FROM_ROOT
724 
725 
726 // http://stackoverflow.com/questions/33939687
727 // This should generate an exception if artdaq::Fragment is not move-constructible
728 inline artdaq::Fragment::Fragment(artdaq::Fragment&&) noexcept = default;
729 inline artdaq::Fragment& artdaq::Fragment::operator=(artdaq::Fragment&&) noexcept = default;
730 
731 inline
732 bool
733 constexpr
734 artdaq::Fragment::
735 isUserFragmentType(type_t fragmentType)
736 {
737  return fragmentType >= detail::RawFragmentHeader::FIRST_USER_TYPE &&
738  fragmentType <= detail::RawFragmentHeader::LAST_USER_TYPE;
739 }
740 
741 inline
742 bool
743 constexpr
746 {
747  return fragmentType >= detail::RawFragmentHeader::FIRST_SYSTEM_TYPE;
748 }
749 
750 template <typename T>
751 std::size_t
752 artdaq::Fragment::
753 validatedMetadataSize_()
754 {
755  // Make sure a size_t is big enough to hold the maximum metadata
756  // size. This *should* always be true, but it is a compile-time check
757  // and therefore cheap.
758  static_assert(sizeof(size_t) >=
759  sizeof(decltype(std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max())),
760  "metadata_word_count_t is too big!");
761 
762  static size_t constexpr max_md_wc =
763  std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max();
764  size_t requested_md_wc =
765  std::ceil(sizeof(T) / static_cast<double>(sizeof(artdaq::RawDataType)));
766  if (requested_md_wc > max_md_wc)
767  {
768  throw cet::exception("InvalidRequest")
769  << "The requested metadata structure is too large: "
770  << "requested word count = " << requested_md_wc
771  << ", maximum word count = " << max_md_wc;
772  }
773  return requested_md_wc;
774 }
775 
776 template <class T>
778 Fragment(std::size_t payload_size, sequence_id_t sequence_id,
779  fragment_id_t fragment_id,
780  type_t type, const T& metadata, timestamp_t timestamp) :
781  vals_((artdaq::detail::RawFragmentHeader::num_words() + // Header
782  validatedMetadataSize_<T>() + // Metadata
783  payload_size) // User data
784  )
785 {
786  TRACEN( "Fragment", 50, "Fragment ctor num_word()=%zu MetadataSize_=%zu payload_size=%zu"
787  ,artdaq::detail::RawFragmentHeader::num_words(), validatedMetadataSize_<T>(), payload_size );
788  // vals ctor w/o init val is used; make sure header is ALL initialized.
789  for (iterator ii = vals_.begin();
790  ii != (vals_.begin() + detail::RawFragmentHeader::num_words()); ++ii) {
791  *ii = -1;
792  }
794  updateFragmentHeaderWC_();
795  fragmentHeader()->sequence_id = sequence_id;
796  fragmentHeader()->fragment_id = fragment_id;
797  fragmentHeader()->timestamp = timestamp;
798  fragmentHeader()->type = type;
799 
800  fragmentHeader()->metadata_word_count =
801  vals_.size() -
802  (fragmentHeader()->num_words() + payload_size);
803 
804  memcpy(metadataAddress(), &metadata, sizeof(T));
805 }
806 
807 inline
808 std::size_t
810 {
811  return fragmentHeader()->word_count;
812 }
813 
814 inline
817 {
818  return fragmentHeader()->version;
819 }
820 
821 inline
824 {
825  return static_cast<type_t>(fragmentHeader()->type);
826 }
827 
828 inline
829 std::string
831 {
832  return std::to_string(type()) + (isSystemFragmentType(type()) ? " (" + detail::RawFragmentHeader::SystemTypeToString(type()) + ")" : "");
833 }
834 
835 inline
838 {
839  return fragmentHeader()->sequence_id;
840 }
841 
842 inline
845 {
846  return fragmentHeader()->fragment_id;
847 }
848 
849 inline
852 {
853  return fragmentHeader()->timestamp;
854 }
855 
856 inline
857 void
859 {
860  fragmentHeader()->setUserType(static_cast<uint8_t>(type));
861 }
862 
863 inline
864 void
866 {
867  fragmentHeader()->setSystemType(static_cast<uint8_t>(type));
868 }
869 
870 inline
871 void
873 {
874  assert(sequence_id <= detail::RawFragmentHeader::InvalidSequenceID);
875  fragmentHeader()->sequence_id = sequence_id;
876 }
877 
878 inline
879 void
881 {
882  fragmentHeader()->fragment_id = fragment_id;
883 }
884 
885 inline
886 void
888 {
889  fragmentHeader()->timestamp = timestamp;
890 }
891 
892 inline
893 void
894 artdaq::Fragment::updateFragmentHeaderWC_()
895 {
896  // Make sure vals_.size() fits inside 32 bits. Left-shift here should
897  // match bitfield size of word_count in RawFragmentHeader.
898  assert(vals_.size() < (1ULL << 32));
899  TRACEN( "Fragment", 50, "Fragment::updateFragmentHeaderWC_ adjusting fragmentHeader()->word_count from %u to %zu", (unsigned)(fragmentHeader()->word_count), vals_.size() );
900  fragmentHeader()->word_count = vals_.size();
901 }
902 
903 inline
904 std::size_t
906 {
907  return vals_.size() - fragmentHeader()->num_words() -
908  fragmentHeader()->metadata_word_count;
909 }
910 
911 inline
912 bool
914 {
915  return fragmentHeader()->metadata_word_count != 0;
916 }
917 
918 template <class T>
919 T*
921 {
922  if (fragmentHeader()->metadata_word_count == 0)
923  {
924  throw cet::exception("InvalidRequest")
925  << "No metadata has been stored in this Fragment.";
926  }
927 
928  return reinterpret_cast_checked<T *>
929  (&vals_[fragmentHeader()->num_words()]);
930 }
931 
932 template <class T>
933 T const*
935 {
936  if (fragmentHeader()->metadata_word_count == 0)
937  {
938  throw cet::exception("InvalidRequest")
939  << "No metadata has been stored in this Fragment.";
940  }
941  return reinterpret_cast_checked<T const *>
942  (&vals_[fragmentHeader()->num_words()]);
943 }
944 
945 template <class T>
946 void
948 {
949  if (fragmentHeader()->metadata_word_count != 0)
950  {
951  throw cet::exception("InvalidRequest")
952  << "Metadata has already been stored in this Fragment.";
953  }
954  auto const mdSize = validatedMetadataSize_<T>();
955  vals_.insert(dataBegin(), mdSize, 0);
956  updateFragmentHeaderWC_();
957  fragmentHeader()->metadata_word_count = mdSize;
958 
959  memcpy(metadataAddress(), &metadata, sizeof(T));
960 }
961 
962 template <class T>
963 void
965 {
966  if (fragmentHeader()->metadata_word_count == 0)
967  {
968  throw cet::exception("InvalidRequest")
969  << "No metadata in fragment; please use Fragment::setMetadata instead of Fragment::updateMetadata";
970  }
971 
972  auto const mdSize = validatedMetadataSize_<T>();
973 
974  if (fragmentHeader()->metadata_word_count != mdSize)
975  {
976  throw cet::exception("InvalidRequest")
977  << "Mismatch between type of metadata struct passed to updateMetadata and existing metadata struct";
978  }
979 
980  memcpy(metadataAddress(), &metadata, sizeof(T));
981 }
982 
983 inline void
985 {
986  vals_.resize(sz + fragmentHeader()->metadata_word_count +
987  fragmentHeader()->num_words());
988  updateFragmentHeaderWC_();
989 }
990 
991 inline
992 void
994 {
995  vals_.resize(sz + fragmentHeader()->metadata_word_count +
996  fragmentHeader()->num_words(), v);
997  updateFragmentHeaderWC_();
998 }
999 
1000 inline void
1001 artdaq::Fragment::resizeBytes(std::size_t szbytes)
1002 {
1003  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
1004  resize(nwords);
1005 }
1006 
1007 inline void
1008 artdaq::Fragment::resizeBytesWithCushion(std::size_t szbytes, double growthFactor)
1009 {
1010  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
1011  vals_.resizeWithCushion(nwords + fragmentHeader()->metadata_word_count +
1012  fragmentHeader()->num_words(), growthFactor);
1013  updateFragmentHeaderWC_();
1014 }
1015 
1016 inline
1017 void
1018 artdaq::Fragment::resizeBytes(std::size_t szbytes, byte_t v)
1019 {
1020  RawDataType defaultval;
1021  byte_t* ptr = reinterpret_cast_checked<byte_t*>(&defaultval);
1022 
1023  for (uint8_t i = 0; i < sizeof(RawDataType); ++i)
1024  {
1025  *ptr = v;
1026  ptr++;
1027  }
1028 
1029  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
1030 
1031  resize(nwords, defaultval);
1032 }
1033 
1034 
1035 inline
1036 void
1038 {
1039  vals_.resize(fragmentHeader()->word_count);
1040  updateFragmentHeaderWC_();
1041 }
1042 
1043 inline
1046 {
1047  return vals_.begin() + fragmentHeader()->num_words() +
1048  fragmentHeader()->metadata_word_count;
1049 }
1050 
1051 inline
1054 {
1055  return vals_.end();
1056 }
1057 
1058 inline
1061 {
1062  return vals_.begin();
1063 }
1064 
1065 inline
1068 {
1069  return vals_.begin() + fragmentHeader()->num_words() +
1070  fragmentHeader()->metadata_word_count;
1071 }
1072 
1073 inline
1076 {
1077  return vals_.end();
1078 }
1079 
1080 inline
1083 {
1084  return vals_.begin();
1085 }
1086 
1087 
1088 inline
1089 void
1091 {
1092  vals_.erase(dataBegin(), dataEnd());
1093  updateFragmentHeaderWC_();
1094 }
1095 
1096 inline
1097 bool
1099 {
1100  return (vals_.size() - fragmentHeader()->num_words() -
1101  fragmentHeader()->metadata_word_count) == 0;
1102 }
1103 
1104 inline
1105 void
1107 {
1108  vals_.reserve(cap + fragmentHeader()->num_words() +
1109  fragmentHeader()->metadata_word_count);
1110 }
1111 
1112 inline
1113 void
1115 {
1116  vals_.swap(other.vals_);
1117 }
1118 
1119 inline
1122 {
1123  return &vals_[0] + fragmentHeader()->num_words() +
1124  fragmentHeader()->metadata_word_count;
1125 }
1126 
1127 inline
1130 {
1131  if (fragmentHeader()->metadata_word_count == 0)
1132  {
1133  throw cet::exception("InvalidRequest")
1134  << "No metadata has been stored in this Fragment.";
1135  }
1136  return &vals_[0] + fragmentHeader()->num_words();
1137 }
1138 
1139 inline
1142 {
1143  return &vals_[0];
1144 }
1145 
1146 inline
1148 artdaq::Fragment::fragmentHeader()
1149 {
1150  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader *>(&vals_[0]);
1151  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1152  {
1153  switch (hdr->version)
1154  {
1155  case 0xFFFF:
1156  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1157  break;
1158  case 0:
1159  {
1160  std::cout << "Upgrading RawFragmentHeaderV0 (non const)" << std::endl;
1161  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 *>(&vals_[0]);
1162  auto new_hdr = old_hdr->upgrade();
1163 
1164  auto szDiff = hdr->num_words() - old_hdr->num_words();
1165  if (szDiff > 0) vals_.insert(vals_.begin(), szDiff, 0);
1166  memcpy(&vals_[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1167  }
1168  break;
1169  default:
1170  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1171  break;
1172  }
1173  }
1174  return hdr;
1175 }
1176 
1177 inline
1179 artdaq::Fragment::fragmentHeader() const
1180 {
1181  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader const*>(&vals_[0]);
1182  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1183  {
1184  switch (hdr->version)
1185  {
1186  case 0xFFFF:
1187  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1188  break;
1189  case 0:
1190  {
1191  std::cout << "Upgrading RawFragmentHeaderV0 (const)" << std::endl;
1192  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 const*>(&vals_[0]);
1193  auto new_hdr = old_hdr->upgrade();
1194 
1195  auto szDiff = hdr->num_words() - old_hdr->num_words();
1196  auto vals_nc = const_cast<DATAVEC_T*>(&vals_);
1197  if (szDiff > 0) vals_nc->insert(vals_nc->begin(), szDiff, 0);
1198  memcpy(&(*vals_nc)[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1199  }
1200  break;
1201  default:
1202  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1203  break;
1204  }
1205  }
1206  return hdr;
1207 }
1208 
1209 inline
1210 void
1211 swap(artdaq::Fragment& x, artdaq::Fragment& y) noexcept
1212 {
1213  x.swap(y);
1214 }
1215 
1216 inline
1217 std::ostream&
1218 artdaq::operator<<(std::ostream& os, artdaq::Fragment const& f)
1219 {
1220  f.print(os);
1221  return os;
1222 }
1223 #endif/* HIDE_FROM_ROOT */
1224 
1225 #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:1106
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:485
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:872
void setSystemType(type_t stype)
Sets the type of the Fragment, checking that it is a valid system type.
Definition: Fragment.hh:865
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:809
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:964
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:591
static constexpr bool isUserFragmentType(type_t fragmentType)
Returns whether the given type is in the range of user types.
Definition: Fragment.hh:735
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:533
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:1001
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:680
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:837
timestamp_t timestamp() const
Timestamp of the Fragment, from the Fragment header.
Definition: Fragment.hh:851
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:984
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:1037
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:393
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:556
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:887
iterator headerBegin()
Return an iterator to the beginning of the header (should be used for serialization only: use setters...
Definition: Fragment.hh:1060
T reinterpret_cast_checked(RawDataType *in)
Wrapper around reinterpret_cast.
Definition: Fragment.hh:513
byte_t * dataEndBytes()
Return Fragment::byte_t* pointing at the end of the payload.
Definition: Fragment.hh:543
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:1045
bool empty()
Determines if the Fragment contains no data.
Definition: Fragment.hh:1098
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:858
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:1218
void swap(QuickVec &other) noexcept
Exchanges references to two QuickVec objects.
Definition: QuickVec.hh:529
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:947
const byte_t * dataBeginBytes() const
Return const Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:578
type_t type() const
Type of the Fragment, from the Fragment header.
Definition: Fragment.hh:823
RawDataType * dataAddress()
Returns a RawDataType pointer to the beginning of the payload.
Definition: Fragment.hh:1121
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:920
iterator dataEnd()
Return an iterator to the end of the data payload.
Definition: Fragment.hh:1053
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:830
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:1129
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:1090
static constexpr bool isSystemFragmentType(type_t fragmentType)
Returns whether the given type is in the range of system types.
Definition: Fragment.hh:745
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:913
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:607
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:880
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:1114
static constexpr type_t EndOfSubrunFragmentType
Copy EndOfSubrunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:151
void resizeBytesWithCushion(std::size_t szbytes, double growthFactor=1.3)
Resize the data payload to hold szbytes bytes (padded by the 8-byte RawDataTypes, so...
Definition: Fragment.hh:1008
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:905
iterator begin()
Gets an iterator to the beginning of the QuickVec.
Definition: QuickVec.hh:399
void swap(QuickVec< RawDataType > &other) noexcept
Swaps two Fragment data vectors.
Definition: Fragment.hh:641
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:844
RawDataType * headerAddress()
Gets the address of the header.
Definition: Fragment.hh:1141
version_t version() const
Version of the Fragment, from the Fragment header.
Definition: Fragment.hh:816