atria-soft/etk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
etk/etk-core/Buffer.hpp

536 lines
17 KiB
C++
Raw Blame History

/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/os/FSNode.hpp>
#include <etk/debug.hpp>
// minimum gapSize when allocated
#define GAP_SIZE_MIN (80)
// maximum gap that is automatically resize
#define GAP_SIZE_MAX (GAP_SIZE_MIN*4)
/*
______________________________________________________________________________________
| |
| |
| <GapStart |
| *******************************************************************|
|****************************************** |
| Gap Stop > |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|____________________________________________________________________________________|
*/
namespace etk {
/**
* @brief This is an access on raw data that contain an internal gap.
* the gap size has an offset to increase an an offset to decrease.
*/
class Buffer {
private:
int8_t* m_data; //!< pointer on the current table of Data
int32_t m_allocated; //!< Current allocated size
// empty part of the buffer data
int32_t m_gapStart; //!< points to the first character of the gap
int32_t m_gapEnd; //!< points to the first char after the gap
public:
/**
* @brief Create an empty vector
* @param[in] _count Minimum request size of the Buffer
*/
Buffer(int32_t _count = 0) :
m_data(NULL),
m_allocated(0),
m_gapStart(0),
m_gapEnd(GAP_SIZE_MIN) {
changeAllocation(_count+GAP_SIZE_MIN);
}
/**
* @brief Re-copy constructor (copy all needed data)
* @param[in] _obj Buffer that might be copy
*/
Buffer(const etk::Buffer& _obj) :
m_data(NULL),
m_allocated(_obj.m_allocated),
m_gapStart(_obj.m_gapStart),
m_gapEnd(_obj.m_gapEnd) {
// allocate all same data
m_data = (int8_t *)malloc( m_allocated * sizeof(int8_t) );
TK_ASSERT(NULL!=m_data, "Error in data allocation");
// Copy all data ...
memcpy(m_data, _obj.m_data, m_allocated * sizeof(int8_t) );
}
/**
* @brief Destructor of the current Class
*/
~Buffer() {
if (m_data != NULL) {
free(m_data);
}
m_data = NULL;
m_allocated = 0;
m_gapStart = 0;
m_gapEnd = 0;
};
/**
* @brief Store the selected data in the requested file.
* @param[in] _file Name of the file that might be written.
* @return true if the data correctly stored
* @return false if an error occurred
*/
bool dumpIn(const etk::String& _file) {
etk::FSNode file(_file);
if (false == file.fileOpenWrite()) {
return false;
}
bool ret = true;
// write Data
file.fileWrite(m_data, sizeof(int8_t), m_gapStart);
file.fileWrite(&m_data[m_gapEnd], sizeof(int8_t), m_allocated - m_gapEnd);
file.fileClose();
return ret;
}
/**
* @brief Load data from a selected file name.
* @param[in] _file Name of the file to store buffer data.
* @return true if the data correctly stored
* @return false if an error occurred
*/
bool dumpFrom(const etk::String& _file) {
etk::FSNode file(_file);
if (false == file.fileOpenRead()) {
return false;
}
bool ret = true;
int64_t length = file.fileSize();
// error case ...
if (length > 2000000000) {
return false;
}
// allocate the current buffer :
changeAllocation(length + GAP_SIZE_MIN);
// insert Data
int32_t nbReadData = file.fileRead(&m_data[GAP_SIZE_MIN], sizeof(int8_t), length);
TK_INFO("load data : fileSize=" << length << ", readData=" << nbReadData);
// check ERROR
if (nbReadData != length) {
TK_ERROR("load data error: fileSize=" << length << ", readData=" << nbReadData);
ret = false;
}
// set the gap size at the buffer ...
m_gapStart = 0;
m_gapEnd = GAP_SIZE_MIN;
file.fileClose();
return ret;
}
/**
* @brief Re-copy operator
* @param[in] _obj Buffer that might be copy
* @return reference on the current copied Buffer
*/
etk::Buffer& operator=(const etk::Buffer& _obj) {
if( this == &_obj ) {// avoid copy to itself
return *this;
}
if (NULL != m_data) {
free(m_data);
m_data = NULL;
}
// Set the new value
m_allocated = _obj.m_allocated;
m_gapStart = _obj.m_gapStart;
m_gapEnd = _obj.m_gapEnd;
// allocate all same data
m_data = (int8_t *)malloc( m_allocated * sizeof(int8_t) );
TK_ASSERT(NULL!=m_data, "Error in data allocation");
// Copy all data ...
memcpy(m_data, _obj.m_data, m_allocated * sizeof(int8_t) );
// Return the current pointer
return *this;
}
/**
* @brief Get the data at the requested position (gap abstraction done).
* @param[in] _pos Position in the buffer.
* @return Element at the request pos.
*/
int8_t operator[] (int32_t _pos) const {
TK_ASSERT(0 <= _pos || _pos < size(), "try to read an element not existing");
if (_pos < m_gapStart) {
return m_data[_pos];
}
return m_data[_pos + m_gapEnd-m_gapStart];
}
/**
* @brief Get a current element in the vector
* @param[in] _pos Desired position read
* @return Reference on the Element
*/
int8_t& get(int32_t _pos) const {
TK_ASSERT(0 <= _pos || _pos < size(), "try to read an element not existing");
if (_pos < m_gapStart) {
return m_data[_pos];
}
return m_data[_pos + m_gapEnd-m_gapStart];
}
/**
* @brief Get elements from a specific position.
* @param[in] _pos Position of the first element.
* @param[in] _nbElement Number of element needed.
* @return The data requested
*/
etk::Vector<int8_t> get(int32_t _pos, int32_t _nbElement) {
etk::Vector<int8_t> tmpBuffer;
tmpBuffer.clear();
if (_pos < m_gapStart) {
if (_pos + _nbElement < m_gapStart) {
for (int32_t iii = _pos; iii<_pos+_nbElement; ++iii) {
tmpBuffer.pushBack(m_data[iii]);
}
} else {
for (int32_t iii = _pos; iii<m_gapStart; ++iii) {
tmpBuffer.pushBack(m_data[iii]);
}
for (int32_t iii = m_gapEnd; iii<m_gapEnd - (_nbElement - (m_gapStart - _pos)); ++iii) {
tmpBuffer.pushBack(m_data[iii]);
}
}
} else {
for (int32_t iii = _pos+(m_gapEnd-m_gapStart);
iii<_pos+(m_gapEnd-m_gapStart)+_nbElement;
++iii) {
tmpBuffer.pushBack(m_data[iii]);
}
}
return tmpBuffer;
}
/**
* @brief Add at the Last position of the Buffer.
* @param[in] _item Element to add.
*/
void pushBack(const int8_t& _item) {
insert(size(), _item);
}
/**
* @brief Insert One item at the specify position.
* @param[in] _pos Position where data might be inserted
* @param[in] _items Data that might be inserted.
*/
void insert(int32_t _pos, const int8_t& _item) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize=" << size());
return;
}
if( 0 == gapSize() ) {
if (false == gapResize(_pos, GAP_SIZE_MIN + 1) ) {
return;
}
} else if( _pos == m_gapStart
&& _pos == m_gapEnd-1 )
{
// Nothing to do ...
} else {
if (gapMove(_pos) == false) {
return;
}
}
if(_pos == m_gapStart) {
m_data[m_gapStart] = _item;
m_gapStart++;
} else {
m_data[m_gapEnd-1] = _item;
m_gapEnd--;
}
}
/**
* @brief Insert data in the Buffer.
* @param[in] _pos Position where data might be inserted
* @param[in] _items Data that might be inserted.
*/
void insert(int32_t _pos, const etk::Vector<int8_t>& _items) {
insert(_pos, &_items[0], _items.size());
}
/**
* @brief Insert data in the buffer
* @param[in] _pos Position where data might be inserted
* @param[in] _items Data that might be inserted. (no need of '\0')
* @param[in] _nbElement number of element to insert
*/
void insert(int32_t _pos, const int8_t* _items, int32_t _nbElement) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize="<<size());
return;
}
if(_nbElement > gapSize()) {
if (false == gapResize(_pos, GAP_SIZE_MIN + _nbElement) ) {
return;
}
} else {
if (false == gapMove(_pos) ) {
return;
}
}
for(int32_t iii=0; iii<_nbElement; ++iii) {
m_data[m_gapStart+iii] = _items[iii];
}
m_gapStart += _nbElement;
}
/**
* @brief Replace one element in the buffer with an other.
* @param[in] _pos Position of the element to remove.
* @param[in] _items Element that might be inserted.
*/
void replace(int32_t _pos, const int8_t& _item) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize="<<size());
return;
}
// just replace the element, not update Gap position
if (_pos < m_gapStart) {
m_data[_pos] = _item;
} else {
m_data[_pos+gapSize()] = _item;
}
}
/**
* @brief Replace a part of the buffer with the specified data.
* @param[in] _pos The first element to remove.
* @param[in] _nbRemoveElement number of element to remove.
* @param[in] _items Data that will be inserted.
*/
void replace(int32_t _pos, int32_t _nbRemoveElement, const etk::Vector<int8_t>& _items) {
replace(_pos, _nbRemoveElement, &_items[0], _items.size());
}
/**
* @brief Replace a part of the buffer with the specified data.
* @param[in] _pos The first element to remove.
* @param[in] _nbRemoveElement number of element to remove.
* @param[in] _items Data that might be inserted.
* @param[in] _nbElement Number of element that might be added.
*/
void replace(int32_t _pos, int32_t _nbRemoveElement, const int8_t* _items, int32_t _nbElement) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize="<<size());
return;
}
if( _pos+_nbRemoveElement > size() ) {
TK_ERROR("Request remove more element than expected in the buffer pos+nbRemoveElement="
<< _pos+_nbRemoveElement << " bufferSize=" << size());
return;
}
if (false == gapMove(_pos)) {
return;
}
// Remove elements :
m_gapEnd += _nbRemoveElement;
//Display();
// insert elements
insert(_pos, _items, _nbElement);
// Resize buffer if needed...
gapCheckMaxSize();
}
/**
* @brief Remove specific data in the buffer.
* @param[in] _pos The first element to remove.
* @param[in] _nbRemoveElement Number of element to remove.
*/
void remove(int32_t _pos, int32_t _nbRemoveElement = 1) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize="<<size());
return;
}
if( _pos+_nbRemoveElement > size() ) {
TK_ERROR("Request remove more element than expected in the buffer pos+nbRemoveElement="
<< _pos+_nbRemoveElement << " bufferSize=" << size());
return;
}
if (gapMove(_pos) == false) {
return;
}
// Remove elements :
if (m_allocated == m_gapEnd) {
m_gapStart -= _nbRemoveElement;
} else {
m_gapEnd += _nbRemoveElement;
}
// Resize buffer if needed...
gapCheckMaxSize();
}
/**
* @brief Remove the last element of the Buffer.
*/
void popBack() {
if (size() > 0) {
remove( size() );
}
}
/**
* @brief Remove all the data in the buffer.
*/
void clear() {
remove(0, size() );
}
protected:
/**
* @brief Get a current element in the Buffer (iterator system)
* @param[in] _realElementPosition Real position in the buffer (only use in the ITERATOR)
* @return Reference on the Element
*/
int8_t& getDirect(int32_t _realElementPosition) {
return m_data[_realElementPosition];
};
public:
/**
* @brief Get the number of element in the vector. This does not contain the gap size.
* @return The size of the set data.
*/
int32_t size() const {
return m_allocated - gapSize();
};
private:
/**
* @brief Change the current allocation to the new one (depend on the current size)
* @param[in] _newSize Minimum number of element needed
*/
void changeAllocation(int32_t _newSize) {
// Set the minimal size to 1
if(_newSize <= 0) {
_newSize = 1;
}
// Set the size with the correct chose type:
if (_newSize == m_allocated) {
return;
}
//TODO : use new and delete and multiple of power of 2.
TK_DEBUG("Change Allocation : " << m_allocated << " ==> " << _newSize);
// Check if something is allocated:
if (m_data == NULL) {
// no data allocated ==> request an allocation (might be the first)
m_data = (int8_t *)malloc( _newSize * sizeof(int8_t) );
} else {
// move data
m_data = (int8_t *)realloc( m_data, _newSize* sizeof(int8_t) );
}
// Check result with assert :
TK_ASSERT(m_data != NULL, "Error in data allocation");
// set the new allocation size
m_allocated = _newSize;
}
/**
* @brief Move the current gap at an other position
* @param[in] _pos Position of the new Gap.
* @return false The operation can not be processed.
* @return true The operation done correctly.
*/
bool gapMove(int32_t _pos) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize=" << size());
return false;
}
int32_t gapLen = m_gapEnd - m_gapStart;
if (_pos > m_gapStart) {
memmove(&m_data[m_gapStart], &m_data[m_gapEnd], _pos - m_gapStart);
} else {
memmove(&m_data[_pos + gapLen], &m_data[_pos], m_gapStart - _pos);
}
m_gapEnd += _pos - m_gapStart;
m_gapStart += _pos - m_gapStart;
return true;
}
/**
* @brief Change The gap position and size
* @param[in] _pos Position of the new Gap.
* @param[in] _newGapLen Size of the new gap (can be bigger than GAP_SIZE_MAX).
* @return false The operation can not be done.
* @return true The operation done correctly.
*/
bool gapResize(int32_t _pos, int32_t _newGapLen) {
if( _pos > size()
|| _pos < 0 ) {
TK_ERROR("Request higher than buffer size : pos=" << _pos << " bufferSize=" << size());
return false;
}
int32_t previousSize = size();
if (_newGapLen == gapSize() ) {
// nothing to do ...
return true;
} else {
if (_newGapLen > gapSize() ) {
// Change allocation size.
changeAllocation( previousSize + _newGapLen);
}
// move Data
if (_pos <= m_gapStart) {
// just move the end of the gap
memmove(&m_data[m_gapStart + _newGapLen], &m_data[m_gapEnd], previousSize - m_gapStart);
// update gap end position
m_gapEnd = m_gapStart + _newGapLen;
if (_pos < m_gapStart) {
if (false == gapMove(_pos)) {
return false;
}
}
} else {
if (false == gapMove(_pos) ) {
return false;
}
memmove(&m_data[m_gapStart + _newGapLen], &m_data[m_gapEnd], previousSize - m_gapStart);
}
if (_newGapLen < gapSize() ) {
// Change allocation size.
changeAllocation(previousSize + _newGapLen);
}
}
// update gap position
m_gapStart = _pos;
m_gapEnd = _pos + _newGapLen;
return true;
}
/**
* @brief Get the current gap size.
* @return The number of element in the gap.
*/
int32_t gapSize() const {
return m_gapEnd - m_gapStart;
}
/**
* @brief Control if the writing gap is not too big (automatic call when resize the buffer).
*/
void gapCheckMaxSize() {
if(gapSize() > GAP_SIZE_MAX) {
int32_t currentSize = size();
// Change the gap Size
if (false == gapResize(m_gapStart, GAP_SIZE_MAX) ) {
return;
}
// remove deprecated elements at the end of the buffer ...
changeAllocation(currentSize + GAP_SIZE_MAX);
}
}
};
}
Reference in New Issue View Git Blame Copy Permalink