- Boost - lists.preview.boost.org

[bug] bug in 'octonion.hpp' file
by Oleg Anashkin 24 Aug '04

24 Aug '04

I think there is a bug in the 'octonion.hpp' file. There are several tt[0] consecutive assignments (lines 1243-1250, 1292-1299, 1340-1346). It seems that they should be changed to tt[0]..tt[7]. -- Thanks.

2 1

algorithm / string / container regression failure on tru64cxx65
by Markus Schöpflin 24 Aug '04

24 Aug '04

Hello, currently beforementioned test fails on tru64cxx65 with the following error message: cxx: Error: ../libs/algorithm/string/test/container_test.cpp, line 94: #434 a reference of type "char *&" (not const-qualified) cannot be initialized with a value of type "char [4]" argument_test( ach1, "abc" ); The underlying problem is illustrated by the following code snippet: ---%<--- template< typename T > void argument_cv_test( const T& C, const string& strResult ) { } template< typename T > void argument_test( T& C, const string& strResult ) { } void foo() { char ach1[]="abc"; argument_cv_test( ach1, "abc" ); // ok argument_test( ach1, "abc" ); // not ok } --->%--- The line marked as not ok triggers the error. I tried to compile that code snippet with Comeau online and it succeeds. But I could not find a definitive answer in the C++ standard whether that code is legal or not. If it's legal, could anyone please provide me with a reference to the paragraph of the standard which applies here? I would need that to file a proper bug report to HP. TIA, Markus

2 2

Re: [boost] Re: Re: New design proposal for boost::filesystem
by Ferdinand Prantl 24 Aug '04

24 Aug '04

Hi Patrick, > Patrick Bennett wrote: > > Ferdinand Prantl wrote: > > What do you think about imbuing and codecvt-like approach in > > boost::filesystem for the names of the files? > I don't (personally) care for it. More and more libraries and standards are using UTF-8 (for good > reason) these days. It's a nice, simple, and flexible encoding. I have nothing against usage of UTF-8 if it suits the scenario well. I just say that it is not an encoding for all purposes. It is a multibyte one and so extremely inefficient for getting size, searching, etc. Why to prescribe it for all boost::filesystem users and force them to put recoding into their sources, when it can be achived inside the boost::filesystem as it is done in std::streams? I would like to have the boost filesystem as flexible as possible. Someone can work with filenames in std::string in current locale, in UTF-8 or a different locale, someone can use std::wstring with UCS-2 or UTF-16, etc. The question is, if such a flexibility is not so rare, that it rather spoils the interface. I don't think so. > Win32 doesn't support UTF-8 filenames natively. That's why boost::filesystem > would have to convert to/from UCS-2 along Win32 interface boundaries. > If you're concerned about other platforms, you shouldn't be. boost::filesystem > currently works only with latin encodings in ascii strings so no functionality > would be taken away. UTF-8 is not identical with the complete iso-8859-1 (latin1) codepage. Some code could be broken by accepting UTF-8 in the new version. > The UTF-8 representation of ascii strings is identical, so if you already use > ascii strings, nothing will change, and nothing will break. If you want your > application to be runnable in multiple countries though, an operating system > which boost::filesystem has translations defined for would be required. Linux > is UTF-8 natively (assuming the right environment variable is set), so > boost::filesystem would just pass everything through as-is. The Win32 poet > would have to make some simple conversions (Windows even has built-in functions > to perform this conversion) . Other platforms might have to have make other > conversions to/from UTF-8, but assuming that platform supports Unicode at all, > this is a no-brainer. Linux can be configured to support UTF-8 natively. However, it is not necessary and depends on your locale installation and configuration. By imbuing I meant the conversion "application filenames encoding" -> "machine filenames encoding". Instead of putting a platform dependent code into conditions, which does the translation, one could simply say "I am running in UTF-8, boost::filesystem, please understand it and do the system translation for me". Exceptoins could sourt out incompatibilities. boost::filesystem::imbue("UTF-8"); // more abstract than codecvt pseudocode :-) In this example an internal conversion into UCS-2 would be done on Windows, on Linux it would depend on the configured locale and on the other systems, which could support ASCII only, it would convert into ASCII only. However, it does not constrain the application from running wholly in wchar_t (e.g. UCS-2) or char (UTF-8 or something else), or does not force the user to write extra code for character conversion if it is not necessary. Ferda > Patrick Bennett

1 0

Proposal for New Template Metafunction 'is_iterator'
by Alex Chovanec 24 Aug '04

24 Aug '04

Is there a utility in Boost which determines at compile time whether or not a given type meets the most basic requirements for an iterator, without generating an error if the test fails? (This last part is crucial, so concept checks are insufficient.) I recently needed something like this, and I couldn't seem to find it in any of the libraries, so I went ahead and wrote a template metafunction called 'is_iterator' which gets the job done. It uses the same SFINAE techniques as the enable_if library. The declaration looks like this: template <typename T> struct is_iterator; The 'is_iterator' struct template is a model of the "integral constant expression" concept. Thus, 'is_iterator<T>::value' evaluates to true if-and-only-if type T defines iterator traits as well as overloaded operators with the following signatures: boost::iterator_reference<T>::type operator*(void) const; boost::iterator_pointer<T>::type operator->(void) const; T & operator++(void); T operator++(int); These seem to be the minimal requirements (i.e. Readable and Incrementable) according to the New Iterator Concepts. Ideally, T would also have to be a Copy Constructible type, but I don't know of a reliable way to detect this. Originally, i needed the ability to determine at compile time whether or not a given type meets the requirements for a Readable Lvalue iterator. The 'is_readable_iterator' and 'is_lvalue_iterator' template metafunctions work fine for this purpose, except that they both generate an error when passed a template argument that is not an iterator at all. Assuming I'm correct in stating that a utility like 'is_iterator' does not already exist in Boost, is there any interest in such a utility? Thanks, Alex

4 16

boost-sandbox question
by Eric Niebler 23 Aug '04

23 Aug '04

I'd like to make the documentation for xpressive available from the boost-sandbox project home page, like the FSM docs (http://boost-sandbox.sourceforge.net/libs/fsm/doc/index.html) According to the SourceForge docs, I should be able to copy my files there with scp like this: scp index.html eric_niebler@shell.sourceforge.net:/home/groups/b/bo/boost-sandbox/htdoc/libs/xpressive But when I tried that, I got "permission denied". Then I ssh'ed to shell.sourceforge.net and tried to mkdir /home/groups/b/bo/boost-sandbox/htdoc/libs/xpressive, but I got "permission denied" there, too. Do I need special permission to be able to do this? I already have CVS write access -- I guess that's not enough. Any hints? -- Eric Niebler Boost Consulting www.boost-consulting.com

4 3

boost::random overflow bug
by Samuel Krempp 23 Aug '04

23 Aug '04

while checking uniform_int.hpp, I spotted 2 weirdnesses in uniform_int.hpp that almost cancel themselves out, but not to the point that a contrived example is impossible. The heart of the problem is this loop : while(mult <= limit) { result += (eng() - bmin) * mult; mult *= result_type(brange)+result_type(1); // <-- overflow possible } where limit = (range+1)/(brange+1) the multiplication is almost always guaranteed not to overflow (that was the motivation to write the loop that way, I guess), except when mult==limit (which is reached when range+1 is a power of brange+1) in that case, the last multiplication assigns (range+1) to mult. And range+1 might in fact overflow. Now, it turns out in cases where range+1 overflows, limit is computed with special anti-overflow code, and there 's a bizarre condition there that looks like a bug : if(_range % result_type(brange)+1 == result_type(brange)) ++limit; instead of expected if(_range % result_type(brange+1) == result_type(brange+1)) ++limit; so in the end, most of the time when range==max, limit is assigned the value : range/(brange+1) instead of (range+1)/(brange+1). So it cancels out the first bug most of the time (maybe that is the reason for the bizarre code). but the limit will still be equal to (range+1)/(brange+1) for brange=1 (I'm not sure how useful a coin-flipper generator would be, but we never know..), and mult can then be made to wrap and reach 0 in the previous loop, which loops forever. I've attached a compilable exemple and suggested patch. I've thought it over carefully, the patch works in all situations. after the test on (mult==limit), it's all safe since mult is guaranteed to be > limit, and thus _range/mult will still be < brange+1, so the recursive call at the end is safe. -- Samuel

2 2

Shouldn't boost::filesystem be BOOST_POSIX on cygwin?
by Carlo Wood 23 Aug '04

23 Aug '04

At several places in the code we find something like: // BOOST_POSIX or BOOST_WINDOWS specify which API to use. # if !defined( BOOST_WINDOWS ) && !defined( BOOST_POSIX ) # if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__) # define BOOST_WINDOWS # else # define BOOST_POSIX # endif # endif (As in for example boost/libs/filesystem/src/path_posix_windows.cpp) This sets BOOST_WINDOWS explicitely, as default, for cygwin - which is a POSIX operating system with a single root. This breaks a lot of code - if not all - of boost::filesystem. For example, the following code: #include <iostream> #include <boost/filesystem/path.hpp> #include <boost/filesystem/operations.hpp> int main() { boost::filesystem::path p = "/usr"; if (!boost::filesystem::exists(p)) std::cerr << p.string() << " doesn't exist according to boost::filesystem" << std::endl; } indeed causes boost::filesystem::exists to return 'false' on cygwin while "/usr" definitely exists. The reason for that is obvious and looks like a clear bug: The code of boost::filesystem::exists is as follows: BOOST_FILESYSTEM_DECL bool exists( const path & ph ) { # ifdef BOOST_POSIX struct stat path_stat; if(::stat( ph.string().c_str(), &path_stat ) != 0) { if((errno == ENOENT) || (errno == ENOTDIR)) return false; // stat failed because the path does not exist // for any other error we assume the file does exist and fall through, // this may not be the best policy though... (JM 20040330) } return true; # else if(::GetFileAttributesA( ph.string().c_str() ) == 0xFFFFFFFF) { UINT err = ::GetLastError(); if((err == ERROR_FILE_NOT_FOUND) || (err == ERROR_PATH_NOT_FOUND) || (err == ERROR_INVALID_NAME)) return false; // GetFileAttributes failed because the path does not exist // for any other error we assume the file does exist and fall through, // this may not be the best policy though... (JM 20040330) return true; } return true; # endif } Therefore, with BOOST_POSIX undefined, "/usr" is passed directly to ::GetFileAttributesA() and that can obviously not work. My question is therefore: shouldn't BOOST_POSIX be forced to be defined on cygwin? -- Carlo Wood <carlo(a)alinoe.com> PS Please note that, looking at http://www.meta-comm.com/engineering/boost-regression/developer/summary.html nobody is running the testsuite on cygwin! How broken on cygwin is boost really?

8 21

boost::random uniform_int bias and speed
by Samuel Krempp 23 Aug '04

23 Aug '04

Looking inside boost::random, I noticed a few things that I think could be better, and since I could not find mentions about those in the lists's archive, I'll ask here. 1. the case : brange / _range <= 4 Is implemented by rejection, directly. But the average number of rejects could be decreased (by a factor up to 4) by rescaling before rejection. i.e. (pseudo code) : .k = (brange+1) / (_range+1) .rejection_thresh = k * (_range+1) .keep generating random number until result < rejection_thresh .return result/k; the probabilty of a reject is then less than _range/brange, and also always less than 1/2, and can reach 0 (if (brange+1) is a multiple of (_range+1)) Was this possible speedup considered useless ? 2. the case brange / _range > 4 since direct rejection could mean very very many retries in this case, this case is dealt with uniform_smallint (which always uses exactly one number generation). But by using previous rejection scheme, there is no need for this case since the average number of needed number generations will be fairly close to 1, and the generator's speed will be equivalent to uniform_smallint. Plus, using a rejection scheme would completely avoid any added bias (contrary to uniform_smallint in which the added bias can reach 1/32, thus unsuitable for high-precision statistics programs) Why not use such a "rescaled" rejection scheme as I describe rather than uniform_smallint's possibly biased computation ? -- Samuel

1 2

RE: [boost] Java style GUI in C++
by Hurd, Matthew 23 Aug '04

23 Aug '04

> Behalf Of John Torjo > > Some rambling thoughts on things I'd like to see are: > > > > 1. run-time and compile-time configurability, especially with some like > > compile time specification language like layout capability. There was > > some talk about this and some suggestions previously on this list. > > Marrying this to run-time would be interesting. > > > > Perhaps at compile time you can decide if there is an explicit handling > > method and if not call something with your source and event type that > > will dispatch. However this would lock you in at run-time if did this > > as a compile time metaprogramming thing that ending up optimizing to a > > function call equivalent but perhaps both options are appropriate... > > that's more or less what win32gui does. > > And more to the point, when you extend a window class, you can add your > own handlers into the picture. > > Thus, you can end up with more event handlers for the same > event/command/notificiation. > > This is TOTALLY ok. > Whenever a handler for an event/command/notification gets called, it can > decide what to consider this event: > - event_not_handled: I consider this handler did not handle this event. > If more handlers exist, call them. If no more handlers, call default (in > our case, DefWindowProc) > > - event_is_handling. I did handle his event, but it's ok if other > handlers handle it too. So, if there are other handlers, call them too. > After all handlers are called, DO NOT call default (in our case, > DefWindowProc). > > - event_handled: I handled this event. DO NOT call other handlers, nor > the default( DefWindowProc). > > > I thinks this handles most (if not all) cases. Yep, in my mind it should be handled by the highest level event handler in the structural tree composite thingo that represents the ui layout. That event handler has the option to allow dispatch to the next lower level handler. I was thinking that you would attach event handlers for messages from sources to any place in the structural ui tree. It is handled by the highest handler in the structural tree or it is ignored if there is no handler. > > > > 2. reverse structural inheritance of events handler equivalents. > > Widgets are composed of other widgets. A window may handle the click, > > or prevent it, for a child. You can attach a handler for a named event > > at any point in the composition / structural hierarchy, it doesn't have > > to be the source, but is aware of it. Handling goes down the hierarchy > > to source. > > In fact, I think it should be quite reversed. > If a window cannot handle a command/notification, forward it to its > parent and so on - until someone handles it or reaches top. I think it should be the other way around, if I understand it. You need to be able to over-ride the behaviour of your components by interposing another handler. E.g. don't do the normal stock window click event do this instead (which may also continue the chain down...). More importantly, should be able to disable and enable all contained (child) messages. Doing so by category as someone else suggested would be nice... e.g. all drag drop, all mouse, etc... Goodluck, your lib sounds interesting. Matt. IMPORTANT: The information contained in this email and/or its attachments is confidential. If you are not the intended recipient, please notify the sender immediately by reply and immediately delete this message and all its attachments. Any review, use, reproduction, disclosure or dissemination of this message or any attachment by an unintended recipient is strictly prohibited. Neither this message nor any attachment is intended as or should be construed as an offer, solicitation or recommendation to buy or sell any security or other financial instrument. Neither the sender, his or her employer nor any of their respective affiliates makes any warranties as to the completeness or accuracy of any of the information contained herein or that this message or any of its attachments is free of viruses.

2 1

New design proposal for boost::filesystem
by Carlo Wood 23 Aug '04

23 Aug '04

I propose the following design. The aim of boost::filesystem should be to support the following coding idiom: * The programmer should take care to only handle two types of paths in his application: 1) Complete paths 2) Relative paths * The programmer will have to specifically tell the libary when a constructed path is 'native' and when not. A native path is accepted according to native rules and never gives any problem (exceptions) further on. A non-native path is checked according to the existing rules, which basically means that the programmer can set a default check routine that will in effect determine how portable the application will be. I propose two design changes: 1) 'native' is now not only a representation, but an *internal state* of fs::path. (this has no effect on the representation as returned by fs::path::string()). 2) All 'complete' paths are automatically marked as 'native'. Examples, the following code is legal: fs::path p1("C:\\foo\\a.exe", native); // As one might do on windows. fs::path p2("/usr/src/a.out, native); // As one might do on linux. std::cout << p1.native_file_string(); // ok, p1 is native. fs::path p3("foo/bar"); // Relative path, always succeeds. std::cout << p.string(); // ok std::cout << p.native_directory_string(); // Useless, but ok. fs::path p4(complete(p3)); // p4 is now "native", because now it is complete. std::cout << p4.native_directory_string(); // ok And the following will fail (assertion?): std::cout << p4.string() // Not allowed because p4 is native (complete). Since there would be a default way defined of how a relative path is completed, all operation functions will accept both, relative and complete paths. For example: fs::path p1("C:\\cygwin\\usr/bin/ls", native); // Legal path on Cygwin. if (fs::exists(p1)) // Ok, access complete path. // For clarification fs::path p2("C:\\cygwin\\usr"); // Just an example fs::default_working_directory(p2); // fictuous function. fs::path p3("bin/ls"); // Portable representation (refers in fact to "C:\cygwin\usr\bin\ls.exe"). if (fs::exists(p3)) // Ok : exists() will make the path complete before testing. And this throws: fs::path p4("/bin/ls"); // Not allowed: this path has a root but is not marked 'native'. Setting the default_working_directory shall allways need to be done for each supported OS seperately. Of course you can set it to "/" on single root machines, and set it to "E:/" after extracting the 'E:' from the current path at application start up, in effect simulating a 'single root': int main() { fs::default_working_directory(fs::current_path().root_path()); // ... simulate single root machine below. fs::path p("bin/ls"); } The average application will work with relative paths, relative to some (native) base directory and next to that have some arbitrary, complete and thus native directories (ie, read from environment variables). But in case more than one 'working' directory seems needed then we can add support for that too by allowing to construct paths with a reference to the (complete/native) working directory. Ie, fs::path homedir(g_getenv("HOME"), native); fs::path rcdir(homedir / "edragon/rc", native); fs::path tmpdir(current_path().root_path() / "tmp"); // ... fs::path runtime_rcfile(rcdir); // Set 'runtime_rcfile' to be relative to 'rcdir'. // ... runtime_rcfile = "config/runtimerc"; which is then relative to `rcdir' instead of a single, global 'working directory' (as now returned by fs::current_path()). Most of the current boost::filesystem API can be preserved with this design. -- Carlo Wood <carlo(a)alinoe.com>

10 26