Boost logo

Boost :

From: William E. Kempf (williamkempf_at_[hidden])
Date: 2002-08-06 09:07:30


----- Original Message -----
From: "Glen Knowles" <gknowles_at_[hidden]>
To: <boost_at_[hidden]>
Sent: Monday, August 05, 2002 7:45 PM
Subject: RE: [boost] Re: Re:
Re:Re:PlatformNeutrality-withoutreinterpret_cast<>andifdef

> From: William E. Kempf [mailto:williamkempf_at_[hidden]]
> > In Eric's defense, the use of #ifdef's in Boost.Threads is generally not
> > done to "assist... deficient compiler(s)" but to provide platform
specific
> > implementations. His argument is that there are other ways to do the
same
> > thing with more "clarity", but the problem is that this view is only an
> > opinion, and one that was strongly argued against by the majority of the
> > Boost membership (at least in regards to this specific library). I have
> > sympathy for his opinion, if not with his presentation and even if I
find
> > the opinion of the majority to be more compelling.
>
> I'm not sure his suggested implementation was addressed. My understanding
is
>
> that he was advocating separate files for the implementations of, at
least,
> the major operating system "families". This would compile only the files
> required for a given platform, with the hope of needing much less #ifdef
> clutter. Not the pimpl idiom, unless you wanted to classify it as a
compile
> time pimpl. :)

It was a PIMPL idiom. The implementation was entirely hidden from the
interface through the usage of a "pointer to implementation". This means
dynamic allocation of the implementation class (whether it's a polymorphic
class or not), which is specifically what people disliked. In fact, the
original code had a simpler variation on exactly what Eric posted.

// thread.hpp
namespace boost
{
class thread
{
// ...
private:
   class impl;
   impl* pimpl;
};
}

// thread_platform.inl
namespace boost
{
class thread::impl
{
// ...
};
}

// thread.cpp
#include <boost/thread.hpp>
#include <thread_platform.inl>

// ...

Even when I switched to conditional compilation I originally retained the
platform specific implementation files, and the main cpp file simply
#included these. This kept the code a *little* more readable, but at a
large expense in maintainability. I really don't think the current code has
any problems with clarity as the various implementations are usually clearly
separated into sections of the source file, rather then having the
conditional code in every function. There are a few exceptions to this, but
when the exceptions occur it's for compelling reasons of maintainability.

Bill Kempf


Boost list run by bdawes at acm.org, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk