/* Add a new current_block to the Blocks* chain, adjust size if nbytes big. */
static void
add_block(Blocks *blocks, int nbytes)
{
int header_size;
int block_size;
BlockHeader *block_header;
HPROF_ASSERT(blocks!=NULL);
HPROF_ASSERT(nbytes>0);
header_size = real_size(blocks->alignment, sizeof(BlockHeader));
block_size = blocks->elem_size*blocks->population;
if ( nbytes > block_size ) {
block_size = real_size(blocks->alignment, nbytes);
}
block_header = (BlockHeader*)HPROF_MALLOC(block_size+header_size);
block_header->next = NULL;
block_header->bytes_left = block_size;
block_header->next_pos = header_size;
/* Link in new block */
if ( blocks->current_block != NULL ) {
blocks->current_block->next = block_header;
}
blocks->current_block = block_header;
if ( blocks->first_block == NULL ) {
blocks->first_block = block_header;
}
}
static size_t onWrite(char *ptr, size_t size, size_t nmemb, void *userdata)
{
WebRequestInternalState *is_(reinterpret_cast<WebRequestInternalState*>(userdata));
is_->state = HTTP_OPEN;
if (is_->isAborted)
{
is_->state = HTTP_CLOSED;
// This should probably be CURL_WRITEFUNC_ABORT, but that doesn't
// exist. It probably would be the same numeric value, if it did.
// The docs say that it just has to be a number of bytes that is
// not "size * nmemb" to abort.
return CURL_READFUNC_ABORT;
}
// Find the size in bytes.
size_t real_size(size * nmemb);
// Write the date into the download buffer queue.
Serializer* download(dynamic_cast<Serializer*>(is_->download.Get()));
download->Write(ptr, (unsigned int)real_size);
// Emit a "download_chunk" event.
VariantMap eventData;
eventData.Insert(MakePair(StringHash("download"), Variant(is_->download)));
eventData.Insert(MakePair(StringHash("size"), Variant((unsigned int)real_size)));
is_->es.SendEvent("download_chunk", eventData);
return real_size;
}
/* Allocate bytes from a Blocks area. */
void *
blocks_alloc(Blocks *blocks, int nbytes)
{
BlockHeader *block;
int pos;
void *ptr;
HPROF_ASSERT(blocks!=NULL);
HPROF_ASSERT(nbytes>=0);
if ( nbytes == 0 ) {
return NULL;
}
block = blocks->current_block;
nbytes = real_size(blocks->alignment, nbytes);
if ( block == NULL || block->bytes_left < nbytes ) {
add_block(blocks, nbytes);
block = blocks->current_block;
}
pos = block->next_pos;
ptr = (void*)(((char*)block)+pos);
block->next_pos += nbytes;
block->bytes_left -= nbytes;
return ptr;
}
static size_t onRead(char *buffer, size_t size, size_t nitems, void *instream)
{
WebRequestInternalState *is_(reinterpret_cast<WebRequestInternalState*>(instream));
is_->state = HTTP_OPEN;
if (is_->isAborted)
{
is_->state = HTTP_CLOSED;
return CURL_READFUNC_ABORT;
}
// Find the size in bytes.
size_t real_size(size * nitems);
// Read as much as we can from the upload buffer queue.
Deserializer* upload(dynamic_cast<Deserializer*>(is_->upload.Get()));
size_t size_queued(upload->GetSize());
size_t size_left(real_size);
if ((size_left > 0) && (size_queued > 0))
{
size_t read_size(std::min(size_queued, size_left));
upload->Read(buffer, (unsigned int)read_size);
size_left -= read_size;
}
// If we still have bytes to fill, then emit a "upload_chunk" event.
if (size_left > 0)
{
VariantMap eventData;
eventData.Insert(MakePair(StringHash("upload"), Variant(is_->upload)));
eventData.Insert(MakePair(StringHash("size"), Variant((unsigned int)size_left)));
is_->es.SendEvent("upload_chunk", eventData);
}
// Read as much as we can from the upload buffer queue (again).
size_queued = upload->GetSize();
size_left = real_size;
if ((size_left > 0) && (size_queued > 0))
{
size_t read_size(std::min(size_queued, size_left));
upload->Read(buffer, (unsigned int)read_size);
size_left -= read_size;
}
// If we still have bytes to fill, then something went wrong, so we should abort.
if (size_left > 0)
{
is_->isAborted = true;
return CURL_READFUNC_ABORT;
}
return real_size;
}
static size_t onHeader(char *ptr, size_t size, size_t nmemb, void *userdata)
{
WebRequestInternalState *is_(reinterpret_cast<WebRequestInternalState*>(userdata));
if (is_->isAborted)
{
is_->state = HTTP_CLOSED;
// This should probably be CURL_HEADERFUNC_ABORT, but that doesn't
// exist. It probably would be the same numeric value, if it did.
// The docs say that it just has to be a number of bytes that is
// not "size * nmemb" to abort.
return CURL_READFUNC_ABORT;
}
// Find the size in bytes.
size_t real_size(size * nmemb);
// Check for some known values.
if (real_size == 2 && ptr[0] == '\r' && ptr[1] == '\n')
{
return real_size;
}
if (real_size > 5 && !strncmp(ptr, "HTTP/", 5))
{
return real_size;
}
// Get the header key and value, and add them to the map.
unsigned int key_end = 0;
unsigned int value_begin = 2;
while (value_begin < real_size)
{
if (ptr[key_end] == ':' && ptr[key_end + 1] == ' ')
{
break;
}
++key_end;
++value_begin;
}
if (value_begin == real_size)
{
String key(ptr, (unsigned int)real_size);
is_->responseHeaders.InsertNew(key.ToUpper(), MakePair(key, String()));
}
else
{
String key(ptr, (unsigned int)key_end);
is_->responseHeaders.InsertNew(key.ToUpper(), MakePair(key, String(ptr + value_begin, (unsigned int)real_size - value_begin - 2)));
}
return real_size;
}
template<typename T> SegmentTree<T>::SegmentTree( NVector size,
T (*f)(T,T),
T zero_element,
bool sparse):
dim(size.dim),
operation(f),
SIZE(real_size(size)),
zero(zero_element){
if(!sparse)
data=new DenseNArray<T>(2*SIZE,zero_element);
else
data=new SparseNArray<T>(2*SIZE,zero_element);
}
