I was trying not to be too abstract and hand wavy and give a concrete
example, but I lost you in the details. Sorry!

The generic API represented in the interface is this:

 extern int stream_open __P ((stream_t, const char *, int, int));

 extern int stream_close __P ((stream_t));
 extern int stream_read __P ((stream_t, void *, size_t, off_t, size_t *))
 extern int stream_write __P ((stream_t, const void *, size_t, off_t, size_t*))
 ... etc ...

But stream_open() isn't a generic member of the interface, it is only
meaningful for tcp and file streams (and file only if you don't use one
argument). You can see that because the "open" arguments have moved out
of the generic interface and into the factory constructors for all other
stream types:

 extern int stream_stdio_create __P ((stream_t *, FILE *))
 extern int stream_mmap_create __P ((stream_t *))
 extern int stream_memory_create __P ((stream_t *, size_t))
 extern int stream_fd_create __P ((stream_t *, int))
 extern int stream_buffer_create __P ((stream_t *, stream_t, size_t)) 

 extern int stream_file_create __P ((stream_t *))
 extern int stream_tcp_create __P ((stream_t *))

The stream factories arent handled the same, you can see that tcp and file
are special cases. The stream_open() probably used to be generic, but now
that there are are wider variety of factories it isn't anymore.

I see two ways to make the interfaces symetric around stream type:

1) Provide  the specific information to "open".

Replace the specific stream_*_create() functions with a generic
stream_create(), and replace the tcp/file-specific stream_open() with a
stream_*_open() specific to every kind of stream. Now the variability in
streams would effect only one operation, the "open" operation.

(The reopening was a detail of my example, not an end goal, it just reopened
because the existing implementation of the file stream's open reopens.)

2) Provide the specific information to "create".

So here the existing stream_*_create() functions would stay the same, except
for tcp and file which would become

extern int stream_file_create __P ((stream_t *, char* filename, int flags))
extern int stream_tcp_create __P ((stream_t *, char* host, int port, int flags))

(If you want to seperate specification of the resource and opening, then
having a generic stream_open(stream_t) would be useful. When you create the
stream it wouldnt be automatically opened it would just create the stream_t
and return the interface, then you would call stream_open() when you wanted
the stream opened.

--

It sounds like (2) might keep the idea that stream_t is an interface.

How about:

 extern int stream_file_create __P ((stream_t *, char* filename, int flags))
 extern int stream_tcp_create __P ((stream_t *, char* host, int port, int flags))
 extern int stream_stdio_create __P ((stream_t *, FILE *))
 extern int stream_mmap_create __P ((stream_t *))
 extern int stream_memory_create __P ((stream_t *, size_t))
 extern int stream_fd_create __P ((stream_t *, int))
 extern int stream_buffer_create __P ((stream_t *, stream_t, size_t)) 

And:

 extern int stream_open __P ((stream_t));

   (Open's the stream, how it does this is its business, the information
    it needs to open the resource was specified in the stream_X_create()
    function.)

 extern int stream_close __P ((stream_t));
 extern int stream_read __P ((stream_t, void *, size_t, off_t, size_t *))
 extern int stream_write __P ((stream_t, const void *, size_t, off_t, size_t*))
 ... etc ...


Does this make more sense?

Bon soir,
Sam