//
// mp::ipc_vector
//
// 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_IPC_VECTOR_IMPL_H__
#define MP_IPC_VECTOR_IMPL_H__

#include <iterator>
#include <string.h>

namespace mp {


class ipc_vector::buffer {
public:
	buffer();
	~buffer();
	void reset(const char* ptr, size_t size);

private:
	template <typename PointerType>
	struct value_type_base;

	template <typename PointerType, typename ValueType>
	class iterator_base;

public:
	typedef value_type_base<char*>                       value_type;
	typedef value_type_base<const char*>                 const_value_type;
	typedef value_type&                                  reference;
	typedef const_value_type&                            const_reference;
	typedef value_type*                                  pointer;
	typedef const_value_type*                            const_pointer;
	typedef size_t                                       size_type;
	typedef ptrdiff_t                                    difference_type;
	typedef iterator_base<char*, value_type>             iterator;
	typedef iterator_base<const char*, const_value_type> const_iterator;

public:
	iterator begin();
	iterator end();
	const_iterator begin() const;
	const_iterator end() const;

private:
	char* m_start;
	char* m_end;
	size_t m_alloc_size;

private:
	buffer(const buffer&);
};


template <typename PointerType>
struct ipc_vector::buffer::value_type_base {
	value_type_base() : ptr(NULL), size(0) { }
	value_type_base(PointerType p, size_t s) : ptr(p), size(s) { }

	PointerType ptr;
	size_t size;
};


template <typename PointerType, typename ValueType>
class ipc_vector::buffer::iterator_base :
	std::iterator<std::input_iterator_tag, ValueType, ptrdiff_t> {
public:
	typedef iterator_base<PointerType, ValueType> iterator_type;

	iterator_base() : m_p(NULL) { }
	iterator_base(PointerType p) : m_p(p) { }

	iterator_type& operator++ ()
	{
		m_p += sizeof(size_t) + *(const size_t*)m_p;
		return *this;
	}

	ValueType operator* ()
	{
		return ValueType(m_p+sizeof(size_t), *(const size_t*)m_p);
	}

	bool operator== (const iterator& other) const
	{
		return m_p == other.m_p;
	}

	bool operator!= (const iterator& other) const
	{
		return m_p != other.m_p;
	}

	bool operator< (const iterator& other) const
	{
		return m_p < other.m_p;
	}

	bool operator> (const iterator& other) const
	{
		return m_p > other.m_p;
	}

	bool operator<= (const iterator& other)
	{
		return m_p <= other.m_p;
	}

	bool operator>= (const iterator& other)
	{
		return m_p >= other.m_p;
	}

public:
	PointerType m_p;
};


inline void ipc_vector::server::receive(buffer& result)
{
	base::receive(result);
}

inline bool ipc_vector::server::try_receive(buffer& result)
{
	return base::try_receive(result);
}

inline void ipc_vector::server::push(const char* ptr, size_t size)
{
	base::push(ptr, size);
}


inline void ipc_vector::client::receive(buffer& result)
{
	base::receive(result);
}

inline bool ipc_vector::client::try_receive(buffer& result)
{
	return base::try_receive(result);
}

inline void ipc_vector::client::push(const char* ptr, size_t size)
{
	base::push(ptr, size);
}


inline ipc_vector::buffer::buffer() :
	m_start(NULL), m_end(NULL), m_alloc_size(0) { }

inline ipc_vector::buffer::~buffer()
{
	::free(m_start);
}

inline void ipc_vector::buffer::reset(const char* ptr, size_t size)
{
	if(m_alloc_size < size) {
		char* tmp = (char*)::realloc(m_start, size);
		if(!tmp) { throw std::bad_alloc(); }
		m_start = tmp;
		m_alloc_size = size;
	}
	memcpy(m_start, ptr, size);
	m_end = m_start + size;
}


inline ipc_vector::buffer::iterator
ipc_vector::buffer::begin()
{
	return iterator(m_start);
}

inline ipc_vector::buffer::iterator
ipc_vector::buffer::end()
{
	return iterator(m_end);
}

inline ipc_vector::buffer::const_iterator
ipc_vector::buffer::begin() const
{
	return const_iterator(m_start);
}

inline ipc_vector::buffer::const_iterator
ipc_vector::buffer::end() const
{
	return const_iterator(m_end);
}


}  // namespace mp

#endif /* mp/ipc_vector_impl.h */