Chapter 1

i += p.Length();
p.Set(aBuffer->Ptr(i));
};
_LIT(KNewLine,"\n");
console->Printf(KNewLine);
}
The result is
buffer=[hell][o!]
buffer=[hell][o wo][rld!]
buffer=[he][ld!]
buffer=[held][!]
buffer=[held][ `
I`
I `
I `
I][!ld!]
buffer=[hell][o wo][rld!]
Because I specified a granularity of 4, at first, the segments are all 4 bytes long.
When I delete the seven characters from the middle of the string, the segments are
optimized for minimum data shuffling. After random operations on the buffer over a long
period – say, operations controlled by a user typing and editing text in a word processor –
the buffer can become very fragmented, with many segments containing less than the
maximum amount of data. Compress() moves the data so that as few segments as
possible are used.
ExpandL() and ResizeL() (which puts extra bytes at the end, if the new size is greater
than the current size) are useful for making a sequence of InsertL() operations atomic
and for improving their performance. Say you needed to insert six items: if you used six
InsertL()s within your function InsertSixItemsL(), you would need to trap each one
and, if it failed because of an out-of-memory error, you would need to delete all the items
you had so far inserted. In addition, the use of repeated allocation for each InsertL()
would impact performance and fragment the heap – especially for flat buffers. You can avoid
all these problems by using ExpandL() or ResizeL(), and then a series of Write()s –
which cannot leave.
If you're at your PC, replace the allocation of CBufSeg with a CBufFlat and run buffers
again. You should have little difficulty predicting or explaining the results.
Dynamic buffers are used to store array elements in expandable arrays. Both flat and
segmented arrays are provided, corresponding to the buffer types used to implement them.
CArrayFixFlat uses a flat buffer to store an array of T objects, while
CArrayFixSeg uses a segmented buffer. Ts are stored so that the nth T occupies
sizeof(T)bytes from position n*sizeof(T) in the buffer. A CBufSeg granularity of a
multiple of sizeof(T) is specified, so that a T never spans a segment boundary. These
and other array types are described in Section 8.1.3.