Boost logo

Boost :

From: Thorsten Ottosen (nesotto_at_[hidden])
Date: 2005-08-18 18:09:58

"Christopher Kohlhoff" <chris_at_[hidden]> wrote in message

> > 3. why is everything public in a host?
> Only because the host represented data without behaviour, but if a
> class with member functions is preferred I can do it that way.

it is not much that the data is without the data without all posssible configurations of those data rmain legal
values for the program? (I doubt they do)

> > 4. why does both the stream_socket and the socket_connector need to
> > know about the demuxer? Can't the socket_connector ask the
> > stream_socket
> > for its demuxer (I want to simplify usage if possible)
> This may be moot if asio is changed to use connect/async_connect
> functions on the socket itself. What do you think of that change?

I'm not quailfied to comment on that.

> As others have commented, vector<char> can introduce a performance hit
> due to default construction of the elements. Also, some applications
> need to send data structures directly, to avoid additional copies. So
> I'd prefer to keep the operations on the socket class itself using
> void*.

please consider the other mails too. there are too many drawback
in void* IMO.

I have seen/used code where a statically allocated data was far
slower than putting it on the heap. This wsa not stack-allocated, but
static data. So I'm a bit concerned about performance claims.

With a vector it should't be difficult to pull the construction
out-side the loop. From then on it would have a fixd size.

> However, IMHO the place for supporting high level types is in
> non-member functions like asio::send and asio::recv. E.g.
> template <typename SyncStream,
> typename InputIterator,
> typename Handler>
> size_t send_range(
> SyncStream& s,
> InputIterator begin,
> InputIterator end,
> size_t* total_bytes_sent = 0);
> template <typename AsyncStream,
> typename InputIterator,
> typename Handler>
> void async_send_range(
> AsyncStream& s,
> InputIterator begin,
> InputIterator end,
> Handler handler);
> I believe that it's in these sorts of functions that asio offers the
> most extensibility. Would it be useful to add functions like this to
> the library itself, and what form should they take?

If the only performance sensible iterator types are T*,
I would't mind simply

template< unsigned N >
void receive( char (&)[N] );

template< unsigned N >
void receive( char (&)[N], unsigned size );

void recieve( vector<char>& );

void recieve( vector<char>&, unsigned size );

or something.

I have a hard time imagining any overhead imposed by
vector<char> compared to a heap-allocated char*.



Boost list run by bdawes at, gregod at, cpdaniel at, john at