openPMD::Container< T, T_key, T_container > Class Template Reference

Map-like container that enforces openPMD requirements and handles IO. More...

#include <Container.hpp>

Inheritance diagram for openPMD::Container< T, T_key, T_container >:

Public Types
using	key_type = typename InternalContainer::key_type
using	mapped_type = typename InternalContainer::mapped_type
using	value_type = typename InternalContainer::value_type
using	size_type = typename InternalContainer::size_type
using	difference_type = typename InternalContainer::difference_type
using	allocator_type = typename InternalContainer::allocator_type
using	reference = typename InternalContainer::reference
using	const_reference = typename InternalContainer::const_reference
using	pointer = typename InternalContainer::pointer
using	const_pointer = typename InternalContainer::const_pointer
using	iterator = typename InternalContainer::iterator
using	const_iterator = typename InternalContainer::const_iterator
using	reverse_iterator = typename InternalContainer::reverse_iterator
using	const_reverse_iterator

Public Member Functions
iterator	begin () noexcept
const_iterator	begin () const noexcept
const_iterator	cbegin () const noexcept
iterator	end () noexcept
const_iterator	end () const noexcept
const_iterator	cend () const noexcept
reverse_iterator	rbegin () noexcept
const_reverse_iterator	rbegin () const noexcept
const_reverse_iterator	crbegin () const noexcept
reverse_iterator	rend () noexcept
const_reverse_iterator	rend () const noexcept
const_reverse_iterator	crend () const noexcept
bool	empty () const noexcept
size_type	size () const noexcept
void	clear ()
	Remove all objects from the container and (if written) from disk.
std::pair< iterator, bool >	insert (value_type const &value)
std::pair< iterator, bool >	insert (value_type &&value)
iterator	insert (const_iterator hint, value_type const &value)
iterator	insert (const_iterator hint, value_type &&value)
template<class InputIt>
void	insert (InputIt first, InputIt last)
void	insert (std::initializer_list< value_type > ilist)
void	swap (Container &other)
mapped_type &	at (key_type const &key)
mapped_type const &	at (key_type const &key) const
mapped_type &	operator[] (key_type const &key)
	Access the value that is mapped to a key equivalent to key, creating it if such key does not exist already.
mapped_type &	operator[] (key_type &&key)
	Access the value that is mapped to a key equivalent to key, creating it if such key does not exist already.
iterator	find (key_type const &key)
const_iterator	find (key_type const &key) const
size_type	count (key_type const &key) const
	This returns either 1 if the key is found in the container of 0 if not.
bool	contains (key_type const &key) const
	Checks if there is an element with a key equivalent to an exiting key in the container.
size_type	erase (key_type const &key)
	Remove a single element from the container and (if written) from disk.
iterator	erase (iterator res)
template<class... Args>
auto	emplace (Args &&...args) -> decltype(InternalContainer().emplace(std::forward< Args >(args)...))
	Container (Container const &other)
	Container (Container &&other) noexcept
Container &	operator= (Container const &other)
Container &	operator= (Container &&other) noexcept
Public Member Functions inherited from openPMD::Attributable
	Attributable (NoInit) noexcept
Attribute	getAttribute (std::string const &key) const
	Retrieve value of Attribute stored with provided key.
bool	deleteAttribute (std::string const &key)
	Remove Attribute of provided value both logically and physically.
std::vector< std::string >	attributes () const
	List all currently stored Attributes' keys.
size_t	numAttributes () const
	Count all currently stored Attributes.
bool	containsAttribute (std::string const &key) const
	Check whether am Attribute with a given key exists.
std::string	comment () const
	Retrieve a user-supplied comment associated with the object.
Attributable &	setComment (std::string const &comment)
	Populate Attribute corresponding to a comment with the user-supplied comment.
void	seriesFlush (std::string backendConfig="{}")
	Flush the corresponding Series object.
void	iterationFlush (std::string backendConfig="{}")
	Flush the containing Iteration.
MyPath	myPath () const
	The path to this object within its containing Series.
void	touch ()
	Sets the object dirty to make internal procedures think it has been modified.
OpenpmdStandard	openPMDStandard () const
template<typename T>
bool	setAttribute (std::string const &key, T value)
	Populate Attribute of provided name with provided value.
bool	setAttribute (std::string const &key, char const value[])

Protected Types
using	ContainerData = internal::ContainerData<T, T_key, T_container>
using	InternalContainer = T_container
Protected Types inherited from openPMD::Attributable
enum	ReadMode { IgnoreExisting , OverrideExisting , FullyReread }
enum class	EnqueueAsynchronously : bool { Yes , No }
using	Data_t = internal::AttributableData

Protected Member Functions
void	setData (std::shared_ptr< ContainerData > containerData)
InternalContainer const &	container () const
InternalContainer &	container ()
void	clear_unchecked ()
virtual void	flush (std::string const &path, internal::FlushParams const &flushParams)
	Container (NoInit)
Protected Member Functions inherited from openPMD::Attributable
Series	retrieveSeries () const
template<bool flush_entire_series>
void	seriesFlush_impl (internal::FlushParams const &)
void	flushAttributes (internal::FlushParams const &)
void	readAttributes (ReadMode)
template<typename T>
T	readFloatingpoint (std::string const &key) const
	Retrieve the value of a floating point Attribute of user-defined precision with ensured type-safety.
template<typename T>
std::vector< T >	readVectorFloatingpoint (std::string const &key) const
	Retrieve a vector of values of a floating point Attributes of user-defined precision with ensured type-safety.
AbstractIOHandler *	IOHandler ()
AbstractIOHandler const *	IOHandler () const
Writable *&	parent ()
Writable const *	parent () const
Writable &	writable ()
Writable const &	writable () const
void	setData (std::shared_ptr< internal::AttributableData > attri)
internal::SharedAttributableData &	get ()
internal::SharedAttributableData const &	get () const
bool	dirty () const
bool	dirtyRecursive () const
	O(1).
void	setDirty (bool dirty_in)
void	setDirtyRecursive (bool dirty_in)
bool	written () const
void	setWritten (bool val, EnqueueAsynchronously)
auto	containingIteration () const -> std::pair< std::optional< internal::IterationData const * >, internal::SeriesData const * >
	Returns the corresponding Iteration.
auto	containingIteration () -> std::pair< std::optional< internal::IterationData * >, internal::SeriesData * >

Protected Attributes
std::shared_ptr< ContainerData >	m_containerData
Protected Attributes inherited from openPMD::Attributable
std::shared_ptr< Data_t >	m_attri

Friends
class	Iteration
class	ParticleSpecies
class	ParticlePatches
class	internal::SeriesData
class	Series
template<typename>
class	internal::EraseStaleEntries
class	StatefulIterator

Detailed Description

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>
class openPMD::Container< T, T_key, T_container >

Map-like container that enforces openPMD requirements and handles IO.

See also

http://en.cppreference.com/w/cpp/container/map

Template Parameters

T	Type of objects stored
T_key	Key type to look elements up by
T_container	Type of container used for internal storage (must supply the same type traits and interface as std::map)

Member Typedef Documentation

const_reverse_iterator

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

using openPMD::Container< T, T_key, T_container >::const_reverse_iterator

Initial value:

 
        typename InternalContainer::const_reverse_iterator

Member Function Documentation

clear()

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

void openPMD::Container< T, T_key, T_container >::clear

(

)

Remove all objects from the container and (if written) from disk.

Note

Calling this operation on any container in a Series with Access::READ_ONLY will throw an exception.

Exceptions

std::runtime_error

contains()

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

bool openPMD::Container< T, T_key, T_container >::contains

(

key_type const &

key

)

const

Checks if there is an element with a key equivalent to an exiting key in the container.

Parameters

key	key value of the element to search for

Returns

true of key is found, else false

count()

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

size_type openPMD::Container< T, T_key, T_container >::count

(

key_type const &

key

)

const

This returns either 1 if the key is found in the container of 0 if not.

Parameters

key	key value of the element to count

Returns

since keys are unique in this container, returns 0 or 1

emplace()

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

template<class... Args>

auto openPMD::Container< T, T_key, T_container >::emplace ( Args &&... args ) -> decltype(InternalContainer().emplace(std::forward<Args>(args)...))

inline

Todo

add also:

erase() [1/2]

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

iterator openPMD::Container< T, T_key, T_container >::erase

(

iterator

res

)

Todo

why does const_iterator not work compile with pybind11?

erase() [2/2]

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

size_type openPMD::Container< T, T_key, T_container >::erase

(

key_type const &

key

)

Remove a single element from the container and (if written) from disk.

Note

Calling this operation on any container in a Series with Access::READ_ONLY will throw an exception.

Exceptions

std::runtime_error

Parameters

key	Key of the element to remove.

Returns

Number of elements removed (either 0 or 1).

operator[]() [1/2]

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

mapped_type & openPMD::Container< T, T_key, T_container >::operator[]

(

key_type &&

key

)

Access the value that is mapped to a key equivalent to key, creating it if such key does not exist already.

Parameters

key	Key of the element to find (rvalue).

Returns

Reference to the mapped value of the new element if no element with key key existed. Otherwise a reference to the mapped value of the existing element whose key is equivalent to key.

Exceptions

std::out_of_range

error if in READ_ONLY mode and key does not exist, otherwise key will be created

operator[]() [2/2]

template<typename T, typename T_key = std::string, typename T_container = std::map<T_key, T>>

mapped_type & openPMD::Container< T, T_key, T_container >::operator[]

(

key_type const &

key

)

Access the value that is mapped to a key equivalent to key, creating it if such key does not exist already.

Parameters

key	Key of the element to find (lvalue).

Returns

Reference to the mapped value of the new element if no element with key key existed. Otherwise a reference to the mapped value of the existing element whose key is equivalent to key.

Exceptions

std::out_of_range

error if in READ_ONLY mode and key does not exist, otherwise key will be created

---

The documentation for this class was generated from the following file:

• /tmp/tmp.NhLRcLhrNZ/openPMD-api/include/openPMD/backend/Container.hpp