How to pass memory range to functions?

[Olaf van der Spek]

Hi,

I've got a lot of functions (compression, encryption, hashing,
encoding, etc) that work on a memory range.
I wrote my own class that has constructors for
void*, void*
void*, size_t
std::string&
and that automatically reinterpret_cas t to unsigned char*.

But I'm wondering, is there a standard C++ or Boost class that already
does this?
Or is there a better way to do this?

[Puppet_Sock]

Olaf van der Spek wrote:

I've got a lot of functions (compression, encryption, hashing,
encoding, etc) that work on a memory range.
I wrote my own class that has constructors for
void*, void*
void*, size_t
std::string&
and that automatically reinterpret_cas t to unsigned char*.

But I'm wondering, is there a standard C++ or Boost class that already
does this?
Or is there a better way to do this?

The standard C++ way is to use containers like list, vector,
and such, and not to do the reinterpret_cas t thing.
Socks

[Olaf van der Spek]

On 8 May 2006 07:58:12 -0700, "Puppet_Soc k" <pu*********@ho tmail.com>
wrote:

Olaf van der Spek wrote:

I've got a lot of functions (compression, encryption, hashing,
encoding, etc) that work on a memory range.
I wrote my own class that has constructors for
void*, void*
void*, size_t
std::string&
and that automatically reinterpret_cas t to unsigned char*.

But I'm wondering, is there a standard C++ or Boost class that already
does this?
Or is there a better way to do this?

The standard C++ way is to use containers like list, vector,
and such, and not to do the reinterpret_cas t thing.

I know, but that doesn't work if you're doing low-level stuff and the
functions you're calling except pointers.

[Ivan Vecerina]

"Olaf van der Spek" <Ol********@GMa il.Com> wrote in message
news:8d******** *************** *********@4ax.c om...
: I've got a lot of functions (compression, encryption, hashing,
: encoding, etc) that work on a memory range.
: I wrote my own class that has constructors for
: void*, void*
: void*, size_t
: std::string&
: and that automatically reinterpret_cas t to unsigned char*.
:
: But I'm wondering, is there a standard C++ or Boost class that already
: does this?

The usual approach is to pass a pair of poiters or iterators
that define the bounds of data to be processed (begin-end).

: Or is there a better way to do this?

The standard/generic approach is to write template functions
that can process different kinds of data ranges. It might
also be desirable to separate the input and output buffers.

For example, consider std::transform:
void transform( srcBegin, srcEnd, dstBegin, operation );

Of course, many low-level utilities prefer to process
memory ranges, or memory chunks.
Another standard approach would be to use streams. But then
again, standard classes are geared towards text-based i/o.
The binary-level streambuf does not provide separate input-only
and output-only classes. Plus locale and facet handling impair
efficiency.
So, IMO, when one wants to do low-level binary processing, one
should not count too much on standard library support.
Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form

[Olaf van der Spek]

On Mon, 8 May 2006 22:23:02 +0200, "Ivan Vecerina"
<IN************ *****@ivan.vece rina.com> wrote:

"Olaf van der Spek" <Ol********@GMa il.Com> wrote in message
news:8d******* *************** **********@4ax. com...
: I've got a lot of functions (compression, encryption, hashing,
: encoding, etc) that work on a memory range.
: I wrote my own class that has constructors for
: void*, void*
: void*, size_t
: std::string&
: and that automatically reinterpret_cas t to unsigned char*.
:
: But I'm wondering, is there a standard C++ or Boost class that already
: does this?

The usual approach is to pass a pair of poiters or iterators
that define the bounds of data to be processed (begin-end).
But using two arguments is a disadvantage, see also Boost.Range.
For example, you can't use automatic conversion.
So, IMO, when one wants to do low-level binary processing, one
should not count too much on standard library support.

That's a shame, as I think it's a frequent task.

[Ian Collins]

Olaf van der Spek wrote:

On Mon, 8 May 2006 22:23:02 +0200, "Ivan Vecerina"
<IN************ *****@ivan.vece rina.com> wrote:

"Olaf van der Spek" <Ol********@GMa il.Com> wrote in message
news:8d****** *************** ***********@4ax .com...
: I've got a lot of functions (compression, encryption, hashing,
: encoding, etc) that work on a memory range.
: I wrote my own class that has constructors for
: void*, void*
: void*, size_t
: std::string&
: and that automatically reinterpret_cas t to unsigned char*.
:
: But I'm wondering, is there a standard C++ or Boost class that already
: does this?

The usual approach is to pass a pair of poiters or iterators
that define the bounds of data to be processed (begin-end).

But using two arguments is a disadvantage, see also Boost.Range.
For example, you can't use automatic conversion.

So, IMO, when one wants to do low-level binary processing, one
should not count too much on standard library support.

That's a shame, as I think it's a frequent task.

What would you expect a library to do in this case? You have a block of
data to process, which requires two parameters to define it, unless it
has an end marker.

--
Ian Collins.

[Olaf van der Spek]

On Tue, 09 May 2006 20:08:03 +1200, Ian Collins <ia******@hotma il.com>
wrote:

Olaf van der Spek wrote:

So, IMO, when one wants to do low-level binary processing, one
should not count too much on standard library support.

That's a shame, as I think it's a frequent task.

What would you expect a library to do in this case? You have a block of
data to process, which requires two parameters to define it, unless it
has an end marker.

I expected it to have a class like pair<unsigned char*, unsigned
char*> with constructors that take (void*, void*), (void*, size_t),
(const string&), etc.