File Frame.h

namespace podio

Typedefs

template<typename T>
using EnableIfCollection = typename std::enable_if_t<isCollection<T>>

Alias template for enabling overloads only for Collections.

template<typename T>
using EnableIfCollectionRValue = typename std::enable_if_t<isCollection<T> && !std::is_lvalue_reference_v<T>>

Alias template for enabling overloads only for Collection r-values.

template<typename T>
using EnableIfRValue = typename std::enable_if_t<!std::is_lvalue_reference_v<T>>

Alias template for enabling overloads for r-values.

Functions

template<typename FrameDataT>
std::optional<podio::CollectionReadBuffers> unpack(FrameDataT *data, const std::string &name)

class Frame

#include <podio/Frame.h>

The Frame is a generalized (event) data container that aggregates all relevant data.

It is possible to store collections as well as parameters / meta data in a Frame and all I/O facilities of podio operate on Frames.

Public Functions

inline Frame()

Empty Frame constructor.

template<typename FrameDataT>
Frame(std::unique_ptr<FrameDataT>)

Frame constructor from (almost) arbitrary raw data.

Template Parameters:

FrameDataT – Arbitrary data container that provides access to the collection buffers as well as the metadata, when requested by the Frame. The unique_ptr has to be checked for validity before calling this construtor.

Throws:

std::invalid_argument – if the passed pointer is a nullptr.

template<typename FrameDataT, typename = EnableIfRValue<FrameDataT>>
Frame(FrameDataT&&)

Frame constructor from (almost) arbitrary raw data.

This r-value overload is mainly present for enabling the python bindings, where cppyy seems to strip the std::unique_ptr somewhere in the process

Template Parameters:

FrameDataT – Arbitrary data container that provides access to the collection buffers as well as the metadata, when requested by the Frame.

Frame(const Frame&) = delete

A Frame is move-only.

Frame &operator=(const Frame&) = delete

A Frame is move-only.

Frame(Frame&&) = default

Frame move constructor.

Frame &operator=(Frame&&) = default

Frame move assignment operator.

~Frame() = default

Frame destructor.

Note

Since the Frame owns all the collections that have been put into it, or that can be obtained from it, this invalidates all references to these collections.

template<typename CollT, typename = EnableIfCollection<CollT>>
const CollT &get(const std::string &name) const

Get a collection from the Frame by name.

Template Parameters:

CollT – The type of the desired collection

Parameters:

name – The name of the collection

Returns:

A const reference to the collection if it is available or to an empty (static) collection

inline const podio::CollectionBase *get(const std::string &name) const

Get a collection pointer from the Frame by name.

This is a type-erased version that is also used by the python bindings.

Returns:

A const pointer to a collection if it is available or a nullptr if it is not

template<typename CollT, typename = EnableIfCollectionRValue<CollT>>
const CollT &put(CollT &&coll, const std::string &name)

(Destructively) move a collection into the Frame and get a reference to the inserted collection back for further use.

The collection that is passed into the Frame has to be moved into it explicitly and the moved-from collection will be in the typical valid but undefined state in c++.

Template Parameters:

CollT – The type of the collection

Parameters:

• coll – An rvalue reference to the collection to put into the Frame.

• name – The name under which this collection should be stored in the Frame

Returns:

A const reference to the collection that has just been inserted

inline void put(std::unique_ptr<podio::CollectionBase> coll, const std::string &name)

(Destructively) move a collection into the Frame.

Parameters:

• coll – The collection that should be moved into the Frame

• name – The name under which this collection should be stored in the Frame

template<typename T, typename = podio::EnableIfValidGenericDataType<T>>
inline void putParameter(const std::string &key, T value)

Add a value to the parameters of the Frame (if the type is supported).

Template Parameters:

T – The type of the parameter. Has to be one of the types that is supported by GenericParameters

Parameters:

• key – The name under which this parameter should be stored

• value – The value of the parameter. A copy will be put into the Frame

inline void putParameter(const std::string &key, std::string value)

Add a string value to the parameters of the Frame.

This is a dedicated overload for enabling on-the-fly conversion from string literals.

Parameters:

• key – The name under which this parameter should be stored

• value – The value of the parameter. A copy will be put into the Frame

inline void putParameter(const std::string &key, std::vector<std::string> values)

Add a vector of strings value the parameters of the Frame.

This is a dedicated overload for enabling on-the-fly conversion from an initializer_list of string literals

Parameters:

• key – The name under which this parameter should be stored

• values – The values of the parameter. A copy will be put into the Frame

template<typename T, typename = std::enable_if_t<detail::isInTuple<T, SupportedGenericDataTypes>>>
inline void putParameter(const std::string &key, std::initializer_list<T> &&values)

Add a vector of values to the parameters of the Frame (if the type is supported).

This is a dedicated overload for enabling on-the-fly conversions of initializer_list of values

Template Parameters:

T – The type of the parameter. Has to be one of the types that is supported by GenericParameters

Parameters:

• key – The name under which this parameter should be stored

• values – The values of the parameter. A copy will be put into the Frame

template<typename T, typename = podio::EnableIfValidGenericDataType<T>>
inline auto getParameter(const std::string &key) const

Retrieve parameters via key from the internal store.

Template Parameters:

T – The desired type of the parameter (can also be std::vector<T>)

Parameters:

key – The key under which the value is stored

Returns:

An optional holding the value if it is present

inline const podio::GenericParameters &getParameters() const

Retrieve all parameters stored in this Frame.

This is mainly intended for I/O purposes and we encourage to use the Frame functionality of getParameter or getParameterKeys in general.

Returns:

The internally used GenericParameters

template<typename T, typename = podio::EnableIfValidGenericDataType<T>>
inline std::vector<std::string> getParameterKeys() const

Get the keys of all stored parameters for a given type.

Template Parameters:

T – The desired parameter type

Returns:

A vector of keys for this parameter type

inline std::vector<std::string> getAvailableCollections() const

Get all currently available collection names.

Returns:

The names of all collections, including those that might still need unpacking from the internal FrameData

inline std::optional<std::string> getName(const podio::CollectionBase &coll) const

Get the name of the passed collection.

Parameters:

coll – The collection for which the name should be obtained

Returns:

The name of the collection or an empty optional if this collection is not known to the Frame

inline std::optional<std::string> getName(const uint32_t collectionID) const

Get the name for the passed collectionID.

Parameters:

collectionID – The collection ID of the collection for which the name should be obtained

Returns:

The name of the collection or an empty optional if this collectionID is not known to the Frame

inline const podio::CollectionBase *getCollectionForWrite(const std::string &name) const

Get a collection for writing.

Note

This method is intended for I/O purposes only and should not be used in other code.

Returns:

The collection pointer in a prepared and “ready-to-write” state

inline podio::CollectionIDTable getCollectionIDTableForWrite() const

Get the internal CollectionIDTable for writing.

Note

This method is intended for I/O purposes only and should not be used in other code.

Returns:

A copy of the internal collection id table

Private Members

std::unique_ptr<FrameConcept> m_self

The internal concept pointer through which all the work is done.

struct FrameConcept

Internal abstract interface for the type-erased implementation of the Frame class.

Public Functions

virtual ~FrameConcept() = default

virtual const podio::CollectionBase *get(const std::string &name) const = 0

virtual const podio::CollectionBase *put(std::unique_ptr<podio::CollectionBase> coll, const std::string &name) = 0

virtual podio::GenericParameters &parameters() = 0

virtual const podio::GenericParameters &parameters() const = 0

virtual std::vector<std::string> availableCollections() const = 0

virtual podio::CollectionIDTable getIDTable() const = 0

template<typename FrameDataT>
struct FrameModel : public podio::Frame::FrameConcept, public podio::ICollectionProvider

The interface implementation of the abstract FrameConcept that is necessary for a type-erased implementation of the Frame class.

Public Functions

FrameModel(std::unique_ptr<FrameDataT> data)

~FrameModel() = default

FrameModel(const FrameModel&) = delete

FrameModel &operator=(const FrameModel&) = delete

FrameModel(FrameModel&&) = default

FrameModel &operator=(FrameModel&&) = default

const podio::CollectionBase *get(const std::string &name) const final

Try and get the collection from the internal storage and return a pointer to it if found.

Otherwise return a nullptr

const podio::CollectionBase *put(std::unique_ptr<CollectionBase> coll, const std::string &name) final

Try and place the collection into the internal storage and return a pointer to it.

If a collection already exists or insertion fails, return a nullptr

inline podio::GenericParameters &parameters() override

Get a reference to the internally used GenericParameters.

inline const podio::GenericParameters &parameters() const override

Get a const reference to the internally used GenericParameters.

bool get(uint32_t collectionID, podio::CollectionBase *&collection) const override

inline podio::CollectionIDTable getIDTable() const override

std::vector<std::string> availableCollections() const override

Private Types

using CollectionMapT = std::unordered_map<std::string, std::unique_ptr<podio::CollectionBase>>

Private Functions

podio::CollectionBase *doGet(const std::string &name, bool setReferences = true) const

Private Members

mutable CollectionMapT m_collections = {}

The internal map for storing unpacked collections.

mutable std::unique_ptr<std::mutex> m_mapMtx = {nullptr}

The mutex for guarding the internal collection map.

std::unique_ptr<FrameDataT> m_data = {nullptr}

The raw data read from file.

mutable std::unique_ptr<std::mutex> m_dataMtx = {nullptr}

The mutex for guarding the raw data.

podio::CollectionIDTable m_idTable = {}

The collection ID table.

std::unique_ptr<podio::GenericParameters> m_parameters = {nullptr}

The generic parameter store for this frame.

mutable std::set<uint32_t> m_retrievedIDs = {}

The IDs of the collections that we have already read (but not yet put into the map)