include/podio/CollectionBuffers.h

0001 #ifndef PODIO_COLLECTIONBUFFERS_H
0002 #define PODIO_COLLECTIONBUFFERS_H
0003
0004 #include "podio/ObjectID.h"
0005 #include "podio/SchemaEvolution.h"
0006
0007 #include <functional>
0008 #include <memory>
0009 #include <string>
0010 #include <string_view>
0011 #include <utility>
0012 #include <vector>
0013
0014 namespace podio {
0015
0016 class CollectionBase;
0017
0018 template <typename T>
0019 using UVecPtr = std::unique_ptr<std::vector<T>>;
0020
0021 using CollRefCollection = std::vector<UVecPtr<podio::ObjectID>>;
0022 using VectorMembersInfo = std::vector<std::pair<std::string, void*>>;
0023
0024 /// Struct bundling the buffers that represent a collection for writing.
0025 ///
0026 /// data is used by ROOT and holds the address of a unique_ptr.
0027 /// vecPtr holds the raw vector pointer, used by SIO and RNTuple.
0028 struct CollectionWriteBuffers {
0029   void* data{nullptr};
0030   void* vecPtr{nullptr};
0031   CollRefCollection* references{nullptr};
0032   VectorMembersInfo* vectorMembers{nullptr};
0033
0034   template <typename T>
0035   std::vector<T>* dataAsVector() {
0036     return static_cast<std::vector<T>*>(vecPtr);
0037   }
0038 };
0039
0040 struct CollectionReadBuffers {
0041   void* data{nullptr};
0042   CollRefCollection* references{nullptr};
0043   VectorMembersInfo* vectorMembers{nullptr};
0044   SchemaVersionT schemaVersion{0};
0045   std::string_view type{};
0046
0047   using CreateFuncT = std::function<std::unique_ptr<podio::CollectionBase>(podio::CollectionReadBuffers&&, bool)>;
0048
0049   using DeleteFuncT = std::function<void(CollectionReadBuffers&)>;
0050
0051   CollectionReadBuffers(void* d, CollRefCollection* ref, VectorMembersInfo* vec, SchemaVersionT version,
0052                         std::string_view typ, CreateFuncT&& createFunc, DeleteFuncT&& deleteFunc) :
0053       data(d),
0054       references(ref),
0055       vectorMembers(vec),
0056       schemaVersion(version),
0057       type(typ),
0058       createCollection(std::move(createFunc)),
0059       deleteBuffers(std::move(deleteFunc)) {
0060   }
0061
0062   CollectionReadBuffers() = default;
0063
0064   // Copying is not allowed since we own the buffers
0065   CollectionReadBuffers(const CollectionReadBuffers&) = delete;
0066   CollectionReadBuffers& operator=(const CollectionReadBuffers&) = delete;
0067
0068   CollectionReadBuffers(CollectionReadBuffers&& other) :
0069       data(other.data),
0070       references(other.references),
0071       vectorMembers(other.vectorMembers),
0072       schemaVersion(other.schemaVersion),
0073       type(other.type),
0074       createCollection(std::move(other.createCollection)),
0075       deleteBuffers(std::move(other.deleteBuffers)) {
0076     other.data = nullptr;
0077     other.references = nullptr;
0078     other.vectorMembers = nullptr;
0079     other.schemaVersion = 0;
0080     other.type = {};
0081   }
0082
0083   CollectionReadBuffers& operator=(CollectionReadBuffers&& other) {
0084     if (this != &other) {
0085       // Clean up our own buffers first
0086       if (deleteBuffers) {
0087         deleteBuffers(*this);
0088       }
0089       data = other.data;
0090       references = other.references;
0091       vectorMembers = other.vectorMembers;
0092       schemaVersion = other.schemaVersion;
0093       type = other.type;
0094       createCollection = std::move(other.createCollection);
0095       deleteBuffers = std::move(other.deleteBuffers);
0096
0097       other.data = nullptr;
0098       other.references = nullptr;
0099       other.vectorMembers = nullptr;
0100       other.schemaVersion = 0;
0101       other.type = {};
0102     }
0103     return *this;
0104   }
0105
0106   ~CollectionReadBuffers() {
0107     if (deleteBuffers) {
0108       deleteBuffers(*this);
0109     }
0110   }
0111
0112   CollectionReadBuffers(CollectionWriteBuffers buffers) :
0113       data(buffers.data), references(buffers.references), vectorMembers(buffers.vectorMembers) {
0114   }
0115
0116   template <typename DataT>
0117   std::vector<DataT>* dataAsVector() {
0118     return asVector<DataT>(data);
0119   }
0120
0121   template <typename T>
0122   static std::vector<T>* asVector(void* raw) {
0123     return static_cast<std::vector<T>*>(raw);
0124   }
0125
0126   CreateFuncT createCollection{};
0127
0128   // Type-erased deleter for the owned buffers. Set at generation time since
0129   // only the generated code knows the concrete types behind the void pointers
0130   DeleteFuncT deleteBuffers{};
0131 };
0132
0133 } // namespace podio
0134
0135 #endif // PODIO_COLLECTIONBUFFERS_H