- Boost - lists.preview.boost.org

[optional] warning removal
by Vicente J. Botet Escriba 21 Oct '12

21 Oct '12

Hi, can I commit this simple patch Best, Vicente svn diff ../../../boost/optional/ Index: ../../../boost/optional/optional.hpp =================================================================== --- ../../../boost/optional/optional.hpp (revision 81020) +++ ../../../boost/optional/optional.hpp (working copy) @@ -890,12 +890,12 @@ template<class T> inline -bool operator == ( none_t x, optional<T> const& y ) +bool operator == ( none_t , optional<T> const& y ) { return equal_pointees(optional<T>() ,y); } template<class T> inline -bool operator < ( none_t x, optional<T> const& y ) +bool operator < ( none_t , optional<T> const& y ) { return less_pointees(optional<T>() ,y); } template<class T>

3 3

[thread] Integration with Chrono and DateTime (was: [release][1.52] Release Notes)
by Andrey Semashev 20 Oct '12

20 Oct '12

On Oct 13, 2012 12:10 AM, "Vicente J. Botet Escriba" < vicente.botet(a)wanadoo.fr> wrote: > > Le 12/10/12 21:51, Andrey Semashev a écrit : > >> On Oct 12, 2012 8:35 PM, "Vicente J. Botet Escriba" < >> vicente.botet(a)wanadoo.fr> wrote: >>> >>> Hi, >>> Why you don't want to depend on Boost.Chrono? >> >> Because I want to minimize dependencies (especially, binary build >> dependencies). > > Me too, I want to limit dependencies :) Fair enough. Perhaps, we could absract away Boost.Thread from both libraries? Seems like a logical solution for a case like this. For example, Boost.Thread could define an internal interface for integrating with time units from different libraries. Chrono and DateTime would support this interface, and Boost.Thread could also provide the necessary glue for std::chrono integration. I think, Boost.Thread could use its own time units internally and use ADL-found functions to convert from other time units. Boost.Thread will not depend on either timing library then. Does this look viable? >> Unlike Boost.DateTime, Boost.Chrono is not needed by my library, so this >> would really be a false dependency. > > If you don't need time related thread facilities you could set BOOST_THREAD_DONT_USE_CHRONO. Would this work for you? Yes, that's what I'm doing now. I'm using DateTime units for timed functions. >> I understand that the dual interface adds more redundancy but does it >> really require active maintenance? The code has been there for quite some >> time, it's well tested and doesn't require additional work. >> >> > Any addition code has its influence on how the library could evolve. I really would prefer to remove these interfaces for Boost 1.56. I think that 1 year and a half is enough time to move to the new interface. Then I think library decoupling is the right way even more.

5 15

Boost.log: set_channel name dynamically for a basic_composite_logger
by syvyi 20 Oct '12

20 Oct '12

Hi, how to set attribute dynamically for a composite logger? lass my_logger_mt : public src::basic_composite_logger< char, my_logger_mt, src::multi_thread_model<boost::log_mt_nt5::aux::light_rw_mutex>, src::features< src::severity< severity_levels >, src::exception_handler, src::channel< std::string > > > { BOOST_LOG_FORWARD_LOGGER_CONSTRUCTORS(my_logger_mt) }; -- View this message in context: http://boost.2283326.n4.nabble.com/Boost-log-set-channel-name-dynamically-f… Sent from the Boost - Dev mailing list archive at Nabble.com.

3 34

[thread] deprecating Mutex::scoped_lock and Mutex::scoped_try_lock and boost::condition
by Vicente J. Botet Escriba 20 Oct '12

20 Oct '12

Hi, I would like to deprecate the following features in Boost.Thread: * Mutex::scoped_lock and Mutex::scoped_try_lock so that we can make mutex types independent from locks. The user should use instead unique_lock<Mutex> and the new public class try_unique_lock. * condition: This was there for forward compatibility since 1.35. The user should use instead condition_variable_any. What do you think? Best, Vicente

4 9

boost::python feature request: unique_ptr, interfaces and factory functions
by Maxim Yegorushkin 20 Oct '12

20 Oct '12

Hi Boost, I am using boost::python to expose a C++ API into Python. The class I would like to export is: struct Subscriber { virtual ~Subscriber() = 0; static std::unique_ptr<Subscriber> create(); }; It's an interface with a factory function returning a std::unique_ptr<>. I would like to be able to export it in the following manner: BOOST_PYTHON_MODULE(pub_sub) { boost::python::class_< Subscriber , std::unique_ptr<Subscriber> , boost::noncopyable >("Subscriber") .def(boost::python::init<>, Subscriber::create) ; ; } I.e., the python wrapper would hold a std::unique_ptr<Subscriber> and use Subscriber::create() factory function as a constructor for Python Subscriber class. The above code doesn't compile with boost-1.51.0 for two reasons: * std::unique_ptr<> is not supported by boost::python. On the other hand, std::auto_ptr<> is. * The factory function can't be used used as a Python object constructor. I thought there could be a way to specialize certain boost::python traits/metaclasses to make it work with std::unique_ptr<> and factory functions as constructors, but couldn't figure it out. The workaround I managed to get working is: std::auto_ptr<Subscriber> createSubscriber() { return std::auto_ptr<Subscriber>(Subscriber::create().release()); } BOOST_PYTHON_MODULE(pub_sub) { // Expose the class. boost::python::class_< Subscriber , std::auto_ptr<Subscriber> , boost::noncopyable >("Subscriber_", boost::python::no_init) ; ; // Expose its factory function. boost::python::def("Subscriber", createSubscriber); } I.e., std::unique_ptr<> gets replaced with std::auto_ptr<>, the Python class is renamed to Subscriber_ and the factory function gets exported as Subscriber allowing for Python syntax: import pub_sub s = pub_sub.Subscriber() # however assert isinstance(s, pub_sub.Subscriber) # fails assert isinstance(s, pub_sub.Subscriber_) # succeeds So, I was wondering if there are ways to make my original Python class export syntax work? -- Maxim

1 0

[test] new features use c++11 features
by Jürgen Hunold 19 Oct '12

19 Oct '12

Hi Gennadiy, the new features introduced in revision 81010 and81011 use c++ features unconditionally. This breaks compilation of Boost.Test on all older compilers. Even the recent gcc-4.6 (Ubuntu 12.04). The critical places are: std::tuple std::shared_ptr std::false_type std::remove_cv those can be replaced with std::tr1:: equivalents using boost/tr1. See a quick patch attached. The usage of std::enable_if is critical, as I could not find it in boost::tr1. But this should be available as boost::enable_if and be detected by the appropriate Boost.Config macro. And at least gcc-4.6.3 ist missing the angle bracket hack, so closing ">>" template argument lists are interpreted as operator >>. Also patched. Could you please try your changes with an older compiler first? As I can not use c++11 at the moment (I'm stuck with gcc-4.2) I would like to use the new features with this older compiler. Yours, Jürgen -- * Dipl.-Math. Jürgen Hunold ! * voice: ++49 4257 300 ! Fährstraße 1 * fax : ++49 4257 300 ! 31609 Balge/Sebbenhausen * jhunold(a)gmx.eu ! Germany

2 4

[iterator] Using zip_iterator with std::pair
by "Claas H. Köhler" 19 Oct '12

19 Oct '12

Hi! I would like to use the boost::zip_iterator with std::pair. Unfortunately this does not work out of the box, but there exists a namespace boost::detail::tuple_impl_specific, which apparently needs to be specialised for each tuple type. I managed to re-implement tuple_meta_transform and tuple_meta_accumulate for std::tuple, which seems to be straightforward. However, there are functions of the form template<typename Tuple, typename Fun> complex_result_type tuple_transform(const Tuple&, Fun) which have to be overloaded as well, if I am not mistaken. However, overloading this with something like template<typename... Args, typename Fun> complex_result_type tuple_transform(const std::tuple<Args...>&, Fun) is probably not going to work, since this would be a partial template specialisation of a function. What is the recommended way of proceeding here? Or am I making things to complicated and there exists a simpler solution to using the zip iterator with std::pair / std::tuple. Any support would be appreciated. Regards Claas P.S: I am using boost 1.50 with gcc-4.6 and the C++11 standard.

3 11

[graph] dijkstra_shortest_paths solution stability
by Jan Hudec 18 Oct '12

18 Oct '12

Hello All, I need to implement an algorithm, that uses dijkstra's algorithm as key component. However it has two additional requirements on it: 1. If for any two vertices u, v there is an edge and a path of the same length through additional vertices, the direct edge is always selected and 2. If for any two vertices u, v there is more than one shortest path, all calculates shortest path trees that include path u, v contain the same path between those vertices. Now the article that describes the algorithm uses additional property with random values to disambiguate the paths, but I am sure the following two simple rules will achieve the effect more easily: 1. When u is reached at the same distance through two vertices, v and w, the one with lower distance from start will be used in the shortest path tree. 2. When u is reached at the same distance through two vertices, v and w, that both have the same distance from start, the one that comes first in some arbitrary fixed total ordering will be used inthe shortest path tree. These rules are trivially implementable by: 1. Not updating the parent map if the new distance is not strictly less. 2. Using additional criterion in the heap comparing the vertices by index or descriptor if they have the same tentative distance. Now I suspect rule 1 is already satisfied though it's not documented. And if rule 2 is not satisfied, would it be more generally useful and worth, possibly optionally, implementing in the library? -- Jan 'Bulb' Hudec <bulb(a)ucw.cz>

3 2

Fix some "unused variable" warnings
by Martin Martin 18 Oct '12

18 Oct '12

Hi, I'm using boost with clang++, with some style-related warnings turned on, and got a few warnings for unused variables. Here's the patch; are you interested in these changes? If so, is there a better way to get them to you? Thanks, Martin --- boost_1_51_0/boost/date_time/dst_rules.hpp 2008-02-27 15:00:24.000000000 -0500 +++ boost_1_51_0-fixed/boost/date_time/dst_rules.hpp 2012-10-18 09:31:08.433591299 -0400 @@ -369,11 +369,11 @@ const time_duration_type&) { return is_not_in_dst; } - static bool is_dst_boundary_day(date_type d) + static bool is_dst_boundary_day(date_type) { return false; } static time_duration_type dst_offset() diff '--unified=5' -r boost_1_51_0/boost/optional/optional.hpp boost_1_51_0-fixed/boost/optional/optional.hpp --- boost_1_51_0/boost/optional/optional.hpp 2010-12-18 16:29:39.000000000 -0500 +++ boost_1_51_0-fixed/boost/optional/optional.hpp 2012-10-18 09:31:50.737591130 -0400 @@ -888,16 +888,16 @@ // none vs optional<T> cases // template<class T> inline -bool operator == ( none_t x, optional<T> const& y ) +bool operator == ( none_t, optional<T> const& y ) { return equal_pointees(optional<T>() ,y); } template<class T> inline -bool operator < ( none_t x, optional<T> const& y ) +bool operator < ( none_t, optional<T> const& y ) { return less_pointees(optional<T>() ,y); } template<class T> inline bool operator != ( none_t x, optional<T> const& y )

2 1

[container] #7531 shadowing warnings under gcc
by Jeffrey Lee Hellrung, Jr. 18 Oct '12

18 Oct '12

Ion: I just wanted to make sure you see this. I can identify and make the necessary changes to trunk then release if you want me to. https://svn.boost.org/trac/boost/ticket/7531 Thanks, - Jeff

1 0

[graph] Efficiency of index map in dijkstra_shortest_paths
by Jan Hudec 18 Oct '12

18 Oct '12

Hello, The dijkstra_shortest_paths function requires an index map that maps vertices to index in range [0, num_vertices(g)). However there are several practially important algorithms that requite calculating shortest path trees with many times from each vertex, but each tree only spanning small fraction of an otherwise huge graph. I am somewhat concerned about allocating arrays of the size of the graph (that has millions of vertices) over and over (hundred million or more times) when many scans will stop after hundreds of vertices. Note that filtering the graph is not an option, because the stopping condition is given by radius or number of scanned vertices, but you obviously don't know which vertices will be scanned. Is there an option to use associative container for the queue indices? Or would it be useful to add it? Thanks Jan -- Jan 'Bulb' Hudec <bulb(a)ucw.cz>

3 5

[pool2] Requests for comment
by DUPUIS Etienne 18 Oct '12

18 Oct '12

Greetings, I am currently working on a replacement for boost ::pool. I have a few questions regarding what would be an ideal implementation. Hopefully some members of the Boost mailing list will be able to help me answering these questions. The first question requires to look at the source code; my other questions are more general. First question : I have started by defining a pool object which manage fixed size buffers of a given object type. Documented code is found here : http://svn.boost.org/svn/boost/sandbox/pool2/boost/pool/pool.hpp. The code is short and hopefully well documented. Note that the 'ThreadSafe' template parameter is currently ignored; I have not implemented thread safety yet. My question is about the "pool growth policy". This policy defines how the pool grows when it needs to allocate more memory. This policy is given as a parameter to the pool constructor. Should this policy be a template argument instead ? Moreover, if the policy is a template argument, I could add a constant 'MaximumNumberOfTimesThePoolWillBeGrown' into the policy class. This constant would allow me to replace the std::vector() which holds allocated pointers with a static array. Is this the right solution ? Other questions : - I have defined a pool class which manage fixed sized buffers of some object T. Do we also need a pool class that can manage variable sized buffers of some object T ? - From a pool, I can implement a pool_allocator which inherits from std::allocator, exactly like it was done in the original boost::pool. Do we need something else ? Thank you for your valuable insights, Etienne Dupuis Ce message et toutes les pièces jointes sont confidentiels et établis à l'intention exclusive de ses destinataires. Toute modification, édition, utilisation ou diffusion non autorisée est interdite. Si vous avez reçu ce message par erreur, merci de nous en avertir immédiatement. ATEME décline toute responsabilité au titre de ce message s'il a été altéré, déformé, falsifié ou encore édité ou diffusé sans autorisation. This message and any attachments are confidential and intended solely for the addressees. Any unauthorized modification, edition, use or dissemination is prohibited. If you have received this message by mistake, please notify us immediately. ATEME decline all responsibility for this message if it has been altered, deformed, falsified or even edited or disseminated without authorization. Note: To protect against computer viruses, e-mail programs may prevent sending or receiving certain types of file attachments.

9 20

[coroutine] final version?
by Oliver Kowalke 17 Oct '12

17 Oct '12

a final (?) version of boost.coroutine is available at http://ok73.ok.funpic.de/boost-coroutine.zip In contrast to the original concept coroutine<> is not similar to a function/functor. 1.) the coroutine-fn is started at construction of coroutine<> - helps to solve some problems related to the last 'yield'-operation - similar to the behaviour of boost::thread - arguments which have to be the first arguments of coroutine-fn must be applied to coroutine<>-ctor (arguments()) 2.) coroutine<>::operator() returns a reference to the coroutine instead the return-value 3.) return-values must be accessed via coroutine<>::get() regards, Oliver

2 2

[smart_ptr] [shared_ptr] BOOST_NOEXCEPT patch
by Antony Polukhin 17 Oct '12

17 Oct '12

Hi, There is a trivial patch in ticket #7523 that marks some functions of Boost.SmartPtr library as noexcept. I'll test the patch for some more time and if there will be no objections, I'll commit it to trunk after boost_1_52_0 release. Any suggestions and comments are welcomed. -- Best regards, Antony Polukhin

1 0

[lexical_cast] cast of int8_t
by Jochen Wilhelmy 16 Oct '12

16 Oct '12

Hi! In a previous message I asked if lexical_cast could throw boost::numeric::positive_overflow when the parsing is ok but the value too large for the target type. this turned out to be difficult because it breaks existing code, alternatively there could be another exception derived from bad_lexical_cast that indicates the overflow but this seems to be a lot of work. another question is why does lexical_cast treat int8_t and uint8_t like char? technically I see no reason for this as c++ has three types: char, signed char and unsigned char. in my code I use only char for characters and signed/unsigned char as numbers. I know that the standard stream operator << treats signed/unsigned char as char but I know no explanation for this (I consider it a bug ;-) -Jochen

5 4

[type_erasure] any and shared_ptr
by Christophe Henry 16 Oct '12

16 Oct '12

Hi Steven, I need to use the associated types but don't get them to do what I need. Consider struct Pointee : public boost::enable_shared_from_this<Pointee> { void foo() { std::cout << "Pointee::foo called" << std::endl; //shared_from_this(); std::cout << "Pointee::foo end" << std::endl; } }; Pointee needs to be enable_shared_from_this for some reason, which forces me to use it in a shared_ptr. I reused your pointee / pointer structures: template<class T> struct pointee { typedef typename mpl::eval_if< boost::type_erasure::is_placeholder<T>, mpl::identity<void>, boost::pointee<T> >::type type; }; template<class T = _self> struct pointer : mpl::vector< copy_constructible<T>, dereferenceable<deduced<pointee<T> >&, T> > { typedef deduced<pointee<T> > element_type; }; I (naively) tried to define a pointee concept: typedef mpl::vector< pointer<>, same_type<pointer<>::element_type,_a >, relaxed_match, has_foo<void()> > PointeeConcept; // will not compile, shared_ptr<Pointee> has no foo... boost::shared_ptr<Pointee> p (new Pointee) ; any<PointeeConcept> ap (p); ap.foo(); So in the end I had to resort to a wrapper: struct PointeeWrap { PointeeWrap(boost::shared_ptr<Pointee>p):myPointee(p){} void foo() { std::cout << "PointeeWrap::foo called" << std::endl; myPointee->foo(); } boost::shared_ptr<Pointee> myPointee; }; BOOST_TYPE_ERASURE_MEMBER((has_foo), foo, 0); typedef any< mpl::vector< relaxed_match, copy_constructible<>, has_foo<void()> > > AnyPointee; boost::shared_ptr<Pointee> p (new Pointee); PointeeWrap wrap(p); AnyPointee ap(wrap); ap.foo(); But this will become tedious with an increasing number of members. Is there a better way? Thanks, Christophe

2 2

[mpl] Nested BOOST_MPL_ASSERT fails on VC11
by Steven Watanabe 15 Oct '12

15 Oct '12

AMDG I just ran into the following bug: template<class T> struct test : T { BOOST_MPL_ASSERT((T)); }; BOOST_MPL_ASSERT((test<T>)); I've reworked BOOST_MPL_ASSERT to avoid the problem in the attached patch. Okay to commit? In Christ, Steven Watanabe

3 4

[GIL] default_color_converter from float to integer should clamp
by Fabien Castan 15 Oct '12

15 Oct '12

Hi, The conversion from floating point image to 8 bits or 16 bits image should clamp instead of writing arbitrary values... // a floating point image, with some pixel values < 0.0 and > 1.0 boost::gil::rgba32f_view_t HDR; // use default_color_converter to convert this HDR image to 8 bits boost::gil::png_write_view( "LDR.png", boost::gil::color_converted_view<boost::gil::rgba8_pixel_t>( HDR ) ); The 8 bits LDR image contains arbitrary cast conversion values, that are not very nice. The conversion from floating point to integer values has no other valid solution than clamping. So I suggest this patch, for the file "boost/gil/channel_algorithm.hpp": @@ -272,7 +272,13 @@ template <typename DstChannelV> struct channel_converter_unsigned<bits32f,DstChannelV> : public std::unary_function<bits32f,DstChannelV> { DstChannelV operator()(bits32f x) const { typedef typename detail::unsigned_integral_max_value< DstChannelV >::value_type dst_integer_t; - return DstChannelV( static_cast< dst_integer_t >(x*channel_traits<DstChannelV>::max_value()+0.5f )); + + const bits32f convertedValue = x * channel_traits<DstChannelV>::max_value() + 0.5f; + const bits32f clampedValue = std::min( + (bits32f)channel_traits<DstChannelV>::max_value(), + std::max( (bits32f)channel_traits<DstChannelV>::min_value(), convertedValue ) ); + + return DstChannelV( static_cast< dst_integer_t >(clampedValue) ); } }; Regards, Fabien Castan

3 2

[asio::ssl] TLS support
by ToBeKi＠gmx.de 15 Oct '12

15 Oct '12

Hello all, in asio::ssl context/context_base i couldn't find any TLS 1.1/1.2 method implementations. Is it missing/not supported yet? If so is there a roadmap supporting versions 1.1/1.2? Best, kito

1 0

[config] call to destructor of temporary
by Vicente J. Botet Escriba 15 Oct '12

15 Oct '12

Hi, I have had some trouble debugging some code with clang-2.9 c++0x. The reason was a known bug on the compiler as it doesn't call the destructor of temporaries at the end of the expression. Is there a macro stating this missing feature? Best, Vicente

4 4

maybe a bug in boost.iostreams
by leiming2006 15 Oct '12

15 Oct '12

Hello, I'm using boost 1.5.1 in windows 7 with vc 2010 express. today I'm trying using boost.iostreams with audio samples, whose char_type is not char or wchar_t. thought I failed at the end, but I guess that I found a bug in the library. In the file boost\iostreams\chain.hpp, line 136, I wonder if it's typedef linked_streambuf<Ch, Tr> streambuf_type; not typedef linked_streambuf<Ch> streambuf_type; Regards, LeiMing

1 0

[program options] Support for storage to 'optional' objects
by Chris Glover 15 Oct '12

15 Oct '12

Hi, Recently when using the Boost Program options library, I was surprised to find that I was unable to pass a boost.optional object to store supplied options in. For example; namespace bpo = boost::program_options; boost::optional<std::string> opt_str; bpo::options_description desc("Allowed options"); desc.add_options() ("help", "produce help message") ("opt", bpo::value(&opt_str), "Something optional") // Store value of 'opt' in 'opt_str' ; What I expected to happen would be that 'opt_str' would be valid if 'opt' is supplied by the user, and not valid otherwise. However, the above code causes a compile error deep within lexical_cast because, of course, performing such an operation on a boost.optional doesn't make sense. The attached patch to Program Options rectifies the issue by filtering out optional objects within before calling lexical_cast, but to be honest, I'm not sure if this is the correct approach or if this is even a desirable feature. I like the idea of setting an optional object this way instead of testing the variables_map later on, but perhaps there's something I am missing or a better way to accomplish the same thing. Please have a look and let me know your thoughts. Thanks, -- chris

1 0

[contract] concepts: pseudo-signatures vs. usage patterns
by Lorenzo Caminiti 14 Oct '12

14 Oct '12

On Tue, Oct 9, 2012 at 7:16 PM, Dave Abrahams <dave(a)boostpro.com> wrote: > on Tue Oct 09 2012, Lorenzo Caminiti <lorcaminiti-AT-gmail.com> wrote: >> >> I made a first attempt to sketch how N3351-like concepts will look >> into Boost.Contract (just for the find algorithm and its concepts for >> now): >> [...] >> Please tell me what you think now > > Since you asked what I think, > > "pseudo-signatures > usage patterns" Hello all, Can we write down pros and cons for concepts implemented via pseudo-signatures (C++0x-like and Boost.Generic) vs. usage patterns (N3351 and Boost.Contract)? Who wants to start? Matt, Dave, Andrzej, ... I can compile a qbk table with what we discuss. Thanks. --Lorenzo

10 68

[quickbook] Cross-Referencing Source-Snippets
by Matt Calabrese 14 Oct '12

14 Oct '12

I'm currently documenting the Generic library and the documentation itself imports a lot of code from the source files directly (the best documentation for a concept generally involves showing the concept definition itself, and importing it means the code won't be out of sync with the documentation). This imported source code references other concepts and I'd like to be able to have each one of these referenced concepts be a clickable link that brings the person to the documentation for that concept (I.E. in http://generic.nfshost.com/generic/standard_concepts/concepts/equivalencere… the user should be able to click on "Predicate" in the imported source code to see the documentation for the Predicate concept). So, I tried the simplest solution -- make a quickbook macro called Predicate that results in a link to the corresponding Predicate documentation. After a quick test, everything worked fine with one exception -- the name of the section linked to is also "Predicate" and that seems to be causing the link in the generated table of contents to no longer work properly, pointing to a page that doesn't exist even though it displays the link with the proper name (note that the cross-reference links still seem to work fine, it's just the links in the table of contents that break). I realize that I'm doing something hacky here, so if anyone has a better solution, let me know. If this is the best approach, is there a way that I can keep the name of the section the same as the macro name? I.E. Is there some trick I can use to prevent the macro from being expanded when I use it in the section declaration? Keep in mind that I can't simply use templates here instead of macros because the macros are expanded from within imported, working code snippets. I also can't postpone defining the macro until after the section is declared since sections are presented in alphabetical order, meaning that an earlier section's code may reference a later section's code based on dependencies. -- -Matt Calabrese

2 2

[pointee] partially specialize for pointer types?
by Jeffrey Lee Hellrung, Jr. 14 Oct '12

14 Oct '12

Right now, boost::pointee<T*> is evaluated to T via evaluation of boost::detail::is_incrementable<T*>. Unfortunately, this causes a hard error when T is incomplete. See [1] for motivation on why this might be undesirable. It seems there's no loss in partially specializing boost::pointee for pointer types to allow it to be used for incomplete types. Ditto for boost::indirect_reference. Are there issues with this that I might be missing? As both pointee and indirect_reference seem to fall under the purview of Boost.Iterator, I would take responsibility of making this change and adding appropriate unit tests for the incomplete type case. - Jeff [1] https://svn.boost.org/trac/boost/ticket/5965

1 0