- Boost - lists.boost.org

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

21 Sep '04

Vladimir Prus wrote: >John Torjo wrote: > > > The FORMAL Review of "Output Formatter" library begins today, > > Sept 12, 2004. > >The primary case is debugging. I want to either output small vectors to >some >log/dump file (in which case the output will be small one-line), or output >some huge structures (vector<Function>, where Function has a lot of data). >In the latter case, the output should be multiline, with nice indentation, >or I won't understand anything. You can explicitally state where/how new lines and indentation are going to be within my library by adding them to the open/close/separator formatting (see output-3D.cpp for an example). As for more intelligent indentation, it is hard to know in advance if an object you are writing to the stream should be wrapped or not. This is where feeding it through Jonathan's library (via an indentation filter) would be useful. >A particularly interesting question is how the proposed library overlaps >with serialization. When outputting vector<Function> I'd prefer the content >of 'Function' to be outputted too, preferably by describing the members >with the 'serialize' method. The default behaviour for an unrecognised type is to output it directly to the stream so it will use the << operator associated with that type. If you want to use a particular method, such as 'serialize', then you will need to write your own format object that calls that function. > > 1. What is your evaluation of the design? > >There are some things I don't like. First, as many mentioned, the naming is >not optimal. For example: > > boost::io::formatob(v).format(" | "); The naming scheme for the various elements has undergone an overhaul. See my other posts for comments. From here on in, I will use the new naming, with: namespace io = boost::io; namespace fmt = boost::io::format; >or maybe even > > ("[" + io(v)/"," + "]") Cool! I shall look into trying to implement something like this. >It's desirable that the library support some multiline output style out of >the box, so that I could write: > > os << io::multiline(v) << ... Do you mean something like: std::cout << io::object( v ).decorate( "[\n ", "\n]", ",\n " ); resulting in: [ 1, 2, 3 ] > > 2. What is your evaluation of the implementation? > >There should be the <boost/outfmt.hpp> header, including everything else of >the library. ok >Some of the lines are longer than 80 characters (e.g. template header of >formatob_t has 111 characters). ok >Methods defined in the body of the class are implicitly inline, there's no >need to put the "inline" in front of them, as it's just one more word to >read. ok >I don't think defining methods in the class is a good idea -- this makes >the >class interface less obvious. I agree. I prefer to keep interface and implementation seperate, but MS VC (prior to 7.1) will choke on nested templates declared out of line, e.g.: template< typename T > struct foo { template< typename U > void bar(); template< typename U > void ok(){} }; template< typename T > template< typename U > // VC<=7.0 ==> error void foo< T >::bar(){} I also try to be consistent where possible, so don't tend to mix the two. >Why is the formatob_t necessary? It seems to work by delegating everything >to the underlying formatter. Can't the 'formatob' just return the >appropriate formatter? It's necessary because the format objects don't define << and it is necessary to keep a refererence to the object passed to it for formatting so that it can be accessed when inside the implementation of the << operator. >I might be missing something, but the mechanism for getting the type of >formatter from a type to be output seems too complex. First, the >type_deducer.hpp file is used, and 'select' computes a 'category'. Then >format_deducer.hpp takes the category, and again uses 'select' to obtain >the real type of formatter. Why the type_deducer.hpp is needed? I have been working on improving this. There are 3 parts to the type deduction: [1] identifying the type and mapping it to its generic type (e.g. container, array, etc.) This is done by type_traits.hpp. [2] working out the formatter type that is needed to render this to the stream. In the review implementation this is done by format_deducer.hpp, using the information gathered by type_deducer.hpp to compute the nested structure (e.g. std::vector< std::pair< char, std::list< int > > >). [3] creating an instance of the format object. This is also done by format_deducer.hpp in the review version. In the version I am working on at the moment, I have a deduce_type< int > template that is used to simulate partial specialization (for compilers that don't support it). The int parameter is the format object category and is taken from type_traits.hpp (or your own value if you add a custom type and format object). The decude_type template contains template< typename CharT, typename T > struct type_from{ ... }; that has a format_object typedef and the method: static format_object deduce( const T & ); for constructing an instance of that format object. For example: template<> struct deduce_type< io::seq_container_type > { template< typename CharT, typename T > struct type_from { typedef typename T::value_type value_type; typedef typename get_deducer< CharT, value_type >::type value_deducer; typedef container_t < CharT, typename value_deducer::format_object > format_object; static format_object deduce( const T & ) { return( format_object( value_deducer::deduce( value_type()))); } }; }; > > 3. What is your evaluation of the documentation? > >The documentation leaves much to be desired. I'll walk though some of the >aspects (indented text is quote from the docs) I will attempt to address the issues you have raised. > "providing an extensible framework that sits" > >How it's extensible? I see only one section about extending and it's just >one paragraph long I really need to add more documentation regarding this. The idea is that you can: * add your own decorators (delimiters in the review docs) to support more complex types (e.g. trees and graphs). * add your own format objects to control the way the data is rendered, for example adding a format object to call the 'serialize' method on a class. * create state objects used by fmt::state to perform custom formatting (e.g. in the john-torjo.cpp example, a state object is used to render the position: { [0] Vladimir, [1] Terje, [2] John, [3] Dave, [4] Rene } ) * register a type with the type deduction system so it can be implicitly deduced, e.g.: BOOST_IO_CLASSIFY_TYPE( 2, boost::array, io::seq_container_type ); // ... boost::array< int, 5 > a; std::cout << io::object( a ); // output: [ 1, 2, 3, 4, 5 ] > boost::io::formatobex< DelimeterType >( const T & ob ); > > This will format ob according to it's underlying type. > >How is this different from using the 'formatob' function. What's >"underlying >type". Underlying type is: typeid(ob).name(). That is std::vector< int > will be formatted differently to std::pair< char, std::list< std::complex< float > >. >I'd also suggest >for formatobex use the "basic" prefix to indicate it's templated on the >character type. E.g. stlio and basic_stlio, or something like that. That is a good idea. Especially considering the revisions I am in the process of making. > If you need to specify a range or sub-range, boost::io::formatob will >not > recongnise it unless it is a container. > > boost::io::range( ForwardIterator first, ForwardIterator last ); > >This is more of a language problem. Range, by definition, is a pair (but >not >std::pair) of iterators. It's never a container. What I meant is that: std::cout << io::object( vec ); // [1] ok - know how to process containers std::cout << io::object( a, a + 5 ); // [2] oops! don't know how to handle ranges std::cout << io::object( io::range( a, a + 5 )); // [3] ok - range is now explicit The reason I don't allow variant 2 is because that would mess up argument resolution. >For a reference, the code examples are not necessary. For tutorial, >you don't need to list every overload, just mention that there are others. noted. > boost::io::openclose_formatter is a class that allows the user to >change > and access the format used for open and close delimeters > >Here we're definitely in the reference docs already, while I did not get an >overall picture yet. Then, what's "change and access the format". If the >format can be changed, it is stored somewhere. Where? It is stored inside the [openclose_]formatter object (wrapper_decorators and sequence_decorators in the new version). You can set the delimiters (decorators in the new version) using the various 'format' functions ('decorate') and get their values via open(), close() and separator() (used when implementing your own format objects). >The code block before >this comment defines two classes openclose_formatter_t and >openclose_formatter. Is this a typo, or you really have two classes? This is not a typo. The _t variants take a template parameter that contains the return value of the 'format' ('decorate') functions. This is so that: std::cout << io::object( vec, fmt::container().decorate( " | " )); works properly. >Do you mean that every FormatObject class should have this signature? Then, >the phrase about "FormatObject::write(os, fo.ob)" is not necessary. ok. Regards, Reece _________________________________________________________________ FREE pop-up blocking with the new MSN Toolbar get it now! http://toolbar.msn.click-url.com/go/onm00200415ave/direct/01/

2 1

RE: [boost] RE: Re: Formal review of "Output Formatters" librarybeginstoday
by Reece Dunn 21 Sep '04

21 Sep '04

Vladimir Prus wrote: >Reece Dunn wrote: > > > Vladimir Prus wrote: > >>There are some things I don't like. First, as many mentioned, the naming > >>is not optimal. > >>[snip] > >>or maybe even > >> > >> ("[" + io(v)/"," + "]") > >> > >>for nested formats, something like > >> > >> ("[" > >> + io::format( > >> "(" + io::format()/":" + ")" > >> )/"," > >> + > >> "]" > >> ) > >> > >>These are just ideas, though. > > > > In my development version, I now have this working! That is, you can do: > > > > std::cout << io::object > > ( > > std::make_pair( 'a', 5 ), > > "{ " + fmt::pair()/" == " + " }" > > ) << '\n'; // output: { a == 5 } > >Great. I wonder what others think? Personally, I really like the / >operator. >Probably that's because I've borrowed the idea from one parser generator >which allows to write: > > (literal / "," ) > >to mean a list of literals separated by ",". Sure. Another alternative would be: fmt::pair()[ " = " ] but this may be confusing WRT the standard behaviour of the [] operator. >The opening and closing braces look less clear for me now. Maybe, we can >use > > fmt::pair("{", "}")/" == " The problem with this is deducing that the parameters passed to fmt::pair or others are format objects (for formatting first and second data members) or delimiter strings or other arguments (e.g. DelimiterType or array length). This could possibly be done using MPL, but would further complicate the implementation. >or > > fmt::braces("{", "}") + fmt::pair()/" == " > >But I'm really really not sure. Suggestions are always welcome. fmt::braces is openclose_formatter in the review implementation (wrapper_decorators in the version I am currently working on). The problem with defining operator + for <open_close> + <open_close_separator> value holders is: how do you inherit values, for example: fmt::braces( "<< ", " >>" ) + fmt::pair( "{ ", " }" )/" == " is this: << a == b >> or: { a == b } This would be "<< a == b >>" in this instance, because fmt::pair will set the values and fmt::brace will cause them to be overrided. This is similar to this situation: "<< " + fmt::pair().decorate( "{ ", " }" )/" == " + " >>" Also, MW CodeWarrior 9.2 is complaining about the above: typedef boost::io::sequence_decorators<char> decorators; ### mwcc Compiler: # 122: = "<< " + decorators() / " :: "; # Error: ^ # illegal operands 'boost::io::sequence_decorators<char>' / 'const char *' I will need to investigate this further. Regards, Reece _________________________________________________________________ Express yourself with cool new emoticons http://www.msn.co.uk/specials/myemo

2 1

Re: Formal review of "Output Formatters" library begins today
by Robert Ramey 21 Sep '04

21 Sep '04

Vladimir Prus wrote: >A particularly interesting question is how the proposed library overlaps >with serialization. When outputting vector<Function> I'd prefer the content >of 'Function' to be outputted too, preferably by describing the members >with the 'serialize' method. And the question is if I can use outfmt >library, or have to use the serialization library? The serialization >library is pretty large, so, I'd like outfmt to be able to output UDT which >have 'serialize' defined. IMO, vector<some_UDT> is a very common case, >maybe even more common than vector<pair<int, int> >. If one had nothing else to do, he could make a derivation of one of the existing archives (e.g. text_archive) that would "annotate" the serialization. This might be useful for debugging or other purposes. On the other hand, I just use the xml_archive for that purpose now and its fine (although a little verbose). It also plays nice with XML browsing tools. So that's handy. My real observation is that I see this as orthogonal to serialization and that it should remain that way. I don't seen any real overlap now except that there might be a couple of instances where either one might do. I think even these would be rare cases. I would resist any idea to intertwine these concepts. Robert Ramey

3 3

explicite failures question
by Robert Ramey 21 Sep '04

21 Sep '04

I'm struggling with the explicit-failures XML. About 40% of the serialization tests will fail on platforms which do not include support from wchar_t streams. As Understand the current schema (XML is not all that clear to me) I would have to specify one line for each pair of toolset-test that fails on this scenario. I my case this means 100 test * 6? Toolsets = ? 600 lines of xml added to this file. Robert Ramey

3 8

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

21 Sep '04

Vladimir Prus wrote: >There are some things I don't like. First, as many mentioned, the naming is >not optimal. >[snip] >or maybe even > > ("[" + io(v)/"," + "]") > >for nested formats, something like > > ("[" > + io::format( > "(" + io::format()/":" + ")" > )/"," > + > "]" > ) > >These are just ideas, though. In my development version, I now have this working! That is, you can do: std::cout << io::object ( std::make_pair( 'a', 5 ), "{ " + fmt::pair()/" == " + " }" ) << '\n'; // output: { a == 5 } and: std::cout << io::object ( std::make_pair( std::make_pair( 'a', 1 ), std::make_pair( 'b', 2 )), "{ " + fmt::pair ( "< " + fmt::pair()/" + " + " >", "( " + fmt::pair()/" | " + " )" )/" = " + " }" ) << '\n'; // output: { < a + 1 > = ( b | 2 ) } I have tested with VC 7.x and 8.0. VC7.0 has some problems, but the others build it fine. Regards, Reece _________________________________________________________________ Express yourself with cool new emoticons http://www.msn.co.uk/specials/myemo

2 1

[concept_check] failures in release cfg
by Stefan Slapeta 20 Sep '04

20 Sep '04

see http://tinyurl.com/3t3tc It seems that the concept_checks are inactive in release cfg, at least the lines template <class Concept> inline void function_requires(mpl::identity<Concept>* = 0) { #if !defined(NDEBUG) void (Concept::*x)() = BOOST_FPTR Concept::constraints; ignore_unused_variable_warning(x); #endif } make me think so. If there is no better way to instantiate Concept::constraints (without creating a local variable, which seems to be the reason to avoid the check in release mode), the cf-tests must be disabled for all release configurations. Stefan

6 9

OutFmt library implementation questions
by Rozental, Gennadiy 20 Sep '04

20 Sep '04

Hi, Here some implementation questions I've got: 1. Why does the library brake const correctness. FWIV I could write: const vector<int>& v = ...; std::cin >> io::formatob( v ); and it would compile without questions. 2. Why doesn't insert_iterator is implemented using iterator_facade? 3. Why do you need 2 different functions containerfmtex and containerfmt? 4. How does this all machinery will work with wchar_t? 5. Why do you need static_cast< const base_type * > to cast to the base type in container.hpp? 6. Why the same entity you sometime call format_type and sometime DelimeterType? 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. 8. Why class formatter, formatter_t is defined in namespace io, while it reside among details headers? 9. What is RT2 stands for? 10. detail/formatter.hpp refer to openclose_formatter_t, but does not include no headers. 11. Need for all this hierarchies: Formatter->formater_t->openclose_formatter_t openclose_formatter->openclose_formatter_t are completely unclear. Explanations presented in docs does not help since format methods seems to be returning *this anyway. 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. 12. select and switch templates seems useful. Why doesn't MPL provide these? 13. Doesn't MPL provide eq_int, lt_int? 13. struct selector needs to be PP generated 14. list_object -> formatter_t inheritance look wrong. Where is IS A relationship? 15. You couldn't do this: typename InputStream::char_type ch = '\0'; I think It all for now. Please comment. Gennadiy.

1 0

OutFrmt lib design questions
by Rozental, Gennadiy 20 Sep '04

20 Sep '04

Hi, 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<<) 2. If primary target is collection formatting wouldn't it be better to name library "collection formats something"? 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? 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) 5. Why do we need boost::io::range? Couldn't we use boost::range instead? 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 ); 7. Who come format calls order dependent? boost::io::formatob( vec, boost::io::containerfmt()).format( fmt ).format( " : " ); 8. If I got vector<vector<int> >. How do I supply separators for both internal and external vectors? 9. Let say I print vector<char>. Is there way to print it like this: { 'a', 'b', '0x01', ' ' } That's enough for now. Please comment. Gennadiy.

1 0

[boost.range] late addition, votes needed
by Thorsten Ottosen 20 Sep '04

20 Sep '04

Dear All, In the pre-redmond mailing Walter Brown discusses the possibility of adding these members to standard container classes: const_iterator cbegin(); const_iterator cend(); const_reverse_iterator crbegin(); const_reverse_iterator crbegin(); The motiviation is that we want to be able to say explicitly "give me a const iterator" without doing ugly casts. IMO a sound idea. Given the framework in boost.range these would be absolutely *trivial* to add. 1st vote: for or against adding these? 2nd vote: which naming scheme to use: a: cbegin(), cr_begin() b: const_begin(); const_rbegin(); The motivation for chosing the latter could be that "cr" contracttions become harder to read. Let me know what ya think. best regards Thorsten

14 39

Re:[boost] Re: python/detail/config.hpp bug?
by Robert Ramey 20 Sep '04

20 Sep '04

"Aleksey Gurtovoy" <agurtovoy(a)meta-comm.com> writes: >> Boost.Python fails to build with MSVC 6.x/STLPort (see >> http://tinyurl.com/4nl7l) due to the following (incorrect) >> configuration logic in >> "boost/python/detail/config.hpp": >> >> // The STLport puts all of the standard 'C' library names in std (as >> far as the // user is concerned), but without it you need a fix if >> you're using MSVC or // Intel C++ # if >> defined(BOOST_MSVC_STD_ITERATOR) # define BOOST_CSTD_ # else # >> define BOOST_CSTD_ std # endif >> >> The issue, as explained in "boost/config/stdlib/stlport.hpp" is that: >> >> // STLport does a good job of importing names into namespace std::, // >> but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since >> our // workaround does not conflict with STLports: >> >> Is there a reason why we are not using BOOST_NO_STDC_NAMESPACE here? I had similar problems in my setup. I fixed them by close looking at the release notes for stlport 4.5.3 and found that stlport 4.5.3 puts an altered copy of stlport directory into the msvc include directory. I set environmental variables export STLPORT_PATH="c:/" export STLPORT_VERSION=4.5.3 export STLPORT_INCLUDE_DIRECTORY="c:/program files/Microsoft Visual Studio/vc98/include/stlport" This permitted compile link and test with msvc-stlport toolset. I believe it would also help intel-7.1-v6-stlport-4.5.3 toolset builds. Robert Ramey

1 0