123 lines
2.7 KiB
C++
123 lines
2.7 KiB
C++
/*
|
|
* File: Blob.cpp
|
|
*
|
|
* Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
|
|
* See included license file for license details.
|
|
*/
|
|
|
|
#include "Blob.h"
|
|
#include <stdexcept>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
Blob::Blob()
|
|
: m_data(0)
|
|
, m_length(0)
|
|
{
|
|
}
|
|
|
|
//! Makes a local copy of the \a data argument.
|
|
//!
|
|
Blob::Blob(const uint8_t *data, unsigned length)
|
|
: m_data(0)
|
|
, m_length(length)
|
|
{
|
|
m_data = reinterpret_cast<uint8_t *>(malloc(length));
|
|
memcpy(m_data, data, length);
|
|
}
|
|
|
|
//! Makes a local copy of the data owned by \a other.
|
|
//!
|
|
Blob::Blob(const Blob &other)
|
|
: m_data(0)
|
|
, m_length(other.m_length)
|
|
{
|
|
m_data = reinterpret_cast<uint8_t *>(malloc(m_length));
|
|
memcpy(m_data, other.m_data, m_length);
|
|
}
|
|
|
|
//! Disposes of the binary data associated with this object.
|
|
Blob::~Blob()
|
|
{
|
|
if (m_data)
|
|
{
|
|
free(m_data);
|
|
}
|
|
}
|
|
|
|
//! Copies \a data onto the blob's data. The blob does not assume ownership
|
|
//! of \a data.
|
|
//!
|
|
//! \param data Pointer to a buffer containing the data which will be copied
|
|
//! into the blob.
|
|
//! \param length Number of bytes pointed to by \a data.
|
|
void Blob::setData(const uint8_t *data, unsigned length)
|
|
{
|
|
setLength(length);
|
|
memcpy(m_data, data, length);
|
|
}
|
|
|
|
//! Sets the #m_length member variable to \a length and resizes #m_data to
|
|
//! the new length. The contents of #m_data past any previous contents are undefined.
|
|
//! If the new \a length is 0 then the data will be freed and a subsequent call
|
|
//! to getData() will return NULL.
|
|
//!
|
|
//! \param length New length of the blob's data in bytes.
|
|
void Blob::setLength(unsigned length)
|
|
{
|
|
if (length == 0)
|
|
{
|
|
clear();
|
|
return;
|
|
}
|
|
|
|
// Allocate new block.
|
|
if (!m_data)
|
|
{
|
|
m_data = reinterpret_cast<uint8_t *>(malloc(length));
|
|
if (!m_data)
|
|
{
|
|
throw std::runtime_error("failed to allocate memory");
|
|
}
|
|
}
|
|
// Reallocate previous block.
|
|
else
|
|
{
|
|
void *newBlob = realloc(m_data, length);
|
|
if (!newBlob)
|
|
{
|
|
throw std::runtime_error("failed to reallocate memory");
|
|
}
|
|
m_data = reinterpret_cast<uint8_t *>(newBlob);
|
|
}
|
|
|
|
// Set length.
|
|
m_length = length;
|
|
}
|
|
|
|
void Blob::append(const uint8_t *newData, unsigned newDataLength)
|
|
{
|
|
unsigned oldLength = m_length;
|
|
|
|
setLength(m_length + newDataLength);
|
|
|
|
memcpy(m_data + oldLength, newData, newDataLength);
|
|
}
|
|
|
|
void Blob::clear()
|
|
{
|
|
if (m_data)
|
|
{
|
|
free(m_data);
|
|
m_data = NULL;
|
|
}
|
|
|
|
m_length = 0;
|
|
}
|
|
|
|
void Blob::relinquish()
|
|
{
|
|
m_data = NULL;
|
|
m_length = 0;
|
|
}
|