take!(::IOBuffer) does make copies

[mbauman]

Simple doc change to reflect the implementation.

[stevengj]

As far as I can tell, take! still does not make a copy on 0.7:

julia> buf = IOBuffer(); println(buf, "some stuff...")

julia> pointer(buf.data)
Ptr{UInt8} @0x0000000116f331c8

julia> b = take!(buf); pointer(b)
Ptr{UInt8} @0x0000000116f331c8

julia> pointer(buf.data)
Ptr{UInt8} @0x0000000116e52198

Notice that take! returns an array that points to the same memory location as the previous buf.data, after which buf.data is reset to a new (empty) array.

[mbauman]

Yes, that is true in the b.data isa Array{UInt8} && b.writeable && b.seekable case. In all other cases, a copy is made.

[stevengj]

The writeable case is the most common case in which you would use take!...

[mbauman]

Ok, so would you like this docstring to remain as it is? Or what's your alternative?

If b.data isn't a Vector{UInt8} we make a copy. Arguably this falls "outside" the documentation since this is documenting the IOBuffer method (and not the GenericIOBuffer method). It's also fairly obvious that we cannot return a Vector{UInt8} from a different kind of abstract array without making a copy.

If !b.seekable, we make a copy.

If !b.writable, we make a copy. This is another fairly common case:

julia> b = IOBuffer("asdf")
IOBuffer(data=UInt8[...], readable=true, writable=false, seekable=true, append=false, size=4, maxsize=Inf, ptr=1, mark=-1)

julia> pointer(b.data)
Ptr{UInt8} @0x00007f5dcab57b38

julia> pointer(take!(b))
Ptr{UInt8} @0x00007f5dcace2990

julia> pointer(b.data)
Ptr{UInt8} @0x00007f5dcab57b38

In my opinion we shouldn't make promises about not copying in the docstring.

[stevengj]

Maybe: "In the common case where an IOBuffer is created for writing (and is seekable), take! returns the underlying buffer without making a copy."

[ViralBShah]

@mbauman Would it be possible to update this one and get it in?

[mbauman]

I wish I could remember how I got bit by this, but I had been trusting the docstring not to make copies and got surprised when it did. I don't really like documenting all the fiddly conditions in which this happens to not take a copy; it's quite fiddly (b.data isa Array{UInt8} && b.writeable && b.seekable).

Seems simpler just not to promise it.

[ViralBShah]

Yes, it does seem simpler not to promise it. Can you rebase this one?