- Boost-users - lists.preview.boost.org

[config] Macro to detect no implicitly movable?
by TONGARI J 19 Feb '14

19 Feb '14

Hi, Some compilers support r-value reference while not providing implicitly-defined move ctor/assign (e.g. VC10), is there a way to detect this defect? Macro like BOOST_NO_IMPLICITLY_MOVABLE would be helpful. Is "defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)" good enough? Thanks,

1 0

finite state filters controlled ...
by raespi 19 Feb '14

19 Feb '14

Boost hi .. I'm using the finite state filter component in the iostreams library to create a state machine that can easily help me process incoming data streams from various medical sensors. I'm currently working around the following scenarios and wanted to run them by the list to see if the method I chose was the preferred one. 1- Constant datastream with no variation in datagrams. Solution: use finite state filters as they come, works ok ! 2- Variable datastreams with constant size in datagrams. Solution: use finite state filters with a transition table that can interpret anything and choosing in the processing function the right way to go, not very clean, but works !! 3- Variable datastreams with variable sizes. Solution: trying to change the finite state filter on the go, currently doesn't work. I noticed that when bytes are inserted into the state machine these don't get processed until a certain buffer size is met internally, resulting in a behaviour where data gets analyzed long after it has been inserted. I saw that the flush() function for the iostream that contains de state machine suffices when called before inserting a new character with a line such as: io::flush<io::filtering_ostream> ( this->data ); but the problem is that the only mechanism that can determine when a whole package has been received and one can change state machines to analyze a new state lies within the state machine itself (in the processing functions), I can't issue a flush() from within a state machine since it won't execute until a specific buffer size is met. Any ideas on how to go around this matter ?? I'm currently using boost 1.53 on Linux Thanks ...

2 2

[lexical_cast] Why isn't boost::lexical_cast bijective?
by Egor Tensin 19 Feb '14

19 Feb '14

Why this works: boost::lexical_cast<std::string>((void *) 42UL) and this throws: boost::lexical_cast<void*>(boost::lexical_cast<std::string>((void*) 42UL)) while converting void* to std::string and vice versa works perfectly using std:: streams?

4 4

Fedora upgrade - missing Boost multi-threaded libraries
by David Aldrich 18 Feb '14

18 Feb '14

Hi We have just upgraded a Fedora machine from Fedora 19 (boost 1.53) to Fedora 20 (boost 1.54). We notice that the Boost -mt libraries have disappeared. Please can anyone explain this and tell me how to install the -mt libraries? Best regards David

2 2

[log] Qt integration
by Olivier Tournaire 18 Feb '14

18 Feb '14

Hi all, I would like to use boost::log within a Qt based application. For now, I simply want to redirect the output of BOOST_LOG_TRIVIAL(xxx) macro to a QTextEdit. What is the easiest way to do that? Is there a way to get the logger output string? Best regards

2 5

[Units] Un-scaling dimensionless value
by Lindley French 18 Feb '14

18 Feb '14

I am using Boost.Units to try and compute the number of samples in a time interval, given the sample rate. Given this code: typedef make_scaled_unit<si::frequency, scale<10, static_rational<3> > >::type kilohertz_unit; typedef make_scaled_unit<si::time, scale<10, static_rational<-6> > >::type microseconds_unit; <code> template <typename T=unsigned> using Kilohertz = quantity<kilohertz_unit,T>; template <typename T=unsigned> using Microseconds = quantity<microseconds_unit,T>; // Using boost::rational as the value type neatly avoids overflows Kilohertz<rational<unsigned>> sample_rate(125*si::kilo*si::hertz); Microseconds<rational<unsigned>> duration(10*si::seconds); auto total = sample_rate*duration; </code> Now, when I cout these values, I see that everything is technically the correct. The problem is that total is a dimensionless quantity which is scaled----it's 1,250,000,000, when I expect 1,250,000, and it displays as "1250000000 m", where m is "milli", not "meters". What is the correct way to un-scale dimensionless quantities? I tried this: quantity<si::dimensionless,rational<unsigned>> unscaled(total); However, unscaled still has the same value. I also tried typedef make_scaled_unit<si::dimensionless, scale<10, static_rational<0> > >::type dimensionless_unit; quantity<dimensionless_unit,rational<unsigned>> unscaled(total); but this time, unscaled came out zero. Any suggestions?

3 13

[units] slowness dimension
by Michael Powell 18 Feb '14

18 Feb '14

Hello, I've learned about a "new" (or potentially new-to-boost-units, at any rate) dimension this week. TBD whether we'll be using boost or even units, but in the event we would, I'd like to add a slowness dimension. Basically it is the inverse of velocity: where velocity is time per length, slowness is length per time. Taking a gander at the velocity.hpp physical dimension, doesn't seem like a terribly hard thing to do, and with the new Git-module decomp, even less so today? Thank ye... Best regards, Michael Powell

2 3

[fusion][?] a dictionary with compile time (or types as) keys
by Nick Stokes 17 Feb '14

17 Feb '14

The problem is the following: class TypeDictionary { public: // implementation be here -- and the question is about this }; struct Foo; struct Bar; void userOfTypeDictionary() { TypeDictionary td; td.insert( Foo() ); td.insert( Bar() ); td,insert( double(3.14) ); // and other unknown (to TypeDictionary) // list of types attached // later on, in a different scope perhaps Foo& f = td.get<Foo>() ; Bar& f = td.get<Bar>(); double pi = tg.get<double>(); // ... } Now the question so far seems like right up in the alley of Boost.Fusion, perhaps with a boost::fusion::set, but I am unsure how to manipulate a set of types unknown ahead of time as in code above, and with a -- rather obvious -- extension whereby different instances of TypeDictionary would be used to contain a different set of types, potentially in different compilation units. As for a realistic motivating use case, think of a plugin manager. At any given time of its life an arbitrary heterogeneous set of objects are attached to it, and the it is the manager's job to manage the life time of the attached objects and return (a reference) to them when queried in a type-safe manner. Any ideas on whether such a thing is possible, and how, would be deeply appreciated. Thanks many, Nick

4 5

Boost or Standard when there is the choice?
by Paolo Bolzoni 17 Feb '14

17 Feb '14

Dear list, I was wondering, what is the best pratice when you can select between a standard solution or a boost one? For example, std::tie or boost::tie? std::unordered_map or boost::unordered_map? Personally I tend to use std solutions, but does it make sense? Yours sincerely, Paolo Bolzoni

9 19

[move] differences between results in C++03 and C++11 modes
by Adam Romanek 15 Feb '14

15 Feb '14

Hi! Some time ago I encountered a problem with assigning the return value of boost::move() to a non-const reference in C++11 mode, but not in C++03 mode. See [1] for a StackOverflow question that I created for this issue. It contains all the details so for brevity I won't repeat them here. Could anyone explain this issue? Is this a limitation of C++03 emulation or a defect in the implementation? Best regards, Adam Romanek [1] http://stackoverflow.com/questions/21138869/why-does-assigning-the-return-v…

5 5