How to zip a WideString

> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>
> Hello
>  
> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>  
> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>  
> So my proposed solution is:
>  
> For compression:             myZipString := myWideString utf8Encoded asString zipped.
> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>  
> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>  
> Thanks in advance for any help.
>  
> Peter Kenny

>
> Hi Peter,
>
> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>
> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>
> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>
> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>
> What DB and what sizes are we talking about ?
>
> Sven
>
> > On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
> >
> > Hello
> >
> > I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
> >
> > I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
> >
> > So my proposed solution is:
> >
> > For compression:             myZipString := myWideString utf8Encoded asString zipped.
> > For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
> >
> > As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
> >
> > Thanks in advance for any help.
> >
> > Peter Kenny
>
>

> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>
> Hello
>  
> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>  
> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>  
> So my proposed solution is:
>  
> For compression:             myZipString := myWideString utf8Encoded asString zipped.
> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>  
> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>  
> Thanks in advance for any help.
>  
> Peter Kenny

> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>
> Peter and Sven,
>
> zip API from string to string works fine except that aWideString
> zipped generates malformed zip string.
> I think it might be a good guidance to define
> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
> Such as
> String>>zippedWithEncoding: encoder
> zippedWithEncoding: encoder
>    ^ ByteArray
>        streamContents: [ :stream |
>            | gzstream |
>            gzstream := GZipWriteStream on: stream.
>            encoder
>                next: self size
>                putAll: self
>                startingAt: 1
>                toStream: gzstream.
>            gzstream close ]
>
> and ByteArray>>unzippedWithEncoding: encoder
> unzippedWithEncoding: encoder
>    | byteStream |
>    byteStream := GZipReadStream on: self.
>    ^ String
>        streamContents: [ :stream |
>            [ byteStream atEnd ]
>                whileFalse: [ stream nextPut: (encoder nextFromStream:
> byteStream) ] ]
>
> Then, you can write something like
> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>
> This will not affect the existing zipped/unzipped API and you can
> handle other encodings.
> This zippedWithEncoding: generates a ByteArray, which is kind of
> conformant to the encoding API.
> And you don't have to create many intermediate byte arrays and byte strings.
>
> I hope this helps.
> ---
> tomo
>
> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>
>> Hi Peter,
>>
>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>
>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>
>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>
>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>
>> What DB and what sizes are we talking about ?
>>
>> Sven
>>
>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>
>>> Hello
>>>
>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>
>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>
>>> So my proposed solution is:
>>>
>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>
>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>
>>> Thanks in advance for any help.
>>>
>>> Peter Kenny
>>
>>
>

> On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
>
> Hi Tomo,
>
> Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
>
> data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
>
> (GZipReadStream on: data) upToEnd utf8Decoded.
>
> Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
>
> Thanks again for the correction !
>
> Sven
>
>> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>>
>> Peter and Sven,
>>
>> zip API from string to string works fine except that aWideString
>> zipped generates malformed zip string.
>> I think it might be a good guidance to define
>> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
>> Such as
>> String>>zippedWithEncoding: encoder
>> zippedWithEncoding: encoder
>>   ^ ByteArray
>>       streamContents: [ :stream |
>>           | gzstream |
>>           gzstream := GZipWriteStream on: stream.
>>           encoder
>>               next: self size
>>               putAll: self
>>               startingAt: 1
>>               toStream: gzstream.
>>           gzstream close ]
>>
>> and ByteArray>>unzippedWithEncoding: encoder
>> unzippedWithEncoding: encoder
>>   | byteStream |
>>   byteStream := GZipReadStream on: self.
>>   ^ String
>>       streamContents: [ :stream |
>>           [ byteStream atEnd ]
>>               whileFalse: [ stream nextPut: (encoder nextFromStream:
>> byteStream) ] ]
>>
>> Then, you can write something like
>> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
>> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>>
>> This will not affect the existing zipped/unzipped API and you can
>> handle other encodings.
>> This zippedWithEncoding: generates a ByteArray, which is kind of
>> conformant to the encoding API.
>> And you don't have to create many intermediate byte arrays and byte strings.
>>
>> I hope this helps.
>> ---
>> tomo
>>
>> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>>
>>> Hi Peter,
>>>
>>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>>
>>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>>
>>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>>
>>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>>
>>> What DB and what sizes are we talking about ?
>>>
>>> Sven
>>>
>>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>>
>>>> Hello
>>>>
>>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>>
>>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>>
>>>> So my proposed solution is:
>>>>
>>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>>
>>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>>
>>>> Thanks in advance for any help.
>>>>
>>>> Peter Kenny
>>>
>>>
>>
>

>
> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>
>
> ByteArray>>#zipped
>   "Return a GZIP compressed version of the receiver as a ByteArray"
>
>   ^ ByteArray streamContents: [ :out |
>       (GZipWriteStream on: out) nextPutAll: self; close ]
>
> ByteArray>>#unzipped
>   "Assuming the receiver contains GZIP encoded data,
>    return the decompressed data as a ByteArray"
>
>   ^ (GZipReadStream on: self) upToEnd
>
>
> The original oneliner then becomes
>
>   'string' utf8Encoded zipped.
>
> and
>
>   data unzipped utf8Decoded
>
> which is pretty clear, simple and intention-revealing, IMHO.
>
> > On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
> >
> > Hi Tomo,
> >
> > Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
> >
> > data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
> >
> > (GZipReadStream on: data) upToEnd utf8Decoded.
> >
> > Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
> >
> > Thanks again for the correction !
> >
> > Sven
> >
> >> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
> >>
> >> Peter and Sven,
> >>
> >> zip API from string to string works fine except that aWideString
> >> zipped generates malformed zip string.
> >> I think it might be a good guidance to define
> >> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
> >> Such as
> >> String>>zippedWithEncoding: encoder
> >> zippedWithEncoding: encoder
> >>   ^ ByteArray
> >>       streamContents: [ :stream |
> >>           | gzstream |
> >>           gzstream := GZipWriteStream on: stream.
> >>           encoder
> >>               next: self size
> >>               putAll: self
> >>               startingAt: 1
> >>               toStream: gzstream.
> >>           gzstream close ]
> >>
> >> and ByteArray>>unzippedWithEncoding: encoder
> >> unzippedWithEncoding: encoder
> >>   | byteStream |
> >>   byteStream := GZipReadStream on: self.
> >>   ^ String
> >>       streamContents: [ :stream |
> >>           [ byteStream atEnd ]
> >>               whileFalse: [ stream nextPut: (encoder nextFromStream:
> >> byteStream) ] ]
> >>
> >> Then, you can write something like
> >> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
> >> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
> >>
> >> This will not affect the existing zipped/unzipped API and you can
> >> handle other encodings.
> >> This zippedWithEncoding: generates a ByteArray, which is kind of
> >> conformant to the encoding API.
> >> And you don't have to create many intermediate byte arrays and byte strings.
> >>
> >> I hope this helps.
> >> ---
> >> tomo
> >>
> >> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
> >>>
> >>> Hi Peter,
> >>>
> >>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
> >>>
> >>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
> >>>
> >>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
> >>>
> >>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
> >>>
> >>> What DB and what sizes are we talking about ?
> >>>
> >>> Sven
> >>>
> >>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
> >>>>
> >>>> Hello
> >>>>
> >>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
> >>>>
> >>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
> >>>>
> >>>> So my proposed solution is:
> >>>>
> >>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
> >>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
> >>>>
> >>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
> >>>>
> >>>> Thanks in advance for any help.
> >>>>
> >>>> Peter Kenny
> >>>
> >>>
> >>
> >
>
>

>
> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>
>
> ByteArray>>#zipped
>   "Return a GZIP compressed version of the receiver as a ByteArray"
>
>   ^ ByteArray streamContents: [ :out |
>       (GZipWriteStream on: out) nextPutAll: self; close ]
>
> ByteArray>>#unzipped
>   "Assuming the receiver contains GZIP encoded data,
>    return the decompressed data as a ByteArray"
>
>   ^ (GZipReadStream on: self) upToEnd
>
>
> The original oneliner then becomes
>
>   'string' utf8Encoded zipped.
>
> and
>
>   data unzipped utf8Decoded
>
> which is pretty clear, simple and intention-revealing, IMHO.
>
> > On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
> >
> > Hi Tomo,
> >
> > Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
> >
> > data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
> >
> > (GZipReadStream on: data) upToEnd utf8Decoded.
> >
> > Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
> >
> > Thanks again for the correction !
> >
> > Sven
> >
> >> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
> >>
> >> Peter and Sven,
> >>
> >> zip API from string to string works fine except that aWideString
> >> zipped generates malformed zip string.
> >> I think it might be a good guidance to define
> >> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
> >> Such as
> >> String>>zippedWithEncoding: encoder
> >> zippedWithEncoding: encoder
> >>   ^ ByteArray
> >>       streamContents: [ :stream |
> >>           | gzstream |
> >>           gzstream := GZipWriteStream on: stream.
> >>           encoder
> >>               next: self size
> >>               putAll: self
> >>               startingAt: 1
> >>               toStream: gzstream.
> >>           gzstream close ]
> >>
> >> and ByteArray>>unzippedWithEncoding: encoder
> >> unzippedWithEncoding: encoder
> >>   | byteStream |
> >>   byteStream := GZipReadStream on: self.
> >>   ^ String
> >>       streamContents: [ :stream |
> >>           [ byteStream atEnd ]
> >>               whileFalse: [ stream nextPut: (encoder nextFromStream:
> >> byteStream) ] ]
> >>
> >> Then, you can write something like
> >> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
> >> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
> >>
> >> This will not affect the existing zipped/unzipped API and you can
> >> handle other encodings.
> >> This zippedWithEncoding: generates a ByteArray, which is kind of
> >> conformant to the encoding API.
> >> And you don't have to create many intermediate byte arrays and byte strings.
> >>
> >> I hope this helps.
> >> ---
> >> tomo
> >>
> >> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
> >>>
> >>> Hi Peter,
> >>>
> >>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
> >>>
> >>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
> >>>
> >>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
> >>>
> >>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
> >>>
> >>> What DB and what sizes are we talking about ?
> >>>
> >>> Sven
> >>>
> >>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
> >>>>
> >>>> Hello
> >>>>
> >>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
> >>>>
> >>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
> >>>>
> >>>> So my proposed solution is:
> >>>>
> >>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
> >>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
> >>>>
> >>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
> >>>>
> >>>> Thanks in advance for any help.
> >>>>
> >>>> Peter Kenny
> >>>
> >>>
> >>
> >
>
>

> On 3 Oct 2019, at 13:49, PBKResearch <[hidden email]> wrote:
>
> Sven, Tomo
>
> Thanks for this discussion. I shall bear in mind Sven's proposed extension to ByteArray - this is exactly the sort of neater solution I was hoping for. Any chance this might make it into standard Pharo (perhaps inP8)?
>
> Peter Kenny
>
> -----Original Message-----
> From: Pharo-users <[hidden email]> On Behalf Of Tomohiro Oda
> Sent: 03 October 2019 12:22
> To: Any question about pharo is welcome <[hidden email]>
> Subject: Re: [Pharo-users] How to zip a WideString
>
> Sven,
>
> Yes, ByteArray>>zipped/unzipped are simple, neat and intuitive way of zipping/unzipping binary data.
> I also love the new idioms. They look clean and concise.
>
> Best Regards,
> ---
> tomo
>
> 2019年10月3日(木) 20:14 Sven Van Caekenberghe <[hidden email]>:
>>
>> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>>
>>
>> ByteArray>>#zipped
>>  "Return a GZIP compressed version of the receiver as a ByteArray"
>>
>>  ^ ByteArray streamContents: [ :out |
>>      (GZipWriteStream on: out) nextPutAll: self; close ]
>>
>> ByteArray>>#unzipped
>>  "Assuming the receiver contains GZIP encoded data,
>>   return the decompressed data as a ByteArray"
>>
>>  ^ (GZipReadStream on: self) upToEnd
>>
>>
>> The original oneliner then becomes
>>
>>  'string' utf8Encoded zipped.
>>
>> and
>>
>>  data unzipped utf8Decoded
>>
>> which is pretty clear, simple and intention-revealing, IMHO.
>>
>>> On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
>>>
>>> Hi Tomo,
>>>
>>> Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
>>>
>>> data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
>>>
>>> (GZipReadStream on: data) upToEnd utf8Decoded.
>>>
>>> Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
>>>
>>> Thanks again for the correction !
>>>
>>> Sven
>>>
>>>> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>>>>
>>>> Peter and Sven,
>>>>
>>>> zip API from string to string works fine except that aWideString
>>>> zipped generates malformed zip string.
>>>> I think it might be a good guidance to define
>>>> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
>>>> Such as
>>>> String>>zippedWithEncoding: encoder
>>>> zippedWithEncoding: encoder
>>>>  ^ ByteArray
>>>>      streamContents: [ :stream |
>>>>          | gzstream |
>>>>          gzstream := GZipWriteStream on: stream.
>>>>          encoder
>>>>              next: self size
>>>>              putAll: self
>>>>              startingAt: 1
>>>>              toStream: gzstream.
>>>>          gzstream close ]
>>>>
>>>> and ByteArray>>unzippedWithEncoding: encoder
>>>> unzippedWithEncoding: encoder
>>>>  | byteStream |
>>>>  byteStream := GZipReadStream on: self.
>>>>  ^ String
>>>>      streamContents: [ :stream |
>>>>          [ byteStream atEnd ]
>>>>              whileFalse: [ stream nextPut: (encoder nextFromStream:
>>>> byteStream) ] ]
>>>>
>>>> Then, you can write something like
>>>> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
>>>> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>>>>
>>>> This will not affect the existing zipped/unzipped API and you can
>>>> handle other encodings.
>>>> This zippedWithEncoding: generates a ByteArray, which is kind of
>>>> conformant to the encoding API.
>>>> And you don't have to create many intermediate byte arrays and byte strings.
>>>>
>>>> I hope this helps.
>>>> ---
>>>> tomo
>>>>
>>>> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>>>>
>>>>> Hi Peter,
>>>>>
>>>>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>>>>
>>>>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>>>>
>>>>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>>>>
>>>>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>>>>
>>>>> What DB and what sizes are we talking about ?
>>>>>
>>>>> Sven
>>>>>
>>>>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>>>>
>>>>>> Hello
>>>>>>
>>>>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>>>>
>>>>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>>>>
>>>>>> So my proposed solution is:
>>>>>>
>>>>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>>>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>>>>
>>>>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>>>>
>>>>>> Thanks in advance for any help.
>>>>>>
>>>>>> Peter Kenny
>>>>>
>>>>>
>>>>
>>>
>>
>>
>
>

> On 3 Oct 2019, at 14:05, Sven Van Caekenberghe <[hidden email]> wrote:
>
> https://github.com/pharo-project/pharo/issues/4806
>
> PR will follow
>
>> On 3 Oct 2019, at 13:49, PBKResearch <[hidden email]> wrote:
>>
>> Sven, Tomo
>>
>> Thanks for this discussion. I shall bear in mind Sven's proposed extension to ByteArray - this is exactly the sort of neater solution I was hoping for. Any chance this might make it into standard Pharo (perhaps inP8)?
>>
>> Peter Kenny
>>
>> -----Original Message-----
>> From: Pharo-users <[hidden email]> On Behalf Of Tomohiro Oda
>> Sent: 03 October 2019 12:22
>> To: Any question about pharo is welcome <[hidden email]>
>> Subject: Re: [Pharo-users] How to zip a WideString
>>
>> Sven,
>>
>> Yes, ByteArray>>zipped/unzipped are simple, neat and intuitive way of zipping/unzipping binary data.
>> I also love the new idioms. They look clean and concise.
>>
>> Best Regards,
>> ---
>> tomo
>>
>> 2019年10月3日(木) 20:14 Sven Van Caekenberghe <[hidden email]>:
>>>
>>> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>>>
>>>
>>> ByteArray>>#zipped
>>> "Return a GZIP compressed version of the receiver as a ByteArray"
>>>
>>> ^ ByteArray streamContents: [ :out |
>>>     (GZipWriteStream on: out) nextPutAll: self; close ]
>>>
>>> ByteArray>>#unzipped
>>> "Assuming the receiver contains GZIP encoded data,
>>>  return the decompressed data as a ByteArray"
>>>
>>> ^ (GZipReadStream on: self) upToEnd
>>>
>>>
>>> The original oneliner then becomes
>>>
>>> 'string' utf8Encoded zipped.
>>>
>>> and
>>>
>>> data unzipped utf8Decoded
>>>
>>> which is pretty clear, simple and intention-revealing, IMHO.
>>>
>>>> On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
>>>>
>>>> Hi Tomo,
>>>>
>>>> Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
>>>>
>>>> data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
>>>>
>>>> (GZipReadStream on: data) upToEnd utf8Decoded.
>>>>
>>>> Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
>>>>
>>>> Thanks again for the correction !
>>>>
>>>> Sven
>>>>
>>>>> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>>>>>
>>>>> Peter and Sven,
>>>>>
>>>>> zip API from string to string works fine except that aWideString
>>>>> zipped generates malformed zip string.
>>>>> I think it might be a good guidance to define
>>>>> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
>>>>> Such as
>>>>> String>>zippedWithEncoding: encoder
>>>>> zippedWithEncoding: encoder
>>>>> ^ ByteArray
>>>>>     streamContents: [ :stream |
>>>>>         | gzstream |
>>>>>         gzstream := GZipWriteStream on: stream.
>>>>>         encoder
>>>>>             next: self size
>>>>>             putAll: self
>>>>>             startingAt: 1
>>>>>             toStream: gzstream.
>>>>>         gzstream close ]
>>>>>
>>>>> and ByteArray>>unzippedWithEncoding: encoder
>>>>> unzippedWithEncoding: encoder
>>>>> | byteStream |
>>>>> byteStream := GZipReadStream on: self.
>>>>> ^ String
>>>>>     streamContents: [ :stream |
>>>>>         [ byteStream atEnd ]
>>>>>             whileFalse: [ stream nextPut: (encoder nextFromStream:
>>>>> byteStream) ] ]
>>>>>
>>>>> Then, you can write something like
>>>>> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
>>>>> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>>>>>
>>>>> This will not affect the existing zipped/unzipped API and you can
>>>>> handle other encodings.
>>>>> This zippedWithEncoding: generates a ByteArray, which is kind of
>>>>> conformant to the encoding API.
>>>>> And you don't have to create many intermediate byte arrays and byte strings.
>>>>>
>>>>> I hope this helps.
>>>>> ---
>>>>> tomo
>>>>>
>>>>> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>>>>>
>>>>>> Hi Peter,
>>>>>>
>>>>>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>>>>>
>>>>>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>>>>>
>>>>>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>>>>>
>>>>>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>>>>>
>>>>>> What DB and what sizes are we talking about ?
>>>>>>
>>>>>> Sven
>>>>>>
>>>>>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>>>>>
>>>>>>> Hello
>>>>>>>
>>>>>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>>>>>
>>>>>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>>>>>
>>>>>>> So my proposed solution is:
>>>>>>>
>>>>>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>>>>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>>>>>
>>>>>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>>>>>
>>>>>>> Thanks in advance for any help.
>>>>>>>
>>>>>>> Peter Kenny
>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>>
>>
>>
>

> On 3 Oct 2019, at 14:05, Sven Van Caekenberghe <[hidden email]> wrote:
>
> https://github.com/pharo-project/pharo/issues/4806
>
> PR will follow
>
>> On 3 Oct 2019, at 13:49, PBKResearch <[hidden email]> wrote:
>>
>> Sven, Tomo
>>
>> Thanks for this discussion. I shall bear in mind Sven's proposed extension to ByteArray - this is exactly the sort of neater solution I was hoping for. Any chance this might make it into standard Pharo (perhaps inP8)?
>>
>> Peter Kenny
>>
>> -----Original Message-----
>> From: Pharo-users <[hidden email]> On Behalf Of
>> Tomohiro Oda
>> Sent: 03 October 2019 12:22
>> To: Any question about pharo is welcome <[hidden email]>
>> Subject: Re: [Pharo-users] How to zip a WideString
>>
>> Sven,
>>
>> Yes, ByteArray>>zipped/unzipped are simple, neat and intuitive way of zipping/unzipping binary data.
>> I also love the new idioms. They look clean and concise.
>>
>> Best Regards,
>> ---
>> tomo
>>
>> 2019年10月3日(木) 20:14 Sven Van Caekenberghe <[hidden email]>:
>>>
>>> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>>>
>>>
>>> ByteArray>>#zipped
>>> "Return a GZIP compressed version of the receiver as a ByteArray"
>>>
>>> ^ ByteArray streamContents: [ :out |
>>>     (GZipWriteStream on: out) nextPutAll: self; close ]
>>>
>>> ByteArray>>#unzipped
>>> "Assuming the receiver contains GZIP encoded data,  return the
>>> decompressed data as a ByteArray"
>>>
>>> ^ (GZipReadStream on: self) upToEnd
>>>
>>>
>>> The original oneliner then becomes
>>>
>>> 'string' utf8Encoded zipped.
>>>
>>> and
>>>
>>> data unzipped utf8Decoded
>>>
>>> which is pretty clear, simple and intention-revealing, IMHO.
>>>
>>>> On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
>>>>
>>>> Hi Tomo,
>>>>
>>>> Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
>>>>
>>>> data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
>>>>
>>>> (GZipReadStream on: data) upToEnd utf8Decoded.
>>>>
>>>> Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
>>>>
>>>> Thanks again for the correction !
>>>>
>>>> Sven
>>>>
>>>>> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>>>>>
>>>>> Peter and Sven,
>>>>>
>>>>> zip API from string to string works fine except that aWideString
>>>>> zipped generates malformed zip string.
>>>>> I think it might be a good guidance to define
>>>>> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
>>>>> Such as
>>>>> String>>zippedWithEncoding: encoder
>>>>> zippedWithEncoding: encoder
>>>>> ^ ByteArray
>>>>>     streamContents: [ :stream |
>>>>>         | gzstream |
>>>>>         gzstream := GZipWriteStream on: stream.
>>>>>         encoder
>>>>>             next: self size
>>>>>             putAll: self
>>>>>             startingAt: 1
>>>>>             toStream: gzstream.
>>>>>         gzstream close ]
>>>>>
>>>>> and ByteArray>>unzippedWithEncoding: encoder
>>>>> unzippedWithEncoding: encoder
>>>>> | byteStream |
>>>>> byteStream := GZipReadStream on: self.
>>>>> ^ String
>>>>>     streamContents: [ :stream |
>>>>>         [ byteStream atEnd ]
>>>>>             whileFalse: [ stream nextPut: (encoder nextFromStream:
>>>>> byteStream) ] ]
>>>>>
>>>>> Then, you can write something like zipped := yourLongWideString
>>>>> zippedWithEncoding: ZnCharacterEncoder utf8.
>>>>> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>>>>>
>>>>> This will not affect the existing zipped/unzipped API and you can
>>>>> handle other encodings.
>>>>> This zippedWithEncoding: generates a ByteArray, which is kind of
>>>>> conformant to the encoding API.
>>>>> And you don't have to create many intermediate byte arrays and byte strings.
>>>>>
>>>>> I hope this helps.
>>>>> ---
>>>>> tomo
>>>>>
>>>>> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>>>>>
>>>>>> Hi Peter,
>>>>>>
>>>>>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>>>>>
>>>>>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>>>>>
>>>>>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>>>>>
>>>>>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>>>>>
>>>>>> What DB and what sizes are we talking about ?
>>>>>>
>>>>>> Sven
>>>>>>
>>>>>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>>>>>
>>>>>>> Hello
>>>>>>>
>>>>>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>>>>>
>>>>>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>>>>>
>>>>>>> So my proposed solution is:
>>>>>>>
>>>>>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>>>>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>>>>>
>>>>>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>>>>>
>>>>>>> Thanks in advance for any help.
>>>>>>>
>>>>>>> Peter Kenny
>>>>>>
>>>>>>
>>>>>
>>>>
>>>
>>>
>>
>>
>

>
> Richard
>
> I don't think so. The case being considered for my problem is the compression of a ByteArray produced by applying #utf8Encoded to a WideString, but it extends to any other form of ByteArray. If you substitute ByteArray for SomeClass in your examples, I think you will see why the chosen interface was used.
>
> Peter Kenny
>
>
> -----Original Message-----
> From: Pharo-users <[hidden email]> On Behalf Of Richard O'Keefe
> Sent: 03 October 2019 23:08
> To: Any question about pharo is welcome <[hidden email]>
> Subject: Re: [Pharo-users] How to zip a WideString
>
> The interface should surely be
>    SomeClass
>      methods for: 'compression'
>        zipped "return a byte array"
>
>     class methods for: 'decompression'
>       unzip: aByteArray "return an instance of SomeClass"
>
>

> On 4 Oct 2019, at 06:36, Richard O'Keefe <[hidden email]> wrote:
>
> Here's how it would look in my library:
>   compressed := original zipped.
>      "There is currently one definition, in
> AbstractStringOrByteArray, covering [ReadOnly]ByteArray,
> [ReadOnly]String and its many subclasses,
>       ByteBuffer,StringBuffer, Substring, [ReadOnly]ShortArray,
> [ReadOnly]MappedByteArray, and some others.  This relies on
>       _ asByteArraySize and _ asByteArrayDo: _.  There is no need for
> a separate #utf8Encoded, that's what asByteArrayDo: *does*."
>
>  copy := original class unzip: compressed.
>    "This is a little trickier, but not hugely so.  There is no need
> for special case code.   [ReadOnly][Mapped]ByteArray and ByteBuffer
> are
>     sequences of bytes, Stringy things are Unicode, and
> [ReadOnly]ShortArrays are treated as UTF16."
>
> As far as I can tell, this just works for the original use case.
>
> On Fri, 4 Oct 2019 at 11:42, PBKResearch <[hidden email]> wrote:
>>
>> Richard
>>
>> I don't think so. The case being considered for my problem is the compression of a ByteArray produced by applying #utf8Encoded to a WideString, but it extends to any other form of ByteArray. If you substitute ByteArray for SomeClass in your examples, I think you will see why the chosen interface was used.
>>
>> Peter Kenny
>>
>>
>> -----Original Message-----
>> From: Pharo-users <[hidden email]> On Behalf Of Richard O'Keefe
>> Sent: 03 October 2019 23:08
>> To: Any question about pharo is welcome <[hidden email]>
>> Subject: Re: [Pharo-users] How to zip a WideString
>>
>> The interface should surely be
>>   SomeClass
>>     methods for: 'compression'
>>       zipped "return a byte array"
>>
>>    class methods for: 'decompression'
>>      unzip: aByteArray "return an instance of SomeClass"
>>
>>
>

> On 3 Oct 2019, at 13:21, Tomohiro Oda <[hidden email]> wrote:
>
> Sven,
>
> Yes, ByteArray>>zipped/unzipped are simple, neat and intuitive way of
> zipping/unzipping binary data.
> I also love the new idioms. They look clean and concise.
>
> Best Regards,
> ---
> tomo
>
> 2019年10月3日(木) 20:14 Sven Van Caekenberghe <[hidden email]>:
>>
>> Actually, thinking about this a bit more, why not add #zipped #unzipped to ByteArray ?
>>
>>
>> ByteArray>>#zipped
>>  "Return a GZIP compressed version of the receiver as a ByteArray"
>>
>>  ^ ByteArray streamContents: [ :out |
>>      (GZipWriteStream on: out) nextPutAll: self; close ]
>>
>> ByteArray>>#unzipped
>>  "Assuming the receiver contains GZIP encoded data,
>>   return the decompressed data as a ByteArray"
>>
>>  ^ (GZipReadStream on: self) upToEnd
>>
>>
>> The original oneliner then becomes
>>
>>  'string' utf8Encoded zipped.
>>
>> and
>>
>>  data unzipped utf8Decoded
>>
>> which is pretty clear, simple and intention-revealing, IMHO.
>>
>>> On 3 Oct 2019, at 13:04, Sven Van Caekenberghe <[hidden email]> wrote:
>>>
>>> Hi Tomo,
>>>
>>> Indeed, I stand corrected, it does indeed seem possible to use the existing gzip classes to work from bytes to bytes, this works fine:
>>>
>>> data := ByteArray streamContents: [ :out | (GZipWriteStream on: out) nextPutAll: 'foo 10 €' utf8Encoded; close ].
>>>
>>> (GZipReadStream on: data) upToEnd utf8Decoded.
>>>
>>> Now regarding the encoding option, I am not so sure that is really necessary (though nice to have). Why would anyone use anything except UTF8 (today).
>>>
>>> Thanks again for the correction !
>>>
>>> Sven
>>>
>>>> On 3 Oct 2019, at 12:41, Tomohiro Oda <[hidden email]> wrote:
>>>>
>>>> Peter and Sven,
>>>>
>>>> zip API from string to string works fine except that aWideString
>>>> zipped generates malformed zip string.
>>>> I think it might be a good guidance to define
>>>> String>>zippedWithEncoding: and ByteArray>>unzippedWithEncoding: .
>>>> Such as
>>>> String>>zippedWithEncoding: encoder
>>>> zippedWithEncoding: encoder
>>>>  ^ ByteArray
>>>>      streamContents: [ :stream |
>>>>          | gzstream |
>>>>          gzstream := GZipWriteStream on: stream.
>>>>          encoder
>>>>              next: self size
>>>>              putAll: self
>>>>              startingAt: 1
>>>>              toStream: gzstream.
>>>>          gzstream close ]
>>>>
>>>> and ByteArray>>unzippedWithEncoding: encoder
>>>> unzippedWithEncoding: encoder
>>>>  | byteStream |
>>>>  byteStream := GZipReadStream on: self.
>>>>  ^ String
>>>>      streamContents: [ :stream |
>>>>          [ byteStream atEnd ]
>>>>              whileFalse: [ stream nextPut: (encoder nextFromStream:
>>>> byteStream) ] ]
>>>>
>>>> Then, you can write something like
>>>> zipped := yourLongWideString zippedWithEncoding: ZnCharacterEncoder utf8.
>>>> unzipped := zipped unzippedWithEncoding: ZnCharacterEncoder utf8.
>>>>
>>>> This will not affect the existing zipped/unzipped API and you can
>>>> handle other encodings.
>>>> This zippedWithEncoding: generates a ByteArray, which is kind of
>>>> conformant to the encoding API.
>>>> And you don't have to create many intermediate byte arrays and byte strings.
>>>>
>>>> I hope this helps.
>>>> ---
>>>> tomo
>>>>
>>>> 2019/10/3(Thu) 18:56 Sven Van Caekenberghe <[hidden email]>:
>>>>>
>>>>> Hi Peter,
>>>>>
>>>>> About #zipped / #unzipped and the inflate / deflate classes: your observation is correct, these work from string to string, while clearly the compressed representation should be binary.
>>>>>
>>>>> The contents (input, what is inside the compressed data) can be anything, it is not necessarily a string (it could be an image, so also something binary). Only the creator of the compressed data knows, you cannot assume to know in general.
>>>>>
>>>>> It would be possible (and it would be very nice) to change this, however that will have serious impact on users (as the contract changes).
>>>>>
>>>>> About your use case: why would your DB not be capable of storing large strings ? A good DB should be capable of storing any kind of string (full unicode) efficiently.
>>>>>
>>>>> What DB and what sizes are we talking about ?
>>>>>
>>>>> Sven
>>>>>
>>>>>> On 3 Oct 2019, at 11:06, PBKResearch <[hidden email]> wrote:
>>>>>>
>>>>>> Hello
>>>>>>
>>>>>> I have a problem with text storage, to which I seem to have found a solution, but it’s a bit clumsy-looking. I would be grateful for confirmation that (a) there is no neater solution, (b) I can rely on this to work – I only know that it works in a few test cases.
>>>>>>
>>>>>> I need to store a large number of text strings in a database. To avoid the database files becoming too large, I am thinking of zipping the strings, or at least the less frequently accessed ones. Depending on the source, some of the strings will be instances of ByteString, some of WideString (because they contain characters not representable in one byte). Storing a WideString uncompressed seems to occupy 4 bytes per character, so I decided, before thinking of compression, to store the strings utf8Encoded, which yields a ByteArray. But zipped can only be applied to a String, not a ByteArray.
>>>>>>
>>>>>> So my proposed solution is:
>>>>>>
>>>>>> For compression:             myZipString := myWideString utf8Encoded asString zipped.
>>>>>> For decompression:         myOutputString := myZipString unzipped asByteArray utf8Decoded.
>>>>>>
>>>>>> As I said, it works in all the cases I tried, whether WideString or not, but the chains of transformations look clunky somehow. Can anyone see a neater way of doing it? And can I rely on it working, especially when I am handling foreign texts with many multi-byte characters?
>>>>>>
>>>>>> Thanks in advance for any help.
>>>>>>
>>>>>> Peter Kenny
>>>>>
>>>>>
>>>>
>>>
>>
>>
>

>
> Richard,
>
> Your implementation mixes zipping/unzipping and encoding/decoding, dictating a single way to do so, if I understand it correctly.
>
> The composition with several messages allows for end users to choose their own encoding format, depending on their own needs, which I think is more flexible.
>
> Sven
>
> > On 4 Oct 2019, at 06:36, Richard O'Keefe <[hidden email]> wrote:
> >
> > Here's how it would look in my library:
> >   compressed := original zipped.
> >      "There is currently one definition, in
> > AbstractStringOrByteArray, covering [ReadOnly]ByteArray,
> > [ReadOnly]String and its many subclasses,
> >       ByteBuffer,StringBuffer, Substring, [ReadOnly]ShortArray,
> > [ReadOnly]MappedByteArray, and some others.  This relies on
> >       _ asByteArraySize and _ asByteArrayDo: _.  There is no need for
> > a separate #utf8Encoded, that's what asByteArrayDo: *does*."
> >
> >  copy := original class unzip: compressed.
> >    "This is a little trickier, but not hugely so.  There is no need
> > for special case code.   [ReadOnly][Mapped]ByteArray and ByteBuffer
> > are
> >     sequences of bytes, Stringy things are Unicode, and
> > [ReadOnly]ShortArrays are treated as UTF16."
> >
> > As far as I can tell, this just works for the original use case.
> >
> > On Fri, 4 Oct 2019 at 11:42, PBKResearch <[hidden email]> wrote:
> >>
> >> Richard
> >>
> >> I don't think so. The case being considered for my problem is the compression of a ByteArray produced by applying #utf8Encoded to a WideString, but it extends to any other form of ByteArray. If you substitute ByteArray for SomeClass in your examples, I think you will see why the chosen interface was used.
> >>
> >> Peter Kenny
> >>
> >>
> >> -----Original Message-----
> >> From: Pharo-users <[hidden email]> On Behalf Of Richard O'Keefe
> >> Sent: 03 October 2019 23:08
> >> To: Any question about pharo is welcome <[hidden email]>
> >> Subject: Re: [Pharo-users] How to zip a WideString
> >>
> >> The interface should surely be
> >>   SomeClass
> >>     methods for: 'compression'
> >>       zipped "return a byte array"
> >>
> >>    class methods for: 'decompression'
> >>      unzip: aByteArray "return an instance of SomeClass"
> >>
> >>
> >
>
>