Represents an EBML Master Element with on-disk, transactional child management. More...

#include <ebmlLazyLoad.h>

Inheritance diagram for ebml::ebmlLazyLoad:

Public Member Functions
const children_m &	seeksByOffset () const

const std::unordered_map< ebmlID_t, std::map< off_t, seekData_t * > > &	seeksByEBMLID () const

const std::unordered_map< ebmlID_t, std::unique_ptr< seekMapBase > > &	seeksByKey () const

ioBase &	file () const

readLock_t	getRLock () const

readLock_t	getRLock (const readLock_t &) const

writeLock_t	getWLock () const

writeLock_t	getWLock (const readLock_t &) const

writeLock_t	getWLock (const writeLock_t &) const

writeLock_t	getGlobalLock () const

off_t	endOfData () const

ebml::ptr< ebmlElement >	get (off_t)

ebml::ptr< ebmlElement >	get (off_t, const readLock_t &)

ebml::ptr< ebmlElement >	get (off_t, const writeLock_t &)

template<typename T >
ebml::ptr< T >	get (off_t)

template<typename T >
ebml::ptr< T >	get (off_t, const readLock_t &)

template<typename T >
ebml::ptr< T >	get (off_t, const writeLock_t &)

ebml::ptr< ebmlElement >	get (ebmlID_t, size_t)

ebml::ptr< ebmlElement >	get (ebmlID_t, size_t, const readLock_t &)

ebml::ptr< ebmlElement >	get (ebmlID_t, size_t, const writeLock_t &)

template<typename T >
ebml::ptr< T >	get (ebmlID_t, size_t)

template<typename T >
ebml::ptr< T >	get (ebmlID_t, size_t, const readLock_t &)

template<typename T >
ebml::ptr< T >	get (ebmlID_t, size_t, const writeLock_t &)

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > >	getByKey (ebmlID_t, const K &)
	Gets a child element based on a user-defined key. More...

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > >	getByKey (ebmlID_t, const K &, const readLock_t &)

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > >	getByKey (ebmlID_t, const K &, const writeLock_t &)

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	getByKey (ebmlID_t, const K &)

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	getByKey (ebmlID_t, const K &, const readLock_t &)

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	getByKey (ebmlID_t, const K &, const writeLock_t &)

ebml::ptr< const ebmlElement >	cget (off_t) const

ebml::ptr< const ebmlElement >	cget (off_t, const readLock_t &) const

ebml::ptr< const ebmlElement >	cget (off_t, const writeLock_t &) const

template<typename T >
ebml::ptr< T >	cget (off_t) const

template<typename T >
ebml::ptr< T >	cget (off_t, const readLock_t &) const

template<typename T >
ebml::ptr< T >	cget (off_t, const writeLock_t &) const

ebml::ptr< const ebmlElement >	cget (ebmlID_t, size_t) const

ebml::ptr< const ebmlElement >	cget (ebmlID_t, size_t, const readLock_t &) const

ebml::ptr< const ebmlElement >	cget (ebmlID_t, size_t, const writeLock_t &) const

template<typename T >
ebml::ptr< T >	cget (ebmlID_t, size_t) const

template<typename T >
ebml::ptr< T >	cget (ebmlID_t, size_t, const readLock_t &) const

template<typename T >
ebml::ptr< T >	cget (ebmlID_t, size_t, const writeLock_t &) const

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< const ebmlElement > >	cgetByKey (ebmlID_t, const K &) const

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< const ebmlElement > >	cgetByKey (ebmlID_t, const K &, const readLock_t &) const

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< const ebmlElement > >	cgetByKey (ebmlID_t, const K &, const writeLock_t &) const

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	cgetByKey (ebmlID_t, const K &) const

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	cgetByKey (ebmlID_t, const K &, const readLock_t &) const

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > >	cgetByKey (ebmlID_t, const K &, const writeLock_t &) const

status_t< prepared_insert_t >	canInsert (off_t, sizetree_t &&, const writeLock_t &)

status_t< prepared_multiinsert_t >	canInsert (off_t, std::vector< sizetree_t > &&, const writeLock_t &)

status_t< prepared_insert_t >	canInsert (off_t, const ebml::ptr< ebmlElement > &, const writeLock_t &)

seekData_t *	insert (off_t, const ebml::ptr< ebmlElement > &)

seekData_t *	insert (off_t, const ebml::ptr< ebmlElement > &, const readLock_t &)

seekData_t *	insert (off_t, const ebml::ptr< ebmlElement > &, const writeLock_t &)

seekData_t *	insert (off_t, const ebml::ptr< ebmlElement > &, const writeLock_t &, const status_t< prepared_insert_t > &)

status_t< prepared_multiinsert_t >	canInsert (off_t, const ebmlElement_l &, const writeLock_t &)

std::vector< seekData_t * >	insert (off_t, const ebmlElement_l &)

std::vector< seekData_t * >	insert (off_t, const ebmlElement_l &, const readLock_t &)

std::vector< seekData_t * >	insert (off_t, const ebmlElement_l &, const writeLock_t &)

std::vector< seekData_t * >	insert (off_t, const ebmlElement_l &, const writeLock_t &, const status_t< prepared_multiinsert_t > &)

status_t< prepared_insert_t >	canInsert (off_t, const std::string &, const writeLock_t &)

seekData_t *	insert (off_t, const std::string &)

seekData_t *	insert (off_t, const std::string &, const readLock_t &)

seekData_t *	insert (off_t, const std::string &, const writeLock_t &)

seekData_t *	insert (off_t, const std::string &, const writeLock_t &, const status_t< prepared_insert_t > &)

status_t< prepared_insert_t >	canInsert (off_t, const char *, const writeLock_t &)

seekData_t *	insert (off_t, const char *data)

seekData_t *	insert (off_t, const char *data, const readLock_t &)

seekData_t *	insert (off_t, const char *data, const writeLock_t &)

seekData_t *	insert (off_t, const char *data, const writeLock_t &, const status_t< prepared_insert_t > &)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t, const T &cls, Args &&...)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t, const readLock_t &, const T &cls, Args &&...)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t, const writeLock_t &, const T &cls, Args &&...)
	Inserts a new child element at a specified offset. More...

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t, const writeLock_t &, const status_t< prepared_insert_t > &, const T &cls, Args &&...)

status_t< prepared_move_t >	canMove (off_t, off_t, const writeLock_t &)

void	move (off_t, off_t)

void	move (off_t, off_t, const readLock_t &)

void	move (off_t, off_t, const writeLock_t &)

void	move (off_t, off_t, const writeLock_t &, const status_t< prepared_move_t > &)

bool	sizeSupported (size_t size, const writeLock_t &)

status_t< prepared_resize_t >	canResize (size_t, const writeLock_t &)

void	resize (size_t size)

void	resize (size_t size, const readLock_t &)

void	resize (size_t size, const writeLock_t &)

void	resize (size_t size, const writeLock_t &, const status_t< prepared_resize_t > &)

status_t< prepared_remove_t >	canRemove (off_t, const writeLock_t &)

void	remove (off_t offset)

void	remove (off_t offset, const readLock_t &)

void	remove (off_t offset, const writeLock_t &)

void	remove (off_t offset, const status_t< prepared_remove_t > &, const writeLock_t &)

off_t	findBoundary (off_t offset)

off_t	findBoundary (off_t offset, const readLock_t &)

off_t	findBoundary (off_t offset, const writeLock_t &)

off_t	rfindBoundary (off_t offset)

off_t	rfindBoundary (off_t offset, const readLock_t &)

off_t	rfindBoundary (off_t offset, const writeLock_t &)

seekData_t *	firstChild ()

seekData_t *	firstChild (const readLock_t &)

seekData_t *	firstChild (const writeLock_t &)

seekData_t *	lastChild ()

seekData_t *	lastChild (const readLock_t &)

seekData_t *	lastChild (const writeLock_t &)

seekData_t *	nextChild (off_t offset)

seekData_t *	nextChild (off_t offset, const readLock_t &)

seekData_t *	nextChild (off_t offset, const writeLock_t &)

seekData_t *	prevChild (off_t offset)

seekData_t *	prevChild (off_t offset, const readLock_t &)

seekData_t *	prevChild (off_t offset, const writeLock_t &)

std::wstring	minirepr () const override

size_t	dataSize () const override

seekData_t *	_firstChildSeek () const

seekData_t *	_lastChildSeek () const

seekData_t *	_prevChildSeek (off_t offset, bool strict=true) const

seekData_t *	_nextChildSeek (off_t offset, bool strict=true) const

std::pair< children_m::iterator, children_m::iterator >	_find (off_t offset, bool left=true)

children_m::iterator	_findNext (off_t offset, bool strict=true)

children_m::iterator	_findPrev (off_t offset, bool strict=true)

off_t	_findFree (off_t offset, size_t size)

off_t	_rfindFree (off_t offset, size_t size)

prepared_resize_t	_canResizeChild (off_t, size_t size)

prepared_resize_t	_canResizeChild (const seekData_t &, size_t size)

const children_m &	seeksByOffset () const

const std::unordered_map< ebmlID_t, std::map< off_t, seekData_t * > > &	seeksByEBMLID () const

const std::unordered_map< ebmlID_t, std::unique_ptr< seekMapBase > > &	seeksByKey () const

ioBase &	file () const

off_t	endOfData () const

ebmlElement_sp	get (off_t)

template<typename T >
ebml::ptr< T >	get (off_t)

ebmlElement_sp	get (ebmlID_t, size_t)

template<typename T >
ebml::ptr< T >	get (ebmlID_t, size_t)

c_ebmlElement_sp	cget (off_t) const

template<typename T >
ebml::ptr< T >	cget (off_t) const

c_ebmlElement_sp	cget (ebmlID_t, size_t) const

template<typename T >
ebml::ptr< T >	cget (ebmlID_t, size_t) const

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
ebmlElement_sp	getByKey (ebmlID_t, const K &)

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, T >::value, ebml::ptr< T > >	getByKey (ebmlID_t, const K &)

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
c_ebmlElement_sp	cgetByKey (ebmlID_t, const K &) const

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< const ebmlElement, T >::value &&std::is_base_of< const ebmlElement, T >::value, ebml::ptr< T > >	cgetByKey (ebmlID_t, const K &) const

seekData_t *	insert (off_t offset, const ebmlElement_sp &child)

std::vector< seekData_t * >	insert (off_t offset, const ebmlElement_l &children)

seekData_t *	insert (off_t offset, const std::string &data)

std::vector< seekData_t * >	insert (off_t offset, const std::vector< std::string > &data)

seekData_t *	insert (off_t offset, const char *data)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementClass, T >::value, std::pair< ebmlElement_sp, seekData_t * > >	insert (off_t offset, const T &cls, Args...)

template<typename T >
std::enable_if_t<!std::is_base_of< ebmlLazyLoad, T >::value &&std::is_base_of< ebmlElement, T >::value, seekData_t * >	insert (off_t offset, const ebml::ptr< T > &child)

void	move (off_t src_offset, off_t dest_offset)

void	resize (size_t size)

void	remove (const ebmlElement_sp &child)

void	remove (off_t offset)

off_t	findBoundary (off_t offset)

off_t	rfindBoundary (off_t offset)

seekData_t *	firstChild ()

seekData_t *	lastChild ()

seekData_t *	nextChild (off_t offset)

seekData_t *	prevChild (off_t offset)

off_t	findFree (off_t offset, size_t size)

off_t	rfindFree (off_t offset, size_t size)

status_t< prepared_insert_t >	canInsert (off_t offset, size_t size)

status_t< prepared_insert_t >	canInsert (off_t offset, const ebmlElement_sp &)

status_t< prepared_insert_t >	canInsert (off_t offset, const ebmlElement_l &)

status_t< prepared_insert_t >	canMove (off_t src_offset, off_t dst_offset)

status_t< prepared_insert_t >	canResize (size_t size)

status_t< prepared_insert_t >	canResizeChild (const seekData_t &, size_t size)

status_t< prepared_insert_t >	canResizeChild (ebmlElement *child, size_t size)

status_t< prepared_insert_t >	canInsertRange (off_t offset, size_t size)

status_t< prepared_insert_t >	insertRange (off_t offset, size_t size)

status_t< prepared_insert_t >	canCollapseRange (off_t offset, size_t size)

status_t< prepared_insert_t >	collapseRange (off_t offset, size_t size)

status_t< prepared_insert_t >	canPunchHole (off_t offset, size_t size)

status_t< prepared_insert_t >	punchHole (off_t offset, size_t size)

std::wstring	minirepr () const override

size_t	dataSize () const override

bool	sizeSupported (size_t size)

ebmlElement_sp	_get (off_t)

template<typename T >
ebml::ptr< T >	_get (off_t)

c_ebmlElement_sp	_cget (off_t) const

template<typename T >
ebml::ptr< T >	_cget (off_t) const

ebmlElement_sp	_get (ebmlID_t, size_t)

template<typename T >
ebml::ptr< T >	_get (ebmlID_t, size_t)

c_ebmlElement_sp	_cget (ebmlID_t, size_t) const

template<typename T >
ebml::ptr< T >	_cget (ebmlID_t, size_t) const

template<typename T >
ebml::ptr< T >	_cget (ebmlID_t, size_t)

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
ebmlElement_sp	_getByKey (ebmlID_t, const K &)

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, T >::value, ebml::ptr< T > >	_getByKey (ebmlID_t, const K &)

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
c_ebmlElement_sp	_cgetByKey (ebmlID_t, const K &) const

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>
std::enable_if_t<!std::is_same< const ebmlElement, T >::value &&std::is_base_of< const ebmlElement, T >::value, ebml::ptr< T > >	_cgetByKey (ebmlID_t, const K &) const

off_t	_findBoundary (off_t offset)

off_t	_rfindBoundary (off_t offset)

seekData_t *	_firstChildSeek () const

seekData_t *	_lastChildSeek () const

seekData_t *	_prevChildSeek (off_t offset, bool strict=true) const

seekData_t *	_nextChildSeek (off_t offset, bool strict=true) const

std::pair< children_m::iterator, children_m::iterator >	_find (off_t offset, bool left=true)

children_m::iterator	_findNext (off_t offset, bool strict=true)

children_m::iterator	_findPrev (off_t offset, bool strict=true)

off_t	_findFree (off_t offset, size_t size)

off_t	_rfindFree (off_t offset, size_t size)

status_t< prepared_insert_t >	_canInsert (off_t offset, size_t size)

status_t< prepared_insert_t >	_canInsert (off_t offset, const ebmlElement_sp &)

status_t< prepared_insert_t >	_canInsert (off_t offset, const ebmlElement_l &)

status_t< prepared_insert_t >	_canInsert (off_t offset, const std::string &data)

status_t< prepared_insert_t >	_canInsert (off_t offset, const char *data)

prepared_move_t	_canMove (off_t src_offset, off_t dst_offset)

prepared_resize_t	_canResize (size_t size)

prepared_resize_t	_canResizeChild (off_t, size_t size)

prepared_resize_t	_canResizeChild (const seekData_t &, size_t size)

status_t< prepared_insert_t >	_canInsertRange (off_t offset, size_t size)

status_t< prepared_insert_t >	_canCollapseRange (off_t offset, size_t size)

status_t< prepared_insert_t >	_canPunchHole (off_t offset, size_t size)

seekData_t *	_insert (off_t offset, const ebmlElement_sp &child)

seekData_t *	_insert (off_t offset, const ebmlElement_sp &child, const status_t< prepared_insert_t > &)

seekData_t *	_insert (off_t offset, const std::string &data)

seekData_t *	_insert (off_t offset, const std::string &data, const status_t< prepared_insert_t > &)

std::vector< seekData_t * >	_insert (off_t offset, const std::vector< std::string > &data)

std::vector< seekData_t * >	_insert (off_t offset, const std::vector< std::string > &data, const status_t< prepared_insert_t > &)

std::vector< seekData_t * >	_insert (off_t offset, const ebmlElement_l &children)

std::vector< seekData_t * >	_insert (off_t offset, const ebmlElement_l &children, const status_t< prepared_insert_t > &)

seekData_t *	_insert (off_t offset, const char *data)

seekData_t *	_insert (off_t offset, const char *data, const status_t< prepared_insert_t > &)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlLazyLoadClass, T >::value, std::pair< ebmlElement_sp, seekData_t * > >	_insert (off_t offset, const T &cls, vintWidth_t sizeWidth, size_t dataSize, Args...)

template<typename T , typename... Args>
std::enable_if_t<!std::is_base_of< ebmlLazyLoadClass, T >::value &&std::is_base_of< ebmlElementClass, T >::value, std::pair< ebmlElement_sp, seekData_t * > >	_insert (off_t offset, const T &cls, Args... args)

template<typename T >
std::enable_if_t<!std::is_base_of< ebmlLazyLoad, T >::value &&std::is_base_of< ebmlElement, T >::value, seekData_t * >	_insert (off_t offset, const ebml::ptr< T > &child)

void	_move (off_t src_offset, off_t dest_offset)

void	_move (off_t src_offset, off_t dest_offset, const prepared_move_t &)

void	_resize (size_t size)

void	_resize (size_t size, const prepared_resize_t &)

void	_remove (off_t offset)

void	_remove (children_m::iterator)

void	_insertRange (off_t offset, size_t size)

void	_collapseRange (off_t offset, size_t size)

void	_punchHole (off_t offset, size_t size)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t offset, const T &cls, Args &&... args)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t offset, const readLock_t &rlock, const T &cls, Args &&... args)

template<typename T , typename... Args>
std::enable_if_t< std::is_base_of< ebmlElementType, std::decay_t< T > >::value, elem_seek_pair >	insert (off_t offset, const writeLock_t &wlock, const T &cls, Args &&... args)

Public Member Functions inherited from ebml::ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >
	ebmlElementCRTP (const ebmlLazyLoadType *cls, Args &&... args)

const ebmlLazyLoadType &	cls () const

ebml::ptr< ebmlLazyLoad >	sp ()

ebml::ptr< const ebmlLazyLoad >	sp () const

ebml::ptr< ebmlElement >	sp ()
	Returns a shared pointer to the element instance. More...

ebml::ptr< const ebmlElement >	sp () const
	Returns a shared pointer to a const element. More...

ebml::ptr< T >	sp ()

ebml::ptr< T >	sp () const

ebml::wptr< ebmlLazyLoad >	wp ()

ebml::wptr< const ebmlLazyLoad >	wp () const

ebml::wptr< ebmlElement >	wp ()

ebml::wptr< const ebmlElement >	wp () const

ebml::wptr< T >	wp ()

ebml::wptr< T >	wp () const

ebml::ptr< ebmlLazyLoad >	clone () const

Public Member Functions inherited from ebml::ebmlMasterElement
sizetree_t	sizetree () const
	Generates the size tree for the element hierarchy. More...

size_t	encode (char *, const sizetree_t &) const
	Encodes the element using a precomputed size tree. More...

iterator	begin ()

iterator	end ()

const_iterator	cbegin () const

const_iterator	cend () const

size_t	encode (char *) const

std::string	encode () const

size_t	encode (ioBase &) const

size_t	encode (ioBase &, off_t) const

Public Member Functions inherited from ebml::ebmlElementCRTP< ebmlMasterElementType, ebmlMasterElement >
	ebmlElementCRTP (const ebmlMasterElementType *cls, Args &&... args)

ebml::ptr< ebmlMasterElement >	sp ()

ebml::ptr< const ebmlMasterElement >	sp () const

ebml::ptr< ebmlElement >	sp ()
	Returns a shared pointer to the element instance. More...

ebml::ptr< const ebmlElement >	sp () const
	Returns a shared pointer to a const element. More...

ebml::ptr< T >	sp ()

ebml::ptr< T >	sp () const

ebml::wptr< ebmlMasterElement >	wp ()

ebml::wptr< const ebmlMasterElement >	wp () const

ebml::wptr< ebmlElement >	wp ()

ebml::wptr< const ebmlElement >	wp () const

ebml::wptr< T >	wp ()

ebml::wptr< T >	wp () const

ebml::ptr< ebmlMasterElement >	clone () const

Public Member Functions inherited from ebml::ebmlElement
virtual	~ebmlElement ()

ebmlID_t	ebmlID () const
	Retrieve the EBML ID of the element. More...

template<typename T = ebmlElement>
T &	as ()
	Dynamically cast the element to the requested type. More...

template<typename T = ebmlElement>
T &	as () const
	Const version of the dynamic cast. More...

ebml::ptr< ebmlElement >	sp ()
	Returns a shared pointer to the element instance. More...

ebml::ptr< const ebmlElement >	sp () const
	Returns a shared pointer to a const element. More...

template<typename T >
ebml::ptr< T >	sp ()

template<typename T >
ebml::ptr< T >	sp () const

ebml::wptr< ebmlElement >	wp ()

ebml::wptr< const ebmlElement >	wp () const

template<typename T >
ebml::wptr< T >	wp ()

template<typename T >
ebml::wptr< T >	wp () const

bool	parent_is_const () const
	Check if the element's parent is a const object. More...

ebml::ptr< ebmlMasterElement >	parent () const
	Retrieve the parent of this element. More...

ebml::ptr< const ebmlMasterElement >	c_parent () const
	Retrieve a const shared pointer to the parent element. More...

ebmlElement_sp	root () const

c_ebmlElement_sp	c_root () const

ebmlDocument_sp	document () const

bool	hasParent () const

unsigned char	headSize () const

unsigned char	headSize (size_t) const

unsigned char	sizeWidth () const

unsigned char	sizeWidth (size_t) const

size_t	outerSize () const

size_t	outerSize (size_t) const

off_t	offsetInParent () const

off_t	offsetInFile () const

off_t	dataOffsetInParent () const

off_t	dataOffsetInFile () const

ebml::ptr< ebmlElement >	clone () const

virtual std::wstring	repr () const

seekData_t *	makeSeekData ()

seekData_t *	makeSeekData () const

std::string	encode () const
	Encodes the element and returns it as a `std::string`. More...

size_t	encode (char *) const
	Encodes the element into a pre-allocated buffer. More...

size_t	encode (ioBase &) const
	Encodes the element and writes it to a generic I/O stream. More...

size_t	encode (ioBase &, off_t) const
	Encodes the element and writes it to a specific offset in a stream. More...

size_t	encode (char *, size_t) const
	Encodes the element using a pre-computed size. More...

Protected Member Functions
	ebmlLazyLoad (const ebmlLazyLoadType *)

	ebmlLazyLoad (const ebmlLazyLoadType *, ioBase &, off_t, vintWidth_t, size_t)

	ebmlLazyLoad (const ebmlLazyLoadType *, ioBase &, off_t, vintWidth_t, size_t, const ebmlElement_l &)

	ebmlLazyLoad (const ebmlLazyLoadType *, ebmlLazyLoad &, off_t, vintWidth_t, size_t)

	ebmlLazyLoad (const ebmlLazyLoadType *, ebmlLazyLoad &, off_t, vintWidth_t, size_t, const ebmlElement_l &)

size_t	_initNew (ioBase &, off_t, vintWidth_t, size_t)

void	_handleParseFile (const parseFile &) override
	Handles the parsing of seek data for a child element. More...

void	_handleSeekData (std::unique_ptr< seekData_t > &&)

virtual void	_handleSeekData (std::unique_ptr< seekData_t > &&, const children_m::iterator &)

void	_addChild (const ebmlElement_sp &) override
	Attaches a child element (rvalue version). More...

void	_addChild (ebmlElement_sp &&) override
	Attaches a child element (move version). More...

ebmlMasterElement::_iterator *	_begin () override

ebmlMasterElement::_iterator *	_end () override

ebmlMasterElement::_const_iterator *	_cbegin () const override

ebmlMasterElement::_const_iterator *	_cend () const override

ebml::ptr< ebmlElement >	_read_elem (seekData_t &seekData)

ebml::ptr< const ebmlElement >	_read_elem (seekData_t &seekData) const

	ebmlLazyLoad (const ebmlLazyLoadClass *)

	ebmlLazyLoad (const ebmlLazyLoadClass *, ioBase &, vintWidth_t, size_t)

	ebmlLazyLoad (const ebmlLazyLoadClass *, ioBase &, off_t, vintWidth_t, size_t)

	ebmlLazyLoad (const ebmlLazyLoadClass *, ioBase &, off_t, vintWidth_t, size_t, const ebmlElement_l &)

	ebmlLazyLoad (const ebmlLazyLoadClass *, ebmlLazyLoad &, off_t, vintWidth_t, size_t)

	ebmlLazyLoad (const ebmlLazyLoadClass *, ebmlLazyLoad &, off_t, vintWidth_t, size_t, const ebmlElement_l &)

size_t	_initNew (ioBase &, off_t, vintWidth_t, size_t)

void	_handleParseFile (const parseFile &) override
	Handles the parsing of seek data for a child element. More...

virtual void	_handleSeekData (std::unique_ptr< seekData_t > &&)

virtual void	_handleSeekData (std::unique_ptr< seekData_t > &&, const children_m::iterator &)

void	_addChild (const ebmlElement_sp &) override
	Attaches a child element (rvalue version). More...

void	_addChild (ebmlElement_sp &&) override
	Attaches a child element (move version). More...

ebmlMasterElement::_iterator *	_begin () override

ebmlMasterElement::_iterator *	_end () override

ebmlMasterElement::_const_iterator *	_cbegin () const override

ebmlMasterElement::_const_iterator *	_cend () const override

ebmlElement_sp	_read_elem (seekData_t *seekData)

ebmlElement_sp	_read_elem (seekData_t *seekData) const

ebmlElement_sp	_read_elem (const parseFile &parsed)

ebmlElement_sp	_read_elem (const parseFile &parsed) const

localReadLock_t	getLocalRLock () const

localWriteLock_t	getLocalWLock () const

globalWriteLock_t	getGlobalLock () const

Protected Member Functions inherited from ebml::ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >
ebmlElement *	_clone () const

Protected Member Functions inherited from ebml::ebmlMasterElement
	ebmlMasterElement (const ebmlMasterElementType *)

void	_init (const parseString &)
	Initializes the element from a parsed EBML string. More...

void	_init (const parseFile &)
	Initializes the element from parsed file data. More...

void	_cinit (const parseString &)
	Const initialization from a parsed EBML string. More...

void	_cinit (const parseFile &)
	Const initialization from parsed file data. More...

ebmlElement *	_decodeChild (const parseString &) const
	Decodes a child element from a parsed string. More...

ebmlElement *	_decodeChild (const parseFile &) const
	Decodes a child element from parsed file data. More...

ebmlElement *	_cdecodeChild (const parseString &) const
	Const version: Decodes a child element from a parsed string. More...

ebmlElement *	_cdecodeChild (const parseFile &) const
	Const version: Decodes a child element from parsed file data. More...

size_t	_encode (char *) const

size_t	_encode (char *, const sizetree_t &) const
	Encodes the element using a precomputed size tree. More...

virtual void	_clear ()
	Clears all child elements. More...

virtual void	_decodeChildren (parseString::iterator &)
	Decodes child elements from a parseString iterator. More...

virtual void	_cdecodeChildren (parseString::iterator &)
	Const version of _decodeChildren. More...

virtual void	_scanChildren (parseFile::iterator &)
	Scans for child elements from a parseFile iterator. More...

virtual void	_cscanChildren (parseFile::iterator &)
	Scans for child elements from a parseFile iterator. (const version) More...

virtual void	_chandleParseFile (const parseFile &)
	Handles the parsing of seek data for a child element. (const version) More...

void	_attachChild (const ebmlElement_sp &child, bool weak=true) const
	Attaches a child element to the master element. More...

void	_detachChild (const ebmlElement_sp &child) const
	Detaches a child element. More...

void	_attachChildren (const ebmlElement_l &elems, bool weak=true) const
	Const version of _attachChildren. More...

void	_detachChildren (const ebmlElement_l &elems) const
	Detaches multiple child elements. More...

void	_clonedata (const ebmlElement *)

Protected Member Functions inherited from ebml::ebmlElement
	ebmlElement (const ebmlElementType *)
	Protected constructor. More...

void	_validate ()

void	_setParent (const ebml::ptr< ebmlMasterElement > &parent, bool weak=true)

void	_setParent (const ebml::ptr< const ebmlMasterElement > &parent, bool weak=true)

void	_setParent (ebml::ptr< ebmlMasterElement > &&parent, bool weak=true)

void	_setParent (ebml::ptr< const ebmlMasterElement > &&parent, bool weak=true)

void	_setParent (ebmlMasterElement &parent, bool weak=true)

void	_setParent (const ebmlMasterElement &parent, bool weak=true)

void	_detach ()

size_t	_encode_head (char *, size_t) const

Protected Attributes
std::shared_mutex	_mutex

ioBase_sp	_file

ioBase *	_file_raw = nullptr

size_t	_dataSize

children_m	_children_by_offset

std::unordered_map< ebmlID_t, std::map< off_t, seekData_t * > >	_children_by_ebmlID

std::unordered_map< ebmlID_t, std::unique_ptr< seekMapBase > >	_children_by_key

Protected Attributes inherited from ebml::ebmlMasterElement
occur_d	ebmlIDCount

Protected Attributes inherited from ebml::ebmlElement
const ebmlElementType *	_cls
	Pointer to the companion element type (an ebmlElementClass subclass). More...

wptr< ebmlElement >	_self
	Custom weak pointer to self (used for shared-from-this semantics). More...

ebmlDocument_wp	_document

vintWidth_t	_sizeWidth = 0

off_t	_offsetInParent = -1

Friends
class	ebmlTypeCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElementType >

class	ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >

class	ebmlLazyLoadType

class	seekData_t

class	ClsMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass >

class	InstMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement >

class	ebmlLazyLoadClass

Additional Inherited Members
Public Types inherited from ebml::ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >
using	ebmltype = ebmlLazyLoadType

Public Types inherited from ebml::ebmlElementCRTP< ebmlMasterElementType, ebmlMasterElement >
using	ebmltype = ebmlMasterElementType

Static Protected Member Functions inherited from ebml::ebmlMasterElement
static iterator	make_iter (_iterator *)

static const_iterator	make_iter (_const_iterator *)

Detailed Description

Represents an EBML Master Element with on-disk, transactional child management.

The ebmlLazyLoad class is a high-performance, thread-safe implementation of an EBML Master Element. It is designed for managing large or sparse EBML files by avoiding the need to load all child elements into memory at once.

This class operates as a transactional manager for its children, providing a robust and consistent interface for modifying the on-disk file structure. It uses a dual-map system to balance performance and usability:

A physical map (children_m) is used to manage children based on their on-disk offset, which is crucial for efficient file I/O operations such as inserts, removals, and resizes.
A logical index (_children_by_key) provides fast, in-memory lookups of children using a user-defined key.

The class uses an explicit locking mechanism through readLock_t and writeLock_t instances. This design enables callers to perform a series of atomic, multi-step operations (e.g., a move or a multi-insert) while holding a single lock, thereby preventing race conditions and ensuring on-disk data integrity.

See also: ebmlLazyLoadType; ebmlMasterElement

Constructor & Destructor Documentation

◆ ebmlLazyLoad() [1/11]

ebml::ebmlLazyLoad::ebmlLazyLoad ( const ebmlLazyLoadType * cls )

protected

◆ ebmlLazyLoad() [2/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadType *	cls,
		ioBase &	file,
		off_t	offset,
		vintWidth_t	sizeWidth,
		size_t	dataSize
	)

protected

◆ ebmlLazyLoad() [3/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadType *	,
		ioBase &	,
		off_t	,
		vintWidth_t	,
		size_t	,
		const ebmlElement_l &
	)

protected

◆ ebmlLazyLoad() [4/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadType *	cls,
		ebmlLazyLoad &	parent,
		off_t	offset,
		vintWidth_t	sizeWidth,
		size_t	dataSize
	)

protected

◆ ebmlLazyLoad() [5/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadType *	,
		ebmlLazyLoad &	,
		off_t	,
		vintWidth_t	,
		size_t	,
		const ebmlElement_l &
	)

protected

◆ ebmlLazyLoad() [6/11]

ebml::ebmlLazyLoad::ebmlLazyLoad ( const ebmlLazyLoadClass * )

protected

◆ ebmlLazyLoad() [7/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadClass *	,
		ioBase &	,
		vintWidth_t	,
		size_t
	)

protected

◆ ebmlLazyLoad() [8/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadClass *	,
		ioBase &	,
		off_t	,
		vintWidth_t	,
		size_t
	)

protected

◆ ebmlLazyLoad() [9/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadClass *	,
		ioBase &	,
		off_t	,
		vintWidth_t	,
		size_t	,
		const ebmlElement_l &
	)

protected

◆ ebmlLazyLoad() [10/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadClass *	,
		ebmlLazyLoad &	,
		off_t	,
		vintWidth_t	,
		size_t
	)

protected

◆ ebmlLazyLoad() [11/11]

ebml::ebmlLazyLoad::ebmlLazyLoad	(	const ebmlLazyLoadClass *	,
		ebmlLazyLoad &	,
		off_t	,
		vintWidth_t	,
		size_t	,
		const ebmlElement_l &
	)

protected

Member Function Documentation

◆ _addChild() [1/4]

void ebml::ebmlLazyLoad::_addChild ( const ebmlElement_sp & )

overrideprotectedvirtual

Attaches a child element (rvalue version).

Implements the mechanism for attaching a child element to the parent element.

Parameters

child Shared pointer to the child element.

Implements ebml::ebmlMasterElement.

◆ _addChild() [2/4]

void ebml::ebmlLazyLoad::_addChild ( ebmlElement_sp && )

overrideprotectedvirtual

Attaches a child element (move version).

Implements the mechanism for moving a child element to the parent element.

Parameters

child Rvalue reference to a shared pointer for the child element.

Implements ebml::ebmlMasterElement.

◆ _addChild() [3/4]

void ebml::ebmlLazyLoad::_addChild ( const ebmlElement_sp & )

overrideprotectedvirtual

Attaches a child element (rvalue version).

Implements the mechanism for attaching a child element to the parent element.

Parameters

child Shared pointer to the child element.

Implements ebml::ebmlMasterElement.

◆ _addChild() [4/4]

void ebml::ebmlLazyLoad::_addChild ( ebmlElement_sp && )

overrideprotectedvirtual

Attaches a child element (move version).

Implements the mechanism for moving a child element to the parent element.

Parameters

child Rvalue reference to a shared pointer for the child element.

Implements ebml::ebmlMasterElement.

◆ _begin() [1/2]

ebmlMasterElement::_iterator * ebml::ebmlLazyLoad::_begin ( )

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _begin() [2/2]

ebmlMasterElement::_iterator* ebml::ebmlLazyLoad::_begin ( )

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _canCollapseRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canCollapseRange	(	off_t	offset,
		size_t	size
	)

◆ _canInsert() [1/5]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsert	(	off_t	offset,
		size_t	size
	)

◆ _canInsert() [2/5]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsert	(	off_t	offset,
		const ebmlElement_sp &
	)

◆ _canInsert() [3/5]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsert	(	off_t	offset,
		const ebmlElement_l &
	)

◆ _canInsert() [4/5]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsert	(	off_t	offset,
		const std::string &	data
	)

◆ _canInsert() [5/5]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsert	(	off_t	offset,
		const char *	data
	)

◆ _canInsertRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canInsertRange	(	off_t	offset,
		size_t	size
	)

◆ _canMove()

prepared_move_t ebml::ebmlLazyLoad::_canMove	(	off_t	src_offset,
		off_t	dst_offset
	)

◆ _canPunchHole()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::_canPunchHole	(	off_t	offset,
		size_t	size
	)

◆ _canResize()

prepared_resize_t ebml::ebmlLazyLoad::_canResize ( size_t size )

◆ _canResizeChild() [1/4]

prepared_resize_t ebml::ebmlLazyLoad::_canResizeChild	(	off_t	,
		size_t	size
	)

◆ _canResizeChild() [2/4]

prepared_resize_t ebml::ebmlLazyLoad::_canResizeChild	(	const seekData_t &	,
		size_t	size
	)

◆ _canResizeChild() [3/4]

prepared_resize_t ebml::ebmlLazyLoad::_canResizeChild	(	off_t	,
		size_t	size
	)

◆ _canResizeChild() [4/4]

prepared_resize_t ebml::ebmlLazyLoad::_canResizeChild	(	const seekData_t &	,
		size_t	size
	)

◆ _cbegin() [1/2]

ebmlMasterElement::_const_iterator * ebml::ebmlLazyLoad::_cbegin ( ) const

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _cbegin() [2/2]

ebmlMasterElement::_const_iterator* ebml::ebmlLazyLoad::_cbegin ( ) const

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _cend() [1/2]

ebmlMasterElement::_const_iterator * ebml::ebmlLazyLoad::_cend ( ) const

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _cend() [2/2]

ebmlMasterElement::_const_iterator* ebml::ebmlLazyLoad::_cend ( ) const

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _cget() [1/5]

c_ebmlElement_sp ebml::ebmlLazyLoad::_cget ( off_t ) const

◆ _cget() [2/5]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::_cget ( off_t ) const

◆ _cget() [3/5]

c_ebmlElement_sp ebml::ebmlLazyLoad::_cget	(	ebmlID_t	,
		size_t
	)		const

◆ _cget() [4/5]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::_cget	(	ebmlID_t	,
		size_t
	)		const

◆ _cget() [5/5]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::_cget	(	ebmlID_t	,
		size_t
	)

◆ _cgetByKey() [1/2]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

c_ebmlElement_sp ebml::ebmlLazyLoad::_cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ _cgetByKey() [2/2]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<const ebmlElement, T>::value && std::is_base_of<const ebmlElement, T>::value, ebml::ptr<T> > ebml::ebmlLazyLoad::_cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ _collapseRange()

void ebml::ebmlLazyLoad::_collapseRange	(	off_t	offset,
		size_t	size
	)

◆ _end() [1/2]

ebmlMasterElement::_iterator * ebml::ebmlLazyLoad::_end ( )

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _end() [2/2]

ebmlMasterElement::_iterator* ebml::ebmlLazyLoad::_end ( )

overrideprotectedvirtual

Implements ebml::ebmlMasterElement.

◆ _find() [1/2]

std::pair<children_m::iterator, children_m::iterator> ebml::ebmlLazyLoad::_find	(	off_t	offset,
		bool	left = `true`
	)

◆ _find() [2/2]

std::pair< children_m::iterator, children_m::iterator > ebml::ebmlLazyLoad::_find	(	off_t	offset,
		bool	left = `true`
	)

◆ _findBoundary()

off_t ebml::ebmlLazyLoad::_findBoundary ( off_t offset )

◆ _findFree() [1/2]

off_t ebml::ebmlLazyLoad::_findFree	(	off_t	offset,
		size_t	size
	)

◆ _findFree() [2/2]

off_t ebml::ebmlLazyLoad::_findFree	(	off_t	offset,
		size_t	size
	)

◆ _findNext() [1/2]

children_m::iterator ebml::ebmlLazyLoad::_findNext	(	off_t	offset,
		bool	strict = `true`
	)

◆ _findNext() [2/2]

children_m::iterator ebml::ebmlLazyLoad::_findNext	(	off_t	offset,
		bool	strict = `true`
	)

◆ _findPrev() [1/2]

children_m::iterator ebml::ebmlLazyLoad::_findPrev	(	off_t	offset,
		bool	strict = `true`
	)

◆ _findPrev() [2/2]

children_m::iterator ebml::ebmlLazyLoad::_findPrev	(	off_t	offset,
		bool	strict = `true`
	)

◆ _firstChildSeek() [1/2]

seekData_t* ebml::ebmlLazyLoad::_firstChildSeek ( ) const

◆ _firstChildSeek() [2/2]

seekData_t* ebml::ebmlLazyLoad::_firstChildSeek ( ) const

◆ _get() [1/4]

ebmlElement_sp ebml::ebmlLazyLoad::_get ( off_t )

◆ _get() [2/4]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::_get ( off_t )

◆ _get() [3/4]

ebmlElement_sp ebml::ebmlLazyLoad::_get	(	ebmlID_t	,
		size_t
	)

◆ _get() [4/4]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::_get	(	ebmlID_t	,
		size_t
	)

◆ _getByKey() [1/2]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

ebmlElement_sp ebml::ebmlLazyLoad::_getByKey	(	ebmlID_t	,
		const K &
	)

◆ _getByKey() [2/2]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T>::value && std::is_base_of<ebmlElement, T>::value, ebml::ptr<T> > ebml::ebmlLazyLoad::_getByKey	(	ebmlID_t	,
		const K &
	)

◆ _handleParseFile() [1/2]

void ebml::ebmlLazyLoad::_handleParseFile ( const parseFile & parsed )

overrideprotectedvirtual

Handles the parsing of seek data for a child element.

Processes the parsed file data corresponding to a child element. Default implementation decodes child and attaches it through _addChild.

Parameters

parsed Parsed file data for a child element.

Reimplemented from ebml::ebmlMasterElement.

◆ _handleParseFile() [2/2]

void ebml::ebmlLazyLoad::_handleParseFile ( const parseFile & parsed )

overrideprotectedvirtual

Handles the parsing of seek data for a child element.

Processes the parsed file data corresponding to a child element. Default implementation decodes child and attaches it through _addChild.

Parameters

parsed Parsed file data for a child element.

Reimplemented from ebml::ebmlMasterElement.

◆ _handleSeekData() [1/4]

void ebml::ebmlLazyLoad::_handleSeekData ( std::unique_ptr< seekData_t > && ptr )

protected

◆ _handleSeekData() [2/4]

void ebml::ebmlLazyLoad::_handleSeekData	(	std::unique_ptr< seekData_t > &&	ptr,
		const children_m::iterator &	hint
	)

protectedvirtual

◆ _handleSeekData() [3/4]

virtual void ebml::ebmlLazyLoad::_handleSeekData ( std::unique_ptr< seekData_t > && )

protectedvirtual

◆ _handleSeekData() [4/4]

virtual void ebml::ebmlLazyLoad::_handleSeekData	(	std::unique_ptr< seekData_t > &&	,
		const children_m::iterator &
	)

protectedvirtual

◆ _initNew() [1/2]

size_t ebml::ebmlLazyLoad::_initNew	(	ioBase &	file,
		off_t	offset,
		vintWidth_t	sizeWidth,
		size_t	dataSize
	)

protected

◆ _initNew() [2/2]

size_t ebml::ebmlLazyLoad::_initNew	(	ioBase &	,
		off_t	,
		vintWidth_t	,
		size_t
	)

protected

◆ _insert() [1/13]

seekData_t* ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const ebmlElement_sp &	child
	)

◆ _insert() [2/13]

seekData_t * ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const ebmlElement_sp &	child,
		const status_t< prepared_insert_t > &	prepared
	)

◆ _insert() [3/13]

seekData_t* ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const std::string &	data
	)

◆ _insert() [4/13]

seekData_t* ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const std::string &	data,
		const status_t< prepared_insert_t > &
	)

◆ _insert() [5/13]

std::vector<seekData_t*> ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const std::vector< std::string > &	data
	)

◆ _insert() [6/13]

std::vector<seekData_t*> ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const std::vector< std::string > &	data,
		const status_t< prepared_insert_t > &
	)

◆ _insert() [7/13]

std::vector<seekData_t*> ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const ebmlElement_l &	children
	)

◆ _insert() [8/13]

std::vector<seekData_t*> ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const ebmlElement_l &	children,
		const status_t< prepared_insert_t > &
	)

◆ _insert() [9/13]

seekData_t* ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const char *	data
	)

◆ _insert() [10/13]

seekData_t* ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const char *	data,
		const status_t< prepared_insert_t > &
	)

◆ _insert() [11/13]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlLazyLoadClass, T>::value, std::pair<ebmlElement_sp, seekData_t*> > ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const T &	cls,
		vintWidth_t	sizeWidth,
		size_t	dataSize,
		Args...
	)

◆ _insert() [12/13]

template<typename T , typename... Args>

std::enable_if_t<!std::is_base_of<ebmlLazyLoadClass, T>::value && std::is_base_of<ebmlElementClass, T>::value, std::pair<ebmlElement_sp, seekData_t*> > ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const T &	cls,
		Args...	args
	)

◆ _insert() [13/13]

template<typename T >

std::enable_if_t<!std::is_base_of<ebmlLazyLoad, T>::value && std::is_base_of<ebmlElement, T>::value, seekData_t*> ebml::ebmlLazyLoad::_insert	(	off_t	offset,
		const ebml::ptr< T > &	child
	)

◆ _insertRange()

void ebml::ebmlLazyLoad::_insertRange	(	off_t	offset,
		size_t	size
	)

◆ _lastChildSeek() [1/2]

seekData_t* ebml::ebmlLazyLoad::_lastChildSeek ( ) const

◆ _lastChildSeek() [2/2]

seekData_t* ebml::ebmlLazyLoad::_lastChildSeek ( ) const

◆ _move() [1/2]

void ebml::ebmlLazyLoad::_move	(	off_t	src_offset,
		off_t	dest_offset
	)

◆ _move() [2/2]

void ebml::ebmlLazyLoad::_move	(	off_t	src_offset,
		off_t	dest_offset,
		const prepared_move_t &
	)

◆ _nextChildSeek() [1/2]

seekData_t* ebml::ebmlLazyLoad::_nextChildSeek	(	off_t	offset,
		bool	strict = `true`
	)		const

◆ _nextChildSeek() [2/2]

seekData_t* ebml::ebmlLazyLoad::_nextChildSeek	(	off_t	offset,
		bool	strict = `true`
	)		const

◆ _prevChildSeek() [1/2]

seekData_t* ebml::ebmlLazyLoad::_prevChildSeek	(	off_t	offset,
		bool	strict = `true`
	)		const

◆ _prevChildSeek() [2/2]

seekData_t* ebml::ebmlLazyLoad::_prevChildSeek	(	off_t	offset,
		bool	strict = `true`
	)		const

◆ _punchHole()

void ebml::ebmlLazyLoad::_punchHole	(	off_t	offset,
		size_t	size
	)

◆ _read_elem() [1/6]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::_read_elem ( seekData_t & seekData )

protected

◆ _read_elem() [2/6]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::_read_elem ( seekData_t & seekData ) const

protected

◆ _read_elem() [3/6]

ebmlElement_sp ebml::ebmlLazyLoad::_read_elem ( seekData_t * seekData )

protected

◆ _read_elem() [4/6]

ebmlElement_sp ebml::ebmlLazyLoad::_read_elem ( seekData_t * seekData ) const

protected

◆ _read_elem() [5/6]

ebmlElement_sp ebml::ebmlLazyLoad::_read_elem ( const parseFile & parsed )

protected

◆ _read_elem() [6/6]

ebmlElement_sp ebml::ebmlLazyLoad::_read_elem ( const parseFile & parsed ) const

protected

◆ _remove() [1/2]

void ebml::ebmlLazyLoad::_remove ( off_t offset )

◆ _remove() [2/2]

void ebml::ebmlLazyLoad::_remove ( children_m::iterator )

◆ _resize() [1/2]

void ebml::ebmlLazyLoad::_resize ( size_t size )

◆ _resize() [2/2]

void ebml::ebmlLazyLoad::_resize	(	size_t	size,
		const prepared_resize_t &
	)

◆ _rfindBoundary()

off_t ebml::ebmlLazyLoad::_rfindBoundary ( off_t offset )

◆ _rfindFree() [1/2]

off_t ebml::ebmlLazyLoad::_rfindFree	(	off_t	offset,
		size_t	size
	)

◆ _rfindFree() [2/2]

off_t ebml::ebmlLazyLoad::_rfindFree	(	off_t	offset,
		size_t	size
	)

◆ canCollapseRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canCollapseRange	(	off_t	offset,
		size_t	size
	)

◆ canInsert() [1/9]

status_t< prepared_insert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		sizetree_t &&	sizetree,
		const writeLock_t &	lock
	)

◆ canInsert() [2/9]

status_t< prepared_multiinsert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		std::vector< sizetree_t > &&	sizetrees,
		const writeLock_t &	wlock
	)

◆ canInsert() [3/9]

status_t< prepared_insert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const ebml::ptr< ebmlElement > &	elem_p,
		const writeLock_t &	lock
	)

inline

◆ canInsert() [4/9]

status_t< prepared_multiinsert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const ebmlElement_l &	elems,
		const writeLock_t &	wlock
	)

◆ canInsert() [5/9]

status_t< prepared_insert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const std::string &	data,
		const writeLock_t &	lock
	)

inline

◆ canInsert() [6/9]

status_t< prepared_insert_t > ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const char *	data,
		const writeLock_t &	lock
	)

inline

◆ canInsert() [7/9]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		size_t	size
	)

◆ canInsert() [8/9]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const ebmlElement_sp &
	)

◆ canInsert() [9/9]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canInsert	(	off_t	offset,
		const ebmlElement_l &
	)

◆ canInsertRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canInsertRange	(	off_t	offset,
		size_t	size
	)

◆ canMove() [1/2]

status_t<prepared_move_t> ebml::ebmlLazyLoad::canMove	(	off_t	,
		off_t	,
		const writeLock_t &
	)

◆ canMove() [2/2]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canMove	(	off_t	src_offset,
		off_t	dst_offset
	)

◆ canPunchHole()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canPunchHole	(	off_t	offset,
		size_t	size
	)

◆ canRemove()

status_t< prepared_remove_t > ebml::ebmlLazyLoad::canRemove	(	off_t	offset,
		const writeLock_t &	wlock
	)

inline

◆ canResize() [1/2]

status_t<prepared_resize_t> ebml::ebmlLazyLoad::canResize	(	size_t	,
		const writeLock_t &
	)

inline

◆ canResize() [2/2]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canResize ( size_t size )

◆ canResizeChild() [1/2]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canResizeChild	(	const seekData_t &	,
		size_t	size
	)

◆ canResizeChild() [2/2]

status_t<prepared_insert_t> ebml::ebmlLazyLoad::canResizeChild	(	ebmlElement *	child,
		size_t	size
	)

◆ cget() [1/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget ( off_t offset ) const

inline

◆ cget() [2/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget	(	off_t	offset,
		const readLock_t &	lock
	)		const

inline

◆ cget() [3/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget	(	off_t	offset,
		const writeLock_t &	lock
	)		const

inline

◆ cget() [4/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::cget ( off_t offset ) const

inline

◆ cget() [5/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::cget	(	off_t	offset,
		const readLock_t &	lock
	)		const

inline

◆ cget() [6/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::cget	(	off_t	offset,
		const writeLock_t &	lock
	)		const

inline

◆ cget() [7/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget	(	ebmlID_t	ebmlID,
		size_t	index
	)		const

inline

◆ cget() [8/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget	(	ebmlID_t	ebmlID,
		size_t	index,
		const readLock_t &	lock
	)		const

inline

◆ cget() [9/16]

ebml::ptr< const ebmlElement > ebml::ebmlLazyLoad::cget	(	ebmlID_t	ebmlID,
		size_t	index,
		const writeLock_t &	lock
	)		const

inline

◆ cget() [10/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::cget	(	ebmlID_t	,
		size_t
	)		const

◆ cget() [11/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::cget	(	ebmlID_t	,
		size_t	,
		const readLock_t &
	)		const

◆ cget() [12/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::cget	(	ebmlID_t	,
		size_t	,
		const writeLock_t &
	)		const

◆ cget() [13/16]

c_ebmlElement_sp ebml::ebmlLazyLoad::cget ( off_t ) const

◆ cget() [14/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::cget ( off_t ) const

◆ cget() [15/16]

c_ebmlElement_sp ebml::ebmlLazyLoad::cget	(	ebmlID_t	,
		size_t
	)		const

◆ cget() [16/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::cget	(	ebmlID_t	,
		size_t
	)		const

◆ cgetByKey() [1/8]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_base_of<ebmlElement, std::decay_t< K > >::value, ebml::ptr<const ebmlElement> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ cgetByKey() [2/8]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_base_of<ebmlElement, std::decay_t< K > >::value, ebml::ptr<const ebmlElement> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &	,
		const readLock_t &
	)		const

◆ cgetByKey() [3/8]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_base_of<ebmlElement, std::decay_t< K > >::value, ebml::ptr<const ebmlElement> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &	,
		const writeLock_t &
	)		const

◆ cgetByKey() [4/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T >::value && std::is_base_of<ebmlElement, std::decay_t< T > >::value, ebml::ptr<T> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ cgetByKey() [5/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T >::value && std::is_base_of<ebmlElement, std::decay_t< T > >::value, ebml::ptr<T> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &	,
		const readLock_t &
	)		const

◆ cgetByKey() [6/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T >::value && std::is_base_of<ebmlElement, std::decay_t< T > >::value, ebml::ptr<T> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &	,
		const writeLock_t &
	)		const

◆ cgetByKey() [7/8]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

c_ebmlElement_sp ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ cgetByKey() [8/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<const ebmlElement, T>::value && std::is_base_of<const ebmlElement, T>::value, ebml::ptr<T> > ebml::ebmlLazyLoad::cgetByKey	(	ebmlID_t	,
		const K &
	)		const

◆ collapseRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::collapseRange	(	off_t	offset,
		size_t	size
	)

◆ dataSize() [1/2]

size_t ebml::ebmlLazyLoad::dataSize ( ) const

overridevirtual

Reimplemented from ebml::ebmlMasterElement.

◆ dataSize() [2/2]

size_t ebml::ebmlLazyLoad::dataSize ( ) const

overridevirtual

Reimplemented from ebml::ebmlMasterElement.

◆ endOfData() [1/2]

off_t ebml::ebmlLazyLoad::endOfData ( ) const

◆ endOfData() [2/2]

off_t ebml::ebmlLazyLoad::endOfData ( ) const

◆ file() [1/2]

ioBase & ebml::ebmlLazyLoad::file ( ) const

◆ file() [2/2]

ioBase& ebml::ebmlLazyLoad::file ( ) const

◆ findBoundary() [1/4]

off_t ebml::ebmlLazyLoad::findBoundary ( off_t offset )

◆ findBoundary() [2/4]

off_t ebml::ebmlLazyLoad::findBoundary ( off_t offset )

◆ findBoundary() [3/4]

off_t ebml::ebmlLazyLoad::findBoundary	(	off_t	offset,
		const readLock_t &
	)

◆ findBoundary() [4/4]

off_t ebml::ebmlLazyLoad::findBoundary	(	off_t	offset,
		const writeLock_t &
	)

◆ findFree()

off_t ebml::ebmlLazyLoad::findFree	(	off_t	offset,
		size_t	size
	)

◆ firstChild() [1/4]

seekData_t* ebml::ebmlLazyLoad::firstChild ( )

◆ firstChild() [2/4]

seekData_t* ebml::ebmlLazyLoad::firstChild ( )

◆ firstChild() [3/4]

seekData_t* ebml::ebmlLazyLoad::firstChild ( const readLock_t & )

◆ firstChild() [4/4]

seekData_t* ebml::ebmlLazyLoad::firstChild ( const writeLock_t & )

◆ get() [1/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get ( off_t offset )

inline

◆ get() [2/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get	(	off_t	offset,
		const readLock_t &	lock
	)

inline

◆ get() [3/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get	(	off_t	offset,
		const writeLock_t &	lock
	)

inline

◆ get() [4/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::get ( off_t offset )

inline

◆ get() [5/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::get	(	off_t	offset,
		const readLock_t &	lock
	)

inline

◆ get() [6/16]

template<typename T >

ebml::ptr< T > ebml::ebmlLazyLoad::get	(	off_t	offset,
		const writeLock_t &	lock
	)

inline

◆ get() [7/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get	(	ebmlID_t	ebmlID,
		size_t	index
	)

inline

◆ get() [8/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get	(	ebmlID_t	ebmlID,
		size_t	index,
		const readLock_t &	lock
	)

inline

◆ get() [9/16]

ebml::ptr< ebmlElement > ebml::ebmlLazyLoad::get	(	ebmlID_t	ebmlID,
		size_t	index,
		const writeLock_t &	lock
	)

inline

◆ get() [10/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::get	(	ebmlID_t	,
		size_t
	)

◆ get() [11/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::get	(	ebmlID_t	,
		size_t	,
		const readLock_t &
	)

◆ get() [12/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::get	(	ebmlID_t	,
		size_t	,
		const writeLock_t &
	)

◆ get() [13/16]

ebmlElement_sp ebml::ebmlLazyLoad::get ( off_t )

◆ get() [14/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::get ( off_t )

◆ get() [15/16]

ebmlElement_sp ebml::ebmlLazyLoad::get	(	ebmlID_t	,
		size_t
	)

◆ get() [16/16]

template<typename T >

ebml::ptr<T> ebml::ebmlLazyLoad::get	(	ebmlID_t	,
		size_t
	)

◆ getByKey() [1/8]

template<typename K , typename H , typename E >

std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	ebmlID,
		const K &	key
	)

inline

Gets a child element based on a user-defined key.

Template Parameters

T	The type of the child element to retrieve.
Key	The type of the key used for the lookup.

Parameters

lock	A reference to an existing readLock_t or writeLock_t instance.
key	The key of the child element to find.

Returns: A shared pointer to the found child element.

Exceptions

std::runtime_error If a child with the specified key does not exist.

Note: This method requires an explicit lock instance from the caller, which enables atomic, multi-step transactions.

◆ getByKey() [2/8]

template<typename K , typename H , typename E >

std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	ebmlID,
		const K &	key,
		const readLock_t &	rlock
	)

inline

◆ getByKey() [3/8]

template<typename K , typename H , typename E >

std::enable_if_t<!std::is_base_of< ebmlElement, std::decay_t< K > >::value, ebml::ptr< ebmlElement > > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	ebmlID,
		const K &	key,
		const writeLock_t &	wlock
	)

inline

◆ getByKey() [4/8]

template<typename T , typename K , typename H , typename E >

std::enable_if_t<!std::is_same< ebmlElement, T >::value &&std::is_base_of< ebmlElement, std::decay_t< T > >::value, ebml::ptr< T > > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	ebmlID,
		const K &	key
	)

inline

◆ getByKey() [5/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T >::value && std::is_base_of<ebmlElement, std::decay_t< T > >::value, ebml::ptr<T> > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	,
		const K &	,
		const readLock_t &
	)

◆ getByKey() [6/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T >::value && std::is_base_of<ebmlElement, std::decay_t< T > >::value, ebml::ptr<T> > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	,
		const K &	,
		const writeLock_t &
	)

◆ getByKey() [7/8]

template<typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

ebmlElement_sp ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	,
		const K &
	)

◆ getByKey() [8/8]

template<typename T , typename K , typename H = std::hash<K>, typename E = std::equal_to<K>>

std::enable_if_t<!std::is_same<ebmlElement, T>::value && std::is_base_of<ebmlElement, T>::value, ebml::ptr<T> > ebml::ebmlLazyLoad::getByKey	(	ebmlID_t	,
		const K &
	)

◆ getGlobalLock() [1/2]

writeLock_t ebml::ebmlLazyLoad::getGlobalLock ( ) const

◆ getGlobalLock() [2/2]

globalWriteLock_t ebml::ebmlLazyLoad::getGlobalLock ( ) const

protected

◆ getLocalRLock()

localReadLock_t ebml::ebmlLazyLoad::getLocalRLock ( ) const

protected

◆ getLocalWLock()

localWriteLock_t ebml::ebmlLazyLoad::getLocalWLock ( ) const

protected

◆ getRLock() [1/2]

readLock_t ebml::ebmlLazyLoad::getRLock ( ) const

◆ getRLock() [2/2]

readLock_t ebml::ebmlLazyLoad::getRLock ( const readLock_t & rlock ) const

◆ getWLock() [1/3]

writeLock_t ebml::ebmlLazyLoad::getWLock ( ) const

◆ getWLock() [2/3]

writeLock_t ebml::ebmlLazyLoad::getWLock ( const readLock_t & rlock ) const

◆ getWLock() [3/3]

writeLock_t ebml::ebmlLazyLoad::getWLock ( const writeLock_t & wlock ) const

◆ insert() [1/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebml::ptr< ebmlElement > &	elem_p
	)

inline

◆ insert() [2/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebml::ptr< ebmlElement > &	elem_p,
		const readLock_t &	lock
	)

inline

◆ insert() [3/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebml::ptr< ebmlElement > &	elem_p,
		const writeLock_t &	lock
	)

inline

◆ insert() [4/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebml::ptr< ebmlElement > &	elem_p,
		const writeLock_t &	lock,
		const status_t< prepared_insert_t > &	prepared
	)

inline

◆ insert() [5/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	,
		const ebmlElement_l &
	)

◆ insert() [6/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	,
		const ebmlElement_l &	,
		const readLock_t &
	)

◆ insert() [7/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	,
		const ebmlElement_l &	,
		const writeLock_t &
	)

◆ insert() [8/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	,
		const ebmlElement_l &	,
		const writeLock_t &	,
		const status_t< prepared_multiinsert_t > &
	)

◆ insert() [9/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::string &	data
	)

inline

◆ insert() [10/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::string &	data,
		const readLock_t &	lock
	)

inline

◆ insert() [11/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::string &	data,
		const writeLock_t &	lock
	)

inline

◆ insert() [12/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::string &	data,
		const writeLock_t &	lock,
		const status_t< prepared_insert_t > &	status
	)

inline

◆ insert() [13/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const char *	data
	)

inline

◆ insert() [14/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const char *	data,
		const readLock_t &	lock
	)

inline

◆ insert() [15/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const char *	data,
		const writeLock_t &	lock
	)

inline

◆ insert() [16/30]

seekData_t * ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const char *	data,
		const writeLock_t &	lock,
		const status_t< prepared_insert_t > &	status
	)

inline

◆ insert() [17/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	,
		const T &	cls,
		Args &&	...
	)

inline

◆ insert() [18/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	,
		const readLock_t &	,
		const T &	cls,
		Args &&	...
	)

inline

◆ insert() [19/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	,
		const writeLock_t &	,
		const T &	cls,
		Args &&	...
	)

inline

Inserts a new child element at a specified offset.

Template Parameters

T	The type of the child element class.

Parameters

lock	A reference to an existing writeLock_t instance.
offset	The on-disk offset where the new element should be inserted.
cls	A reference to the ebmlElementType instance for the new child.
args	Arguments to pass to the new child's constructor.

Returns: A pair containing a shared pointer to the new element and its seekData_t object.

Exceptions

std::runtime_error If the insertion is not possible due to file constraints or an invalid offset.

Note: This method is part of a transactional pattern and requires the caller to hold a write lock.

◆ insert() [20/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	,
		const writeLock_t &	,
		const status_t< prepared_insert_t > &	,
		const T &	cls,
		Args &&	...
	)

inline

◆ insert() [21/30]

seekData_t* ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebmlElement_sp &	child
	)

◆ insert() [22/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebmlElement_l &	children
	)

◆ insert() [23/30]

seekData_t* ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::string &	data
	)

◆ insert() [24/30]

std::vector<seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const std::vector< std::string > &	data
	)

◆ insert() [25/30]

seekData_t* ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const char *	data
	)

◆ insert() [26/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementClass, T>::value, std::pair<ebmlElement_sp, seekData_t*> > ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const T &	cls,
		Args...
	)

◆ insert() [27/30]

template<typename T >

std::enable_if_t<!std::is_base_of<ebmlLazyLoad, T>::value && std::is_base_of<ebmlElement, T>::value, seekData_t*> ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const ebml::ptr< T > &	child
	)

◆ insert() [28/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const T &	cls,
		Args &&...	args
	)

inline

◆ insert() [29/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const readLock_t &	rlock,
		const T &	cls,
		Args &&...	args
	)

inline

◆ insert() [30/30]

template<typename T , typename... Args>

std::enable_if_t<std::is_base_of<ebmlElementType, std::decay_t< T > >::value, elem_seek_pair > ebml::ebmlLazyLoad::insert	(	off_t	offset,
		const writeLock_t &	wlock,
		const T &	cls,
		Args &&...	args
	)

inline

◆ insertRange()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::insertRange	(	off_t	offset,
		size_t	size
	)

◆ lastChild() [1/4]

seekData_t* ebml::ebmlLazyLoad::lastChild ( )

◆ lastChild() [2/4]

seekData_t* ebml::ebmlLazyLoad::lastChild ( )

◆ lastChild() [3/4]

seekData_t* ebml::ebmlLazyLoad::lastChild ( const readLock_t & )

◆ lastChild() [4/4]

seekData_t* ebml::ebmlLazyLoad::lastChild ( const writeLock_t & )

◆ minirepr() [1/2]

std::wstring ebml::ebmlLazyLoad::minirepr ( ) const

overridevirtual

Implements ebml::ebmlElement.

◆ minirepr() [2/2]

std::wstring ebml::ebmlLazyLoad::minirepr ( ) const

overridevirtual

Implements ebml::ebmlElement.

◆ move() [1/5]

void ebml::ebmlLazyLoad::move	(	off_t	,
		off_t
	)

◆ move() [2/5]

void ebml::ebmlLazyLoad::move	(	off_t	,
		off_t	,
		const readLock_t &
	)

◆ move() [3/5]

void ebml::ebmlLazyLoad::move	(	off_t	,
		off_t	,
		const writeLock_t &
	)

◆ move() [4/5]

void ebml::ebmlLazyLoad::move	(	off_t	,
		off_t	,
		const writeLock_t &	,
		const status_t< prepared_move_t > &
	)

◆ move() [5/5]

void ebml::ebmlLazyLoad::move	(	off_t	src_offset,
		off_t	dest_offset
	)

◆ nextChild() [1/4]

seekData_t* ebml::ebmlLazyLoad::nextChild ( off_t offset )

◆ nextChild() [2/4]

seekData_t* ebml::ebmlLazyLoad::nextChild ( off_t offset )

◆ nextChild() [3/4]

seekData_t* ebml::ebmlLazyLoad::nextChild	(	off_t	offset,
		const readLock_t &
	)

◆ nextChild() [4/4]

seekData_t* ebml::ebmlLazyLoad::nextChild	(	off_t	offset,
		const writeLock_t &
	)

◆ prevChild() [1/4]

seekData_t* ebml::ebmlLazyLoad::prevChild ( off_t offset )

◆ prevChild() [2/4]

seekData_t* ebml::ebmlLazyLoad::prevChild ( off_t offset )

◆ prevChild() [3/4]

seekData_t* ebml::ebmlLazyLoad::prevChild	(	off_t	offset,
		const readLock_t &
	)

◆ prevChild() [4/4]

seekData_t* ebml::ebmlLazyLoad::prevChild	(	off_t	offset,
		const writeLock_t &
	)

◆ punchHole()

status_t<prepared_insert_t> ebml::ebmlLazyLoad::punchHole	(	off_t	offset,
		size_t	size
	)

◆ remove() [1/6]

void ebml::ebmlLazyLoad::remove ( const ebmlElement_sp & child )

◆ remove() [2/6]

void ebml::ebmlLazyLoad::remove ( off_t offset )

◆ remove() [3/6]

void ebml::ebmlLazyLoad::remove ( off_t offset )

inline

◆ remove() [4/6]

void ebml::ebmlLazyLoad::remove	(	off_t	offset,
		const readLock_t &	rlock
	)

inline

◆ remove() [5/6]

void ebml::ebmlLazyLoad::remove	(	off_t	offset,
		const writeLock_t &	wlock
	)

inline

◆ remove() [6/6]

void ebml::ebmlLazyLoad::remove	(	off_t	offset,
		const status_t< prepared_remove_t > &	status,
		const writeLock_t &	wlock
	)

inline

◆ resize() [1/5]

void ebml::ebmlLazyLoad::resize ( size_t size )

inline

◆ resize() [2/5]

void ebml::ebmlLazyLoad::resize	(	size_t	size,
		const readLock_t &	rlock
	)

inline

◆ resize() [3/5]

void ebml::ebmlLazyLoad::resize	(	size_t	size,
		const writeLock_t &
	)

inline

◆ resize() [4/5]

void ebml::ebmlLazyLoad::resize	(	size_t	size,
		const writeLock_t &	,
		const status_t< prepared_resize_t > &
	)

inline

◆ resize() [5/5]

void ebml::ebmlLazyLoad::resize ( size_t size )

◆ rfindBoundary() [1/4]

off_t ebml::ebmlLazyLoad::rfindBoundary ( off_t offset )

◆ rfindBoundary() [2/4]

off_t ebml::ebmlLazyLoad::rfindBoundary ( off_t offset )

◆ rfindBoundary() [3/4]

off_t ebml::ebmlLazyLoad::rfindBoundary	(	off_t	offset,
		const readLock_t &
	)

◆ rfindBoundary() [4/4]

off_t ebml::ebmlLazyLoad::rfindBoundary	(	off_t	offset,
		const writeLock_t &
	)

◆ rfindFree()

off_t ebml::ebmlLazyLoad::rfindFree	(	off_t	offset,
		size_t	size
	)

◆ seeksByEBMLID() [1/2]

const std::unordered_map< ebmlID_t, std::map<off_t, seekData_t*> >& ebml::ebmlLazyLoad::seeksByEBMLID ( ) const

◆ seeksByEBMLID() [2/2]

const std::unordered_map< ebmlID_t, std::map<off_t, seekData_t*> >& ebml::ebmlLazyLoad::seeksByEBMLID ( ) const

◆ seeksByKey() [1/2]

const std::unordered_map<ebmlID_t, std::unique_ptr<seekMapBase> >& ebml::ebmlLazyLoad::seeksByKey ( ) const

◆ seeksByKey() [2/2]

const std::unordered_map<ebmlID_t, std::unique_ptr<seekMapBase> >& ebml::ebmlLazyLoad::seeksByKey ( ) const

◆ seeksByOffset() [1/2]

const children_m & ebml::ebmlLazyLoad::seeksByOffset ( ) const

◆ seeksByOffset() [2/2]

const children_m& ebml::ebmlLazyLoad::seeksByOffset ( ) const

◆ sizeSupported() [1/2]

bool ebml::ebmlLazyLoad::sizeSupported	(	size_t	size,
		const writeLock_t &	lock
	)

inline

◆ sizeSupported() [2/2]

bool ebml::ebmlLazyLoad::sizeSupported ( size_t size )

Friends And Related Function Documentation

◆ ClsMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass >

friend class ClsMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElementClass >

friend

◆ ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >

friend class ebmlElementCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElement >

friend

◆ ebmlLazyLoadClass

friend class ebmlLazyLoadClass

friend

◆ ebmlLazyLoadType

friend class ebmlLazyLoadType

friend

◆ ebmlTypeCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElementType >

friend class ebmlTypeCRTP< ebmlLazyLoadType, ebmlLazyLoad, ebmlMasterElementType >

friend

◆ InstMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement >

friend class InstMixin< ebmlLazyLoadClass, ebmlLazyLoad, ebmlMasterElement >

friend

◆ seekData_t

seekData_t

friend

Member Data Documentation

◆ _children_by_ebmlID

std::unordered_map< ebmlID_t, std::map< off_t, seekData_t * > > ebml::ebmlLazyLoad::_children_by_ebmlID

protected

◆ _children_by_key

std::unordered_map< ebmlID_t, std::unique_ptr< seekMapBase > > ebml::ebmlLazyLoad::_children_by_key

protected

◆ _children_by_offset

children_m ebml::ebmlLazyLoad::_children_by_offset

protected

◆ _dataSize

size_t ebml::ebmlLazyLoad::_dataSize

protected

◆ _file

ioBase_sp ebml::ebmlLazyLoad::_file

protected

◆ _file_raw

ioBase * ebml::ebmlLazyLoad::_file_raw = nullptr

protected

◆ _mutex

std::shared_mutex ebml::ebmlLazyLoad::_mutex

mutableprotected

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

src/libebml_ng/masterelement/lazyload/ebmlLazyLoad.h
src/libebml_ng/masterelement/lazyload.h
src/libebml_ng/masterelement/lazyload/ebmlLazyLoad.cpp
src/libebml_ng/masterelement/lazyload/remove.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ebmlLazyLoad() [1/11]

◆ ebmlLazyLoad() [2/11]

◆ ebmlLazyLoad() [3/11]

◆ ebmlLazyLoad() [4/11]

◆ ebmlLazyLoad() [5/11]

◆ ebmlLazyLoad() [6/11]

◆ ebmlLazyLoad() [7/11]

◆ ebmlLazyLoad() [8/11]

◆ ebmlLazyLoad() [9/11]

◆ ebmlLazyLoad() [10/11]

◆ ebmlLazyLoad() [11/11]

Member Function Documentation

◆ _addChild() [1/4]

◆ _addChild() [2/4]

◆ _addChild() [3/4]

◆ _addChild() [4/4]

◆ _begin() [1/2]

◆ _begin() [2/2]

◆ _canCollapseRange()

◆ _canInsert() [1/5]

◆ _canInsert() [2/5]

◆ _canInsert() [3/5]

◆ _canInsert() [4/5]

◆ _canInsert() [5/5]

◆ _canInsertRange()

◆ _canMove()

◆ _canPunchHole()

◆ _canResize()

◆ _canResizeChild() [1/4]

◆ _canResizeChild() [2/4]

◆ _canResizeChild() [3/4]

◆ _canResizeChild() [4/4]

◆ _cbegin() [1/2]

◆ _cbegin() [2/2]

◆ _cend() [1/2]

◆ _cend() [2/2]

◆ _cget() [1/5]

◆ _cget() [2/5]

◆ _cget() [3/5]

◆ _cget() [4/5]

◆ _cget() [5/5]

◆ _cgetByKey() [1/2]

◆ _cgetByKey() [2/2]

◆ _collapseRange()

◆ _end() [1/2]

◆ _end() [2/2]

◆ _find() [1/2]

◆ _find() [2/2]

◆ _findBoundary()

◆ _findFree() [1/2]

◆ _findFree() [2/2]

◆ _findNext() [1/2]

◆ _findNext() [2/2]

◆ _findPrev() [1/2]

◆ _findPrev() [2/2]

◆ _firstChildSeek() [1/2]

◆ _firstChildSeek() [2/2]

◆ _get() [1/4]

◆ _get() [2/4]

◆ _get() [3/4]

◆ _get() [4/4]

◆ _getByKey() [1/2]

◆ _getByKey() [2/2]

◆ _handleParseFile() [1/2]

◆ _handleParseFile() [2/2]

◆ _handleSeekData() [1/4]

◆ _handleSeekData() [2/4]

◆ _handleSeekData() [3/4]

◆ _handleSeekData() [4/4]

◆ _initNew() [1/2]

◆ _initNew() [2/2]

◆ _insert() [1/13]

◆ _insert() [2/13]