/*
 * 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;
}