uuu
uuu (Universal Update Utility), mfgtools 3.0
Loading...
Searching...
No Matches
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< FragmentBlockrequest_new_blk ()
bool check_offset_in_seg (size_t offset, std::shared_ptr< FragmentBlock > blk)
std::shared_ptr< FragmentBlockget_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< DataBufferrequest_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< FileBufferm_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< FragmentBlockm_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

◆ 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:
  • /home/builder/.cache/aurutils/sync/mfgtools-git/src/mfgtools-git/libuuu/buffer.h
  • /home/builder/.cache/aurutils/sync/mfgtools-git/src/mfgtools-git/libuuu/buffer.cpp