From 5611cb6d476540e6a1c654c1f9acdce2787b3505 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Mon, 23 Apr 2012 16:19:39 -0400
Subject: Okay, imported the core-http library and got it compiling
 suspiciously easily. The unit/integration tests don't work yet as I'm still
 battling cmake/autobuild as usual but first milestone passed.

---
 indra/llcorehttp/bufferarray.cpp | 281 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 281 insertions(+)
 create mode 100644 indra/llcorehttp/bufferarray.cpp

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
new file mode 100644
index 0000000000..4c20350b13
--- /dev/null
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -0,0 +1,281 @@
+/**
+ * @file bufferarray.cpp
+ * @brief Implements the BufferArray scatter/gather buffer
+ *
+ * $LicenseInfo:firstyear=2012&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2012, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "bufferarray.h"
+
+
+namespace LLCore
+{
+
+
+// ==================================
+// BufferArray::Block Declaration
+// ==================================
+
+class BufferArray::Block
+{
+public:
+	~Block();
+
+	void operator delete(void *);
+	void operator delete(void *, size_t len);
+
+protected:
+	Block(size_t len);
+
+	Block(const Block &);						// Not defined
+	void operator=(const Block &);				// Not defined
+
+	// Allocate the block with the additional space for the
+	// buffered data at the end of the object.
+	void * operator new(size_t len, size_t addl_len);
+	
+public:
+	// Only public entry to get a block.
+	static Block * alloc(size_t len);
+
+public:
+	size_t mLen;
+
+	// *NOTE:  Must be last member of the object.  We'll
+	// overallocate as requested via operator new and index
+	// into the array at will.
+	char mData[1];		
+};
+
+
+// ==================================
+// BufferArray Definitions
+// ==================================
+
+
+BufferArray::BufferArray()
+	: LLCoreInt::RefCounted(true),
+	  mPos(0),
+	  mLen(0)
+{}
+
+
+BufferArray::~BufferArray()
+{
+	for (container_t::iterator it(mBlocks.begin());
+		 it != mBlocks.end();
+		 ++it)
+	{
+		delete *it;
+		*it = NULL;
+	}
+	mBlocks.clear();
+}
+
+
+size_t BufferArray::append(const char * src, size_t len)
+{
+	if (len)
+	{
+		if (mBlocks.size() >= mBlocks.capacity())
+		{
+			mBlocks.reserve(mBlocks.size() + 5);
+		}
+		Block * block = Block::alloc(len);
+		memcpy(block->mData, src, len);
+		mBlocks.push_back(block);
+		mLen += len;
+		mPos = mLen;
+	}
+	return len;
+}
+
+
+char * BufferArray::appendBufferAlloc(size_t len)
+{
+	// If someone asks for zero-length, we give them a valid pointer.
+	if (mBlocks.size() >= mBlocks.capacity())
+	{
+		mBlocks.reserve(mBlocks.size() + 5);
+	}
+	Block * block = Block::alloc(len);
+	mBlocks.push_back(block);
+	mLen += len;
+	mPos = mLen;
+	return block->mData;
+}
+
+
+size_t BufferArray::seek(size_t pos)
+{
+	if (pos > mLen)
+		pos = mLen;
+	mPos = pos;
+	return mPos;
+}
+
+	
+size_t BufferArray::read(char * dst, size_t len)
+{
+	size_t result(0), offset(0);
+	size_t len_limit(mLen - mPos);
+	len = std::min(len, len_limit);
+
+	if (mPos >= mLen || 0 == len)
+		return 0;
+	
+	const int block_limit(mBlocks.size());
+	int block_start(findBlock(mPos, &offset));
+	if (block_start < 0)
+		return 0;
+
+	do
+	{
+		Block & block(*mBlocks[block_start]);
+		size_t block_limit(block.mLen - offset);
+		size_t block_len(std::min(block_limit, len));
+		
+		memcpy(dst, &block.mData[offset], block_len);
+		result += block_len;
+		len -= block_len;
+		dst += block_len;
+		offset = 0;
+		++block_start;
+	}
+	while (len && block_start < block_limit);
+
+	mPos += result;
+	return result;
+}
+
+
+size_t BufferArray::write(const char * src, size_t len)
+{
+	size_t result(0), offset(0);
+	if (mPos > mLen || 0 == len)
+		return 0;
+	
+	const int block_limit(mBlocks.size());
+	int block_start(findBlock(mPos, &offset));
+
+	if (block_start >= 0)
+	{
+		// Some or all of the write will be on top of
+		// existing data.
+		do
+		{
+			Block & block(*mBlocks[block_start]);
+			size_t block_limit(block.mLen - offset);
+			size_t block_len(std::min(block_limit, len));
+		
+			memcpy(&block.mData[offset], src, block_len);
+			result += block_len;
+			len -= block_len;
+			src += block_len;
+			offset = 0;
+			++block_start;
+		}
+		while (len && block_start < block_limit);
+	}
+	mPos += result;
+
+	if (len)
+	{
+		// Some or all of the remaining write data will
+		// be an append.
+		result += append(src, len);
+	}
+
+	return result;
+}
+		
+
+int BufferArray::findBlock(size_t pos, size_t * ret_offset)
+{
+	*ret_offset = 0;
+	if (pos >= mLen)
+		return -1;		// Doesn't exist
+
+	const int block_limit(mBlocks.size());
+	for (int i(0); i < block_limit; ++i)
+	{
+		if (pos < mBlocks[i]->mLen)
+		{
+			*ret_offset = pos;
+			return i;
+		}
+		pos -= mBlocks[i]->mLen;
+	}
+
+	// Shouldn't get here but...
+	return -1;
+}
+
+
+// ==================================
+// BufferArray::Block Definitions
+// ==================================
+
+
+BufferArray::Block::Block(size_t len)
+	: mLen(len)
+{
+	memset(mData, 0, len);
+}
+			
+
+BufferArray::Block::~Block()
+{
+	mLen = 0;
+}
+
+
+void * BufferArray::Block::operator new(size_t len, size_t addl_len)
+{
+	void * mem = new char[len + addl_len + sizeof(void *)];
+	return mem;
+}
+
+
+void BufferArray::Block::operator delete(void * mem)
+{
+	char * cmem = static_cast<char *>(mem);
+	delete [] cmem;
+}
+
+
+void BufferArray::Block::operator delete(void * mem, size_t)
+{
+	operator delete(mem);
+}
+
+
+BufferArray::Block * BufferArray::Block::alloc(size_t len)
+{
+	Block * block = new (len) Block(len);
+	return block;
+}
+	
+
+}  // end namespace LLCore
+
+
-- 
cgit v1.2.3


From 4155301015525a242a79b9b3134e66d366bc0ebd Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Fri, 1 Jun 2012 21:30:45 -0400
Subject: Do some work on BufferArray to make it a bit less naive about
 chunking data.  Remove the stateful use of a seek pointer so that shared read
 is possible (though maybe not interesting).

---
 indra/llcorehttp/bufferarray.cpp | 126 +++++++++++++++++++++++++++------------
 1 file changed, 88 insertions(+), 38 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 4c20350b13..c13b1a3540 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -27,6 +27,18 @@
 #include "bufferarray.h"
 
 
+// BufferArray is a list of chunks, each a BufferArray::Block, of contiguous
+// data presented as a single array.  Chunks are at least BufferArray::BLOCK_ALLOC_SIZE
+// in length and can be larger.  Any chunk may be partially filled or even
+// empty.
+//
+// The BufferArray itself is sharable as a RefCounted entity.  As shared
+// reads don't work with the concept of a current position/seek value,
+// none is kept with the object.  Instead, the read and write operations
+// all take position arguments.  Single write/shared read isn't supported
+// directly and any such attempts have to be serialized outside of this
+// implementation.
+
 namespace LLCore
 {
 
@@ -58,7 +70,8 @@ public:
 	static Block * alloc(size_t len);
 
 public:
-	size_t mLen;
+	size_t mUsed;
+	size_t mAlloced;
 
 	// *NOTE:  Must be last member of the object.  We'll
 	// overallocate as requested via operator new and index
@@ -74,7 +87,6 @@ public:
 
 BufferArray::BufferArray()
 	: LLCoreInt::RefCounted(true),
-	  mPos(0),
 	  mLen(0)
 {}
 
@@ -94,19 +106,45 @@ BufferArray::~BufferArray()
 
 size_t BufferArray::append(const char * src, size_t len)
 {
-	if (len)
+	const size_t ret(len);
+	
+	// First, try to copy into the last block
+	if (len && ! mBlocks.empty())
+	{
+		Block & last(*mBlocks.back());
+		if (last.mUsed < last.mAlloced)
+		{
+			// Some will fit...
+			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
+
+			memcpy(&last.mData[last.mUsed], src, copy_len);
+			last.mUsed += copy_len;
+			llassert_always(last.mUsed <= last.mAlloced);
+			mLen += copy_len;
+			src += copy_len;
+			len -= copy_len;
+		}
+	}
+
+	// Then get new blocks as needed
+	while (len)
 	{
+		const size_t copy_len((std::min)(len, BLOCK_ALLOC_SIZE));
+		
 		if (mBlocks.size() >= mBlocks.capacity())
 		{
 			mBlocks.reserve(mBlocks.size() + 5);
 		}
-		Block * block = Block::alloc(len);
-		memcpy(block->mData, src, len);
+		Block * block = Block::alloc(BLOCK_ALLOC_SIZE);
+		memcpy(block->mData, src, copy_len);
+		block->mUsed = copy_len;
+		llassert_always(block->mUsed <= block->mAlloced);
 		mBlocks.push_back(block);
-		mLen += len;
-		mPos = mLen;
+		mLen += copy_len;
+		src += copy_len;
+		len -= copy_len;
 	}
-	return len;
+	return ret;
 }
 
 
@@ -117,41 +155,33 @@ char * BufferArray::appendBufferAlloc(size_t len)
 	{
 		mBlocks.reserve(mBlocks.size() + 5);
 	}
-	Block * block = Block::alloc(len);
+	Block * block = Block::alloc((std::max)(BLOCK_ALLOC_SIZE, len));
+	block->mUsed = len;
 	mBlocks.push_back(block);
 	mLen += len;
-	mPos = mLen;
 	return block->mData;
 }
 
 
-size_t BufferArray::seek(size_t pos)
+size_t BufferArray::read(size_t pos, char * dst, size_t len)
 {
-	if (pos > mLen)
-		pos = mLen;
-	mPos = pos;
-	return mPos;
-}
-
-	
-size_t BufferArray::read(char * dst, size_t len)
-{
-	size_t result(0), offset(0);
-	size_t len_limit(mLen - mPos);
+	if (pos >= mLen)
+		return 0;
+	size_t len_limit(mLen - pos);
 	len = std::min(len, len_limit);
-
-	if (mPos >= mLen || 0 == len)
+	if (0 == len)
 		return 0;
 	
+	size_t result(0), offset(0);
 	const int block_limit(mBlocks.size());
-	int block_start(findBlock(mPos, &offset));
+	int block_start(findBlock(pos, &offset));
 	if (block_start < 0)
 		return 0;
 
 	do
 	{
 		Block & block(*mBlocks[block_start]);
-		size_t block_limit(block.mLen - offset);
+		size_t block_limit(block.mUsed - offset);
 		size_t block_len(std::min(block_limit, len));
 		
 		memcpy(dst, &block.mData[offset], block_len);
@@ -163,19 +193,18 @@ size_t BufferArray::read(char * dst, size_t len)
 	}
 	while (len && block_start < block_limit);
 
-	mPos += result;
 	return result;
 }
 
 
-size_t BufferArray::write(const char * src, size_t len)
+size_t BufferArray::write(size_t pos, const char * src, size_t len)
 {
-	size_t result(0), offset(0);
-	if (mPos > mLen || 0 == len)
+	if (pos > mLen || 0 == len)
 		return 0;
 	
+	size_t result(0), offset(0);
 	const int block_limit(mBlocks.size());
-	int block_start(findBlock(mPos, &offset));
+	int block_start(findBlock(pos, &offset));
 
 	if (block_start >= 0)
 	{
@@ -184,20 +213,39 @@ size_t BufferArray::write(const char * src, size_t len)
 		do
 		{
 			Block & block(*mBlocks[block_start]);
-			size_t block_limit(block.mLen - offset);
+			size_t block_limit(block.mUsed - offset);
 			size_t block_len(std::min(block_limit, len));
 		
 			memcpy(&block.mData[offset], src, block_len);
 			result += block_len;
-			len -= block_len;
 			src += block_len;
+			len -= block_len;
 			offset = 0;
 			++block_start;
 		}
 		while (len && block_start < block_limit);
 	}
-	mPos += result;
 
+	// Something left, see if it will fit in the free
+	// space of the last block.
+	if (len && ! mBlocks.empty())
+	{
+		Block & last(*mBlocks.back());
+		if (last.mUsed < last.mAlloced)
+		{
+			// Some will fit...
+			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
+
+			memcpy(&last.mData[last.mUsed], src, copy_len);
+			last.mUsed += copy_len;
+			result += copy_len;
+			llassert_always(last.mUsed <= last.mAlloced);
+			mLen += copy_len;
+			src += copy_len;
+			len -= copy_len;
+		}
+	}
+	
 	if (len)
 	{
 		// Some or all of the remaining write data will
@@ -218,12 +266,12 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 	const int block_limit(mBlocks.size());
 	for (int i(0); i < block_limit; ++i)
 	{
-		if (pos < mBlocks[i]->mLen)
+		if (pos < mBlocks[i]->mUsed)
 		{
 			*ret_offset = pos;
 			return i;
 		}
-		pos -= mBlocks[i]->mLen;
+		pos -= mBlocks[i]->mUsed;
 	}
 
 	// Shouldn't get here but...
@@ -237,7 +285,8 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 
 
 BufferArray::Block::Block(size_t len)
-	: mLen(len)
+	: mUsed(0),
+	  mAlloced(len)
 {
 	memset(mData, 0, len);
 }
@@ -245,7 +294,8 @@ BufferArray::Block::Block(size_t len)
 
 BufferArray::Block::~Block()
 {
-	mLen = 0;
+	mUsed = 0;
+	mAlloced = 0;
 }
 
 
-- 
cgit v1.2.3


From c7d5b0dced7f17f77fa00c816286cdbd7a0e9d4b Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Sat, 2 Jun 2012 02:09:33 +0000
Subject: More platform fixes for linux/mac.

---
 indra/llcorehttp/bufferarray.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index c13b1a3540..47389da0be 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -85,6 +85,8 @@ public:
 // ==================================
 
 
+const size_t BufferArray::BLOCK_ALLOC_SIZE;
+
 BufferArray::BufferArray()
 	: LLCoreInt::RefCounted(true),
 	  mLen(0)
-- 
cgit v1.2.3


From 3a9c182d7fe3fdacf5923e3b1b51456472e60bb1 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Sat, 2 Jun 2012 02:22:07 +0000
Subject: Stupid windows tricks.

---
 indra/llcorehttp/bufferarray.cpp | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 47389da0be..36a8006bce 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -85,7 +85,9 @@ public:
 // ==================================
 
 
+#if	! defined(WIN32)
 const size_t BufferArray::BLOCK_ALLOC_SIZE;
+#endif	// ! defined(WIN32)
 
 BufferArray::BufferArray()
 	: LLCoreInt::RefCounted(true),
-- 
cgit v1.2.3


From 267ab5b417eaef64a170d69ad83334df9d566ed9 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Mon, 11 Jun 2012 17:47:04 -0400
Subject: Convert BufferArray interfaces to void * (not char *). 
 HttpRequest::update() honor time limit. Generally, opaque data operations are
 expected to be over 'void *' and have now converted interfaces to do that. 
 Update() method honors millisecond limit to dwell time.  Might want to
 homologate the millis/uSecs mix later....

---
 indra/llcorehttp/bufferarray.cpp | 37 +++++++++++++++++++++----------------
 1 file changed, 21 insertions(+), 16 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 36a8006bce..6d5309a043 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -108,10 +108,11 @@ BufferArray::~BufferArray()
 }
 
 
-size_t BufferArray::append(const char * src, size_t len)
+size_t BufferArray::append(const void * src, size_t len)
 {
 	const size_t ret(len);
-	
+	const char * c_src(static_cast<const char *>(src));
+					  
 	// First, try to copy into the last block
 	if (len && ! mBlocks.empty())
 	{
@@ -121,11 +122,11 @@ size_t BufferArray::append(const char * src, size_t len)
 			// Some will fit...
 			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
 
-			memcpy(&last.mData[last.mUsed], src, copy_len);
+			memcpy(&last.mData[last.mUsed], c_src, copy_len);
 			last.mUsed += copy_len;
 			llassert_always(last.mUsed <= last.mAlloced);
 			mLen += copy_len;
-			src += copy_len;
+			c_src += copy_len;
 			len -= copy_len;
 		}
 	}
@@ -140,19 +141,19 @@ size_t BufferArray::append(const char * src, size_t len)
 			mBlocks.reserve(mBlocks.size() + 5);
 		}
 		Block * block = Block::alloc(BLOCK_ALLOC_SIZE);
-		memcpy(block->mData, src, copy_len);
+		memcpy(block->mData, c_src, copy_len);
 		block->mUsed = copy_len;
 		llassert_always(block->mUsed <= block->mAlloced);
 		mBlocks.push_back(block);
 		mLen += copy_len;
-		src += copy_len;
+		c_src += copy_len;
 		len -= copy_len;
 	}
 	return ret;
 }
 
 
-char * BufferArray::appendBufferAlloc(size_t len)
+void * BufferArray::appendBufferAlloc(size_t len)
 {
 	// If someone asks for zero-length, we give them a valid pointer.
 	if (mBlocks.size() >= mBlocks.capacity())
@@ -167,8 +168,10 @@ char * BufferArray::appendBufferAlloc(size_t len)
 }
 
 
-size_t BufferArray::read(size_t pos, char * dst, size_t len)
+size_t BufferArray::read(size_t pos, void * dst, size_t len)
 {
+	char * c_dst(static_cast<char *>(dst));
+	
 	if (pos >= mLen)
 		return 0;
 	size_t len_limit(mLen - pos);
@@ -188,10 +191,10 @@ size_t BufferArray::read(size_t pos, char * dst, size_t len)
 		size_t block_limit(block.mUsed - offset);
 		size_t block_len(std::min(block_limit, len));
 		
-		memcpy(dst, &block.mData[offset], block_len);
+		memcpy(c_dst, &block.mData[offset], block_len);
 		result += block_len;
 		len -= block_len;
-		dst += block_len;
+		c_dst += block_len;
 		offset = 0;
 		++block_start;
 	}
@@ -201,8 +204,10 @@ size_t BufferArray::read(size_t pos, char * dst, size_t len)
 }
 
 
-size_t BufferArray::write(size_t pos, const char * src, size_t len)
+size_t BufferArray::write(size_t pos, const void * src, size_t len)
 {
+	const char * c_src(static_cast<const char *>(src));
+	
 	if (pos > mLen || 0 == len)
 		return 0;
 	
@@ -220,9 +225,9 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 			size_t block_limit(block.mUsed - offset);
 			size_t block_len(std::min(block_limit, len));
 		
-			memcpy(&block.mData[offset], src, block_len);
+			memcpy(&block.mData[offset], c_src, block_len);
 			result += block_len;
-			src += block_len;
+			c_src += block_len;
 			len -= block_len;
 			offset = 0;
 			++block_start;
@@ -240,12 +245,12 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 			// Some will fit...
 			const size_t copy_len((std::min)(len, (last.mAlloced - last.mUsed)));
 
-			memcpy(&last.mData[last.mUsed], src, copy_len);
+			memcpy(&last.mData[last.mUsed], c_src, copy_len);
 			last.mUsed += copy_len;
 			result += copy_len;
 			llassert_always(last.mUsed <= last.mAlloced);
 			mLen += copy_len;
-			src += copy_len;
+			c_src += copy_len;
 			len -= copy_len;
 		}
 	}
@@ -254,7 +259,7 @@ size_t BufferArray::write(size_t pos, const char * src, size_t len)
 	{
 		// Some or all of the remaining write data will
 		// be an append.
-		result += append(src, len);
+		result += append(c_src, len);
 	}
 
 	return result;
-- 
cgit v1.2.3


From 24e16e1632974057013b86300bb60954ea6f5684 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Tue, 12 Jun 2012 12:41:09 -0400
Subject: Convert _refcounted.h over to using LLAtomic32<>. Beware of bad
 documentation.  operator--(int) does not return what the header claimed it
 did.

---
 indra/llcorehttp/bufferarray.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 6d5309a043..ae92057df0 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -175,7 +175,7 @@ size_t BufferArray::read(size_t pos, void * dst, size_t len)
 	if (pos >= mLen)
 		return 0;
 	size_t len_limit(mLen - pos);
-	len = std::min(len, len_limit);
+	len = (std::min)(len, len_limit);
 	if (0 == len)
 		return 0;
 	
@@ -189,7 +189,7 @@ size_t BufferArray::read(size_t pos, void * dst, size_t len)
 	{
 		Block & block(*mBlocks[block_start]);
 		size_t block_limit(block.mUsed - offset);
-		size_t block_len(std::min(block_limit, len));
+		size_t block_len((std::min)(block_limit, len));
 		
 		memcpy(c_dst, &block.mData[offset], block_len);
 		result += block_len;
@@ -223,7 +223,7 @@ size_t BufferArray::write(size_t pos, const void * src, size_t len)
 		{
 			Block & block(*mBlocks[block_start]);
 			size_t block_limit(block.mUsed - offset);
-			size_t block_len(std::min(block_limit, len));
+			size_t block_len((std::min)(block_limit, len));
 		
 			memcpy(&block.mData[offset], c_src, block_len);
 			result += block_len;
-- 
cgit v1.2.3


From a50944e078b98435685f04eda0ba93e95d4c61f2 Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Tue, 19 Jun 2012 17:01:02 -0400
Subject: Cleanup:  move magic nubmers to new _httpinternal.h header file.

---
 indra/llcorehttp/bufferarray.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index ae92057df0..5eaa60c9ba 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -85,9 +85,9 @@ public:
 // ==================================
 
 
-#if	! defined(WIN32)
+#if	! LL_WINDOWS
 const size_t BufferArray::BLOCK_ALLOC_SIZE;
-#endif	// ! defined(WIN32)
+#endif	// ! LL_WINDOWS
 
 BufferArray::BufferArray()
 	: LLCoreInt::RefCounted(true),
-- 
cgit v1.2.3


From 4da93b6ad91dff1de98c3c8dd3674c0544f2958b Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Thu, 21 Jun 2012 19:45:40 -0400
Subject: SH-3177 Add streambuf/iostream adapters to BufferArray object.
 Initial version that should have enough of the plumbing to produce a working
 adapter.  Memory test is showing 8 bytes held after one of the tests so I'm
 going to revisit that later.  But basic functionality is there going by the
 unit tests.

---
 indra/llcorehttp/bufferarray.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 5eaa60c9ba..5eb8f84c34 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -288,6 +288,20 @@ int BufferArray::findBlock(size_t pos, size_t * ret_offset)
 }
 
 
+bool BufferArray::getBlockStartEnd(int block, const char ** start, const char ** end)
+{
+	if (block < 0 || block >= mBlocks.size())
+	{
+		return false;
+	}
+
+	const Block & b(*mBlocks[block]);
+	*start = &b.mData[0];
+	*end = &b.mData[b.mUsed];
+	return true;
+}
+
+
 // ==================================
 // BufferArray::Block Definitions
 // ==================================
-- 
cgit v1.2.3


From 052f985e7546aff2203773cf43c9a688c9c340ba Mon Sep 17 00:00:00 2001
From: Monty Brandenberg <monty@lindenlab.com>
Date: Tue, 24 Jul 2012 15:21:28 -0400
Subject: Trivial change to tickle build.

---
 indra/llcorehttp/bufferarray.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'indra/llcorehttp/bufferarray.cpp')

diff --git a/indra/llcorehttp/bufferarray.cpp b/indra/llcorehttp/bufferarray.cpp
index 5eb8f84c34..8eaaeed710 100644
--- a/indra/llcorehttp/bufferarray.cpp
+++ b/indra/llcorehttp/bufferarray.cpp
@@ -350,5 +350,3 @@ BufferArray::Block * BufferArray::Block::alloc(size_t len)
 	
 
 }  // end namespace LLCore
-
-
-- 
cgit v1.2.3