jana2_tutorial_podio/datamodel/MutableEventHeader.h

0001 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
0002
0003 #ifndef JANA2_TUTORIAL_PODIO_DATAMODEL_MutableEventHeader_H
0004 #define JANA2_TUTORIAL_PODIO_DATAMODEL_MutableEventHeader_H
0005
0006 #include "jana2_tutorial_podio_datamodel/EventHeaderObj.h"
0007 // Make the immutable class available from its mutable version but not vice versa
0008 #include "jana2_tutorial_podio_datamodel/EventHeader.h"
0009
0010
0011 #include "podio/utilities/MaybeSharedPtr.h"
0012
0013 #include <cstdint>
0014
0015 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
0016 #include "nlohmann/json_fwd.hpp"
0017 #endif
0018
0019 // forward declarations
0020 class EventHeaderCollection;
0021
0022
0023
0024
0025 /** @class MutableEventHeader
0026  *  Persistent IDs for each entry/frame/JEvent
0027  *  @author: N. Brei
0028  */
0029 class MutableEventHeader {
0030
0031   friend class EventHeaderCollection;
0032   friend class EventHeaderMutableCollectionIterator;
0033   friend class EventHeader;
0034
0035 public:
0036   using object_type = EventHeader;
0037   using collection_type = EventHeaderCollection;
0038
0039   /// default constructor
0040   MutableEventHeader() = default;
0041
0042   /// Constructor initializing all members
0043   MutableEventHeader(const int run_number, const int timeframe_number, const int event_number);
0044
0045   /// copy constructor
0046   MutableEventHeader(const MutableEventHeader& other) = default;
0047
0048   /// copy-assignment operator
0049   MutableEventHeader& operator=(MutableEventHeader other) &; // Rebind this to other's internal object
0050   MutableEventHeader& operator=(MutableEventHeader other) && = delete; // Prevent rebinding temporary as the changes wouldn't persist
0051
0052   /// create a mutable deep-copy of the object with identical relations
0053   /// if cloneRelations=false, the relations are not cloned and will be empty
0054   MutableEventHeader clone(bool cloneRelations=true) const;
0055
0056   /// destructor
0057   ~MutableEventHeader() = default;
0058
0059
0060 public:
0061
0062   /// Access the run number
0063   int getRun_number() const;
0064
0065   /// Access the timeframe number
0066   int getTimeframe_number() const;
0067
0068   /// Access the event number
0069   int getEvent_number() const;
0070
0071
0072
0073   /// Set the run number
0074   void setRun_number(const int run_number);
0075   /// Get mutable reference to run number
0076   int& getRun_number();
0077   /// Get reference to run number
0078   [[deprecated("use getRun_number instead")]]
0079   int& run_number();
0080
0081   /// Set the timeframe number
0082   void setTimeframe_number(const int timeframe_number);
0083   /// Get mutable reference to timeframe number
0084   int& getTimeframe_number();
0085   /// Get reference to timeframe number
0086   [[deprecated("use getTimeframe_number instead")]]
0087   int& timeframe_number();
0088
0089   /// Set the event number
0090   void setEvent_number(const int event_number);
0091   /// Get mutable reference to event number
0092   int& getEvent_number();
0093   /// Get reference to event number
0094   [[deprecated("use getEvent_number instead")]]
0095   int& event_number();
0096
0097
0098
0099
0100
0101
0102   /// check whether the object is actually available
0103   bool isAvailable() const;
0104   /// disconnect from EventHeaderObj instance
0105   void unlink() { m_obj = podio::utils::MaybeSharedPtr<EventHeaderObj>{nullptr}; }
0106
0107   bool operator==(const MutableEventHeader& other) const { return m_obj == other.m_obj; }
0108   bool operator==(const EventHeader& other) const;
0109
0110   bool operator!=(const MutableEventHeader& other) const { return !(*this == other); }
0111   bool operator!=(const EventHeader& other) const { return !(*this == other); }
0112
0113   // less comparison operator, so that objects can be e.g. stored in sets.
0114   bool operator<(const MutableEventHeader& other) const { return podio::detail::getOrderKey(*this) < podio::detail::getOrderKey(other); }
0115
0116   podio::ObjectID id() const { return getObjectID(); }
0117
0118   const podio::ObjectID getObjectID() const;
0119
0120   friend std::hash<MutableEventHeader>;
0121
0122   friend void swap(MutableEventHeader& a, MutableEventHeader& b) {
0123     using std::swap;
0124     swap(a.m_obj, b.m_obj); // swap out the internal pointers
0125   }
0126
0127 private:
0128   /// constructor from existing EventHeaderObj
0129   explicit MutableEventHeader(podio::utils::MaybeSharedPtr<EventHeaderObj> obj);
0130
0131   podio::utils::MaybeSharedPtr<EventHeaderObj> m_obj{new EventHeaderObj{}, podio::utils::MarkOwned};
0132 };
0133
0134 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
0135 void to_json(nlohmann::json& j, const MutableEventHeader& value);
0136 #endif
0137
0138
0139
0140
0141
0142 template<>
0143 struct std::hash<MutableEventHeader> {
0144   std::size_t operator()(const MutableEventHeader& obj) const {
0145     return std::hash<EventHeaderObj*>{}(obj.m_obj.get());
0146   }
0147 };
0148
0149
0150 #endif