artdaq_core  v3_00_00
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Pages
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 #include "trace.h" // TRACE
23 
27 namespace artdaq {
28 # define DATAVEC_T QuickVec<RawDataType>
29  //#define DATAVEC_T std::vector<RawDataType>
30 
38 
39  class Fragment;
43  typedef std::vector<Fragment> Fragments;
44 
51  typedef std::unique_ptr<Fragment> FragmentPtr;
52 
56  typedef std::list<FragmentPtr> FragmentPtrs;
57 
65 
72  std::ostream& operator<<(std::ostream& os, Fragment const& f);
73 }
74 
83 {
84 public:
88  Fragment();
89 
97  typedef uint8_t byte_t;
98 
99  // Hide most things from ROOT.
100 #if HIDE_FROM_ROOT
101 
102  // http://stackoverflow.com/questions/33939687
103  // This should generate an exception if artdaq::Fragment is not move-constructible
108  Fragment(const Fragment&) = default;
116  Fragment(Fragment&&) noexcept;
122  Fragment& operator=(const Fragment&) = default;
131  Fragment& operator=(Fragment&&) noexcept;
132 
133  typedef detail::RawFragmentHeader::version_t version_t;
134  typedef detail::RawFragmentHeader::type_t type_t;
135  typedef detail::RawFragmentHeader::sequence_id_t sequence_id_t;
136  typedef detail::RawFragmentHeader::fragment_id_t fragment_id_t;
137  typedef detail::RawFragmentHeader::timestamp_t timestamp_t;
138 
139  static constexpr version_t InvalidVersion = detail::RawFragmentHeader::InvalidVersion;
140  static constexpr sequence_id_t InvalidSequenceID = detail::RawFragmentHeader::InvalidSequenceID;
141  static constexpr fragment_id_t InvalidFragmentID = detail::RawFragmentHeader::InvalidFragmentID;
142  static constexpr timestamp_t InvalidTimestamp = detail::RawFragmentHeader::InvalidTimestamp;
143 
144  static constexpr type_t InvalidFragmentType = detail::RawFragmentHeader::InvalidFragmentType;
145  static constexpr type_t EndOfDataFragmentType = detail::RawFragmentHeader::EndOfDataFragmentType;
146  static constexpr type_t DataFragmentType = detail::RawFragmentHeader::DataFragmentType;
147  static constexpr type_t InitFragmentType = detail::RawFragmentHeader::InitFragmentType;
148  static constexpr type_t EndOfRunFragmentType = detail::RawFragmentHeader::EndOfRunFragmentType;
149  static constexpr type_t EndOfSubrunFragmentType = detail::RawFragmentHeader::EndOfSubrunFragmentType;
150  static constexpr type_t ShutdownFragmentType = detail::RawFragmentHeader::ShutdownFragmentType;
151  static constexpr type_t FirstUserFragmentType = detail::RawFragmentHeader::FIRST_USER_TYPE;
152  static constexpr type_t EmptyFragmentType = detail::RawFragmentHeader::EmptyFragmentType;
153  static constexpr type_t ContainerFragmentType = detail::RawFragmentHeader::ContainerFragmentType;
154 
160  static constexpr bool isUserFragmentType(type_t fragmentType);
161 
167  static constexpr bool isSystemFragmentType(type_t fragmentType);
168 
173  static std::map<type_t, std::string> MakeSystemTypeMap()
174  {
176  }
177 
178  typedef DATAVEC_T::reference reference;
179  typedef DATAVEC_T::iterator iterator;
180  typedef DATAVEC_T::const_iterator const_iterator;
181  typedef DATAVEC_T::value_type value_type;
182  typedef DATAVEC_T::difference_type difference_type;
183  typedef DATAVEC_T::size_type size_type;
184 
190  explicit Fragment(std::size_t n);
191 
198  static FragmentPtr FragmentBytes(std::size_t nbytes)
199  {
200  RawDataType nwords = ceil(nbytes / static_cast<double>(sizeof(RawDataType)));
201  return FragmentPtr(new Fragment(nwords));
202  }
203 
214  template <class T>
215  Fragment(std::size_t payload_size, sequence_id_t sequence_id,
216  fragment_id_t fragment_id, type_t type, const T& metadata,
218 
232  template <class T>
233  static FragmentPtr FragmentBytes(std::size_t payload_size_in_bytes,
234  sequence_id_t sequence_id,
235  fragment_id_t fragment_id,
236  type_t type, const T& metadata,
238  {
239  RawDataType nwords = ceil(payload_size_in_bytes /
240  static_cast<double>(sizeof(RawDataType)));
241  return FragmentPtr(new Fragment(nwords, sequence_id, fragment_id, type, metadata, timestamp));
242  }
243 
252  fragment_id_t fragID,
255 
260  void print(std::ostream& os) const;
261 
266  std::size_t size() const;
267 
272  version_t version() const;
273 
278  type_t type() const;
279 
284  std::string typeString() const;
285 
290  sequence_id_t sequenceID() const;
291 
296  fragment_id_t fragmentID() const;
297 
302  timestamp_t timestamp() const;
303 
308  void setUserType(type_t utype);
309 
314  void setSystemType(type_t stype);
315 
320  void setSequenceID(sequence_id_t sequence_id);
321 
326  void setFragmentID(fragment_id_t fragment_id);
327 
333 
338  std::size_t sizeBytes() const { return sizeof(RawDataType) * size(); }
339 
345  std::size_t dataSize() const;
346 
347 
353  std::size_t dataSizeBytes() const
354  {
355  return sizeof(RawDataType) * dataSize();
356  }
357 
362  bool hasMetadata() const;
363 
371  template <class T>
372  T* metadata();
373 
381  template <class T>
382  T const* metadata() const;
383 
392  template <class T>
393  void setMetadata(const T& md);
394 
402  template <class T>
403  void updateMetadata(const T& md);
404 
409  void resize(std::size_t sz);
410 
416  void resize(std::size_t sz, RawDataType val);
417 
424  void resizeBytes(std::size_t szbytes);
425 
433  void resizeBytes(std::size_t szbytes, byte_t val);
434 
438  void autoResize();
439 
445 
450  iterator dataEnd();
451 
471  template <typename T>
473  {
474  T newpointer = reinterpret_cast<T>(in);
475 
476  if (static_cast<const void*>(newpointer) != static_cast<const void*>(in))
477  {
478  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
479  }
480 
481  return newpointer;
482  }
483 
499  template <typename T>
501  {
502  T newpointer = reinterpret_cast<T>(in);
503 
504  if (static_cast<void*>(newpointer) != static_cast<void*>(in))
505  {
506  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
507  }
508 
509  return newpointer;
510  }
511 
520  byte_t* dataBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* dataBegin()); }
521 
530  byte_t* dataEndBytes() { return reinterpret_cast_checked<byte_t*>(&* dataEnd()); }
531 
538 
543  byte_t* headerBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* headerBegin()); }
544 
549  const_iterator dataBegin() const;
550 
555  const_iterator dataEnd() const;
556 
565  const byte_t* dataBeginBytes() const
566  {
567  return reinterpret_cast_checked<const byte_t*>(&* dataBegin());
568  }
569 
578  const byte_t* dataEndBytes() const
579  {
580  return reinterpret_cast_checked<const byte_t*>(&* dataEnd());
581  }
582 
588  const_iterator headerBegin() const; // See note for non-const, above.
589 
594  const byte_t* headerBeginBytes() const
595  {
596  return reinterpret_cast_checked<const byte_t*>(&* headerBegin());
597  }
598 
602  void clear();
603 
608  bool empty();
609 
614  void reserve(std::size_t cap);
615 
620  void swap(Fragment& other) noexcept;
621 
628  void swap(DATAVEC_T& other) noexcept { vals_.swap(other); };
629 
635 
648 
654  static FragmentPtr eodFrag(size_t nFragsToExpect);
655 
667  template<class InputIterator> static FragmentPtr dataFrag(sequence_id_t sequenceID,
668  fragment_id_t fragID,
669  InputIterator i,
670  InputIterator e)
671  {
672  FragmentPtr result(new Fragment(sequenceID, fragID));
673  result->vals_.reserve(std::distance(i, e) + detail::RawFragmentHeader::num_words());
674  std::copy(i, e, std::back_inserter(result->vals_));
675  result->updateFragmentHeaderWC_();
676  return result;
677  }
678 
689  fragment_id_t fragID,
690  RawDataType const* dataPtr,
691  size_t dataSize,
693 #endif
694 
695 private:
696  template <typename T>
697  static std::size_t validatedMetadataSize_();
698 
699  void updateFragmentHeaderWC_();
700 
701  DATAVEC_T vals_;
702 
703 #if HIDE_FROM_ROOT
704  detail::RawFragmentHeader* fragmentHeader();
705 
706  detail::RawFragmentHeader const* fragmentHeader() const;
707 #endif
708 };
709 
710 #if HIDE_FROM_ROOT
711 
712 
713 // http://stackoverflow.com/questions/33939687
714 // This should generate an exception if artdaq::Fragment is not move-constructible
715 inline artdaq::Fragment::Fragment(artdaq::Fragment&&) noexcept = default;
716 inline artdaq::Fragment& artdaq::Fragment::operator=(artdaq::Fragment&&) noexcept = default;
717 
718 inline
719 bool
720 constexpr
721 artdaq::Fragment::
722 isUserFragmentType(type_t fragmentType)
723 {
724  return fragmentType >= detail::RawFragmentHeader::FIRST_USER_TYPE &&
725  fragmentType <= detail::RawFragmentHeader::LAST_USER_TYPE;
726 }
727 
728 inline
729 bool
730 constexpr
733 {
734  return fragmentType >= detail::RawFragmentHeader::FIRST_SYSTEM_TYPE;
735 }
736 
737 template <typename T>
738 std::size_t
739 artdaq::Fragment::
740 validatedMetadataSize_()
741 {
742  // Make sure a size_t is big enough to hold the maximum metadata
743  // size. This *should* always be true, but it is a compile-time check
744  // and therefore cheap.
745  static_assert(sizeof(size_t) >=
746  sizeof(decltype(std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max())),
747  "metadata_word_count_t is too big!");
748 
749  static size_t constexpr max_md_wc =
750  std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max();
751  size_t requested_md_wc =
752  std::ceil(sizeof(T) / static_cast<double>(sizeof(artdaq::RawDataType)));
753  if (requested_md_wc > max_md_wc)
754  {
755  throw cet::exception("InvalidRequest")
756  << "The requested metadata structure is too large: "
757  << "requested word count = " << requested_md_wc
758  << ", maximum word count = " << max_md_wc;
759  }
760  return requested_md_wc;
761 }
762 
763 template <class T>
765 Fragment(std::size_t payload_size, sequence_id_t sequence_id,
766  fragment_id_t fragment_id,
767  type_t type, const T& metadata, timestamp_t timestamp) :
768  vals_((artdaq::detail::RawFragmentHeader::num_words() + // Header
769  validatedMetadataSize_<T>() + // Metadata
770  payload_size) // User data
771  )
772 {
773  TRACE( 50, "Fragment ctor num_word()=%zu MetadataSize_=%zu payload_size=%zu"
774  ,artdaq::detail::RawFragmentHeader::num_words(), validatedMetadataSize_<T>(), payload_size );
775  // vals ctor w/o init val is used; make sure header is ALL initialized.
776  for (iterator ii = vals_.begin();
777  ii != (vals_.begin() + detail::RawFragmentHeader::num_words()); ++ii) {
778  *ii = -1;
779  }
781  updateFragmentHeaderWC_();
782  fragmentHeader()->sequence_id = sequence_id;
783  fragmentHeader()->fragment_id = fragment_id;
784  fragmentHeader()->timestamp = timestamp;
785  fragmentHeader()->type = type;
786 
787  fragmentHeader()->metadata_word_count =
788  vals_.size() -
789  (fragmentHeader()->num_words() + payload_size);
790 
791  memcpy(metadataAddress(), &metadata, sizeof(T));
792 }
793 
794 inline
795 std::size_t
797 {
798  return fragmentHeader()->word_count;
799 }
800 
801 inline
804 {
805  return fragmentHeader()->version;
806 }
807 
808 inline
811 {
812  return static_cast<type_t>(fragmentHeader()->type);
813 }
814 
815 inline
816 std::string
818 {
819  return std::to_string(type()) + (isSystemFragmentType(type()) ? " (" + detail::RawFragmentHeader::SystemTypeToString(type()) + ")" : "");
820 }
821 
822 inline
825 {
826  return fragmentHeader()->sequence_id;
827 }
828 
829 inline
832 {
833  return fragmentHeader()->fragment_id;
834 }
835 
836 inline
839 {
840  return fragmentHeader()->timestamp;
841 }
842 
843 inline
844 void
846 {
847  fragmentHeader()->setUserType(static_cast<uint8_t>(type));
848 }
849 
850 inline
851 void
853 {
854  fragmentHeader()->setSystemType(static_cast<uint8_t>(type));
855 }
856 
857 inline
858 void
860 {
861  assert(sequence_id <= detail::RawFragmentHeader::InvalidSequenceID);
862  fragmentHeader()->sequence_id = sequence_id;
863 }
864 
865 inline
866 void
868 {
869  fragmentHeader()->fragment_id = fragment_id;
870 }
871 
872 inline
873 void
875 {
876  fragmentHeader()->timestamp = timestamp;
877 }
878 
879 inline
880 void
881 artdaq::Fragment::updateFragmentHeaderWC_()
882 {
883  // Make sure vals_.size() fits inside 32 bits. Left-shift here should
884  // match bitfield size of word_count in RawFragmentHeader.
885  assert(vals_.size() < (1ULL << 32));
886  TRACE( 50, "Fragment::updateFragmentHeaderWC_ adjusting fragmentHeader()->word_count from %u to %zu", (unsigned)(fragmentHeader()->word_count), vals_.size() );
887  fragmentHeader()->word_count = vals_.size();
888 }
889 
890 inline
891 std::size_t
893 {
894  return vals_.size() - fragmentHeader()->num_words() -
895  fragmentHeader()->metadata_word_count;
896 }
897 
898 inline
899 bool
901 {
902  return fragmentHeader()->metadata_word_count != 0;
903 }
904 
905 template <class T>
906 T*
908 {
909  if (fragmentHeader()->metadata_word_count == 0)
910  {
911  throw cet::exception("InvalidRequest")
912  << "No metadata has been stored in this Fragment.";
913  }
914 
915  return reinterpret_cast_checked<T *>
916  (&vals_[fragmentHeader()->num_words()]);
917 }
918 
919 template <class T>
920 T const*
922 {
923  if (fragmentHeader()->metadata_word_count == 0)
924  {
925  throw cet::exception("InvalidRequest")
926  << "No metadata has been stored in this Fragment.";
927  }
928  return reinterpret_cast_checked<T const *>
929  (&vals_[fragmentHeader()->num_words()]);
930 }
931 
932 template <class T>
933 void
935 {
936  if (fragmentHeader()->metadata_word_count != 0)
937  {
938  throw cet::exception("InvalidRequest")
939  << "Metadata has already been stored in this Fragment.";
940  }
941  auto const mdSize = validatedMetadataSize_<T>();
942  vals_.insert(dataBegin(), mdSize, 0);
943  updateFragmentHeaderWC_();
944  fragmentHeader()->metadata_word_count = mdSize;
945 
946  memcpy(metadataAddress(), &metadata, sizeof(T));
947 }
948 
949 template <class T>
950 void
952 {
953  if (fragmentHeader()->metadata_word_count == 0)
954  {
955  throw cet::exception("InvalidRequest")
956  << "No metadata in fragment; please use Fragment::setMetadata instead of Fragment::updateMetadata";
957  }
958 
959  auto const mdSize = validatedMetadataSize_<T>();
960 
961  if (fragmentHeader()->metadata_word_count != mdSize)
962  {
963  throw cet::exception("InvalidRequest")
964  << "Mismatch between type of metadata struct passed to updateMetadata and existing metadata struct";
965  }
966 
967  memcpy(metadataAddress(), &metadata, sizeof(T));
968 }
969 
970 inline void
972 {
973  vals_.resize(sz + fragmentHeader()->metadata_word_count +
974  fragmentHeader()->num_words());
975  updateFragmentHeaderWC_();
976 }
977 
978 inline
979 void
981 {
982  vals_.resize(sz + fragmentHeader()->metadata_word_count +
983  fragmentHeader()->num_words(), v);
984  updateFragmentHeaderWC_();
985 }
986 
987 inline void
988 artdaq::Fragment::resizeBytes(std::size_t szbytes)
989 {
990  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
991  resize(nwords);
992 }
993 
994 inline
995 void
996 artdaq::Fragment::resizeBytes(std::size_t szbytes, byte_t v)
997 {
998  RawDataType defaultval;
999  byte_t* ptr = reinterpret_cast_checked<byte_t*>(&defaultval);
1000 
1001  for (uint8_t i = 0; i < sizeof(RawDataType); ++i)
1002  {
1003  *ptr = v;
1004  ptr++;
1005  }
1006 
1007  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
1008 
1009  resize(nwords, defaultval);
1010 }
1011 
1012 
1013 inline
1014 void
1016 {
1017  vals_.resize(fragmentHeader()->word_count);
1018  updateFragmentHeaderWC_();
1019 }
1020 
1021 inline
1024 {
1025  return vals_.begin() + fragmentHeader()->num_words() +
1026  fragmentHeader()->metadata_word_count;
1027 }
1028 
1029 inline
1032 {
1033  return vals_.end();
1034 }
1035 
1036 inline
1039 {
1040  return vals_.begin();
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 
1066 inline
1067 void
1069 {
1070  vals_.erase(dataBegin(), dataEnd());
1071  updateFragmentHeaderWC_();
1072 }
1073 
1074 inline
1075 bool
1077 {
1078  return (vals_.size() - fragmentHeader()->num_words() -
1079  fragmentHeader()->metadata_word_count) == 0;
1080 }
1081 
1082 inline
1083 void
1085 {
1086  vals_.reserve(cap + fragmentHeader()->num_words() +
1087  fragmentHeader()->metadata_word_count);
1088 }
1089 
1090 inline
1091 void
1093 {
1094  vals_.swap(other.vals_);
1095 }
1096 
1097 inline
1100 {
1101  return &vals_[0] + fragmentHeader()->num_words() +
1102  fragmentHeader()->metadata_word_count;
1103 }
1104 
1105 inline
1108 {
1109  if (fragmentHeader()->metadata_word_count == 0)
1110  {
1111  throw cet::exception("InvalidRequest")
1112  << "No metadata has been stored in this Fragment.";
1113  }
1114  return &vals_[0] + fragmentHeader()->num_words();
1115 }
1116 
1117 inline
1120 {
1121  return &vals_[0];
1122 }
1123 
1124 inline
1126 artdaq::Fragment::fragmentHeader()
1127 {
1128  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader *>(&vals_[0]);
1129  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1130  {
1131  switch (hdr->version)
1132  {
1133  case 0xFFFF:
1134  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1135  break;
1136  case 0:
1137  {
1138  std::cout << "Upgrading RawFragmentHeaderV0 (non const)" << std::endl;
1139  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 *>(&vals_[0]);
1140  auto new_hdr = old_hdr->upgrade();
1141 
1142  auto szDiff = hdr->num_words() - old_hdr->num_words();
1143  if (szDiff > 0) vals_.insert(vals_.begin(), szDiff, 0);
1144  memcpy(&vals_[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1145  }
1146  break;
1147  default:
1148  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1149  break;
1150  }
1151  }
1152  return hdr;
1153 }
1154 
1155 inline
1157 artdaq::Fragment::fragmentHeader() const
1158 {
1159  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader const*>(&vals_[0]);
1160  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1161  {
1162  switch (hdr->version)
1163  {
1164  case 0xFFFF:
1165  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1166  break;
1167  case 0:
1168  {
1169  std::cout << "Upgrading RawFragmentHeaderV0 (const)" << std::endl;
1170  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 const*>(&vals_[0]);
1171  auto new_hdr = old_hdr->upgrade();
1172 
1173  auto szDiff = hdr->num_words() - old_hdr->num_words();
1174  auto vals_nc = const_cast<DATAVEC_T*>(&vals_);
1175  if (szDiff > 0) vals_nc->insert(vals_nc->begin(), szDiff, 0);
1176  memcpy(&(*vals_nc)[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1177  }
1178  break;
1179  default:
1180  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1181  break;
1182  }
1183  }
1184  return hdr;
1185 }
1186 
1187 inline
1188 void
1189 swap(artdaq::Fragment& x, artdaq::Fragment& y) noexcept
1190 {
1191  x.swap(y);
1192 }
1193 
1194 inline
1195 std::ostream&
1196 artdaq::operator<<(std::ostream& os, artdaq::Fragment const& f)
1197 {
1198  f.print(os);
1199  return os;
1200 }
1201 #endif/* HIDE_FROM_ROOT */
1202 
1203 #endif /* artdaq_core_Data_Fragment_hh */
std::unique_ptr< Fragment > FragmentPtr
A std::unique_ptr to a Fragment object.
Definition: Fragment.hh:51
void reserve(std::size_t cap)
Reserves enough memory to hold cap RawDataType words in the Fragment payload.
Definition: Fragment.hh:1084
detail::RawFragmentHeader::timestamp_t timestamp_t
typedef for timestamp_t from RawFragmentHeader
Definition: Fragment.hh:137
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:353
RawDataType type
The type of the fragment, either system or user-defined.
static constexpr type_t InvalidFragmentType
Copy InvalidFragmentType from RawFragmentHeader.
Definition: Fragment.hh:144
T reinterpret_cast_checked(const RawDataType *in) const
Wrapper around reinterpret_cast.
Definition: Fragment.hh:472
QuickVec< RawDataType >::difference_type difference_type
Alias difference_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:182
void setSequenceID(sequence_id_t sequence_id)
Sets the Sequence ID of the Fragment.
Definition: Fragment.hh:859
void setSystemType(type_t stype)
Sets the type of the Fragment, checking that it is a valid system type.
Definition: Fragment.hh:852
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:39
std::size_t size() const
Gets the size of the Fragment, from the Fragment header.
Definition: Fragment.hh:796
static constexpr type_t EndOfDataFragmentType
Copy EndOfDataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:145
static constexpr timestamp_t InvalidTimestamp
Copy InvalidTimestamp from RawFragmentHeader.
Definition: Fragment.hh:142
void updateMetadata(const T &md)
Updates existing metadata with a new metadata object.
Definition: Fragment.hh:951
static constexpr type_t EmptyFragmentType
Copy EmptyFragmentType from RawFragmentHeader.
Definition: Fragment.hh:152
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:578
static constexpr bool isUserFragmentType(type_t fragmentType)
Returns whether the given type is in the range of user types.
Definition: Fragment.hh:722
detail::RawFragmentHeader::fragment_id_t fragment_id_t
typedef for fragment_id_t from RawFragmentHeader
Definition: Fragment.hh:136
std::size_t sizeBytes() const
Size of vals_ vector ( header + (optional) metadata + payload) in bytes.
Definition: Fragment.hh:338
byte_t * dataBeginBytes()
Return Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:520
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:134
void resizeBytes(std::size_t szbytes)
Resize the data payload to hold szbytes bytes (padded by the 8-byte RawDataTypes, so...
Definition: Fragment.hh:988
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:667
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:824
timestamp_t timestamp() const
Timestamp of the Fragment, from the Fragment header.
Definition: Fragment.hh:838
static constexpr type_t DataFragmentType
Copy DataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:146
QuickVec< RawDataType >::const_iterator const_iterator
Alias const_iterator type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:180
uint8_t byte_t
For byte representation.
Definition: Fragment.hh:97
void resize(std::size_t sz)
Resize the data payload to hold sz RawDataType words.
Definition: Fragment.hh:971
RawDataType version
The version of the fragment. Currently always InvalidVersion.
void autoResize()
Resize the fragment to hold the number of words indicated by the header.
Definition: Fragment.hh:1015
static constexpr type_t EndOfRunFragmentType
Copy EndOfRunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:148
static constexpr fragment_id_t InvalidFragmentID
Copy InvalidFragmentID from RawFragmentHeader.
Definition: Fragment.hh:141
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:147
QuickVec< RawDataType >::reference reference
Alias reference type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:178
byte_t * headerBeginBytes()
Return a Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:543
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:233
detail::RawFragmentHeader::version_t version_t
typedef for version_t from RawFragmentHeader
Definition: Fragment.hh:133
void setTimestamp(timestamp_t timestamp)
Sets the Timestamp of the Fragment.
Definition: Fragment.hh:874
iterator headerBegin()
Return an iterator to the beginning of the header (should be used for serialization only: use setters...
Definition: Fragment.hh:1038
T reinterpret_cast_checked(RawDataType *in)
Wrapper around reinterpret_cast.
Definition: Fragment.hh:500
byte_t * dataEndBytes()
Return Fragment::byte_t* pointing at the end of the payload.
Definition: Fragment.hh:530
static constexpr version_t InvalidVersion
Copy InvalidVersion from RawFragmentHeader.
Definition: Fragment.hh:139
iterator dataBegin()
Return an iterator to the beginning of the data payload (after header and metadata) ...
Definition: Fragment.hh:1023
bool empty()
Determines if the Fragment contains no data.
Definition: Fragment.hh:1076
static constexpr sequence_id_t InvalidSequenceID
Copy InvalidSequenceID from RawFragmentHeader.
Definition: Fragment.hh:140
QuickVec< RawDataType >::value_type value_type
Alias value_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:181
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:845
static constexpr type_t ContainerFragmentType
Copy ContainerFragmentType from RawFragmentHeader.
Definition: Fragment.hh:153
static std::map< type_t, std::string > MakeSystemTypeMap()
Returns a map of the most commonly-used system types.
Definition: Fragment.hh:173
std::ostream & operator<<(std::ostream &os, Fragment const &f)
Prints the given Fragment to the stream.
Definition: Fragment.hh:1196
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:934
const byte_t * dataBeginBytes() const
Return const Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:565
type_t type() const
Type of the Fragment, from the Fragment header.
Definition: Fragment.hh:810
RawDataType * dataAddress()
Returns a RawDataType pointer to the beginning of the payload.
Definition: Fragment.hh:1099
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:907
iterator dataEnd()
Return an iterator to the end of the data payload.
Definition: Fragment.hh:1031
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:198
static constexpr type_t ShutdownFragmentType
Copy ShutdownFragmentType from RawFragmentHeader.
Definition: Fragment.hh:150
static constexpr type_t FirstUserFragmentType
Copy FIRST_USER_TYPE from RawFragmentHeader.
Definition: Fragment.hh:151
std::string typeString() const
Print the type of the Fragment.
Definition: Fragment.hh:817
detail::RawFragmentHeader::RawDataType RawDataType
The RawDataType (currently a 64-bit integer) is the basic unit of data representation within artdaq ...
Definition: Fragment.hh:37
RawDataType * metadataAddress()
Get the address of the metadata. For internal use only, use metadata() instead.
Definition: Fragment.hh:1107
std::list< FragmentPtr > FragmentPtrs
A std::list of FragmentPtrs.
Definition: Fragment.hh:56
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:1068
static constexpr bool isSystemFragmentType(type_t fragmentType)
Returns whether the given type is in the range of system types.
Definition: Fragment.hh:732
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:179
bool hasMetadata() const
Test whether this Fragment has metadata.
Definition: Fragment.hh:900
QuickVec< RawDataType >::size_type size_type
Alias size_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:183
const byte_t * headerBeginBytes() const
Return a const Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:594
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:867
A Fragment contains the data from one piece of the DAQ system for one event The artdaq::Fragment is t...
Definition: Fragment.hh:82
void swap(Fragment &other) noexcept
Swaps two Fragment objects.
Definition: Fragment.hh:1092
static constexpr type_t EndOfSubrunFragmentType
Copy EndOfSubrunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:149
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:892
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:628
detail::RawFragmentHeader::sequence_id_t sequence_id_t
typedef for sequence_id_t from RawFragmentHeader
Definition: Fragment.hh:135
fragment_id_t fragmentID() const
Fragment ID of the Fragment, from the Fragment header.
Definition: Fragment.hh:831
RawDataType * headerAddress()
Gets the address of the header.
Definition: Fragment.hh:1119
version_t version() const
Version of the Fragment, from the Fragment header.
Definition: Fragment.hh:803