//
// mp::byte_array
//
// Copyright (C) 2008 FURUHASHI Sadayuki
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//    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 MP_BYTE_ARRAY_IMPL_H__
#define MP_BYTE_ARRAY_IMPL_H__

#include <stdexcept>
#include <cstring>
#include <algorithm>
#include "mp/serialize.h"

namespace mp {


template <typename Allocator>
byte_array<Allocator>::byte_array(size_type initial_size) :
	storage(get_allocator().allocate(initial_size)),
	start(storage),
	finish(storage),
	allocated_end(storage + initial_size)
{ }

template <typename Allocator>
byte_array<Allocator>::~byte_array()
{
	get_allocator().deallocate(storage, allocated_size());
}


template <typename Allocator>
typename byte_array<Allocator>::iterator byte_array<Allocator>::begin()
{
	return start;
}

template <typename Allocator>
typename byte_array<Allocator>::const_iterator byte_array<Allocator>::begin() const
{
	return start;
}


template <typename Allocator>
typename byte_array<Allocator>::iterator byte_array<Allocator>::end()
{
	return finish;
}

template <typename Allocator>
typename byte_array<Allocator>::const_iterator byte_array<Allocator>::end() const
{
	return finish;
}


template <typename Allocator>
bool byte_array<Allocator>::empty() const
{
	return finish == start;
}


template <typename Allocator>
typename byte_array<Allocator>::size_type byte_array<Allocator>::size() const
{
	return finish - start;
}

template <typename Allocator>
typename byte_array<Allocator>::size_type byte_array<Allocator>::capacity() const
{
	return allocated_end - start;
}


template <typename Allocator>
void byte_array<Allocator>::produced(size_type produced_size)
{
	finish += produced_size;
}

template <typename Allocator>
void byte_array<Allocator>::consumed(size_type consumed_size)
{
	if(consumed_size == size()) {
		clear();
	} else {
		start += consumed_size;
	}
}

template <typename Allocator>
void byte_array<Allocator>::clear()
{
	start = finish = storage;
}


template <typename Allocator>
typename byte_array<Allocator>::size_type byte_array<Allocator>::space() const
{
	return allocated_end - finish;
}

template <typename Allocator>
void byte_array<Allocator>::reserve(size_type new_size)
{
	if(capacity() >= new_size) { return; }
	size_type size_save = size();
	if(allocated_size() >= new_size) {
		::memmove(storage, start, size_save);
	} else {
		char* tmp = get_allocator().allocate(new_size);
		::memcpy(tmp, start, size_save);
		get_allocator().deallocate(storage, allocated_size());
		storage = tmp;
	}
	start = storage;
	finish = start + size_save;
}


template <typename Allocator>
void byte_array<Allocator>::reserve_space(size_type required_size)
{
	reserve(size() + required_size);
}

template <typename Allocator>
typename byte_array<Allocator>::size_type byte_array<Allocator>::allocated_size() const
{
	return allocated_end - storage;
}

template <typename Allocator>
typename byte_array<Allocator>::allocator_type byte_array<Allocator>::get_allocator() const
{
	return allocator_type();
}


template <typename Allocator>
void byte_array<Allocator>::swap(byte_array& other)
{
	std::swap(storage,       other.storage);
	std::swap(start,         other.start);
	std::swap(finish,        other.finish);
	std::swap(allocated_end, other.allocated_end);
}


template <typename Allocator>
void byte_array<Allocator>::read(void* buffer, size_type size)
{
	::memcpy(buffer, begin(), size);
	consumed(size);
}

template <typename Allocator>
void byte_array<Allocator>::write(const void* buffer, size_type size)
{
	reserve_space(size);
	::memcpy(end(), buffer, size);
	produced(size);
}


MP_ARGS_BEGIN
template <typename Allocator>
template <MP_ARGS_TEMPLATE>
void byte_array<Allocator>::read(MP_ARGS_PARAMS_PTR)
{
	size_t req_size = 0
MP_ARGS_ITERATOR_BEGIN
		+ sizeof(MP_ARGS_ITERATOR_TYPE)
MP_ARGS_ITERATOR_END
	;
	load<MP_ARGS_TYPES>(begin(), MP_ARGS_FUNC);
	consumed(req_size);
}
MP_ARGS_END


MP_ARGS_BEGIN
template <typename Allocator>
template <MP_ARGS_TEMPLATE>
void byte_array<Allocator>::write(MP_ARGS_PARAMS)
{
	size_t req_size = 0
MP_ARGS_ITERATOR_BEGIN
		+ sizeof(MP_ARGS_ITERATOR_TYPE)
MP_ARGS_ITERATOR_END
	;
	reserve_space(req_size);
	dump<MP_ARGS_TYPES>(end(), MP_ARGS_FUNC);
	produced(req_size);
}
MP_ARGS_END


}  // namespace mp

#endif /* mp/byte_array.h */