- Boost - lists.boost.org

Re: [boost] [optional] generates unnessesary code for trivial types
by Andrzej Krzemienski 10 Feb '12

10 Feb '12

> I have a question though. Why prohibit opt = opt assignment? It looks > quite safe and has a fairly obvious behavior. If I have an optional > reference as a member of my class, the lack of assignment in optional > would force me to define a custom assignment operator for my class. > This seems to be an unnecessary requirement. Also, in the source code > I dealt with I often saw people writing something like opt = > optional<T>() to clear the value. This would break with references for > no apparent reason. First, let me show why opt = nval; is controversial. Current semantics for boost::optional<T&> is to rebind on assignment, which means that in the following code: int i = 1; int j = 2; optional<int&> oi = i; oi = j; The effect of this program is that i remains 1, j remains 2 and oi holds a reference to j. This is surprising to those that think of optional as delayed initialization. I lean towards disabling opt = opt because it is very similar to opt = nval; int i = 1; int j = 2; optional<int&> oi = i; optional<int&> oj = j; i = j; The effect here is that i remains 1, j remains 2 and oi and oj both hold a reference to j. You may find it less surprising but if you think of optional reference as a regular reference that is initialized a bit later, the behavior is not what you would expect. Note that if you store a normal reference to int as class member, you already have to write your assignment yourself. changing a normal reference to an optional reference should not come as something irregular.

3 2

Re: [boost] [git] neglected aspects
by David A. Greene 09 Feb '12

09 Feb '12

Thomas Heller <thom.heller(a)googlemail.com> writes: > On 02/08/2012 07:30 AM, Steven Samuel Cole wrote: >> A quick read on submitting bugs on boost.org, svn co yadi yadi, fix the >> typos locally. Of course I don't have write privileges to the repo, so >> the best I can do for now is create a patch and attach that to a bug >> report. Within minutes, someone takes care of the bug, comments and >> takes ownership. Excellent! Smithers, money fight! > > Great! Now with something like github you create your own fork, push > to that and eventually create a pull request and wait until it gets > applied ... as you described. The process didn't change. You just > named the steps differently. No. The fundamental part you're missing is that the source control utility (git in this case) handles it for you. There is no need to go outside the sournce control utility to make additional changes. >> What are my options now ? Revert my changes, base the new ones on the >> head revision and send another patch ? Create a new patch file and >> manually remove the diffs of the old changes I already sent ? How will >> the upstream maintainer know which changes are based on what version ? > > Simple. Update the bug you already filed with the patch containing all > fixes. What would be the options with git? Update the pull request? > Again, same thing, different name. No, not the same thing. Again, this is all happening within the source control utility. Steven is relating real issues with svn. I have encountered them many times. I have found that git eliminates them. >> Also, I notice a few other things that in my opinion could be done >> better to facilitate adoption of the iostreams library. > So with git you pushed them to your personal fork. Over time, your > fork and the upstream version eventually diverge. You have to maintain > your changes. Same thing when the changes lurk on your local svn > working. There are several advantages to a git fork over an svn local workarea. - You can make a new branch for each feature, keeping the code for logical features separate. You can submit them whenever you want, in whatever order you want. - You can share the forks and branches with others. - You can massage the fork/branch over time to respond to review feedback, all supported directly by the source control utility. IME, git rebase -i and git add -i are killer features for the code review process. >> A couple of hours later: I get an email from boost bugs/svn; the >> upstream maintainer has committed my changes. However, I actually >> receive not one, but two emails, because the upstream guy chose to split >> my patch into changes on documentation and changes on source code (which >> presumably required extra work on his part). > > Frankly, I don't see how this would change with git. Actually, git would make things easier for the maintainer here. Either he/she could request the submitter to break up the patch, which is easily done with rebase -i/add -i or the maintainer could use the same tools to do it him/herself. >> I do an svn up and now have to deal with conflicts between my local >> changes and the new commits: I make a note of my second set of changes >> and overwrite my local files with the new repo versions, then bring the >> second set back in. > > Same again. How is this significantly different to what you'd do with git? It's all within the utility. There's no need to back out patches (the second set of changes in this case) manually from the source and re-apply them manually after update. Because each feature is in its own (local) branch, updates of one branch don't conflict with unrelated features in other branches. Yes, you'll need to resolve conflicts but it's much less messy with this kind of separation. >> Uff! That's a lot of work just to fix some typos! And these are just >> cosmetic issues in discrete chunks that do not require any testing; >> contributing changes to source code would take even more effort and more >> caution - build and test on several platforms, peer review, etc. > > Right, all that wouldn't change with having git as the tool of choice. It does, dramatically. git actually directly supports workflows that developers use when working on large projects. svn does not and there are all sorts of hacks out there to work around those problems. I've written a fair number myself. I don't need any of them with git. >> I don't have to wait for the first set of changes to be merged into >> the trunk before I resync, resolve conflicts and base the second >> set on the new head revision; I simply create a new branch for >> a new change set and send a new pull request once my work is complete. > > Errm ... you can still do that with svn. just continue working. Make a > new patch, update the patch in the bug report you filed, yes trac can > do that. There really is no need to wait for anything. But now you're conflating multiple features. Many times I have a feature in-progress and another feature I'd like to work on that's unrelated to the first feature. I don't want to disturb the source tree of the first feature because I might have to update it (respond to feedback, etc.). I need to be able to test both features in isolation. >> The upstream maintainer has no peer pressure to merge any changes in: >> He/she is sitting on the head revision and is looking at a number of >> pull requests for change sets in various personal forks like mine; > > So, how is it really different from the current trac system? svn doesn't support distributed operation so it can't support cherry-picking from multiple developers. You have to go outside the tool (manual diff/patch) to do it. That is painful. > I think i miss something fundamental here. Yes, you are. You're missing that every operation Steven is talking about is directly supported in git. You use the source control tool to manage source changes, always. There's no need to ever do a manual diff/patch. git manages multiple changes for you and organizes them in a logical way. It is easy to change among them, apply some, test them, revert some of them and so on. It's incredibly easy and productive compared to doing the same in svn. > While there are shortcomings in the current process, they won't be > solved by changing tools. Many will be. -Dave

4 3

[thread] wrong guard for explicit bool operators (c++11)
by Juergen Hunold 09 Feb '12

09 Feb '12

Hi Vicente, your commit New Revision: 76951 URL: http://svn.boost.org/trac/boost/changeset/76951 Thread: Added explicit to operator bool for locks (11 hours ago) leads to the following errors when using gcc-4.6.1 in non-c++11 mode: $BOOST_ROOT/boost/thread/locks.hpp:1323:34: warning: explicit conversion operators only available with -std=c++0x or -std=gnu++0x [enabled by default] It seems that the guards checking for explicit conversion operators are wrong. -#ifndef BOOST_NO_EXPLICIT_CONVERSION_OPERATORS +#if defined(BOOST_NO_EXPLICIT_CONVERSION_OPERATORS) Patch attached. Ok to commit? Yours, Jürgen -- Dipl.-Math. Jürgen Hunold | IVE mbH Software-Entwickler | Lützerodestraße 10 Tel: +49 511 897668 33 | 30161 Hannover, Germany Fax: +49 511 897668 29 | http://www.ivembh.de juergen.hunold(a)ivembh.de | | Geschäftsführer: Sitz des Unternehmens: Hannover | Univ.-Prof. Dr.-Ing. Thomas Siefer Amtsgericht Hannover, HRB 56965 | PD Dr.-Ing. Alfons Radtke

3 2

IDL to C++11 Language Mapping
by Johnny Willemsen 09 Feb '12

09 Feb '12

Hi, Last year I posted a question on this list related to the IDL to C++11 Language Mapping for CORBA. We are currently working on creating such a new mapping and maybe there are people on this list that are interested in giving feedback. All details about this effort are online at http://osportal.remedy.nl (example code and a draft OMG specification) and http://www.orbzone.org for a discussion forum. Best regards, Johnny Willemsen Remedy IT http://www.theaceorb.nl

1 0

quickbook abuse without boostbook
by Andreas Pokorny 09 Feb '12

09 Feb '12

Hi, My company is using docbook for end user documentation and to some degree also for design documentation. Since docbook is nothing anyone seems to be fond of writing, I now started looking into quickbook. The features that attract me the most are the neat syntax and programmability. The docbook environment that I am supposed to use is based on a different docbook version, than the one referenced in boostbook. So at the moment I have an xml file containing the book and booinfo header containing our corporate design foobar and disclaimer stuff. Then each chapter is referenced. The chapters are written in quickbook as chapter documents. When running the toolchain, it complains that it could not find the boostbook dtd - probably because downloading of dtd is disable, or fails because of our proxy. Is there a way to surpress the DOCTYPE tag within the chapter xml output files? regards Andreas Pokorny

6 7

GSoC 2012
by sultana rashid 09 Feb '12

09 Feb '12

Hello all, I am Sultana Rashid,a CSE student.As a computer engineering student I have good programming skills and am familiar with many new tools and technologies.I keep an eye on Boost libraries for almost last one year. Boost libraries are very useful and rich.But I found some new things can be added to it while exploring the libraries as Graph,Math,Geometry etc. I saw that Boost'd like to participate again in GSoC and I wish to work with the organization as a developer.Can I propose my ideas here just now? Thanking you, Sultana rashid. [1] http://lists.boost.org/Archives/boost/2012/02/190176.php

3 2

[interest] Type Aspects and compile-time constraints
by Beren Minor 09 Feb '12

09 Feb '12

Hi everyone, I would like to introduce a project I'm working on and a mechanism that emerged from the projects needs and, as far as I could feel, may be useful in a general case. By lack of words (let say), I named this Type Aspects, as an analogy to Type Traits. The project I'm working on, for quite a while now, is about creating a statically, strongly typed, compile-time checked and heavily simplified interface to OpenGL. I know that "Boost.OpenGL" is a subject that has been discussed many times on this list and that every time the outcome of the discussion is that Boost is not going to support a mere wrapper around some existing API. Well, I perfectly understand this and I'm not looking for the possibility to have this included in Boost. The project itself and its functional goal isn't actually the subject of my post, but it is a good introduction to type aspects, as it is what led me writting this as a general supporting mechanism. So, to introduce the idea, if some people do not know OpenGL, it is a typical C API, full of enumerations (well not even enumerations, integers preprocessor constants), loosely typed, and full of bloated function names with fixed number of parameters of various flavors. Obviously, every single function call takes an average of two of those constants as parameters. And obviously most combinations of values are leading to undefined operations, whithout having anyone complaining about anything, except a black window on your screen and a poor-man error code whenever there is one. Probably the most hideous nightmare you could ever have to use as a programmer. That was my observation. So I decided to take all these constants, that any OpenGL programmer is usually giving directly to feed the function calls, as parameters, to take all these functions, wrapp them all, rename related functions to use nice C++ overloading... but above all, convert these constants as types. This way I was able to write compile time constraints, checking the combination of constants provided to these functions. The goal was (and I must admit that it's working pretty much fine), that I would certainly be able to write the constraints described in the OpenGL specifications in term of templated C++ type constraints, making good use of static assertions with nice messages referring to the spec itself, and of metaprogramming techniques to achieve this. Then it appeared, after struggling a while trying to abstract all the data in use in OpenGL, that I could extract some fundamental properties of all these types and that the constraints described in the specifications would be experessed as simple and clear constraints on these properties. That's what I defined as Type Aspects. Let say OpenGL is able to handle 10 different type of textures. These types are different by the way color components are packed together, by their order, by their precision or numeric type (floating point or integral). All these are aspects of the texture type. Some OpenGL function might then be used to load data to a given texture, but depending on the texture type, it will only accept a certain type of source data. For example, integral textures only accept integral data, whereas floating point textures accept any data. This would be implemented as a simple constraint checking that the "Numeric" aspect of the source data type is compatible with the "Numeric" aspect of the texture type. Moreover, this also allows the user to provide a limited set of these aspects that he desires to have, and not others that he doesn't care of, and the compiler would be able to resolve the more relevant type to use depending on the use case. Type Aspects, as I defined it for the use in my projects, are like axises describing a type, every axis taking a value in a given set of possible values. This is not limited: as these values are types as well, they can also have aspects and be described. As an example that's what I did to describe the "Numeric" aspects of OpenGL data. Numeric aspect takes a value in a given set of predefined numeric archetypes. Every single archetype then has some values the three aspects describing a number type: its signness (signed, unsigned, any), its integralness (floating, fixed point, integral, boolean, any), and its width (number of bits/bytes, any). Well to conclude, I can see that this is certainly not related to OpenGL anymore and that this is a general mechanism that can be used to describe types and create relationships between types. I don't know if it is a subject that already has been discussed or if there's anything like that in Boost already (I don't think so but I don't know all the Boost libraries by heart). Do you see any interest in this kind of thing? Do you think that this could be something that worth working on deeper? TL;DR: 1. OpenGL sucks, I implemented compile-time constraints wrapping the functions calls. 2. Thinking about compile-time constraints made me qualify the types in use with a general mechanism describing the type's "aspects". 3. Aspects are axises and a given set of predefined values on these axises using which a type and its properties can be described. 4. Constraints can then be easily written as MPL checks on aspects axises and values as long as type aspects are formalized. 5. Does it already exist? Is that interesing? Should I try to go deeper in the abstraction? Kind regards, -- Beren Minor

3 7

Re: [boost] [optional] generates unnessesary code for trivial types
by Hite, Christopher 09 Feb '12

09 Feb '12

On Tuesday, February 07, 2012 17:00:04 Andrey Semashev wrote: > Do I understand it correctly that optional_with_traits is an advanced > replacement for optional? If so, will the good old optional be optimized? No, optional will be ("isA") optional_with_traits. It's just a work around. I'd prefer to redefine optional: template<typename T, typename Traits=optional_traits<T> > class optional; That might in rare cases it could break user code like: mpl::quote1<optional> Personaly I doubt that this is such an issue, but have the best of both worlds I can define a temporary "optional_with_traits" which when boost goes to 2.0 we could deprecate and add the parameter to optional. template<typename T, typename Traits=optional_traits<T> > class optional_with_traits; template<typename T> class optional : public optional_with_traits<T> {...}; Do we gurantee boost users that templates will never add default parameters? > BTW, I would really like to see optional< T& > optimized to store T* > internally. I'm going to say something provacative here. I agree with Lucanus. I see no reason for optional<T&>. As far I can tell you could use a T*. The only justification I can think of is on system without memory protection you can build checks into operator*(). Maybe if you're mixing code with old libraries where T* might imply ownership you might use optional<T&> to imply no ownership and some temporary validity. Perhaps we should define a new "smart pointer" called dumb_ptr<T> which can't be assigned into auto_ptr,unique_ptr,shared_ptr, or any pointer type which implies ownership. Maybe I'm missing something, but I don't see the justification. Chris

5 4

Re: [boost] [optional] generates unnessesary code for trivial types
by Andrzej Krzemienski 09 Feb '12

09 Feb '12

> optional< T& > is a useful thing when you want to apply operators (such as > relation operators or streaming) to the referred value. In generic code you > don't have to specialize for pointers to do the right thing. I'm going to use > this property in my Boost.Log library. Andrey, would you mind giving us a short example of how you want to use an optional reference? I am in the middle of designing the new optional interface for TR2, and came to the conclusion that in order to avoid counter-intuitive semantics for optional reference assignment, I had better remove it at all; that is, optional references are to be limited: they should provide no assignment. You could still use optional values and optional references in generic code but with reduced interface: template <typename T> // T is a ref or a value void use( std::tr2::optional<T> opt, T nval ) { if (opt) { std::cout << *out; // fine *opt = nval; // fine, assigning T's not optionals opt = nval; // invalid if T is a ref opt = opt; // invalid if T is a ref } if (needToRebindAReference()) { opt.emplace(nval); // valid - always rebinds } }; Would such a limited interface as I described above be enough for your generic usage of optional? Regards, &rzej

2 1

Simple boost polygon boolean OR doesn't work: help needed
by Praveen Vs 09 Feb '12

09 Feb '12

Hi, Below is code for doing a boolean OR operation. I'm not sure of the mistake I'm doing here. The output generated is wrong. I'm not using the operator+() becaue of the compile issue on MSVC2010. #include <boost/polygon/polygon.hpp> namespace gtl = boost::polygon; using namespace gtl; using namespace boost::polygon::operators; using namespace std; typedef gtl::polygon_set_data<double> CPolygonSet; typedef gtl::polygon_data<double> CPolygon; static void test_boost_polygons() { CPolygonSet polyset1, polyset2, rset; CPolygon polygon1, polygon2; typedef gtl::polygon_traits<CPolygon>::point_type CPoint; vector<CPoint> poly1Points, poly2Points; poly1Points.push_back(gtl::construct<CPoint>(0.0000, 0.0000)); poly1Points.push_back(gtl::construct<CPoint>(50.0000, 50.0000)); poly1Points.push_back(gtl::construct<CPoint>(100.0000, -50.0000)); poly1Points.push_back(gtl::construct<CPoint>(50.0000, -50.0000)); poly2Points.push_back(gtl::construct<CPoint>(50.0000, 0.0000)); poly2Points.push_back(gtl::construct<CPoint>(100.0000, 50.0000)); poly2Points.push_back(gtl::construct<CPoint>(150.0000, -50.0000)); polygon1.set(poly1Points.begin(), poly1Points.end()); polygon2.set(poly2Points.begin(), poly2Points.end()); vector<CPolygon> polygonArray1, polygonArray2; polygonArray1.push_back(polygon1); polygonArray2.push_back(polygon2); polyset1.insert(polygonArray1.begin(), polygonArray1.end()); polyset2.insert(polygonArray2.begin(), polygonArray2.end()); gtl::arbitrary_boolean_op<CPolygonSet::coordinate_type> bop; bop.execute(rset, polyset1.begin(), polyset1.end(), polyset2.begin(), polyset2.end(), 0); vector<CPolygon> polys; rset.get(polys); for(unsigned int i = 0; i < polys.size(); ++i) { CPolygon::iterator_type it = polys[i].begin(); for(; it != polys[i].end(); ++it) { cout<<"("<<(*it).x()<<", "<<(*it).y()<<")"<<endl; } } } void main() { test_boost_polygons(); } -- -praveen

2 6