artdaq_core  v1_07_04
 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 <memory>
11 #include <map>
12 #include <cmath>
13 #include <stdint.h>
14 #include <string.h>
15 
16 #include "artdaq-core/Data/detail/RawFragmentHeader.hh"
17 #include "artdaq-core/Data/detail/RawFragmentHeaderV0.hh"
18 #include "artdaq-core/Data/dictionarycontrol.hh"
19 #include "artdaq-core/Core/QuickVec.hh"
20 #include <iostream>
21 #include "trace.h" // TRACE
22 
26 namespace artdaq {
27 # define DATAVEC_T QuickVec<RawDataType>
28  //#define DATAVEC_T std::vector<RawDataType>
29 
37 
38  class Fragment;
42  typedef std::vector<Fragment> Fragments;
43 
50  typedef std::unique_ptr<Fragment> FragmentPtr;
51 
55  typedef std::list<FragmentPtr> FragmentPtrs;
56 
64 
71  std::ostream& operator<<(std::ostream& os, Fragment const& f);
72 }
73 
82 {
83 public:
87  Fragment();
88 
96  typedef uint8_t byte_t;
97 
98  // Hide most things from ROOT.
99 #if HIDE_FROM_ROOT
100 
101  // http://stackoverflow.com/questions/33939687
102  // This should generate an exception if artdaq::Fragment is not move-constructible
107  Fragment(const Fragment&) = default;
115  Fragment(Fragment&&) noexcept;
121  Fragment& operator=(const Fragment&) = default;
130  Fragment& operator=(Fragment&&) noexcept;
131 
132  typedef detail::RawFragmentHeader::version_t version_t;
133  typedef detail::RawFragmentHeader::type_t type_t;
134  typedef detail::RawFragmentHeader::sequence_id_t sequence_id_t;
135  typedef detail::RawFragmentHeader::fragment_id_t fragment_id_t;
136  typedef detail::RawFragmentHeader::timestamp_t timestamp_t;
137 
138  static constexpr version_t InvalidVersion = detail::RawFragmentHeader::InvalidVersion;
139  static constexpr sequence_id_t InvalidSequenceID = detail::RawFragmentHeader::InvalidSequenceID;
140  static constexpr fragment_id_t InvalidFragmentID = detail::RawFragmentHeader::InvalidFragmentID;
141  static constexpr timestamp_t InvalidTimestamp = detail::RawFragmentHeader::InvalidTimestamp;
142 
143  static constexpr type_t InvalidFragmentType = detail::RawFragmentHeader::InvalidFragmentType;
144  static constexpr type_t EndOfDataFragmentType = detail::RawFragmentHeader::EndOfDataFragmentType;
145  static constexpr type_t DataFragmentType = detail::RawFragmentHeader::DataFragmentType;
146  static constexpr type_t InitFragmentType = detail::RawFragmentHeader::InitFragmentType;
147  static constexpr type_t EndOfRunFragmentType = detail::RawFragmentHeader::EndOfRunFragmentType;
148  static constexpr type_t EndOfSubrunFragmentType = detail::RawFragmentHeader::EndOfSubrunFragmentType;
149  static constexpr type_t ShutdownFragmentType = detail::RawFragmentHeader::ShutdownFragmentType;
150  static constexpr type_t FirstUserFragmentType = detail::RawFragmentHeader::FIRST_USER_TYPE;
151  static constexpr type_t EmptyFragmentType = detail::RawFragmentHeader::EmptyFragmentType;
152  static constexpr type_t ContainerFragmentType = detail::RawFragmentHeader::ContainerFragmentType;
153 
159  static constexpr bool isUserFragmentType(type_t fragmentType);
160 
166  static constexpr bool isSystemFragmentType(type_t fragmentType);
167 
172  static std::map<type_t, std::string> MakeSystemTypeMap()
173  {
175  }
176 
177  typedef DATAVEC_T::reference reference;
178  typedef DATAVEC_T::iterator iterator;
179  typedef DATAVEC_T::const_iterator const_iterator;
180  typedef DATAVEC_T::value_type value_type;
181  typedef DATAVEC_T::difference_type difference_type;
182  typedef DATAVEC_T::size_type size_type;
183 
189  explicit Fragment(std::size_t n);
190 
197  static FragmentPtr FragmentBytes(std::size_t nbytes)
198  {
199  RawDataType nwords = ceil(nbytes / static_cast<double>(sizeof(RawDataType)));
200  return FragmentPtr(new Fragment(nwords));
201  }
202 
213  template <class T>
214  Fragment(std::size_t payload_size, sequence_id_t sequence_id,
215  fragment_id_t fragment_id, type_t type, const T& metadata,
217 
231  template <class T>
232  static FragmentPtr FragmentBytes(std::size_t payload_size_in_bytes,
233  sequence_id_t sequence_id,
234  fragment_id_t fragment_id,
235  type_t type, const T& metadata,
237  {
238  RawDataType nwords = ceil(payload_size_in_bytes /
239  static_cast<double>(sizeof(RawDataType)));
240  return FragmentPtr(new Fragment(nwords, sequence_id, fragment_id, type, metadata, timestamp));
241  }
242 
251  fragment_id_t fragID,
254 
259  void print(std::ostream& os) const;
260 
265  std::size_t size() const;
266 
271  version_t version() const;
272 
277  type_t type() const;
278 
283  sequence_id_t sequenceID() const;
284 
289  fragment_id_t fragmentID() const;
290 
295  timestamp_t timestamp() const;
296 
301  void setUserType(type_t utype);
302 
307  void setSystemType(type_t stype);
308 
313  void setSequenceID(sequence_id_t sequence_id);
314 
319  void setFragmentID(fragment_id_t fragment_id);
320 
326 
331  std::size_t sizeBytes() const { return sizeof(RawDataType) * size(); }
332 
338  std::size_t dataSize() const;
339 
340 
346  std::size_t dataSizeBytes() const
347  {
348  return sizeof(RawDataType) * dataSize();
349  }
350 
355  bool hasMetadata() const;
356 
364  template <class T>
365  T* metadata();
366 
374  template <class T>
375  T const* metadata() const;
376 
385  template <class T>
386  void setMetadata(const T& md);
387 
395  template <class T>
396  void updateMetadata(const T& md);
397 
402  void resize(std::size_t sz);
403 
409  void resize(std::size_t sz, RawDataType val);
410 
417  void resizeBytes(std::size_t szbytes);
418 
426  void resizeBytes(std::size_t szbytes, byte_t val);
427 
431  void autoResize();
432 
438 
443  iterator dataEnd();
444 
464  template <typename T>
466  {
467  T newpointer = reinterpret_cast<T>(in);
468 
469  if (static_cast<const void*>(newpointer) != static_cast<const void*>(in))
470  {
471  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
472  }
473 
474  return newpointer;
475  }
476 
492  template <typename T>
494  {
495  T newpointer = reinterpret_cast<T>(in);
496 
497  if (static_cast<void*>(newpointer) != static_cast<void*>(in))
498  {
499  throw cet::exception("Error in Fragment.hh: reinterpret_cast failed to return expected address-- please contact John Freeman at jcfree@fnal.gov");
500  }
501 
502  return newpointer;
503  }
504 
513  byte_t* dataBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* dataBegin()); }
514 
523  byte_t* dataEndBytes() { return reinterpret_cast_checked<byte_t*>(&* dataEnd()); }
524 
531 
536  byte_t* headerBeginBytes() { return reinterpret_cast_checked<byte_t*>(&* headerBegin()); }
537 
542  const_iterator dataBegin() const;
543 
548  const_iterator dataEnd() const;
549 
558  const byte_t* dataBeginBytes() const
559  {
560  return reinterpret_cast_checked<const byte_t*>(&* dataBegin());
561  }
562 
571  const byte_t* dataEndBytes() const
572  {
573  return reinterpret_cast_checked<const byte_t*>(&* dataEnd());
574  }
575 
581  const_iterator headerBegin() const; // See note for non-const, above.
582 
587  const byte_t* headerBeginBytes() const
588  {
589  return reinterpret_cast_checked<const byte_t*>(&* headerBegin());
590  }
591 
595  void clear();
596 
601  bool empty();
602 
607  void reserve(std::size_t cap);
608 
613  void swap(Fragment& other) noexcept;
614 
621  void swap(DATAVEC_T& other) noexcept { vals_.swap(other); };
622 
628 
641 
647  static FragmentPtr eodFrag(size_t nFragsToExpect);
648 
660  template<class InputIterator> static FragmentPtr dataFrag(sequence_id_t sequenceID,
661  fragment_id_t fragID,
662  InputIterator i,
663  InputIterator e)
664  {
665  FragmentPtr result(new Fragment(sequenceID, fragID));
666  result->vals_.reserve(std::distance(i, e) + detail::RawFragmentHeader::num_words());
667  std::copy(i, e, std::back_inserter(result->vals_));
668  return result;
669  }
670 
681  fragment_id_t fragID,
682  RawDataType const* dataPtr,
683  size_t dataSize,
685 #endif
686 
687 private:
688  template <typename T>
689  static std::size_t validatedMetadataSize_();
690 
691  void updateFragmentHeaderWC_();
692 
693  DATAVEC_T vals_;
694 
695 #if HIDE_FROM_ROOT
696  detail::RawFragmentHeader* fragmentHeader();
697 
698  detail::RawFragmentHeader const* fragmentHeader() const;
699 #endif
700 };
701 
702 #if HIDE_FROM_ROOT
703 
704 
705 // http://stackoverflow.com/questions/33939687
706 // This should generate an exception if artdaq::Fragment is not move-constructible
707 inline artdaq::Fragment::Fragment(artdaq::Fragment&&) noexcept = default;
708 inline artdaq::Fragment& artdaq::Fragment::operator=(artdaq::Fragment&&) noexcept = default;
709 
710 inline
711 bool
712 constexpr
713 artdaq::Fragment::
714 isUserFragmentType(type_t fragmentType)
715 {
716  return fragmentType >= detail::RawFragmentHeader::FIRST_USER_TYPE &&
717  fragmentType <= detail::RawFragmentHeader::LAST_USER_TYPE;
718 }
719 
720 inline
721 bool
722 constexpr
725 {
726  return fragmentType >= detail::RawFragmentHeader::FIRST_SYSTEM_TYPE;
727 }
728 
729 template <typename T>
730 std::size_t
731 artdaq::Fragment::
732 validatedMetadataSize_()
733 {
734  // Make sure a size_t is big enough to hold the maximum metadata
735  // size. This *should* always be true, but it is a compile-time check
736  // and therefore cheap.
737  static_assert(sizeof(size_t) >=
738  sizeof(decltype(std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max())),
739  "metadata_word_count_t is too big!");
740 
741  static size_t constexpr max_md_wc =
742  std::numeric_limits<detail::RawFragmentHeader::metadata_word_count_t>::max();
743  size_t requested_md_wc =
744  std::ceil(sizeof(T) / static_cast<double>(sizeof(artdaq::RawDataType)));
745  if (requested_md_wc > max_md_wc)
746  {
747  throw cet::exception("InvalidRequest")
748  << "The requested metadata structure is too large: "
749  << "requested word count = " << requested_md_wc
750  << ", maximum word count = " << max_md_wc;
751  }
752  return requested_md_wc;
753 }
754 
755 template <class T>
757 Fragment(std::size_t payload_size, sequence_id_t sequence_id,
758  fragment_id_t fragment_id,
759  type_t type, const T& metadata, timestamp_t timestamp) :
760  vals_((artdaq::detail::RawFragmentHeader::num_words() + // Header
761  validatedMetadataSize_<T>() + // Metadata
762  payload_size) // User data
763  )
764 {
765  TRACE( 50, "Fragment ctor num_word()=%zu MetadataSize_=%zu payload_size=%zu"
766  ,artdaq::detail::RawFragmentHeader::num_words(), validatedMetadataSize_<T>(), payload_size );
767  // vals ctor w/o init val is used; make sure header is ALL initialized.
768  for (iterator ii = vals_.begin();
769  ii != (vals_.begin() + detail::RawFragmentHeader::num_words()); ++ii) {
770  *ii = -1;
771  }
773  updateFragmentHeaderWC_();
774  fragmentHeader()->sequence_id = sequence_id;
775  fragmentHeader()->fragment_id = fragment_id;
776  fragmentHeader()->timestamp = timestamp;
777  fragmentHeader()->type = type;
778 
779  fragmentHeader()->metadata_word_count =
780  vals_.size() -
781  (fragmentHeader()->num_words() + payload_size);
782 
783  memcpy(metadataAddress(), &metadata, sizeof(T));
784 }
785 
786 inline
787 std::size_t
789 {
790  return fragmentHeader()->word_count;
791 }
792 
793 inline
796 {
797  return fragmentHeader()->version;
798 }
799 
800 inline
803 {
804  return static_cast<type_t>(fragmentHeader()->type);
805 }
806 
807 inline
810 {
811  return fragmentHeader()->sequence_id;
812 }
813 
814 inline
817 {
818  return fragmentHeader()->fragment_id;
819 }
820 
821 inline
824 {
825  return fragmentHeader()->timestamp;
826 }
827 
828 inline
829 void
831 {
832  fragmentHeader()->setUserType(static_cast<uint8_t>(type));
833 }
834 
835 inline
836 void
838 {
839  fragmentHeader()->setSystemType(static_cast<uint8_t>(type));
840 }
841 
842 inline
843 void
845 {
846  assert(sequence_id <= detail::RawFragmentHeader::InvalidSequenceID);
847  fragmentHeader()->sequence_id = sequence_id;
848 }
849 
850 inline
851 void
853 {
854  fragmentHeader()->fragment_id = fragment_id;
855 }
856 
857 inline
858 void
860 {
861  fragmentHeader()->timestamp = timestamp;
862 }
863 
864 inline
865 void
866 artdaq::Fragment::updateFragmentHeaderWC_()
867 {
868  // Make sure vals_.size() fits inside 32 bits. Left-shift here should
869  // match bitfield size of word_count in RawFragmentHeader.
870  assert(vals_.size() < (1ULL << 32));
871  TRACE( 50, "Fragment::updateFragmentHeaderWC_ adjusting fragmentHeader()->word_count from %u to %zu", (unsigned)(fragmentHeader()->word_count), vals_.size() );
872  fragmentHeader()->word_count = vals_.size();
873 }
874 
875 inline
876 std::size_t
878 {
879  return vals_.size() - fragmentHeader()->num_words() -
880  fragmentHeader()->metadata_word_count;
881 }
882 
883 inline
884 bool
886 {
887  return fragmentHeader()->metadata_word_count != 0;
888 }
889 
890 template <class T>
891 T*
893 {
894  if (fragmentHeader()->metadata_word_count == 0)
895  {
896  throw cet::exception("InvalidRequest")
897  << "No metadata has been stored in this Fragment.";
898  }
899 
900  return reinterpret_cast_checked<T *>
901  (&vals_[fragmentHeader()->num_words()]);
902 }
903 
904 template <class T>
905 T const*
907 {
908  if (fragmentHeader()->metadata_word_count == 0)
909  {
910  throw cet::exception("InvalidRequest")
911  << "No metadata has been stored in this Fragment.";
912  }
913  return reinterpret_cast_checked<T const *>
914  (&vals_[fragmentHeader()->num_words()]);
915 }
916 
917 template <class T>
918 void
920 {
921  if (fragmentHeader()->metadata_word_count != 0)
922  {
923  throw cet::exception("InvalidRequest")
924  << "Metadata has already been stored in this Fragment.";
925  }
926  auto const mdSize = validatedMetadataSize_<T>();
927  vals_.insert(dataBegin(), mdSize, 0);
928  updateFragmentHeaderWC_();
929  fragmentHeader()->metadata_word_count = mdSize;
930 
931  memcpy(metadataAddress(), &metadata, sizeof(T));
932 }
933 
934 template <class T>
935 void
937 {
938  if (fragmentHeader()->metadata_word_count == 0)
939  {
940  throw cet::exception("InvalidRequest")
941  << "No metadata in fragment; please use Fragment::setMetadata instead of Fragment::updateMetadata";
942  }
943 
944  auto const mdSize = validatedMetadataSize_<T>();
945 
946  if (fragmentHeader()->metadata_word_count != mdSize)
947  {
948  throw cet::exception("InvalidRequest")
949  << "Mismatch between type of metadata struct passed to updateMetadata and existing metadata struct";
950  }
951 
952  memcpy(metadataAddress(), &metadata, sizeof(T));
953 }
954 
955 inline void
957 {
958  vals_.resize(sz + fragmentHeader()->metadata_word_count +
959  fragmentHeader()->num_words());
960  updateFragmentHeaderWC_();
961 }
962 
963 inline
964 void
966 {
967  vals_.resize(sz + fragmentHeader()->metadata_word_count +
968  fragmentHeader()->num_words(), v);
969  updateFragmentHeaderWC_();
970 }
971 
972 inline void
973 artdaq::Fragment::resizeBytes(std::size_t szbytes)
974 {
975  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
976  resize(nwords);
977 }
978 
979 inline
980 void
981 artdaq::Fragment::resizeBytes(std::size_t szbytes, byte_t v)
982 {
983  RawDataType defaultval;
984  byte_t* ptr = reinterpret_cast_checked<byte_t*>(&defaultval);
985 
986  for (uint8_t i = 0; i < sizeof(RawDataType); ++i)
987  {
988  *ptr = v;
989  ptr++;
990  }
991 
992  RawDataType nwords = ceil(szbytes / static_cast<double>(sizeof(RawDataType)));
993 
994  resize(nwords, defaultval);
995 }
996 
997 
998 inline
999 void
1001 {
1002  vals_.resize(fragmentHeader()->word_count);
1003  updateFragmentHeaderWC_();
1004 }
1005 
1006 inline
1009 {
1010  return vals_.begin() + fragmentHeader()->num_words() +
1011  fragmentHeader()->metadata_word_count;
1012 }
1013 
1014 inline
1017 {
1018  return vals_.end();
1019 }
1020 
1021 inline
1024 {
1025  return vals_.begin();
1026 }
1027 
1028 inline
1031 {
1032  return vals_.begin() + fragmentHeader()->num_words() +
1033  fragmentHeader()->metadata_word_count;
1034 }
1035 
1036 inline
1039 {
1040  return vals_.end();
1041 }
1042 
1043 inline
1046 {
1047  return vals_.begin();
1048 }
1049 
1050 
1051 inline
1052 void
1054 {
1055  vals_.erase(dataBegin(), dataEnd());
1056  updateFragmentHeaderWC_();
1057 }
1058 
1059 inline
1060 bool
1062 {
1063  return (vals_.size() - fragmentHeader()->num_words() -
1064  fragmentHeader()->metadata_word_count) == 0;
1065 }
1066 
1067 inline
1068 void
1070 {
1071  vals_.reserve(cap + fragmentHeader()->num_words() +
1072  fragmentHeader()->metadata_word_count);
1073 }
1074 
1075 inline
1076 void
1078 {
1079  vals_.swap(other.vals_);
1080 }
1081 
1082 inline
1085 {
1086  return &vals_[0] + fragmentHeader()->num_words() +
1087  fragmentHeader()->metadata_word_count;
1088 }
1089 
1090 inline
1093 {
1094  if (fragmentHeader()->metadata_word_count == 0)
1095  {
1096  throw cet::exception("InvalidRequest")
1097  << "No metadata has been stored in this Fragment.";
1098  }
1099  return &vals_[0] + fragmentHeader()->num_words();
1100 }
1101 
1102 inline
1105 {
1106  return &vals_[0];
1107 }
1108 
1109 inline
1111 artdaq::Fragment::fragmentHeader()
1112 {
1113  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader *>(&vals_[0]);
1114  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1115  {
1116  switch (hdr->version)
1117  {
1118  case 0xFFFF:
1119  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1120  break;
1121  case 0:
1122  {
1123  std::cout << "Upgrading RawFragmentHeaderV0 (non const)" << std::endl;
1124  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 *>(&vals_[0]);
1125  auto new_hdr = old_hdr->upgrade();
1126 
1127  auto szDiff = hdr->num_words() - old_hdr->num_words();
1128  if (szDiff > 0) vals_.insert(vals_.begin(), szDiff, 0);
1129  memcpy(&vals_[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1130  }
1131  break;
1132  default:
1133  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1134  break;
1135  }
1136  }
1137  return hdr;
1138 }
1139 
1140 inline
1142 artdaq::Fragment::fragmentHeader() const
1143 {
1144  auto hdr = reinterpret_cast_checked<detail::RawFragmentHeader const*>(&vals_[0]);
1145  if (hdr->version != detail::RawFragmentHeader::CurrentVersion)
1146  {
1147  switch (hdr->version)
1148  {
1149  case 0xFFFF:
1150  //std::cout << "Not upgrading InvalidVersion Fragment" << std::endl;
1151  break;
1152  case 0:
1153  {
1154  std::cout << "Upgrading RawFragmentHeaderV0 (const)" << std::endl;
1155  auto old_hdr = reinterpret_cast_checked<detail::RawFragmentHeaderV0 const*>(&vals_[0]);
1156  auto new_hdr = old_hdr->upgrade();
1157 
1158  auto szDiff = hdr->num_words() - old_hdr->num_words();
1159  auto vals_nc = const_cast<DATAVEC_T*>(&vals_);
1160  if (szDiff > 0) vals_nc->insert(vals_nc->begin(), szDiff, 0);
1161  memcpy(&(*vals_nc)[0], &new_hdr, hdr->num_words() * sizeof(RawDataType));
1162  }
1163  break;
1164  default:
1165  throw cet::exception("Fragment") << "A Fragment with an unknown version (" << std::to_string(hdr->version) << ") was received!";
1166  break;
1167  }
1168  }
1169  return hdr;
1170 }
1171 
1172 inline
1173 void
1174 swap(artdaq::Fragment& x, artdaq::Fragment& y) noexcept
1175 {
1176  x.swap(y);
1177 }
1178 
1179 inline
1180 std::ostream&
1181 artdaq::operator<<(std::ostream& os, artdaq::Fragment const& f)
1182 {
1183  f.print(os);
1184  return os;
1185 }
1186 #endif/* HIDE_FROM_ROOT */
1187 
1188 #endif /* artdaq_core_Data_Fragment_hh */
std::unique_ptr< Fragment > FragmentPtr
A std::unique_ptr to a Fragment object.
Definition: Fragment.hh:50
void reserve(std::size_t cap)
Reserves enough memory to hold cap RawDataType words in the Fragment payload.
Definition: Fragment.hh:1069
detail::RawFragmentHeader::timestamp_t timestamp_t
typedef for timestamp_t from RawFragmentHeader
Definition: Fragment.hh:136
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:346
RawDataType type
The type of the fragment, either system or user-defined.
static constexpr type_t InvalidFragmentType
Copy InvalidFragmentType from RawFragmentHeader.
Definition: Fragment.hh:143
T reinterpret_cast_checked(const RawDataType *in) const
Wrapper around reinterpret_cast.
Definition: Fragment.hh:465
QuickVec< RawDataType >::difference_type difference_type
Alias difference_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:181
void setSequenceID(sequence_id_t sequence_id)
Sets the Sequence ID of the Fragment.
Definition: Fragment.hh:844
void setSystemType(type_t stype)
Sets the type of the Fragment, checking that it is a valid system type.
Definition: Fragment.hh:837
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:38
std::size_t size() const
Gets the size of the Fragment, from the Fragment header.
Definition: Fragment.hh:788
static constexpr type_t EndOfDataFragmentType
Copy EndOfDataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:144
static constexpr timestamp_t InvalidTimestamp
Copy InvalidTimestamp from RawFragmentHeader.
Definition: Fragment.hh:141
void updateMetadata(const T &md)
Updates existing metadata with a new metadata object.
Definition: Fragment.hh:936
static constexpr type_t EmptyFragmentType
Copy EmptyFragmentType from RawFragmentHeader.
Definition: Fragment.hh:151
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:571
static constexpr bool isUserFragmentType(type_t fragmentType)
Returns whether the given type is in the range of user types.
Definition: Fragment.hh:714
detail::RawFragmentHeader::fragment_id_t fragment_id_t
typedef for fragment_id_t from RawFragmentHeader
Definition: Fragment.hh:135
std::size_t sizeBytes() const
Size of vals_ vector ( header + (optional) metadata + payload) in bytes.
Definition: Fragment.hh:331
byte_t * dataBeginBytes()
Return Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:513
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:133
void resizeBytes(std::size_t szbytes)
Resize the data payload to hold szbytes bytes (padded by the 8-byte RawDataTypes, so...
Definition: Fragment.hh:973
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:660
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:809
timestamp_t timestamp() const
Timestamp of the Fragment, from the Fragment header.
Definition: Fragment.hh:823
static constexpr type_t DataFragmentType
Copy DataFragmentType from RawFragmentHeader.
Definition: Fragment.hh:145
QuickVec< RawDataType >::const_iterator const_iterator
Alias const_iterator type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:179
uint8_t byte_t
For byte representation.
Definition: Fragment.hh:96
void resize(std::size_t sz)
Resize the data payload to hold sz RawDataType words.
Definition: Fragment.hh:956
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:1000
static constexpr type_t EndOfRunFragmentType
Copy EndOfRunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:147
static constexpr fragment_id_t InvalidFragmentID
Copy InvalidFragmentID from RawFragmentHeader.
Definition: Fragment.hh:140
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:398
static constexpr type_t InitFragmentType
Copy InitFragmentType from RawFragmentHeader.
Definition: Fragment.hh:146
QuickVec< RawDataType >::reference reference
Alias reference type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:177
byte_t * headerBeginBytes()
Return a Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:536
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:232
detail::RawFragmentHeader::version_t version_t
typedef for version_t from RawFragmentHeader
Definition: Fragment.hh:132
void setTimestamp(timestamp_t timestamp)
Sets the Timestamp of the Fragment.
Definition: Fragment.hh:859
iterator headerBegin()
Return an iterator to the beginning of the header (should be used for serialization only: use setters...
Definition: Fragment.hh:1023
T reinterpret_cast_checked(RawDataType *in)
Wrapper around reinterpret_cast.
Definition: Fragment.hh:493
byte_t * dataEndBytes()
Return Fragment::byte_t* pointing at the end of the payload.
Definition: Fragment.hh:523
static constexpr version_t InvalidVersion
Copy InvalidVersion from RawFragmentHeader.
Definition: Fragment.hh:138
iterator dataBegin()
Return an iterator to the beginning of the data payload (after header and metadata) ...
Definition: Fragment.hh:1008
bool empty()
Determines if the Fragment contains no data.
Definition: Fragment.hh:1061
static constexpr sequence_id_t InvalidSequenceID
Copy InvalidSequenceID from RawFragmentHeader.
Definition: Fragment.hh:139
QuickVec< RawDataType >::value_type value_type
Alias value_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:180
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:830
static constexpr type_t ContainerFragmentType
Copy ContainerFragmentType from RawFragmentHeader.
Definition: Fragment.hh:152
static std::map< type_t, std::string > MakeSystemTypeMap()
Returns a map of the most commonly-used system types.
Definition: Fragment.hh:172
std::ostream & operator<<(std::ostream &os, Fragment const &f)
Prints the given Fragment to the stream.
Definition: Fragment.hh:1181
void swap(QuickVec &other) noexcept
Exchanges references to two QuickVec objects.
Definition: QuickVec.hh:535
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:919
const byte_t * dataBeginBytes() const
Return const Fragment::byte_t* pointing at the beginning of the payload.
Definition: Fragment.hh:558
type_t type() const
Type of the Fragment, from the Fragment header.
Definition: Fragment.hh:802
RawDataType * dataAddress()
Returns a RawDataType pointer to the beginning of the payload.
Definition: Fragment.hh:1084
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:892
iterator dataEnd()
Return an iterator to the end of the data payload.
Definition: Fragment.hh:1016
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:197
static constexpr type_t ShutdownFragmentType
Copy ShutdownFragmentType from RawFragmentHeader.
Definition: Fragment.hh:149
static constexpr type_t FirstUserFragmentType
Copy FIRST_USER_TYPE from RawFragmentHeader.
Definition: Fragment.hh:150
detail::RawFragmentHeader::RawDataType RawDataType
The RawDataType (currently a 64-bit integer) is the basic unit of data representation within artdaq ...
Definition: Fragment.hh:36
RawDataType * metadataAddress()
Get the address of the metadata. For internal use only, use metadata() instead.
Definition: Fragment.hh:1092
std::list< FragmentPtr > FragmentPtrs
A std::list of FragmentPtrs.
Definition: Fragment.hh:55
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:1053
static constexpr bool isSystemFragmentType(type_t fragmentType)
Returns whether the given type is in the range of system types.
Definition: Fragment.hh:724
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:178
bool hasMetadata() const
Test whether this Fragment has metadata.
Definition: Fragment.hh:885
QuickVec< RawDataType >::size_type size_type
Alias size_type type from QuickVec&lt;RawDataType&gt;
Definition: Fragment.hh:182
const byte_t * headerBeginBytes() const
Return a const Fragment::byte_t pointer pointing to the beginning of the header.
Definition: Fragment.hh:587
void setFragmentID(fragment_id_t fragment_id)
Sets the Fragment ID of the Fragment.
Definition: Fragment.hh:852
A Fragment contains the data from one piece of the DAQ system for one event The artdaq::Fragment is t...
Definition: Fragment.hh:81
void swap(Fragment &other) noexcept
Swaps two Fragment objects.
Definition: Fragment.hh:1077
static constexpr type_t EndOfSubrunFragmentType
Copy EndOfSubrunFragmentType from RawFragmentHeader.
Definition: Fragment.hh:148
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:877
iterator begin()
Gets an iterator to the beginning of the QuickVec.
Definition: QuickVec.hh:404
void swap(QuickVec< RawDataType > &other) noexcept
Swaps two Fragment data vectors.
Definition: Fragment.hh:621
detail::RawFragmentHeader::sequence_id_t sequence_id_t
typedef for sequence_id_t from RawFragmentHeader
Definition: Fragment.hh:134
fragment_id_t fragmentID() const
Fragment ID of the Fragment, from the Fragment header.
Definition: Fragment.hh:816
RawDataType * headerAddress()
Gets the address of the header.
Definition: Fragment.hh:1104
version_t version() const
Version of the Fragment, from the Fragment header.
Definition: Fragment.hh:795