FileBuffer Class Reference

#include <buffer.h>

Inheritance diagram for FileBuffer:

Public Types
enum class	ALLOCATION_WAYS {   MALLOC , MMAP , REF , VMALLOC ,   SEGMENT }

Public Member Functions
int	ref_other_buffer (std::shared_ptr< FileBuffer > p, size_t offset, size_t size)
std::shared_ptr< FragmentBlock >	request_new_blk ()
bool	check_offset_in_seg (size_t offset, std::shared_ptr< FragmentBlock > blk)
std::shared_ptr< FragmentBlock >	get_map_it (size_t offset, bool alloc=false)
void	truncate_old_data_in_pool ()
	FileBuffer ()
	FileBuffer (void *p, size_t sz)
	~FileBuffer ()
ALLOCATION_WAYS	get_m_allocate_way () const noexcept
int64_t	request_data (void *data, size_t offset, size_t sz)
int	request_data (std::vector< uint8_t > &data, size_t offset, size_t sz)
std::shared_ptr< DataBuffer >	request_data (size_t offset, size_t sz)
bool	IsLoaded () const noexcept
bool	IsRefable () const noexcept
bool	IsKnownSize () const noexcept
bool	IsError () const noexcept
int	reload (std::string filename, bool async=false)
size_t	size ()

Public Attributes
std::mutex	m_data_mutex
uint8_t *	m_pDatabuffer
size_t	m_DataSize
size_t	m_MemSize
std::shared_ptr< FileBuffer >	m_ref
std::mutex	m_async_mutex
std::map< size_t, std::shared_ptr< FragmentBlock >, std::greater< size_t > >	m_seg_map
std::mutex	m_seg_map_mutex
std::queue< size_t >	m_offset_request
size_t	m_last_request_offset = 0
std::condition_variable	m_pool_load_cv
std::mutex	m_pool_load_cv_mutex
std::shared_ptr< FragmentBlock >	m_last_db
size_t	m_seg_blk_size = 0x800000
size_t	m_total_buffer_size = 8 * m_seg_blk_size
std::atomic_bool	m_reset_stream { false }
std::atomic_int	m_dataflags
std::thread	m_async_thread
std::atomic_size_t	m_available_size
std::condition_variable	m_request_cv
std::mutex	m_request_cv_mutex
uint64_t	m_timesample

Protected Member Functions
uint8_t *	data () noexcept
uint8_t &	operator[] (size_t index)
uint8_t &	at (size_t index)
int	resize (size_t sz)
int	reserve (size_t sz)
int	swap (FileBuffer &a)
int	mapfile (const std::string &filename, size_t sz)
int	unmapfile ()
int64_t	request_data_from_segment (void *data, size_t offset, size_t sz)

Protected Attributes
int	m_pool_size = 10
std::string	m_filename

Private Attributes
ALLOCATION_WAYS	m_allocate_way = ALLOCATION_WAYS::MALLOC

Friends
class	DataBuffer
class	FSBase
class	FSFlat
class	FSHttps
class	FSHttp
class	FSGz
class	FSzstd
class	FSCompressStream
class	Fat
class	Tar
class	Zip
class	Zip_file_Info

Member Enumeration Documentation

ALLOCATION_WAYS

enum class FileBuffer::ALLOCATION_WAYS

strong

Enumerator
MALLOC
MMAP
REF
VMALLOC
SEGMENT

Constructor & Destructor Documentation

FileBuffer() [1/2]

FileBuffer::FileBuffer

(

)

FileBuffer() [2/2]

FileBuffer::FileBuffer	(	void *	p,
		size_t	sz )

~FileBuffer()

FileBuffer::~FileBuffer

(

)

Member Function Documentation

at()

uint8_t & FileBuffer::at ( size_t index )

inlineprotected

check_offset_in_seg()

bool FileBuffer::check_offset_in_seg ( size_t offset, std::shared_ptr< FragmentBlock > blk )

inline

data()

uint8_t * FileBuffer::data ( )

inlineprotectednoexcept

get_m_allocate_way()

ALLOCATION_WAYS FileBuffer::get_m_allocate_way ( ) const

inlinenoexcept

get_map_it()

std::shared_ptr< FragmentBlock > FileBuffer::get_map_it ( size_t offset, bool alloc = false )

inline

IsError()

bool FileBuffer::IsError ( ) const

inlinenoexcept

IsKnownSize()

bool FileBuffer::IsKnownSize ( ) const

inlinenoexcept

IsLoaded()

bool FileBuffer::IsLoaded ( ) const

inlinenoexcept

IsRefable()

bool FileBuffer::IsRefable ( ) const

inlinenoexcept

mapfile()

int FileBuffer::mapfile ( const std::string & filename, size_t sz )

protected

operator[]()

uint8_t & FileBuffer::operator[] ( size_t index )

inlineprotected

ref_other_buffer()

int FileBuffer::ref_other_buffer	(	std::shared_ptr< FileBuffer >	p,
		size_t	offset,
		size_t	size )

reload()

int FileBuffer::reload	(	std::string	filename,
		bool	async = false )

request_data() [1/3]

std::shared_ptr< DataBuffer > FileBuffer::request_data	(	size_t	offset,
		size_t	sz )

request_data() [2/3]

int FileBuffer::request_data	(	std::vector< uint8_t > &	data,
		size_t	offset,
		size_t	sz )

request_data() [3/3]

int64_t FileBuffer::request_data	(	void *	data,
		size_t	offset,
		size_t	sz )

request_data_from_segment()

int64_t FileBuffer::request_data_from_segment ( void * data, size_t offset, size_t sz )

protected

request_new_blk()

std::shared_ptr< FragmentBlock > FileBuffer::request_new_blk

(

)

reserve()

int FileBuffer::reserve ( size_t sz )

protected

resize()

int FileBuffer::resize ( size_t sz )

protected

size()

size_t FileBuffer::size ( )

inline

swap()

int FileBuffer::swap ( FileBuffer & a )

protected

truncate_old_data_in_pool()

void FileBuffer::truncate_old_data_in_pool

(

)

unmapfile()

int FileBuffer::unmapfile ( )

protected

Friends And Related Symbol Documentation

DataBuffer

friend class DataBuffer

friend

Fat

friend class Fat

friend

FSBase

friend class FSBase

friend

FSCompressStream

friend class FSCompressStream

friend

FSFlat

friend class FSFlat

friend

FSGz

friend class FSGz

friend

FSHttp

friend class FSHttp

friend

FSHttps

friend class FSHttps

friend

FSzstd

friend class FSzstd

friend

Tar

friend class Tar

friend

Zip

friend class Zip

friend

Zip_file_Info

friend class Zip_file_Info

friend

Member Data Documentation

m_allocate_way

ALLOCATION_WAYS FileBuffer::m_allocate_way = ALLOCATION_WAYS::MALLOC

private

m_async_mutex

std::mutex FileBuffer::m_async_mutex

m_async_thread

std::thread FileBuffer::m_async_thread

m_available_size

std::atomic_size_t FileBuffer::m_available_size

m_data_mutex

std::mutex FileBuffer::m_data_mutex

m_dataflags

std::atomic_int FileBuffer::m_dataflags

m_DataSize

size_t FileBuffer::m_DataSize

m_filename

std::string FileBuffer::m_filename

protected

m_last_db

std::shared_ptr<FragmentBlock> FileBuffer::m_last_db

m_last_request_offset

size_t FileBuffer::m_last_request_offset = 0

m_MemSize

size_t FileBuffer::m_MemSize

m_offset_request

std::queue<size_t> FileBuffer::m_offset_request

m_pDatabuffer

uint8_t* FileBuffer::m_pDatabuffer

m_pool_load_cv

std::condition_variable FileBuffer::m_pool_load_cv

m_pool_load_cv_mutex

std::mutex FileBuffer::m_pool_load_cv_mutex

m_pool_size

int FileBuffer::m_pool_size = 10

protected

m_ref

std::shared_ptr<FileBuffer> FileBuffer::m_ref

m_request_cv

std::condition_variable FileBuffer::m_request_cv

m_request_cv_mutex

std::mutex FileBuffer::m_request_cv_mutex

m_reset_stream

std::atomic_bool FileBuffer::m_reset_stream { false }

m_seg_blk_size

size_t FileBuffer::m_seg_blk_size = 0x800000

m_seg_map

std::map<size_t, std::shared_ptr<FragmentBlock>, std::greater<size_t> > FileBuffer::m_seg_map

m_seg_map_mutex

std::mutex FileBuffer::m_seg_map_mutex

m_timesample

uint64_t FileBuffer::m_timesample

m_total_buffer_size

size_t FileBuffer::m_total_buffer_size = 8 * m_seg_blk_size

---

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

• /build/mfgtools-git/src/mfgtools-git/libuuu/buffer.h
• /build/mfgtools-git/src/mfgtools-git/libuuu/buffer.cpp