- Boost - lists.boost.org

RE: [boost] [shared_ptr] InterlockedIncrement rocks!
by Ben Hutchings 22 Sep '04

22 Sep '04

Tomas Puverle <Tomas.Puverle(a)morganstanley.com> wrote: > > Also, why not including windows.h directly, like this: > > #define WIN32_LEAN_AND_MEAN > > #include <windows.h> > > I believe WIN32_EXTRA_LEAN may be even better. > > > <side-note> > > From my tests it seems your version as is now fails to link > > for gcc (unresolved external > > _InterlockedIncrement/_InterlockedDecrement). > > However, if #including <windows.h> and use > > InterlockedIncrement/Decrement - they work. > > </side-note> > > That is not suprising - Interlocked* are parts of the Win32 API. > > In fact, it has been a complete mistery to me as to why boost doesn't > use atomic operations for its ref counting. The mutex on the counter > was one of the big reasons why people here decided not to use > shared_ptr. Atomic operations are highly platform-dependent, with different platforms having different capabilities and many requiring use of assembly language rather than providing an API for atomic operations. Second, shared_ptr has two counters and updating them safely without using a lock requires some subtlety. It's something I meant to implement but hadn't quite got round to. Perhaps I could make it work on g++ (and hence most Linux configurations) by using libstdc++'s atomic primitives? I don't think they are really public though, so this might be a bad idea.

1 0

Multimethods Design
by Jesse Jones 22 Sep '04

22 Sep '04

There seems to be some interest in my multimethod library so I thought I'd post a message describing the design in more detail. In this message I'll focus on the API and ignore the implementation except when it affects the API. I may post another message later focusing on the implementation. The vault is still full, so if you want to look at the code go to <https://sourceforge.net/projects/multimethods/>. The draft proposal to add multimethods as a core feature is also interesting: <http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2003/n1529.html#1.1.1>. Also <http://www.op59.net/accu-2003-multimethods.html> has some info on why multimethods are a Good Thing. The design is actually quite simple. Function objects (aka methods) may be added to a generic function object. Then the generic function can be called with a set of actual arguments. It will then dispatch to the most specialized method using the dynamic type of the actual arguments. One way to think of this is as a form of runtime overloading. The API for generic functions looks like this (using an arity 2 function as an example): template <typename Result, typename Formal1, typename Formal2> class generic_function2 : public detail::base_generic_function< Result > { When this is instantiated it creates a function object. Currently the arity is encoded in the class name, but presumably boost::preprocessor could be used to allow users to instantiate the classes in the way that boost:;function does. base_generic_function is a helper class that does all of the heavy lifting. Method formal arguments and actual argument types must be compatible with Formal1 and Formal2 (this is checked at compile time). The formal argument types may also be any_type which means that the formal argument in the methods for that position may be of any type. The API is as follows. First there are some standard typedefs: typedef Result result_type; typedef typename Formal1 first_argument_type; typedef typename Formal2 second_argument_type; A default ctor (and compiler provided copy ctor/assignment op): generic_function2(); Members to add methods: template <typename R, typename T1, typename T2> generic_function2& operator<<(R (*method)(T1, T2)); template <typename Functor> generic_function2& operator<<(Functor method); If the method has the same arguments as an existing method a std::runtime_error exception is thrown. If the Functor version is used the functor must have result_type, first_argument_type, and second_argument_type typedefs. A member used to invoke the generic function: template <typename T1, typename T2> RESULT operator()(const T1& arg1, const T2& arg2) const; This works by building a list of the applicable methods and then sorting this list from most to least specific using the dynamic type of the actual arguments. A method A is more specific than another method B if, for a given set of actual argument, for each argument, A has a better match for the actual argument than B in at least one slot and the other arguments are no worse than B's (this is similar to the rule used for overloaded functions). Argument matching follows the usual C++ rules so derived types are better matches than base types and promotions are better matches than conversions. If no applicable methods or a most specific method cannot be found a runtime_error exception is thrown. When a method is called it may call the next most specific method using one of the following methods: RESULT next_method(); template <typename T1, typename T2> RESULT next_method(const T1& arg1, const T2& arg2); The second overload calls the next method using a new set of actual arguments, but the types of those arguments don't affect which method is called. The first overload calls the next method with the last set of actual arguments that were used. If there are no more methods or the next method is ambiguous a runtime_error exception is thrown. The only missing piece is that clients of the library must register polymorphic types if they want them to be treated polymorphically. This is done with a macro that looks like this: #define DECLARE_SUBTYPE(type, base) This seems like a simple yet flexible API, but there's probably room for improvement. For example: 0) The names "generic function" and "method" seem potentially confusing in a C++ context (they're from Dylan and (I think) CLOS). 1) There's no support for removing methods. This seems like a good idea, but it's not possible to compare arbitrary function objects so we'd probably have to add an add_method member which returned a cookie that a remove_method member would take to determine which method to remove (similar to the way boost::signal works). 2) Policy decisions like type compatibility and ordering are hardwired into the code. It might make sense to refactor these into policy classes although I'm not sure what they'd be used for. Maybe special casing smart pointers. 3) The library allows lossy conversions like floats to chars. This was done so that it world work as much like normal C++ code as possible, but it's a pretty evil thing. Maybe an option could be added that would reject such conversions. 4) boost::bind is a bit annoying because it doesn't provide the typedefs that the library requires. This is a known issue with bind and, as far as I know, isn't fixable. The workaround is to assign the result of boost:;bind to a boost:;function and add that to the generic function. 5) Method formal arguments can't be non-const reference types. The problem here is that typeid(const T&) == typeid(T&) == typeid(T). It might be possible to work around this, but the type code is already full of hacks working around typeid and type_info limitations... 6) It might be a good idea to add a member that will return a function pointer or boost:;function to the most specific method for a given set of types. This would allow users to skip the overhead of dispatching when using multimethods inside loops in some cases. -- Jesse

1 0

RE: [boost] Re: Formal review of "Output Formatters" library beginstoday
by Reece Dunn 22 Sep '04

22 Sep '04

Rozental, Gennadiy wrote: >Here some more details: > > > 1. What is your evaluation of the design? > >Library trying to solve in fact trivial problem. Would it be presented as >trivial function > >Template<typename C> >Foo( C const& c, std::string open, std::string close, std::string sep ); > >I may understand it. This would mean that you would duplicate code for rendreing container types. Also, you are missing special formatting, e.g. wrapping open/close values around elements, e.g.: std::cout << formatob( vec, containerfmt( wrappedfmt().format( "<e>", "</e>" )).format( "<l>", "</l>" )); // output: <l><e>a</e><e>b</e></l> the indentation functionality that Volodya has expressed an interest in, and position-based output, e.g.: [0] John, [1] James, [2] Marina Also, the library should be usable on a standard stream. This is one of the key design aims. Can you do: std::cout << Foo( vec, "< ", " >", " :: " ); ? This requires returning an object that has << implemented. The mechanism for this is outlined in the standard by using *manipulators*. Thus, you would need that class to defer processing to the Foo function if you want to use your approach. >As to presented design - I see it as unnecessary complicated. And in many >cases simply incorrect. >Library does not follow standard practice as to wide char support. I am addressing these issues. See my other discussions for details. >Interfaces seem confusing and error prone. >Decoration model seems too simple to warrant so much trouble as reusable >library. Maybe more powerful/flexible solution should be considered. I have been reshaping the decoration model and have commented on it elsewhere. > > 2. What is your evaluation of the implementation? > >In most part I either don't understand or don't like it. IMO simple task >library trying to solve shouldn't require that much code. Simple >overloading >base solution should've done the trick. This does not allow for flexibility to add indenting, wrapped data, etc. > > 4. What is your evaluation of the potential usefulness of the library? > >Now to the most important: why would I ever want to use library like this? > >We have already: >std::ostream >boost::format >boost::serailization > >In what scenario I would use this library? But you can't do: std::vector< int > vec; std::cout << vec; // oops! no operator << defined for vectors. >I most definitely wouldn't want to repeat all this formatting every time I >need to output my vector. If you want [ a, b, c, d ] style output, you don't. The extra machinery is used to customize this. Also, you can save a format object, e.g.: // old style containerfmt_t< char, pairfmt_t< char > > myformat = containerfmt( pairfmt().format( " = " )).format( "<< ", " >>" ); std::cout << formatob( vec, myformat ); // << ( a = 5 ), ( b = 7 ), ... >> std::cout << formatob( lst, myformat ); // << ( i = 2.132 ), ( j = 3.14159 ), ... >> std::cin >> formatob( vec, myformat ); >If I write output operation rarely - I would use explicit loop -it's more >flexible anyway. Depends what you are outputting. If the type contains nested containers, it can be more complex. >I wouldn't use this library for filtering - we will have iostreams library >for that (If I am not mistaken). This library does not provide filtering capabilities. What I was saying is that if you want to pretty print the data, it might be worth using Jonathan's library. >I wouldn't use this library for XML printing - why would I want to mention >tag name twice? You can use a wrapper format object: std::cout << formatob( vec, containerfmt( wrappedfmt().format( "<e>", "</e>" )).format( "<l>", "</l>" )); // output: <l><e>a</e><e>b</e></l> Regards, Reece _________________________________________________________________ Want to block unwanted pop-ups? Download the free MSN Toolbar now! http://toolbar.msn.co.uk/

1 0

RE: [boost] OutFmt library implementation questions
by Reece Dunn 22 Sep '04

22 Sep '04

Rozental, Gennadiy wrote: > > >4. How does this all machinery will work with wchar_t? > > > > std::wcout << formatob( vec, containerfmtex< wchar_t * > > >()).format( L" - > > " ); > > > > Use the ex< DelimiterType > variant on the innermost construct. > >This is inacceptable and does not follow standard practice. The new version templates that are templatized on character type are also templatized on the format object that they use (to render their elements). This means that in order to provide c/w-style interface, you need: template< typename CharT, class ElementRenderer = basic_default< CharT > > class basic_container{ ... }; basic_container< char > ccontainer(){ return( basic_container< char >()); } basic_container< char, ElementRenderer > ccontainer( const ElementRenderer & er ){ return( basic_container< char >( er )); } basic_container< wchar_t > wcontainer(){ return( basic_container< wchar_t >()); } basic_container< wchar_t, ElementRenderer > wcontainer( const ElementRenderer & er ){ return( basic_container< wchar_t >( er )); } // what about custom character type (e.g. unicode?) basic_container< char > my_format = ccontainer().decorate( " : " ); std::cout << io::object( vec, my_format ); std::cout << io::object( vec, ccontainer().decorate( "< ", " >" )); > > This is a VC 6.x workaround. > >But you don't list this compiler amoung supported. At the moment there are a few problems with it. I am looking to resolve these if possible. > > >6. Why the same entity you sometime call format_type and sometime > > >DelimeterType? > > > > format_type is the typedefed version (should be delimiter_type) and > > DelimiterType is the template parameter. > >So is it delimeter type or forat type - it can't be both. delimiter type. In the new version it is char_type since the decorators (formatters in the review implementation) now take a CharT parameter instead of the storage type. > > >7. What deducer is supposed to deduce? I couldn't get > > through all the > > >details, but couldn't the same be achieved using partial > > specialization > > >and/or partial ordering. Cause it look way too complex and > > unnecessary. > > > > The deduction mechanism is used to evaluate what type T is > > (e.g. std::pair< > > char, int >), what format object is needed to render it > > (including nested > > format objects) and to construct the appropriate format object. > > > > It could be possible to use partial specialization, but the > > type traits are > > used elsewhere to redirect formatting behaviour (e.g. when > > reading in a > > container do diffreent things if it is a sequential, > > associative or set > > container). > >IMO all that you needed is function overloading. I don't see a place for >all >these deduce/trats staff. Consider the pair format object (pair renderer): how do you render each pair type. Using function overloading, you would have: class basic_pair { public: OutStream & write( OutStream & os, const std::pair< T1, T2 > & p ){ ... } OutStream & write( OutStream & os, const boost::compact_pair< T1, T2 > & p ){ ... } OutStream & write( OutStream & os, const std::complex< T > & p ){ ... } OutStream & write( OutStream & os, const boost::math::interval< T > & p ){ ... } }; But this would add dependencies on those libraries. Also, it is not extensible: how do you add support for boost::rational< T >, for instance? Using the deduction mechanism, I implement the output using boost::io::detail::getval< n >( pair_type ). Input is more complex because you need to distinguish between types that you can get the elements separately (e.g. std::pair) and types that you need to set both values together (e.g. boost::math::rational): the former uses refval< n >( type ) and the latter uses assignval( type, first, second ). How would function overloading solve this? (Note, function overloading is used for getval, refval and assignval). For containers, you need to use a different function/function arguments to insert an element depending on whether the container is sequential, associative or a set. My library provides a description of the types that it can render (e.g. separable pairs, 4-ary types, associative containers) without saying what these types are. The stl and boost directories in my library then tell my library that a std::vector is a sequential container. My library then knows how to handle a std::vector. Doing this, I can separate the dependencies on external libraries and allow it to be extended to support other sequential containers, pairs, etc. > > >11. Need for all this hierarchies: > > >Formatter->formater_t->openclose_formatter_t > > > > This is to ensure that the return type of 'format' in Formatter > > [FormatObject] is Formatter and not openclose_formatter_t. Thus: > > formatob( vec, containerfmt().format( " / " )); > > will work as intended without overriding 'format' in > > containerfmt_t (created > > by containerfmt()) to return the correct type. > > > > >openclose_formatter->openclose_formatter_t > > > > > >are completely unclear. Explanations presented in docs does not help > > >since format methods seems to be returning *this anyway. > > > > They return: > > *static_cast< ReturnType * >( this ) > > to allow 'format' to return the correct type when inherited > > in the format > > objects. > >Formatob_t::format return *this. You did not answer my question. I still >believe it's all unnecessary. formatob_t::format returns *this because the FormatObject (Renderer) that it inherits returns a value of type FormatObject. Thus, if you didn't have these overloads, then: std::cout << formatob( vec ).format( " + " ); would not work, since it will try to output a containerfmt() type. > > >Why couldn't we just use something trivial like > > > > > >template<char Ch> > > >struct formatter > > >{ > > > std::basic_string<Ch> m_open; > > > std::basic_string<Ch> m_close; > > > std::basic_string<Ch> m_sep; > > >}; > > > > > >Is beyond me. If any member is empty it means it missing. > > > > This is the direction I am going in the development version. The only > > difference is that I am using io::decoration< CharT, int id > > > instead of > > std::basic_string< CharT >. The decoration class uses > > std::basic_string to > > store the values, while providing support for looking up the > > default value > > on a stream and an external function for checking for a match > > on an input > > stream. > >You presented library call *Output* formatter. Why do we talk about input >at >all. The *output* designation is a "legacy" from before the library supported input facilities. People expressed an interest in inputting as well, so I added it; output stuck. Regards, Reece _________________________________________________________________ Use MSN Messenger to send music and pics to your friends http://www.msn.co.uk/messenger

1 0

Spirit on Intel 8.0/Linux
by Aleksey Gurtovoy 22 Sep '04

22 Sep '04

Folks, Is this a known problem that somebody can comment on (from http://tinyurl.com/5hhne) icc: error: Fatal error in /opt/intel_cc_80/bin/mcpcom, terminated by segmentation violation compilation aborted for ../libs/spirit/test/./ast_calc_tests.cpp (code 1) . /opt/intel_cc_80/bin/iccvars.sh icc -c -w1 -g -O0 -I"../bin/boost/libs/spirit/test" -I"../libs/spirit" -I".." -I"/usr/include" -I"/boost/head-regression/boost" -o "../bin/boost/libs/spirit/test/ast_calc_tests.test/intel-8.0-linux/debug/ast_calc_tests.o" "../libs/spirit/test/./ast_calc_tests.cpp" ? This obviously looks like a compiler issue, but before I mark it up as such I'd like to hear if anybody has to say anything on it. There are more Spirit tests failing in a similar manner on this configuration -- see http://tinyurl.com/5dtbz. -- Aleksey Gurtovoy MetaCommunications Engineering

1 0

RE: [boost] outputformatters - using just one decorator string
by Reece Dunn 22 Sep '04

22 Sep '04

John Torjo wrote: >Hi Reece, > >This just popped into my head. A lot of confusion seems to come from how >you pass decorators. What I'm trying to say is that it can be very >difficult to get the decorator strings right (especially for more complex >things like XML) from the first time. > >I would suggest every formatter takes only one string which parses and >finds all decorators itself. >Each formatter will have one or more escape sequences which it uses to find >the decorators. > >Something like: > >// in this case, '%' is used for identifying an element >// '*' is to mean "leave default" (don't change) > >std::vector<int> v; >// equivalent to your "[ ", ", ", " ]" >std::cout << formatob(v, "[ %, % ]"); This looks good :) On the implementation side it would require splitting the string into the 2/3 components and constructing the decorators accordingly. Maybe defining an "extract_decorators" function internally, so wrapper_decorators and sequence_decorators can process this internally. How about: std::cout << io::object( v )( "[ %, % ]" ); I am sure this would be feasible. >// eq. to "<< ", " | ", " >>" >std::cout << formatob(v, "<< % | % >>"); > >// set only open/close decorators >std::cout << formatob(v, "<< %*% >>"); Here, you would need special handling of string == "*". This should also be implementable. >// sets only the separator >std::cout << formatob(v, "*% | %*"); > >// for pair - you have "%1" and "%2" >std::vector< std::pair<int,long> > vp; >// write XML >std::cout << formatob(vp, > containerfmt("<elem> % </elem><elem> % </elem>", > pairfrt("<int>%1</int><long>%2</long>"))); Here, you don't need %1 and %2. You just do: "<int>%</int><long>%</long>". >How's that? In terms of implementability, I don't see a problem. The two issues I have are: [1] What are the performance penalties for this? [2] What if you want '%' or '*' in your format string, e.g. "[ a * b * c ]"? You would thus need to implement some sort of escaping capability. NOTE: This could sit along side using the 'decorate' function and Volodya's idea for expressions, e.g.: io::object( v, "<<" + fmt::container( fmt::pair()( "<a>%</a>%" )) + " >>" ).decorate( " : " ); // output: << <a>2.75</a>1 : <a>3.14159</a>7 >> Regards, Reece _________________________________________________________________ Use MSN Messenger to send music and pics to your friends http://www.msn.co.uk/messenger

2 1

[Boost-bugs] [ boost-Support Requests-1032391 ] bug in boost using STLport?
by SourceForge.net 22 Sep '04

22 Sep '04

Support Requests item #1032391, was opened at 2004-09-22 07:09 Message generated for change (Tracker Item Submitted) made by Item Submitter You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=207586&aid=1032391&group_… Category: None Group: None Status: Open Resolution: None Priority: 5 Submitted By: Andi (andreasfuchs) Assigned to: Nobody/Anonymous (nobody) Summary: bug in boost using STLport? Initial Comment: Hi, I want to run a project under Visual .Net 2003 using boost1.31.0 and STLport. Compilation and linking runs perfect. But if I start the excecutable the debugger terminates with an "Access violation" error at at line 97 in _construct.h of STLport. I posted this message to the STLport forum. They told me that this could also be a bug in the boost library because before this error occurs some boost functions are called. So are there any known bugs using boost together with STLport und Visual .Net? Any help would be appreciated. Thanks a lot Andi ---------------------------------------------------------------------- You can respond by visiting: https://sourceforge.net/tracker/?func=detail&atid=207586&aid=1032391&group_… ------------------------------------------------------- This SF.Net email is sponsored by: YOU BE THE JUDGE. Be one of 170 Project Admins to receive an Apple iPod Mini FREE for your judgement on who ports your project to Linux PPC the best. Sponsored by IBM. Deadline: Sept. 24. Go here: http://sf.net/ppc_contest.php _______________________________________________ Boost-bugs mailing list Boost-bugs(a)lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/boost-bugs

1 0

RE: [boost] OutFrmt lib design questions
by Rozental, Gennadiy 22 Sep '04

22 Sep '04

> >Here some question I've got while reading submitted library. > > > >1. What is an advantage if using this library for scalar types (vs. > >defining > >operator<<) > > Do you mean for things like int, Person, etc. If that is the > case, the > default behaviour of the library is to delegate output of > these types to > operator<<, so it doesn't do much. However, with support for a > fmt::serialize formatter that calls 'serialize' instead of > <<, you can > register a particular class as being serializable so my type > deduction > system knows to associate instances of that type with > fmt::serialize, so you > can then do: > > // new design > std::cout << io::object( my_serializable_object ) << '\n'; > std::cout << io::object( vec_of_serializable_objects ) << > '\n'; // [ ..., > ..., ... ] I don't really interested in another serialization library. We already have one. > The advantage of using this for things like std::complex or > boost::math::quaternion that already supply << and >> > operators is if you > want to have control over how a type is rendered, e.g.: > > // new design > std::cout << io::object( complex_val ).decorate( "", "", " + i" ) > << " = " << io::object( complex_val ).decorate( "( ", " > )" ) << '\n'; And you believe that I will keep repeating this code every time I need to print my complex value? > >2. If primary target is collection formatting wouldn't it be > better to > >name library "collection formats something"? > > This is a good idea. The name is from when the library just > had output > support, thus the "outfmt" directory in the sandbox. I am > thinking about > moving to a "formatter" directory. What do other people think? > > >3. If there is a way to assign format to collection/type combination > >permanently (through global operator <<), why would I want > to do it in > >every instance of output operation? > > Do you mean: > std::vector< int > vec; > std::cout << "vector = " << vec << '\n'; // [1] > std::cout << "vector = " << io::formatob( vec ) << '\n'; // [2] > > using [1] vs using [2]? If so, these are the same, but the > second allows you > to customize the decoration around the sequence, for example: > std::cout << io::formatob( vec ).format( " : " ); // [ 1 : > 2 : 3 : 4 ] No my question was Is there a way to assign custom (meaning different from one you selected) decoration permanently. > >4. What is an advantage of using this library to assign format to > >collection/type combination permanently vs. explicit implementation > >(using FOREACH construct for example) > > Using a foreach construct you would need to hand-code the surrounding > decoration, e.g.: > > // output: { a + b + c } > std::cout << "{ "; > foreach( char ch : vec ) > { > std::cout << ch; > if( !atend ) std::cout << " + "; > } > std::cout << " }"; > > vs: > > std::cout << io::formatob( vec ).format( "{ ", " }", " + " ); // output: > { a + b + c } > > If you have a nested construct, such as int tictactoe[ 3 ][ 3 > ], std::list< > std::list< float > > or math::matrix4x4< float > then > outputting/inputting > it manually would be more complex, whereas my library has all > the machinery > to handle this simply. Yeah. But I do it only once. And using foreach is way more flexible. I don't believe your library bring any advantage in this scenario. > >5. Why do we need boost::io::range? Couldn't we use boost::range > >instead? > > I suppose it would be possible to use > boost::range::make_iterator_range > instead. The only thing I have against this is its length. Consider: > > // new design > using boost::range::make_iterator_range; > namespace range = boost::range; > namespace io = boost::io; > > std::cout << io::object( range::make_iterator_range( i, i > + 7 )); // [1] > std::cout << io::object( make_iterator_range( i, i + 7 )); // [2] > std::cout << io::object( io::range( i, i + 7 )); // [3] > > If only you could alias functions, e.g.: > namespace io{ alias range = boost::range::make_iterator_range; } IMO you shouldn't introduce yet another range notion. > >6. In a formatter usage how would I guess what is what? > > boost::io::formatter< char * > fmt( "\ ", " /", " | " ); > > boost::io::formatob( vec, > boost::io::containerfmt()).format( fmt ); > > I have revised the names, so that is now: > namespace fmt = boost::io::format; > > io::sequence_decorators< char > seq( "\\ ", " /", " | " ); > io::object( vec, fmt::container()).decorate( seq ); IMO it's really bad idea to introduce interfaces that change meaning depend on number of arguments of the same type. Moreover it easy to confuse one with another. Your interface: ( str1, str2, str3 ) - open, close, separator ( str1, str2 ) - open, close ( str1 ) - separator Now If I do not use your library on everyday basis, And look on invocation of first function - how would I now what is what. There should be something that tell explicitly - here is open/close brackets, here is separator. > >7. Who come format calls order dependent? > > boost::io::formatob( vec, boost::io::containerfmt()).format( fmt > >).format( > >" : " ); > > format( fmt ) is called first, then format( " : " ). Thus, > you will have "\ > a : b : c /" as the formatting. You did not answer the question. I believe that interface is incorrect if it order dependent > >9. Let say I print vector<char>. Is there way to print it > like this: { > >'a', 'b', 0x01, ' ' } Actually I did not want '' around hex value - intent was to print array in c++ format. > Yes. You need to provide a wrappedfmt() format object. For example: > > formatob( vec, containerfmt( wrappedfmt().format( "'", "'" > ))).format( "{ > ", " }" ); > // output: { 'a', 'b', 'c' } So this wouldn't wark for me since I do not want '' around some of the values. > With the 0x01 character, special treatment needs to be > applied. You will > need to supply a custom format object to see if the character > is printable, > e.g.: > [your 20 lines solution skipped] IMO In this scenario your library doesn't stand a comparison with handcrafted solution. > > Regards, > Reece Gennadiy.

2 2

Patch for program_options<mingw>
by Janusz Piwowarski 22 Sep '04

22 Sep '04

Hello I'm attaching patch for program_options which fixes known problem with wstring in mingw. Regards, Janusz

2 2

RE: [boost] immutable string
by Ben Hutchings 22 Sep '04

22 Sep '04

Maxim Yegorushkin <e-maxim(a)yandex.ru> wrote: > I've been working on a small library - an immutable C++ string. Now > it is in usable state and has been put in use in a couple of real > projects. > Although it needs further polishing, I would like to know is there > any interest in such a library? Great stuff. I certainly think it would be useful to have a light- weight string. > Here is the link: http://conststring.sourceforge.net/ There's one possible problem I noticed, which is that an allocated buffer will be aligned properly for boost::detail::atomic_count but perhaps might not be aligned properly for char_t (or to whatever buffer_storage_alignment specifies). Let me apply the James Kanze test [*]: is it safe to create a const_string<double> on a SPARC? [*] See <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=8670> if you don't know what I'm talking about. Ben.

3 4