On 04/10/12 15:29, Lubos Lunak wrote:
On Wednesday 03 of October 2012, Michael Stahl wrote:
On 03/10/12 18:19, Lubos Lunak wrote:
As such, as far as I can tell, immutable OUString is only a complication
with no practical advantages.
please read my other mail for other benefits...
I assume you mean the mail where you refer to std.string from the D language
and call it immutable because "cannot be mutated element-by-element", even
though there is e.g. std.string.toUpperInPlace() , which clearly makes it
mutable as far as I understand the definition of mutable. So we apparently do
not agree on what immutable actually means after all.
hmm i am not really familiar with "D" and just believed the first
sentence on its string documentation page :)
so let's read more of it...
void toLowerInPlace(C)(ref C[] s);
Converts s to lowercase (in unicode, not just ASCII) in place. If s does not have any
uppercase characters, then s is unaltered.
void toUpperInPlace(C)(ref C[] s);
Converts s to uppercase (in unicode, not just ASCII) in place. If s does not have any
lowercase characters, then s is unaltered.
these do not actually seem to operate on std.string but on arrays of
characters (presumably C is a type parameter here?).
so it appears they really mean it when they say:
String handling functions. Objects of types string, wstring, and
dstring are value types and cannot be mutated element-by-element.
For using mutation during building strings, use char[], wchar[], or
dchar[]. The *string types are preferable because they don't
exhibit undesired aliasing, thus making code more robust.
There already is OUString::operator+=, so what exactly is your definition of
mutable if you think OUString is mutable despite this (and, moreover, why
does that definition matter)?
And if you think that OUString is immutable and the operator+= is some kind
of mistake that should not be there, then what is the difference between
operator= and operator+= given that, as far as the outside world is
concerned, they do almost the same, except for operator+= modifying its own
internal copy of _rtl_uString that's not accessible from outside at the time?
OUString & operator+=( const OUString & str ) SAL_THROW(())
{
rtl_uString_newConcat( &pData, pData, str.pData );
return *this;
}
it allocates a new string buffer, and does not mutate the OUString's
exising buffer.
I do not see any problem with OUString::operator+= that OUString::operator=
would not already have. And since the consensus seems to be that operator= is
needed (and indeed OUString would be awfully cumbersome without it), then
operator+= can be there as well. And, by extension, a number of other
modifying functions.
it seems you are missing the distinction between changing which buffer
the OUString points to, and mutating elements of the buffer that an
existing OUString points to, which are separate concerns, as has already
been discussed in this thread:
On 28/09/12 13:59, Michael Stahl wrote:
On 28/09/12 13:46, Noel Grandin wrote:
Hi
I don't really understand the point of not being able to mutate OUString
in-place, but being able to overwrite it via the assignment operator?
It seems to me it should be one or the other.
Either OUString is immutable, and it cannot be assigned to, except via a
constructor, or it is mutable, and we can pretty much throw away
OUStringBuffer.
the point you are missing is that OUString is a sort of "smart pointer"
to an immutable buffer. it works similarly to "String" in Java, e.g. in
Java "String s = "foo"; s = "bar"" is legal but you cannot modify the
content of whatever value is assigned to "s".
that's why OUString has an operator= that makes it point at a different
buffer but offers no way to write into the buffer (at least i hope it
doesn't...).
Context
- RE: OUString is mutable? (continued)
Re: OUString is mutable? · Stephan Bergmann
Privacy Policy |
Impressum (Legal Info) |
Copyright information: Unless otherwise specified, all text and images
on this website are licensed under the
Creative Commons Attribution-Share Alike 3.0 License.
This does not include the source code of LibreOffice, which is
licensed under the Mozilla Public License (
MPLv2).
"LibreOffice" and "The Document Foundation" are
registered trademarks of their corresponding registered owners or are
in actual use as trademarks in one or more countries. Their respective
logos and icons are also subject to international copyright laws. Use
thereof is explained in our
trademark policy.