May 2015 - Boost - lists.preview.boost.org

[branch master] add library to regression tests
by Oliver Kowalke 26 May '15

26 May '15

Hello, could you please add boost.coroutine2 to the regression tests of branch master?! best regards, Oliver

1 0

Aho - Corasick String Search (for searching multiple patterns) Interface
by meghana madhyastha 26 May '15

26 May '15

Hi, In some of my previous mails I had suggested that the Rabin Karp and Aho - Corasick string search algorithms be implemented as a part of the Boost algorithm library. This is primarily because these algorithms perform well for searching for multiple patterns. The Aho - Corasick algorithm works by building a trie (a tree with each node corresponding to an ASCII character) of the patterns strings and traversing the trie to search for the pattern in a given text. Additionally, the Aho - Corasick introduced the concept of "failure pointer/failure node" which is the node to be traversed when there is a mismatch. For more information: http://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_string_matching_algorithm The interface I propose is as follows. 1. The input of the patterns should be strings within a *container*. This is because these algorithms are primarily used for multiple pattern searching. The user can input pointers/iterators to the first and last pattern . The final output which is returned is a container with each pattern and a iterator/pointer to their occurrences (There are multiple patterns so just returning an iterator/pointer to where the patterns first occurs in the pattern will not suffice). 2. Just like the previous string searching algorithms that have been implemented in Boost, there can be an object based interface as well as a procedure based interface. In the object based interface, the trie is constructed and the failure nodes are computed in the constructor (while creating the object). The user can then search the text using the operator(). template <typename patIter> class aho_corasick { public: aho_corasick(patIter first, patIter last): pat_first(first), pat_last(last), head(std::shared_ptr<trie_node>(new trie_node)) { //first and last are pointers/iterators to the first and last patterns in the container gotoFn(head); failureFn(head); } ~aho_corasick () {}; template <typename corpusIter> corpusIter operator ()(corpusIter corpus_first, corpusIter corpus_last) //Note: using the same notation as used in the other search algorithms. Corpus- refers to the text to be searched. I've implemented this and would like to get feedback/suggestions on the code as well as the interface. Where should I put up the code for it to be reviewed ? Thanks, Meghana

1 0

boost [vmd]: configuration issue in Jamfile.v2 for Oracle Solaris Studio compiler
by Aparna Kumta 26 May '15

26 May '15

I am looking at my test run for vmd in develop branch. http://www.boost.org/development/tests/develop/developer/vmd.html under SunOS. My tests are run with cxxflags="-compat=5 -library=stlport4" as configured in user-config.jam An example of a test, http://www.boost.org/development/tests/develop/developer/output/oracle-spar… The test fails as follows: "CC" -std=c++0x -std=c++11 -compat=5 -library=stlport4 -xO4 -mt -erroff=%none -m32 -KPIC -DBOOST_ALL_NO_LIB=1 -DNDEBUG -I".." -c -o "/export/home/sstrunk-tester/boost_regression/boost_sparc-S2_stlport4/results/boost/bin.v2/libs/vmd/test/test_after_identifier_elem.test/sun-stlport4/release/threading-multi/test_after_identifier_elem.o" "../libs/vmd/test/test_after_identifier_elem.cpp" CC: -compat=5 can not be used with -std CC: -library=stlport4 cannot be used with -std=c++11 If I compile the test manually without '-std=c++0x -std=c++11', the test compiles OK. %CC -compat=5 -library=stlport4 -xO4 -mt -erroff=%none -m64 -KPIC -DBOOST_AL0%L_NO_LIB=1 -DNDEBUG -I.. -c -o ./test_after_identifier_elem.o ../libs/vmd/test/test_after_identifier_elem.cpp % It looks like boost_root/libs/vmd/test/Jamfile.v2 needs to be modified for this compiler. Any ideas on how this can be done? Thanks, Aparna

2 3

boost::bind C2664 error with two non-const references
by Nicolas FRANCOIS 25 May '15

25 May '15

Hi, Relatively to this thread http://lists.boost.org/Archives/boost/2015/03/220930.php and this correcting commit 42b5cef177603328ead66bc6a98a3067aebc433d, I still have errors using boost::bind. #include <boost/bind.hpp> #include <boost/function.hpp> struct A { void f(int&, std::vector<int*>&); }; int main(){ A a; auto f = boost::bind(&A:f, &a, _1, _2); } results in error C2664: cannot convert from 'const std::vector<int*> &' to 'std::vector<int*> &' Defining BOOST_NO_CXX11_RVALUE_REFERENCES solves the issue for now. Nicolas FRANCOIS Software Department L-ACOUSTICS Tel : +33 (0) 1 69 63 23 90 Fax : +33 (0) 1 69 63 69 64 www.l-acoustics.com<http://www.l-acoustics.com/> Please consider the environment before printing this email.

2 7

Environment Variables Library?
by Michael Ainsworth 24 May '15

24 May '15

StackOverflow regarding the (non) standardisation of the "setenv" function, does Boost provide a library to interact with environment variables? http://stackoverflow.com/questions/30292642/c-standard-library-stdsetenv-vs… Michael

10 34

[testing][CrystaX.NET] Missing header
by Andrey Semashev 23 May '15

23 May '15

Hi, Many of the CrystaX.NET testers fail to compile tests because of this error: fatal error: crystax/google/sys/select.h: No such file or directory See here for example: http://www.boost.org/development/tests/develop/developer/CrystaX-NET-apilev… Could this be fixed?

2 1

boostdep documentation?
by Robert Ramey 22 May '15

22 May '15

I am interesting in taking a look at boostdep. I see the code in tools/... but I don't see any documentation. Is there any? will there be in the future? Robert Ramey

2 3

Re: [boost] [Better Enums] Interest in/feedback on C++11 enums library
by Anton Bachin 22 May '15

22 May '15

I've been keeping away because I am doing a ton of work on the library, and I don't want to attract too much attention until the work is ready, since there are lots of changes. But, I think I should reply, and I will also give a brief update of the progress at the end of the message. > I suspect this code: > > Depth depth = default_<Depth>(); > > could be made to look like this: > > Depth depth = _default; > > > ie all enums have a constructor that takes a default_t type. The > constructor then calls default_<T>(). > Or something like that. And then change the names to get > > Depth depth = default_; // calls default_impl<T>(); That’s a good idea. I hadn't thought of such a constructor. I will try it out, but I am not sure that it would belong directly in the library, if that's what you mean. It's not clear where one should stop. Should there also be an "invalid" constructor for projects that have such a notion? Are there other special values we can't predict? Perhaps this could be achieved with some kind of extension facility. I will eventually be adding either support for subclassing, or extra macros, or some kind of template-based extensibility. To the other commenters: thanks :) As for progress: there are substantial improvements. - The entire interface is now constexpr, including string functions and iterators. - I ported the interface to C++98, though it still requires __VA_ARGS__. This makes the topic of this message inaccurate. Should I start a new thread for the new version when it's up? - The C++98 conversion means that, in theory, the library should work on MSVC down to VS2005. I will be testing that when I get my new notebook in a few days. If successful, Better Enums will be compatible with the 3 major compiler families. - Eliminated all weak symbols, leaving only standard C++. Some may be brought back later for optimization, but they are no longer required. - When compiling for C++11, there are no more implicit conversions to integers. - The library is now a single header file, containing both the C++11 version and the C++98 port, and all helper macros. - The documentation is getting a major improvement, so please don't look now. The all-constexpr version is unfortunately noticeably slower to compile. The performance test that was previously two times faster than including iostream is now twice as slow, but I can mitigate this with some combination of opt-in and optimization. Anton

1 0

[build][test][gsoc] question about compiling tests with multiple compile params using b2
by Damian Vicino 22 May '15

22 May '15

Hi, I’m working in the safe_float library for the GSOC. For testing I’m using the boost.test library and for building I’m using b2. The implementation have several pieces that are implemented in two flavours, one for compilers supporting FLOAT_ENV and one for those not supporting it. (this is a C++11 feature missed in at least clang and gcc compilers) Right now, the implementation is selected with an #ifdef and I #define them with a -D parameter. My config file for test is: using testing ; lib boost_unit_test_framework ; unit-test test : main-test.cpp [ glob *_test.cpp ] boost_unit_test_framework ; I guess I can generate 2 different executables using 2 targets, duplicating last line and adding something to tell it to pass -DFENV_AVAILABLE, but I couldn’t find how to do that. Having 2 executables for the tests and running them both will provide testing for both compilation paths (when using a compiler supporting FENV). Also, I’m wondering if B2 has the inteligence detect and pass a parameter when using a compiler supporting FENV. Is there any common approach for these situations where conditionally compiling based on a c++ feature support? In the case a Boost.Build needs to define a test for detecting if the compiler supports the feature (autoconf-like) it can be tested compiling a one-liner file: test.fenv.cpp #pragma STDC FENV_ACCESS ON When compiled: clang++ -c test.fenv.cpp test.clang.cpp:1:14: warning: pragma STDC FENV_ACCESS ON is not supported, ignoring pragma [-Wunknown-pragmas] #pragma STDC FENV_ACCESS ON The warning means the feature is not supported. Thanks for any guidance in this area, I’m pretty newbie with the b2 system. Best regards, Damian

2 1

[Better Enums] Interest in/feedback on C++11 enums library
by Anton Bachin 21 May '15

21 May '15

Hello, I’ve just released an enum library that takes advantage of constexpr functions and literal types to provide a nice declaration syntax and decent feature set: https://github.com/aantron/better-enums <https://github.com/aantron/better-enums> I’d like to get feedback on it from the experienced developers here at Boost. Is this approach useful? Are any major features missing? Would this be an interesting candidate for enums in Boost? I am very willing to do further development on this project. The library's basic features are string conversions, value and name listing, some type safety, and a declaration syntax that is based on built-in enums and is easy to learn and use. A much more "advanced” feature is that the generated class is a literal type, and almost everything is constexpr. Here is a simple example, that takes advantage of this, of a compile-time encoding of project policy: https://github.com/aantron/better-enums/blob/master/example/6-traits.cc <https://github.com/aantron/better-enums/blob/master/example/6-traits.cc> . Once I make the iterators constexpr as well, by providing a way to increment them other than mutation (++), it will be easy to write rather involved compile-time algorithms that process Better Enums declarations. Here is an example of a whole bunch of simple compile-time processing already possible: https://github.com/aantron/better-enums/blob/master/example/4-constexpr.cc <https://github.com/aantron/better-enums/blob/master/example/4-constexpr.cc> . Some of that could be useful when C++ declarations are generated by script. The library is all standard C++11 (to the best of my knowledge), except for the usage of weak symbols for some generated constexpr static arrays. I have tested it successfully on clang and g++, but I would need help getting access to more compilers. I believe weak symbols are not a problem for MSVC, but I still don’t believe the library will compile on MSVC since I don’t think MSVC supports enough of C++11 yet. Performance is what I would call excellent. I compared compilation times of these two files to each other: https://github.com/aantron/better-enums/blob/master/test/performance/4-decl… <https://github.com/aantron/better-enums/blob/master/test/performance/4-decl…> https://github.com/aantron/better-enums/blob/master/test/performance/5-iost… <https://github.com/aantron/better-enums/blob/master/test/performance/5-iost…> The first file includes enum.h and declares a bunch of enums, and the second merely includes iostream. On my machine, clang compiled all those enums in about half the time it took to process iostream. g++ was faster on iostream, but only slightly. Using a lot of compile-time expressions would have additional cost, but it has been too small to measure for “realistic” examples from my own usage. I haven’t yet made an example that repeatedly deals with a very large enum at compile time to properly measure that impact. I’ve also explored an alternative interface where the constexpr properties provided by the library are in a traits class parametrized by a normal C++11 enum class, but the interface seemed too verbose. There is also a bitset type that has a very slightly nicer interface than std::bitset for usage with enums, but I didn’t think the improvement was worth the user’s learning effort. I can put these in branches if there is interest, however. Please let me know what you think. Best, Anton

5 4