gmane.comp.lib.boost.user

Re: [msm] Two identical orthogonal regions?

Christophe Henry — 2012-05-24T20:23:08


Hi,

for MSM they just need to be different types. You can define structs 
inheriting from base states, you can templatize them with an int parameter, 
you can even define a submachine which you inherit from and paste 2 
instances, one in each region.

Though I didn't try it since the times of MSM v1, something like the 
following should work (assuming Functor Front-end):

struct SubFront : msm::front_state_machine_def<SubFront>{...};
typedef msm::back::state_machine<SubFront> SubHelper;

template <int index>
struct Sub: public SubHelper{};

// Outer machine
// we have only the submachines in the regions so that it is easier to 
duplicate
typedef mpl::vector<Sub<0>, Sub<1> > initial_state;
// excerpt from transition table
Row<Sub<0>,...>,
Row<Sub<1>,...>

HTH,
Christophe

[range] any_iterator ?

Kim Barrett — 2012-05-24T20:15:50

original subject was: Re: [Boost-users] offlist - Re: [iterator] Problems with iterator_facade and const-qualification

On May 15, 2011, at 5:16 PM, Neil Groves wrote:

I was recently reminded of this and went looking for it in boost 1.49, but see no sign of it there (outside the existing range_detail version), nor in boost svn trunk.

Anything I can do to help make this happen?

[msm] Two identical orthogonal regions?

Aurelian Melinte — 2012-05-24T18:25:33

Hi,

I am trying to put two identical orthogonal regions in a state machine 
(each region would model a "channel" and I can have multiple such 
channels).

One way I can think of is duplicating the states through typedefs and 
duplicating entries in the transition table.

Is there a way to avoid this duplication?

Regards,
a.

Re: Iterator concept checking

Jeffrey Lee Hellrung, Jr. — 2012-05-24T17:11:16


Hmmm...the below code (with a slight modification) compiles for me on
MSVC9, Boost 1.49.0.



I don't know where the following concept checking classes are defined, but
from [1], it appears you should be using
boost_concepts::ForwardTraversalConcept, etc. (badly named, IMHO, but
that's what I'm finding in the documentation).



(Also, could you please use plain formatting in your emails? It makes it
easier to reply inline and easier to read across a wide variety of media.
Thanks.)

- Jeff

[1]
http://www.boost.org/doc/libs/1_49_0/libs/iterator/doc/iterator_concepts.html
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Iterator concept checking

McNamara, Nate — 2012-05-24T15:39:41

I'm trying to learn to use BOOST_CONCEPT_CHECK for custom iterators,
ranges, and containers.  I've built a simple linked list class with an
iterator (and const_iterator) that, as far as I can tell, satisfies the
forward traversal iterator requirements.  However, g++ gives the
following errors:

concept.cpp:81: error: `*' cannot appear in a constant-expression
concept.cpp:81: error: a call to a constructor cannot appear in a
constant-expression
concept.cpp:81: error: template argument 1 is invalid
concept.cpp:81: error: template argument 1 is invalid
concept.cpp:82: error: `*' cannot appear in a constant-expression
concept.cpp:82: error: a call to a constructor cannot appear in a
constant-expression
concept.cpp:82: error: template argument 1 is invalid
concept.cpp:82: error: template argument 1 is invalid
concept.cpp:83: error: `*' cannot appear in a constant-expression
concept.cpp:83: error: a call to a constructor cannot appear in a
constant-expression
concept.cpp:83: error: template argument 1 is invalid
concept.cpp:83: error: template argument 1 is invalid
concept.cpp:84: error: `*' cannot appear in a constant-expression
concept.cpp:84: error: a call to a constructor cannot appear in a
constant-expression
concept.cpp:84: error: template argument 1 is invalid
concept.cpp:84: error: template argument 1 is invalid

Compiling with -E, lines 81-84 are as follows:

typedef ::boost::concepts::detail::instantiate<
&::boost::concepts::requirement_<void(*)(boost::concepts::ForwardTravers
alIterator<iterator>)>::failed> boost_concept_check81;
typedef ::boost::concepts::detail::instantiate<
&::boost::concepts::requirement_<void(*)(boost::concepts::WritableIterat
or<iterator>)>::failed> boost_concept_check82;
typedef ::boost::concepts::detail::instantiate<
&::boost::concepts::requirement_<void(*)(boost::concepts::ForwardTravers
alIterator<const_iterator>)>::failed> boost_concept_check83;
typedef ::boost::concepts::detail::instantiate<
&::boost::concepts::requirement_<void(*)(boost::concepts::ReadableIterat
or<const_iterator>)>::failed> boost_concept_check84;

That tells me that, regardless of why g++ is having trouble, my iterator
fails to satisfy the concept somehow.  So I wrote some code (see
my_naive_check, below) to try to figure out which requirement is
failing, but my check code is missing the same thing as the iterator,
because the check code runs fine.

Any pointers much appreciated.



// concept.cpp
// What's wrong with the iterators?

#include <cassert>
#include <cstdlib>
#include <iostream>
#include <string>

#include <boost/concept_check.hpp>
#include <boost/iterator/iterator_concepts.hpp>
#include <boost/iterator/iterator_facade.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/range/algorithm.hpp>

template <typename T>
class List {
  struct Node {
    Node(const T& value_, Node *next_): value(value_), next(next_) {}
    T value;
    Node *next;
  } *head;

public:
  List(): head(0) {}

  ~List() {
    Node *node = head;
    while (node) {
      Node *tmp = node->next;
      delete node;
      node = tmp;
    }
  }

  void push_front(const T& value) { head = new Node(value, head); }

  class iterator:
  public boost::iterator_facade<iterator,
                                T,
                                boost::forward_traversal_tag>
  {
  public:
    iterator(): node(0) {}

  private:
    iterator(Node * const node_): node(node_) {}
    friend class List;

    friend class boost::iterator_core_access;
    T& dereference() const { return node->value; }
    bool equal(const iterator& rhs) const { return node == rhs.node; }
    void increment() { node = node->next; }

    Node *node;
  };

  iterator begin() { return iterator(head); }
  iterator end() { return iterator(); }

  class const_iterator:
  public boost::iterator_facade<const_iterator,
                                const T,
                                boost::forward_traversal_tag>
  {
  public:
    const_iterator(): node(0) {}
    const_iterator(const iterator& old): node(old.node) {}

  private:
    friend class boost::iterator_core_access;
    const T& dereference() const { return node->value; }
    bool equal(const const_iterator& rhs) const { return node ==
rhs.node; }
    void increment() { node = node->next; }

    const Node *node;
  };

  const_iterator begin() const { return const_iterator(head); }
  const_iterator end() const { return const_iterator(); }

 
BOOST_CONCEPT_ASSERT((boost::concepts::ForwardTraversalIterator<iterator
  BOOST_CONCEPT_ASSERT((boost::concepts::WritableIterator<iterator>));
 
BOOST_CONCEPT_ASSERT((boost::concepts::ForwardTraversalIterator<const_it
erator>));
 
BOOST_CONCEPT_ASSERT((boost::concepts::ReadableIterator<const_iterator>)
);
};

/*
ForwardTraversalIterator must be
  SinglePassIterator
    IncrementableIterator
      Assignable
      Copy Constructible
      &r == &++r
      r++
      *r++
    ==
    !=
    difference_type
  DefaultConstructible
  iterator_traversal<X>::type => forward_traversal_tag
*/
void my_naive_check(List<std::string>& words) {
  typedef List<std::string>::iterator It;
  It it1 = words.end();
  it1 = words.begin();
  &it1 == &++it1;
  It it2 = it1++;
  std::string word = *it2++;
  assert(it1 == it2);
  assert(words.begin() != words.end());
  It::difference_type distance = 0;
  It it3;
  boost::forward_traversal_tag tag =
boost::iterator_traversal<It>::type();
}

int main() {
  List<std::string> words;
  words.push_front("world");
  words.push_front("Hello");
  my_naive_check(words);
  boost::for_each(words, std::cout << boost::lambda::_1 << "\n");
  return EXIT_SUCCESS;
}

________________________________________

This E-Mail (including any attachments) may contain privileged or confidential information.  It is intended only for the addressee(s) indicated above.

The sender does not waive any of its rights, privileges or other protections respecting this information.  

Any distribution, copying or other use of this E-Mail or the information it contains, by other than an intended recipient, is not sanctioned and is prohibited.

If you received this E-Mail in error, please delete it and advise the sender (by return E-Mail or otherwise) immediately. 

This E-Mail (including any attachments) has been scanned for viruses. 

It is believed to be free of any virus or other defect that might affect any computer system into which it is received and opened. 

However, it is the responsibility of the recipient to ensure that it is virus free. 

The sender accepts no responsibility for any loss or damage arising in any way from its use.

E-Mail received by or sent from RBC Capital Markets is subject to review by Supervisory personnel. 

Such communications are retained and may be produced to regulatory authorities or others with legal rights to the information.

IRS CIRCULAR 230 NOTICE:  TO COMPLY WITH U.S. TREASURY REGULATIONS, WE ADVISE YOU THAT ANY U.S. FEDERAL TAX ADVICE INCLUDED IN THIS COMMUNICATION IS NOT INTENDED OR WRITTEN TO BE USED, AND CANNOT BE USED, TO AVOID ANY U.S. FEDERAL TAX PENALTIES OR TO PROMOTE, MARKET, OR RECOMMEND TO ANOTHER PARTY ANY TRANSACTION OR MATTER.
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

boost::asio one connectio-per-thread

Christer Borgqvist — 2012-05-24T08:25:02

Hello,
is this a code appropriate?

    boost::asio::io_service io_service;
    tcp::acceptor a(io_service, tcp::endpoint(tcp::v4(),3080));
    for (;;) {
        socket_ptr sock(new tcp::socket(io_service));
        a.accept(*sock);
        emv_clientthread_ptr cli(new axf::server::server_socket(sock));
        boost::thread t(boost::bind(&axf::server::server_socket::start, 
cli));
    }
appreciate any help.
Christer

[multi_index] movable only types

Szymon Gatner — 2012-05-23T20:40:20

Hi,

with boost.move available are there any plans to make multi_index work
with movable-only types?

Re: [Chrono] Negative real time

Vicente J. Botet Escriba — 2012-05-23T16:29:15

Le 23/05/12 09:39, Wilfried Kirschenmann a écrit :
Oh my bad, I forget this issue and I was locking on the trunk. Glad to 
see that you will get a solution with 1.50 :)

Best,
Vicente
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

[Geometry] spatial linestring access along line

Stephan Menzel — 2012-05-23T15:08:59

Hi all,

before I begin, let me tell that geometry is not exactly my strong
suite so please forgive my probably dumb question.

I have started to work with boost geometry which, I find very neat,
and assembled a line string.

Now I basically need a method that gives me a point to a length value.
Like when my linestring is 100 units long and I say give me the point
at 3 I want the exact position of the point (coordinates) as if I were
following the line for exactly 3 units.

I have an approach that would allow me to implement this myself by
following the segments (possibly after indexing them) but I have a
feeling that one of those many functions provided by the library
itself might do just that and I simply don't know it. If anyone knows
if such is the case, would be nice to give me a heads up.

Thanks,

Stephan

Re: boost::serialization "input stream error" inrelease-build (msvc2010)

Jens Saathoff — 2012-05-23T10:14:47

Hi Robert!

Currently i'm not using the XML-Archive. Did not define DATA_TO_XML, so the
text-archive is used.
But the main thing....i found the error. I did not initialize all members.
No problem in debug-builds, but deadly for release-builds.

Shall i  remove the explicit datafile.close(); also for text-archives and
let the function just return to do correct destruction?

Thank you very much!

2012/5/22 Robert Ramey <ramey< at >rrsd.com>

_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: Spirit, StateChart, MSM

Klaim - Joël Lamotte — 2012-05-23T09:49:18

Hi,

On Wed, May 23, 2012 at 4:10 PM, asif saeed <asif.lse2< at >gmail.com> wrote:

Here is my understanding:

Spirit allow you to generate a custom-language parser at compile-time,
given a set of expressions.
I don't know if it have any relationship with the finite-state-machine
construct, but I think it is not it's purpose.
It's purpose is to allow you to build domain-specific languages.

StateChart and MSM both provide Finite-state-machine constructs.

In StateChart, you write each state as child class related to it's parent
state class. You set each possible event->action in the state itself. Each
state have a transition table.
In MSM, you setup a transition table for a state machine, you define the
state separately.

StateChart rely on runtime dynamic inheritance to manage states, while MSM
...well do it without inheritance. That's why it's called MSM: it's a meta
state machin, so it will generate the state machine for you given a type
for each state.

On performance, MSM is far more efficient (in my use) but is more expensive
on compile time. Both are in fact, but MSM can kill you compiler if you
setup a really big state machine.
Also, MSM is far easier to work with simply because it's easier to organise
and read the code (if you are used to templates). Having one place to see
all the relationships between the different states is really helping a lot.
MSM provide diffrent ways to express your state relationships, but some
(the more expressive way to me) can kill your compiler even faster. (see
the doc for details)

On runtime, the difference between the two is really important:
Statechart will keep the instance of only one state at a time, or a state,
it's substate, it's substate etc. to the state the machine is currently set
to.
When changing state, Statechart will first destroy (aka call 'delete') the
current state (and parents if the new state is not in the same branches)
and then create (aka call 'new') the new state.
The constructor and destructor are assumed to contain the entry and exit
code of the state.
MSM on the other side, build all state objects inside the state machine on
it's creation. Constructors and destructors of states are just constructors
and destructors.
MSM states can implement functions for entry and exit of the state, that
are called when the machine enter the state and get out. There is no
allocation/deallocation done while processing events (other than the event
queue I suppose). That is very important for example in games or embedded
contexts.

Using Statechart, events have to inherit a statecharte-provided type (that
use CRTP). Same thing with the states, that als have to know the parent
types at compile time.
Using MSM, you can provide whatever types you want for both.

StateChart has still some advanges that I don't remember of but I suppose
the size of the state machine instance itself can be far less than the same
for MSM if it have a lot of states and data inside, because only the
current states are instantiated. That said, it is still not always an
option to have a state machine allocation/deallocating objects at runtime.
I don'nt know if you can provide an allocator though.

So, it depends on your need, but for a state machine I would use MSM by
default, Statechart for specific case or legacy code (MSM is pretty new,
Statechart is pretty old).

Hope it helps.

Joel Lamotte
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: First attempt at using Boost::Test is a flop: the program ends with an exception related to std::string but I don't use any

Oswin Krause — 2012-05-23T08:29:23

Hi,


BOOST_CHECK_CLOSE can't work, because it evaluates a difference between 
the two values in percent. But  no one can answer how many percent 
difference are between 0 and 1 (I think infinite is a good guess, 
though). What you are searching is BOOST_CHECK_SMALL which checks, 
whether a number is smaller than a certain threshold.


Greetings,
Oswin

Re: [Chrono] Negative real time

Wilfried Kirschenmann — 2012-05-23T07:39:31

On Tue, May 22, 2012 at 9:41 PM, Vicente J. Botet Escriba <
vicente.botet< at >wanadoo.fr> wrote:

in fact the case : https://svn.boost.org/trac/boost/ticket/6361
The problem is fixed in 1.50 and I no longer get negative times.

Wilfried K.
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Spirit, StateChart, MSM

asif saeed — 2012-05-23T07:10:53

Hi,

What are the differences between these three libraries? I feel I can use
any of these libs. Is there any page where the comparison/pros&cons are
listed and so on?

Best regards, Asif
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

[mpi] multithreaded/funneled messaging

Brian Budge — 2012-05-22T20:23:54

Hi all -

Is boost.mpi able to work with MPI_THREAD_MULTIPLE?  If so, how is it specified?

Thanks,
  Brian

Re: [Chrono] Negative real time

Vicente J. Botet Escriba — 2012-05-22T19:41:30

Le 22/05/12 18:55, Wilfried Kirschenmann a écrit :

I don't know from where are you getting this conclusion. 
process_real_cpu_clock is using boost::int_least64_t, as representation.

     typedef duration<boost::int_least64_t, nano> nanoseconds;    // at 
least 64 bits needed
     class BOOST_CHRONO_DECL process_real_cpu_clock {
     public:
         typedef nanoseconds                          duration;
         typedef duration::rep                        rep;
         typedef duration::period                     period;
         typedef chrono::time_point<process_real_cpu_clock>    time_point;
         BOOST_STATIC_CONSTEXPR bool is_steady =             true;

         static BOOST_CHRONO_INLINE time_point now() BOOST_NOEXCEPT;
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
         static BOOST_CHRONO_INLINE time_point now(system::error_code & 
ec );
#endif
     };



I guess that you have included chrono_io.hpp. Could you confim this? If 
not, you will need to get the number of nanoseconds using count()

        std::cout << "took real     : " << elapsed.count() << 
"nanoseconds\n";

If you have included it, the output should contain nanoseconds twice. E.g.

2383000 nanoseconds since process start-up
took real     : 37000 nanosecondsnanoseconds

It depends of whether you have included chrono_io.hpp or not. If not, 
could you post the complete program?

HTH,
Vicente
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: boost::signals2::signal - is a "decimated" version available?

Vicente J. Botet Escriba — 2012-05-22T17:29:32

Le 22/05/12 02:01, Chris Stankevitz a écrit :
Hi,

I don't think this exist in Boost.

I would define instead a functor that takes care of the timing 
constraint. This functor could be use in other contexts, as 
Boost.Signal,  or whatever library requesting callbacks.

Best,
Vicente

[Chrono] Negative real time

Wilfried Kirschenmann — 2012-05-22T16:55:56

Dear chrono maintainer team,

Using the following example :

int main(int argc, char **argv)
{
       boost::chrono::process_real_cpu_clock::time_point start =
boost::chrono::process_real_cpu_clock::now();

       for ( long i = 0; i < 1000; ++i )  std::sqrt( 123.456L ); // burn
some time
       Sleep(10000); //idle some time

       boost::chrono::process_real_cpu_clock::time_point end =
boost::chrono::process_real_cpu_clock::now();
       std::cout << end << std::endl;

        boost::chrono::process_real_cpu_clock::duration elapsed = (end -
start);
       std::cout << "took real     : " << elapsed  << "nanoseconds\n";

       return 0;
}

I obtain negative times.

I run boost 1.49 win32 on Windows 7 x64 with Visual studio 2010.

Studying the behavior of the timer, I think that the error is one of these :
- process_real_cpu_clock::now() only stores the current time in a 32 bit
integer instead of a 64 bit integer
- time_points only prints the 32 lowest bits.
I came to this conclusion by observing the results printed before they got
negatives (printing in the loop with the sqrt): 2019000000 nanoseconds is
the last value printed before getting negative.

 Is there any mistake in my way of using this chronometer ?
Do you have a workaround ?

Thank you for your help !
Wilfried K.

-----
Cordialement,
Wilfried Kirschenmann

"An expert is a person who has made all the mistakes that can be made in a
very narrow field."*
*Niels Bohr - *Danish physicist (1885 - 1962)*
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: boost::signals2::signal - is a "decimated"version available?

Chris Stankevitz — 2012-05-22T15:07:40



Igor,

Thank you for your reply.  Consider the case where two signals are
generated 1 ms apart.  With your implementation, the observer will end up
with the arguments from the first signal.  With my more complicated
implementation, the observer will end up with the most recent signal
arguments.

 Chris
_______________________________________________
Boost-users mailing list
Boost-users< at >lists.boost.org
http://lists.boost.org/mailman/listinfo.cgi/boost-users

Re: boost::serialization "input stream error"inrelease-build (msvc2010)

Robert Ramey — 2012-05-22T15:51:25

Hmmm - closing the datafile while the archive class is still open?  Bad 
idea.

when an XML archive closes, it has to add some end tags - but in your case
you're closing the archive AFTER the stream has already been closed!

Try


std::wofstream datafile(wxString::Format(_T("%shuddata.prd"), 
paths.GetUserLocalDataDir()).ToStdWstring().c_str());
#ifdef DATA_TO_XML
{
   boost::archive::xml_woarchive dataarchive(datafile);
   dataarchive << BOOST_SERIALIZATION_NVP(huddata);
}
#else
{
   boost::archive::text_woarchive dataarchive(datafile);
   dataarchive << BOOST_SERIALIZATION_NVP(huddata);
}
   datafile.close();
#endif

Re: asio - improving chat server example

Lars Viklund — 2012-05-22T14:46:09

If you have a soft-realtime main loop as is common in games, it's
perfectly fine to invoke poll() instead of having separate threads
running run().

My canonical main loop tends to be:
  while (1)
  {
    PeekOSMessages();
    main_io.poll();
    simulate();
    render();
  }

This has the added benefit of executing in the main thread, so you don't
need as much synchronization and checking for changes compared to
running handlers in different threads.

Personally, I have
* an io_service for post()ing callbacks to the main thread,
* an io_service with a bunch of worker threads for small network jobs,
* an io_service with low-priority threads for bulk deferred work.

This tends to cover all the workloads I encounter in a networked game
client.