kopia lustrzana https://github.com/gopro/gpr
149 wiersze
3.7 KiB
C++
Executable File
149 wiersze
3.7 KiB
C++
Executable File
/*! @file gpr_internal_buffer
|
|
*
|
|
* @brief Declaration of gpr_buffer_auto object. This object
|
|
* implements a buffer that carries size information. gpr_buffer_auto can
|
|
* deallocate itself in destructor (depending on free_in_destructor member)
|
|
*
|
|
* @version 1.0.0
|
|
*
|
|
* (C) Copyright 2018 GoPro Inc (http://gopro.com/).
|
|
*
|
|
* Licensed under either:
|
|
* - Apache License, Version 2.0, http://www.apache.org/licenses/LICENSE-2.0
|
|
* - MIT license, http://opensource.org/licenses/MIT
|
|
* at your option.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifndef GPR_INTERNAL_BUFFER_H
|
|
#define GPR_INTERNAL_BUFFER_H
|
|
|
|
#include "gpr_allocator.h"
|
|
#include "gpr_buffer.h"
|
|
#include "gpr_platform.h"
|
|
#include "stdc_includes.h"
|
|
|
|
class gpr_buffer_auto
|
|
{
|
|
private:
|
|
gpr_buffer buffer;
|
|
|
|
bool free_in_destructor;
|
|
|
|
gpr_malloc mem_alloc;
|
|
|
|
gpr_free mem_free;
|
|
|
|
public:
|
|
void reset()
|
|
{
|
|
buffer.buffer = NULL;
|
|
buffer.size = 0;
|
|
free_in_destructor = false;
|
|
}
|
|
|
|
gpr_buffer_auto(gpr_malloc malloc_function, gpr_free free_function)
|
|
{
|
|
reset();
|
|
|
|
mem_alloc = malloc_function;
|
|
mem_free = free_function;
|
|
}
|
|
|
|
~gpr_buffer_auto()
|
|
{
|
|
deallocate();
|
|
}
|
|
|
|
void allocate(size_t size_of_memory)
|
|
{
|
|
assert(buffer.buffer == NULL);
|
|
assert(buffer.size == 0);
|
|
|
|
buffer.size = size_of_memory;
|
|
|
|
if(buffer.size > 0)
|
|
{
|
|
buffer.buffer = mem_alloc(buffer.size);
|
|
assert(buffer.buffer);
|
|
|
|
free_in_destructor = true;
|
|
}
|
|
}
|
|
|
|
void deallocate()
|
|
{
|
|
if(buffer.buffer && free_in_destructor)
|
|
mem_free( (char*)buffer.buffer );
|
|
|
|
reset();
|
|
}
|
|
|
|
void resize( size_t new_size )
|
|
{
|
|
buffer.size = new_size;
|
|
|
|
assert(buffer.buffer);
|
|
assert(buffer.size);
|
|
}
|
|
|
|
void set(void* _buffer, size_t _size, bool _free_in_destructor = false )
|
|
{
|
|
assert(buffer.buffer == NULL);
|
|
assert(buffer.size == 0);
|
|
|
|
buffer.buffer = _buffer;
|
|
buffer.size = _size;
|
|
free_in_destructor = _free_in_destructor;
|
|
|
|
assert(buffer.buffer);
|
|
assert(buffer.size);
|
|
}
|
|
|
|
void zero()
|
|
{
|
|
// Cant call zero for the case when buffer has been preallocated
|
|
// Call deallocate()
|
|
assert( free_in_destructor == false );
|
|
|
|
buffer.buffer = NULL;
|
|
buffer.size = 0;
|
|
}
|
|
|
|
bool is_valid() const
|
|
{
|
|
return ( buffer.buffer != NULL ) && buffer.size > 0;
|
|
}
|
|
|
|
// Accessors
|
|
void* get_buffer() const { return buffer.buffer; }
|
|
|
|
char* to_char() const { return (char*)buffer.buffer; }
|
|
|
|
unsigned char* to_uchar() const { return (unsigned char*)buffer.buffer; }
|
|
|
|
unsigned short* to_ushort() const { return (unsigned short*)buffer.buffer; }
|
|
|
|
uint16_t* to_uint16_t() const { return (uint16_t*)buffer.buffer; }
|
|
|
|
size_t get_size() const { return buffer.size; }
|
|
|
|
gpr_malloc get_malloc() const { return mem_alloc; }
|
|
|
|
gpr_free get_free() const { return mem_free; }
|
|
|
|
// Operations
|
|
int read_from_file(const char* file_path);
|
|
|
|
int write_to_file(const char* file_path);
|
|
|
|
const gpr_buffer& get_gpr_buffer() { return buffer; }
|
|
};
|
|
|
|
#endif // GPR_INTERNAL_BUFFER_H
|