#include?
#include?
#include?
#include?“asynclogging.h“
#include?“logfile.h“
#include?“timestamp.h“

const?char?digits[]?=?“9876543210123456789“;
const?char*?zero?=?digits?+?9;
static_assert（sizeof（digits）?==?20?“digitshex?failed“）;

const?char?digitsHex[]?=?“0123456789ABCDEF“;
static_assert（sizeof（digitsHex）?==?17?“digitshex?failed“）;

//?Efficient?Integer?to?String?Conversions?by?Matthew?Wilson.
template
size_t?convert（char?buf[]?T?value）
{
	T?i?=?value;
	char*?p?=?buf;

	do
	{
		int?lsd?=?static_cast（i?%?10）;
		i?/=?10;
		*p++?=?zero[lsd];
	}?while?（i?!=?0）;

	if?（value?	{
		*p++?=?‘-‘;
	}
	*p?=?‘\0‘;
	std::reverse（buf?p）;

	return?p?-?buf;
}

size_t?convertHex（char?buf[]?uintptr_t?value）
{
	uintptr_t?i?=?value;
	char*?p?=?buf;

	do
	{
		int?lsd?=?static_cast（i?%?16）;
		i?/=?16;
		*p++?=?digitsHex[lsd];
	}?while?（i?!=?0）;

	*p?=?‘\0‘;
	std::reverse（buf?p）;

	return?p?-?buf;
}

template?class?FixedBuffer;
template?class?FixedBuffer;


template
const?char*?FixedBuffer::debugString（）
{
	*cur_?=?‘\0‘;
	return?data_;
}

template
void?FixedBuffer::cookieStart（）
{
}

template
void?FixedBuffer::cookieEnd（）
{
}

AsyncLogging::AsyncLogging（const?string&?basename
						???size_t?rollSize
						???int?flushInterval）
						???:?flushInterval_（flushInterval）
						???running_（false）
						???basename_（basename）
						???rollSize_（rollSize）						???
						???latch_（1）
						???currentBuffer_（new?Buffer）
						???nextBuffer_（new?Buffer）
						???buffers_（）
{
	currentBuffer_->bzero（）;
	nextBuffer_->bzero（）;
	buffers_.reserve（16）;
}

void?AsyncLogging::append（const?char*?logline?int?len）
{
	std::unique_lock?lock（mutex_）;
	if?（currentBuffer_->avail（）?>?len）
	{
		currentBuffer_->append（logline?len）;
	}
	else
	{
		buffers_.push_back（currentBuffer_）;

		if?（nextBuffer_）
		{
			currentBuffer_?=?std::move（nextBuffer_）;
		}
		else
		{
			currentBuffer_.reset（new?Buffer）;?//?Rarely?happens
		}
		currentBuffer_->append（logline?len）;
		cond_.notify_all（）;
	}
}

void?AsyncLogging::threadFunc（）
{
	assert（running_?==?true）;
	latch_.countDown（）;
	LogFile?output（basename_?rollSize_?false）;
	BufferPtr?newBuffer1（new?Buffer）;
	BufferPtr?newBuffer2（new?Buffer）;
	newBuffer1->bzero（）;
	newBuffer2->bzero（）;
	BufferVector?buffersToWrite;
	buffersToWrite.reserve（16）;
	while?（running_）
	{
		assert（newBuffer1?&&?newBuffer1->length（）?==?0）;
		assert（newBuffer2?&&?newBuffer2->length（）?==?0）;
		assert（buffersToWrite.empty（））;

		{
			std::unique_lock?lock（mutex_）;
			if?（buffers_.empty（））??//?unusual?usage!
			{
				cond_.wait_for（lock?chrono::seconds（flushInterval_））;
			}
			buffers_.push_back（currentBuffer_）;
			currentBuffer_?=?std::move（newBuffer1）;
			buffersToWrite.swap