include/edm4hep/CalorimeterHitCollection.h

0001 // AUTOMATICALLY GENERATED FILE - DO NOT EDIT
0002
0003 #ifndef EDM4HEP_CalorimeterHitCollection_H
0004 #define EDM4HEP_CalorimeterHitCollection_H
0005
0006 // datamodel specific includes
0007 #include "edm4hep/CalorimeterHit.h"
0008 #include "edm4hep/CalorimeterHitCollectionData.h"
0009 #include "edm4hep/CalorimeterHitObj.h"
0010 #include "edm4hep/MutableCalorimeterHit.h"
0011
0012 // podio specific includes
0013 #include "podio/CollectionBase.h"
0014 #include "podio/ICollectionProvider.h"
0015 #include "podio/detail/Pythonizations.h"
0016 #include "podio/utilities/TypeHelpers.h"
0017
0018 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
0019 #include "nlohmann/json_fwd.hpp"
0020 #endif
0021
0022 #include <algorithm>
0023 #include <cstddef>
0024 #include <memory>
0025 #include <mutex>
0026 #include <ostream>
0027 #include <string_view>
0028 #include <vector>
0029
0030 namespace podio {
0031 struct RelationNames;
0032 }
0033
0034 namespace edm4hep {
0035
0036 class CalorimeterHitCollectionIterator {
0037 public:
0038   using value_type = CalorimeterHit;
0039   using difference_type = ptrdiff_t;
0040   using reference = CalorimeterHit;
0041   using pointer = CalorimeterHit*;
0042   using iterator_category = std::input_iterator_tag;
0043   // `std::forward_iterator` is supported except that the pointers obtained with `operator->()`
0044   // remain valid as long as the iterator is valid, not as long as the range is valid.
0045   using iterator_concept = std::random_access_iterator_tag;
0046
0047   CalorimeterHitCollectionIterator(size_t index, const CalorimeterHitObjPointerContainer* collection)
0048       : m_index(index), m_object(podio::utils::MaybeSharedPtr<CalorimeterHitObj>{nullptr}), m_collection(collection) {}
0049   CalorimeterHitCollectionIterator() = default;
0050
0051   CalorimeterHitCollectionIterator(const CalorimeterHitCollectionIterator&) = default;
0052   CalorimeterHitCollectionIterator(CalorimeterHitCollectionIterator&&) = default;
0053   CalorimeterHitCollectionIterator& operator=(const CalorimeterHitCollectionIterator&) = default;
0054   CalorimeterHitCollectionIterator& operator=(CalorimeterHitCollectionIterator&&) = default;
0055   ~CalorimeterHitCollectionIterator() = default;
0056
0057   constexpr auto operator<=>(const CalorimeterHitCollectionIterator& other) const { return m_index <=> other.m_index; }
0058
0059   constexpr bool operator==(const CalorimeterHitCollectionIterator& x) const { return m_index == x.m_index; }
0060
0061   reference operator*() const;
0062   pointer operator->();
0063   CalorimeterHitCollectionIterator& operator++();
0064   CalorimeterHitCollectionIterator operator++(int);
0065   CalorimeterHitCollectionIterator& operator--();
0066   CalorimeterHitCollectionIterator operator--(int);
0067   CalorimeterHitCollectionIterator& operator+=(difference_type n);
0068   CalorimeterHitCollectionIterator operator+(difference_type n) const;
0069   friend CalorimeterHitCollectionIterator operator+(difference_type n, const CalorimeterHitCollectionIterator& it);
0070   CalorimeterHitCollectionIterator& operator-=(difference_type n);
0071   CalorimeterHitCollectionIterator operator-(difference_type n) const;
0072   reference operator[](difference_type n) const;
0073   difference_type operator-(const CalorimeterHitCollectionIterator& other) const;
0074
0075 private:
0076   size_t m_index{0};
0077   CalorimeterHit m_object{podio::utils::MaybeSharedPtr<CalorimeterHitObj>{nullptr}};
0078   const CalorimeterHitObjPointerContainer* m_collection{nullptr};
0079 };
0080
0081 class CalorimeterHitMutableCollectionIterator {
0082 public:
0083   using value_type = CalorimeterHit;
0084   using difference_type = ptrdiff_t;
0085   using reference = MutableCalorimeterHit;
0086   using pointer = MutableCalorimeterHit*;
0087   using iterator_category = std::input_iterator_tag;
0088   // `std::forward_iterator` is supported except that the pointers obtained with `operator->()`
0089   // remain valid as long as the iterator is valid, not as long as the range is valid.
0090   using iterator_concept = std::random_access_iterator_tag;
0091
0092   CalorimeterHitMutableCollectionIterator(size_t index, const CalorimeterHitObjPointerContainer* collection)
0093       : m_index(index), m_object(podio::utils::MaybeSharedPtr<CalorimeterHitObj>{nullptr}), m_collection(collection) {}
0094   CalorimeterHitMutableCollectionIterator() = default;
0095
0096   CalorimeterHitMutableCollectionIterator(const CalorimeterHitMutableCollectionIterator&) = default;
0097   CalorimeterHitMutableCollectionIterator(CalorimeterHitMutableCollectionIterator&&) = default;
0098   CalorimeterHitMutableCollectionIterator& operator=(const CalorimeterHitMutableCollectionIterator&) = default;
0099   CalorimeterHitMutableCollectionIterator& operator=(CalorimeterHitMutableCollectionIterator&&) = default;
0100   ~CalorimeterHitMutableCollectionIterator() = default;
0101
0102   constexpr auto operator<=>(const CalorimeterHitMutableCollectionIterator& other) const {
0103     return m_index <=> other.m_index;
0104   }
0105
0106   constexpr bool operator==(const CalorimeterHitMutableCollectionIterator& x) const { return m_index == x.m_index; }
0107
0108   reference operator*() const;
0109   pointer operator->();
0110   CalorimeterHitMutableCollectionIterator& operator++();
0111   CalorimeterHitMutableCollectionIterator operator++(int);
0112   CalorimeterHitMutableCollectionIterator& operator--();
0113   CalorimeterHitMutableCollectionIterator operator--(int);
0114   CalorimeterHitMutableCollectionIterator& operator+=(difference_type n);
0115   CalorimeterHitMutableCollectionIterator operator+(difference_type n) const;
0116   friend CalorimeterHitMutableCollectionIterator operator+(difference_type n,
0117                                                            const CalorimeterHitMutableCollectionIterator& it);
0118   CalorimeterHitMutableCollectionIterator& operator-=(difference_type n);
0119   CalorimeterHitMutableCollectionIterator operator-(difference_type n) const;
0120   reference operator[](difference_type n) const;
0121   difference_type operator-(const CalorimeterHitMutableCollectionIterator& other) const;
0122
0123 private:
0124   size_t m_index{0};
0125   MutableCalorimeterHit m_object{podio::utils::MaybeSharedPtr<CalorimeterHitObj>{nullptr}};
0126   const CalorimeterHitObjPointerContainer* m_collection{nullptr};
0127 };
0128
0129 /**
0130 A Collection is identified by an ID.
0131 */
0132 class CalorimeterHitCollection : public podio::CollectionBase {
0133 public:
0134   using value_type = CalorimeterHit;
0135   using mutable_type = MutableCalorimeterHit;
0136   using const_iterator = CalorimeterHitCollectionIterator;
0137   using iterator = CalorimeterHitMutableCollectionIterator;
0138   using difference_type = ptrdiff_t;
0139   using size_type = size_t;
0140   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
0141   using reverse_iterator = std::reverse_iterator<iterator>;
0142
0143   CalorimeterHitCollection() = default;
0144   CalorimeterHitCollection(CalorimeterHitCollectionData&& data, bool isSubsetColl);
0145   // This is a move-only type
0146   CalorimeterHitCollection(const CalorimeterHitCollection&) = delete;
0147   CalorimeterHitCollection& operator=(const CalorimeterHitCollection&) = delete;
0148   CalorimeterHitCollection(CalorimeterHitCollection&&) = default;
0149   CalorimeterHitCollection& operator=(CalorimeterHitCollection&&) = default;
0150
0151   ~CalorimeterHitCollection() override;
0152 #if defined(__cpp_lib_containers_ranges)
0153   template <podio::detail::RangeConvertibleTo<value_type> R>
0154   CalorimeterHitCollection(std::from_range_t, R&& range);
0155 #endif
0156
0157   /// Construct a CalorimeterHit collection from a range of mutable or
0158   /// immutable handles
0159   template <podio::detail::RangeConvertibleTo<value_type> R>
0160   static CalorimeterHitCollection from(R&& range);
0161
0162   constexpr static std::string_view typeName = "edm4hep::CalorimeterHitCollection";
0163   constexpr static std::string_view valueTypeName = "edm4hep::CalorimeterHit";
0164   constexpr static std::string_view dataTypeName = "edm4hep::CalorimeterHitData";
0165
0166   void clear() final;
0167
0168   /// Cppyy protocol to setup the pythonizations for this class. Not to be called directly.
0169   static void __cppyy_pythonize__(PyObject* klass, const std::string& name) {
0170     podio::detail::pythonizations::pythonize_subscript(klass, name);
0171   }
0172
0173   /// Print this collection to the passed stream
0174   void print(std::ostream& os = std::cout, bool flush = true) const final;
0175
0176   /// Append a new object to the collection, and return this object.
0177   MutableCalorimeterHit create();
0178
0179   /// Append a new object to the collection, and return this object.
0180   /// Initialized with the parameters given
0181   template <typename... Args>
0182   MutableCalorimeterHit create(Args&&... args);
0183
0184   /// number of elements in the collection
0185   std::size_t size() const final;
0186
0187   /// maximal number of elements in the collection
0188   std::size_t max_size() const final;
0189
0190   /// Is the collection empty
0191   bool empty() const final;
0192
0193   /// fully qualified type name
0194   const std::string_view getTypeName() const final { return typeName; }
0195   /// fully qualified type name of elements - with namespace
0196   const std::string_view getValueTypeName() const final { return valueTypeName; }
0197   /// fully qualified type name of stored POD elements - with namespace
0198   const std::string_view getDataTypeName() const final { return dataTypeName; }
0199   /// schema version
0200   podio::SchemaVersionT getSchemaVersion() const final;
0201
0202   bool isSubsetCollection() const final { return m_isSubsetColl; }
0203
0204   void setSubsetCollection(bool setSubset = true) final;
0205
0206   /// Returns the const object of given index
0207   CalorimeterHit operator[](std::size_t index) const;
0208   /// Returns the object of a given index
0209   MutableCalorimeterHit operator[](std::size_t index);
0210   /// Returns the const object of given index
0211   CalorimeterHit at(std::size_t index) const;
0212   /// Returns the object of given index
0213   MutableCalorimeterHit at(std::size_t index);
0214
0215   /// Append object to the collection
0216   void push_back(const MutableCalorimeterHit& object);
0217   /// Append an object to the (subset) collection
0218   void push_back(const CalorimeterHit& object);
0219
0220   void prepareForWrite() const final;
0221   void prepareAfterRead() final;
0222   bool setReferences(const podio::ICollectionProvider* collectionProvider) final;
0223
0224   /// Get the collection buffers for this collection
0225   podio::CollectionWriteBuffers getBuffers() final;
0226
0227   void setID(uint32_t ID) final {
0228     m_collectionID = ID;
0229     if (!m_isSubsetColl) {
0230       std::for_each(m_storage.entries.begin(), m_storage.entries.end(),
0231                     [ID](CalorimeterHitObj* obj) { obj->id = {obj->id.index, static_cast<uint32_t>(ID)}; });
0232     }
0233   }
0234
0235   uint32_t getID() const final { return m_collectionID; }
0236
0237   /// check if the collection has a valid ID
0238   bool hasID() const final {
0239     return getID() != static_cast<uint32_t>(podio::ObjectID::untracked) &&
0240            getID() != static_cast<uint32_t>(podio::ObjectID::invalid);
0241   }
0242
0243   [[deprecated("isValid will be removed, use hasID() if you want to check if it has an ID, otherwise assume the "
0244                "collection is valid")]] bool
0245   isValid() const final {
0246     return hasID();
0247   }
0248
0249   size_t getDatamodelRegistryIndex() const final;
0250
0251   // support for the iterator protocol
0252   iterator begin() { return iterator(0, &m_storage.entries); }
0253   const_iterator begin() const { return const_iterator(0, &m_storage.entries); }
0254   const_iterator cbegin() const { return begin(); }
0255   iterator end() { return iterator(m_storage.entries.size(), &m_storage.entries); }
0256   const_iterator end() const { return const_iterator(m_storage.entries.size(), &m_storage.entries); }
0257   const_iterator cend() const { return end(); }
0258   // reverse iterators
0259   reverse_iterator rbegin() { return reverse_iterator(end()); }
0260   const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
0261   const_reverse_iterator crbegin() const { return rbegin(); }
0262   reverse_iterator rend() { return reverse_iterator(begin()); }
0263   const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
0264   const_reverse_iterator crend() const { return rend(); }
0265
0266   std::vector<std::uint64_t> cellID(const size_t nElem = 0) const;
0267   std::vector<float> energy(const size_t nElem = 0) const;
0268   std::vector<float> energyError(const size_t nElem = 0) const;
0269   std::vector<float> time(const size_t nElem = 0) const;
0270   std::vector<edm4hep::Vector3f> position(const size_t nElem = 0) const;
0271   std::vector<std::int32_t> type(const size_t nElem = 0) const;
0272
0273 private:
0274   // For setReferences, we need to give our own CollectionData access to our
0275   // private entries. Otherwise we would need to expose a public member function
0276   // that gives access to the Obj* which is definitely not what we want
0277   friend class CalorimeterHitCollectionData;
0278
0279   mutable bool m_isPrepared{false};
0280   bool m_isSubsetColl{false};
0281   uint32_t m_collectionID{static_cast<uint32_t>(podio::ObjectID::untracked)};
0282   mutable std::unique_ptr<std::mutex> m_storageMtx{std::make_unique<std::mutex>()};
0283   mutable CalorimeterHitCollectionData m_storage{};
0284 };
0285
0286 std::ostream& operator<<(std::ostream& o, const CalorimeterHitCollection& v);
0287
0288 template <typename... Args>
0289 MutableCalorimeterHit CalorimeterHitCollection::create(Args&&... args) {
0290   if (m_isSubsetColl) {
0291     throw std::logic_error("Cannot create new elements on a subset collection");
0292   }
0293   auto obj = new CalorimeterHitObj({static_cast<int>(m_storage.entries.size()), m_collectionID},
0294                                    {std::forward<Args>(args)...});
0295   m_storage.entries.push_back(obj);
0296
0297   return MutableCalorimeterHit(podio::utils::MaybeSharedPtr(obj));
0298 }
0299
0300 #if defined(__cpp_lib_containers_ranges)
0301 template <podio::detail::RangeConvertibleTo<CalorimeterHitCollection::value_type> R>
0302 CalorimeterHitCollection::CalorimeterHitCollection(std::from_range_t, R&& range) : CalorimeterHitCollection() {
0303   setSubsetCollection(podio::detail::RangeOf<R, value_type>);
0304
0305   for (auto&& elem : range) {
0306     push_back(std::forward<decltype(elem)>(elem));
0307   }
0308 }
0309 #endif
0310
0311 template <podio::detail::RangeConvertibleTo<CalorimeterHitCollection::value_type> R>
0312 CalorimeterHitCollection CalorimeterHitCollection::from(R&& range) {
0313   CalorimeterHitCollection coll;
0314   if constexpr (podio::detail::RangeOf<R, value_type>) {
0315     coll.setSubsetCollection();
0316   }
0317
0318   for (auto&& elem : range) {
0319     coll.push_back(std::forward<decltype(elem)>(elem));
0320   }
0321
0322   return coll;
0323 }
0324
0325 #if defined(PODIO_JSON_OUTPUT) && !defined(__CLING__)
0326 void to_json(nlohmann::json& j, const CalorimeterHitCollection& collection);
0327 #endif
0328
0329 } // namespace edm4hep
0330
0331 // This is needed to avoid triggering opening every library in LD_LIBRARY_PATH
0332 // until it's fixed in ROOT. See https://github.com/root-project/root/issues/18489
0333 // and https://github.com/AIDASoft/podio/issues/770
0334 #if defined(__clang__)
0335 #pragma clang diagnostic push
0336 #pragma clang diagnostic ignored "-Wunknown-warning-option"
0337 #pragma clang diagnostic ignored "-Wdeprecated-redundant-constexpr-static-def"
0338 #pragma clang diagnostic ignored "-Wdeprecated"
0339 constexpr std::string_view edm4hep::CalorimeterHitCollection::typeName;
0340 constexpr std::string_view edm4hep::CalorimeterHitCollection::valueTypeName;
0341 constexpr std::string_view edm4hep::CalorimeterHitCollection::dataTypeName;
0342 #pragma clang diagnostic pop
0343 #elif defined(__GNUC__)
0344 #pragma GCC diagnostic push
0345 #pragma GCC diagnostic ignored "-Wdeprecated"
0346 constexpr std::string_view edm4hep::CalorimeterHitCollection::typeName;
0347 constexpr std::string_view edm4hep::CalorimeterHitCollection::valueTypeName;
0348 constexpr std::string_view edm4hep::CalorimeterHitCollection::dataTypeName;
0349 #pragma GCC diagnostic pop
0350 #endif
0351
0352 #endif