- Boost - lists.boost.org

Subject: Re: [Boost-users] [Containers] Marshalling deques
by Brian Wood 26 Aug '11

26 Aug '11

Michael Goldshteyn: > I think that having a ?configurable? deque class template > is one of the best things that could be offered by a boost > Containers library. I have always wondered why noone > wrote a version of the deque class template that allowed > the configuration of such things as the page / block size, > rather than have it be determined by a compile time > formula based on the size of the data type being stored. > It would seem to me that the page / block size is one of > the more critical pieces affecting the size / speed > tradeoffs in a deque?s performance when there are many > insertions taking place. The thread I mentioned has a link to a segmented_array container which may be of interest. I agree that what you suggest would be an improvement. Shalom, Brian Wood Ebenezer Enterprises http://webEbenezer.net <http://webebenezer.net/>

1 0

Lighweight header-only version of Boost.Filesystem?
by Mathias Gaunard 25 Aug '11

25 Aug '11

I use Boost.Filesystem in a C++ "script": I use C++ instead of Python or shell script in order to be portable across operating systems. That script is used in bootstrapping the build system of my C++ project, and people have complained that they need to build boost.filesystem just to be able to bootstrap the project. This is made worse by the fact than the rest of my C++ project requires very recent versions of Boost headers and the fact that the ABI of filesystem has changed relatively recently. I had instances of people having problems because they were linking old versions of the filesystem library but using recent filesystem headers. They had a lot of trouble compiling the correct versions of filesystem themselves. I would also like to ship the script at installation time. To do that I statically link filesystem to reduce dependencies. My pretty trivial program, however, is more than 650kB in release mode after stripping (2.2 MB before stripping). All it does is walk a directory recursively and create a few files. I think this is too big. Therefore, I would really like it if there was a lightweight header-only version of Boost.Filesystem. I don't need the full extent of features; I just need to have the ability to do the following portably: - read all files of a directory - create directories - remove files and directories - rename files and directories The first point being the most important.

8 11

[msm]intarnal_transition_table's behavior
by Takatoshi Kondo 25 Aug '11

25 Aug '11

Hello, When I was trying to answer an another thread, I encountered strange behavior. (Re: [boost] [msm]exit pseudo state and event) See 18_InternalTransitionTableTest.cpp. (attached file) I believe that internal_transition_table should work correctly without transition_table. Here is internal_transition_table. // Internal Transition table struct internal_transition_table : mpl::vector< // Event Action Guard msmf::Internal < Event1, Action1_1 ,Guard1_1 > > {}; But Event1 isn't dispatched. I don't understand why. When I add transition_table that includes the Event1, internal_transition_table works correctly. #if 1 // Why is it needed? // Transition table struct transition_table:mpl::vector< // Start Event Next Action Guard msmf::Row < State1_1, Event1, State1_2, msmf::none, msmf::none > // OK // msmf::Row < State1_1, Event2, State1_2, msmf::none, msmf::none > // NG > {}; #endif But if transition_table don't have Event1, internal_transition_table doesn't work correctly. msmf::Row < State1_1, Event2, State1_2, msmf::none, msmf::none > // NG I suspect it is bug. How do you think? Thanks, Takatoshi

3 6

[type_traits] is_enum on scoped enums doesn't works as expected
by Vicente J. Botet Escriba 25 Aug '11

25 Aug '11

Hi, The following file fails to compile under clang 2.9 c++0x #include <boost/static_assert.hpp> #include <boost/type_traits/is_enum.hpp> enum E {E_a,E_b,E_c}; BOOST_STATIC_ASSERT((boost::is_enum<E>::value)); enum class EC {a,b,c}; BOOST_STATIC_ASSERT((boost::is_enum<EC>::value)); //#include <type_traits> The command line and error is "/Users/viboes/clang/clang+llvm-2.9/bin/clang++" -x c++ -std=c++0x -O0 -g -Wextra -Wno-long-long -pedantic -O0 -fno-inline -Wall -pedantic -g -DBOOST_ALL_NO_LIB=1 -DBOOST_CONVERSION_DOUBLE_CP -DBOOST_ENABLE_WARNINGS -I"." -I"../../.." -c -o "../../../bin.v2/libs/enums/test/is_enum_pass.test/clang-darwin-2.9x/debug/is_enum_pass.o" "enum_class/is_enum_pass.cpp" enum_class/is_enum_pass.cpp:7:1: error: static_assert failed "(boost::is_enum<EC>::value)" BOOST_STATIC_ASSERT((boost::is_enum<EC>::value)); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In file included from enum_class/is_enum_pass.cpp:1: Am I missing something evident? Is this a known bug of is_enum? BTW, I have tried to use directly the type_traits standard file and my build configuration is unable to find it. enum_class/is_enum_pass.cpp:9:10: fatal error: 'type_traits' file not found #include <type_traits> Which is the default library when buildding with Boost.Build (bjam) and clang 2.9 c++0x? Best, Vicente

6 11

Re: [boost] Query for interest in including a shim class converting between char*, wchar_t*, string, wstring
by Zhi Tan 25 Aug '11

25 Aug '11

> > From: Yakov Galka <ybungalobill(a)gmail.com> > > On Thu, Aug 25, 2011 at 12:11, Tan, Tom (Shanghai) <TTan(a)husky.ca> wrote: > > > As a C++ programmer, often times there's a need to widen or narrow a > > string to match some 3rd APIs. After writing similar code again and > > again, I decided to have a wrapper to simplify this trivial but frequent > > work, hence the TR and TR2 class. Features include: > > > > If something fails to compile, there must be a reason. Just shutting up the > compiler doesn't make your code correct. What you're doing is like > reinterpret_casting an int to float... > no reinterpret_casting is involved here. it's just a wrapping of one of basic_string's standard constructors. template<class InputIterator> string (InputIterator begin, InputIterator end) template<class InputIterator> wstring (InputIterator begin, InputIterator end) and this usage is a distorted usage. > [...] > > - Many Boost libraries (e.g. Boost.Test) that output plain > > English (ASCII) message literals can be easily extended to support both > > wide-char version with this class. > > > > They don't have to support wide-char. Many programmers are not interested > in > any wide-char support at all. See > > http://programmers.stackexchange.com/questions/102205/should-utf-16-be-cons… > As explicitly stated below, it does not have anything to to with any encoding/decoding of UNICODE and the like. It only does widening and narrowing of *plain ACSII Engish text*, where the operation does not change the meaning and readability of the literals. I can understand how some people can live without wide-char all life by living in a culture where wide-char is not needed(e.g. English speaking countries), or in a tech culture where UTF8 is used(Linux). But I happen to live in a culture(Chinese language) where 16-byte wide-chars are a matter of fact and easier to use. The default on Windows(UTF16) is implemented on wide-char too. I believe there are many out there like me facing cases where *widening *the English text is only need and correct enough. While the scope is very specific, the need is real. Think of std::exception class exception {public: exception () throw(); exception (const exception&) throw(); exception& operator= (const exception&) throw(); virtual ~exception() throw(); virtual const char* what() const throw(); } exception::what() only returns narrow chars, many exception-derived classes only provide simple English message too, where widening is necessary my wide-char app. The same goes to Boost Informational Macros <http://www.boost.org/doc/libs/1_47_0/libs/config/doc/html/boost_config/boos…>, and compiler predefined macros. Do not mistake it as a solution to endcodings or locale, rather, it's a solution between char* and wchar_t*, when you know the operation is safe, which is usually the case of writing libraries, where messages are in short and plain ASCII English literals. > - The 2 classes do not involve any encoding/decoding. > > > > tr.hpp: > > > * N.B. it doe not do any code conversion like: MBCS <--> UNICODE > > > > This is just wrong. Your code is useless as it doesn't solve any real > problem. This is not going to be accepted to boost, especially since it > misguides programmers to write Unicode incorrect and *broken* code. Yes, > you > may find this library useful, and, say, half of non-expert programmers will > find this library useful. The sad thing is that most of them just don't > understand what Unicode is or what's text at all. > see above. This is NOT a code conversion solution, rather, a wrapping of standard C++ solution for a real need. > > Btw, you're not the first to propose some kind of tools for 'Unicode > support'. I can count at least 4 other proposals trying to solve different > aspects by different means. None of them was accepted to boost yet. > > -- > Yakov > > >

1 0

Re: [boost] Query for interest in including a shim class converting between char*, wchar_t*, string, wstring
by Zhi Tan 25 Aug '11

25 Aug '11

> > Date: Thu, 25 Aug 2011 11:24:59 +0200 > From: Sebastian Redl <sebastian.redl(a)getdesigned.at> > > On 25.08.2011 11:11, Tan, Tom (Shanghai) wrote: > > - The name TR is inspired from QT' tr() macro. > > > Qt's tr() stands for "translate" because that thing is the entry point > for Qt's localization/message catalog system. In other words, you use > tr() only for user-visible string that should get translated. That makes > it a poor inspiration for something that is concerned with encoding > conversion. > > Sebastian > I am aware this is not translation, but I like the shortness of tr(). One of the things I am expecting from the community is a proper naming. Vicente Botet renamed it to be adaptive_string, but it seems too long for me to type. Wile I am typing, it occurs to me as() might be a better name.

1 0

Query for interest in including a shim class converting between char*, wchar_t, string, wstring
by Tan, Tom (Shanghai) 25 Aug '11

25 Aug '11

As a C++ programmer, often times there's a need to widen or narrow a string to match some 3rd APIs. After writing similar code again and again, I decided to have a wrapper to simplify this trivial but frequent work, hence the TR and TR2 class. Features include: - Each class serves as a shim between wide-char and marrow-char string types. It accepts a std::basic_string type or C-style literal, returns a std::basic_string type or streamming to std::basic_ostream according to the context(e.g. type on the left side of '=' operator): - 2 classes o Non-template class TR: convenient and intuitive interface, e.g. std::string s = TR(L"hello"); std::wstring s = TR("hello"); o template class TR2<SourceRange>: more verbose but faster e.g. std::string s = TR2<const wchar_t*>(L"hello"); std::wstring s = TR2<const char*>("hello"); - Many Boost libraries (e.g. Boost.Test) that output plain English (ASCII) message literals can be easily extended to support both wide-char version with this class. - The 2 classes do not involve any encoding/decoding. - The name TR is inspired from QT' tr() macro. If there's enough interest, I am ready to improve the code, including renaming, style cleaning, documenting and compiler testing etc, for a final inclusion. And I also would like to have a mentor to guide me through as I've never submitted any code to boost before. This class started as some test code snippet for boost.chrono while exchanging ideas with Vicente J. Botet Escriba. One major improvement since then is that the conversion is bi-directional now..

3 2

[type traits] Extension to operator detection -> choose your preferred naming
by Brent Spillner 25 Aug '11

25 Aug '11

On 8/24/2011 07:23 Frederic Bron wrote: > Please give your preference between A, B and C before Sept. 5th. Of these three choices, I think C is easiest to live with. However, if you're going to have has_unary_plus I think the symmetry of has_unary_minus is preferable to has_negate, and I continue to believe that an additional has_operator<Tag, TypeA, TypeB> (or can_call_operator<>) should be provided for use in more generic code (e.g. forwarding ETs from a higher level without caring exactly which operators are involved.) Brent

1 0

[Conversion] Practical applications
by Phil Endecott 25 Aug '11

25 Aug '11

Dear Vicente & others, Would anyone like to share any practical or motivating applications for the proposed Boost.Conversion library? It seems to me that there are practical applications for particular types of conversion, e.g. T-to-string and string-to-T, and numeric casts, and serialisation. Apart from that, I am having trouble seeing practical reasons for generic conversion. A motivating case would be if a generic algorithm required conversion, but in the cases that I can think of either (a) the generic algorithm takes a functor, so the caller can pass the currently-required conversion as part of a lambda expression, or (b) you might need to select one of several possible conversions between a pair of types, which this library can't do, or (c) the algorithms are std:: ones which won't work with this library anyway. Example: struct person { string firstname; string surname; }; vector<person> people; // sorted by firstname // Try to find everyone with firstname "John": std::equal_range(people.begin(),people.end(),"John"); That doesn't work. Making it work has always struck me as more difficult than it should be. Can this library make it easier? If not, what similar problems can it help with? Regards, Phil.

6 12

[gsoc] Final evaluations
by Andrew Sutton 25 Aug '11

25 Aug '11

Mentors, Please don't forget to submit your final evaluations. You must submit the evaluation before August 26. Thanks, Andrew

1 0