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