Hi, I'm starting a library providing synchronized execution of objects, something like Ada 'rendez-vous'. A component Sender may request execution of a member function of a concurrent component Reveiver. The component Receiver must accept that the request can be fulfilled. Synchronized communication is described in a generic class concurrent_component. A concurrent_component defines the notion of a port for controlling the communication. A port has a nested entry class for defining operations controlled by the port; it also has an accept operation for signaling that an operation associated with the port can be executed. The concurrent_component and port classes interface will be the following: struct concurrent_component { class port { public: class entry_synchronizer { public: entry_synchronizer(port&); ~entry_synchronizer(); }; static void accept(port& p); }; }; In the following example, two concurrent components prod (Producer) and cons (Consumer) communicate via a single element buffer represented by a buf (SingleBuffer) concurrent component. The SingleBuffer class alternates between accepting a Push and a Pull: class SingleBuffer : concurrent_component { port PutPort_; port GetPort_; char bufCh_; public: void Put(char ch) { port::entry_synchronizer _(PutPort_); bufCh_ = ch; } char Get() { port::entry_synchronizer _(GetPort_); return bufCh_; } void operator()() { for(;;) { port::accept(PutPort_); port::accept(GetPort_); } } }; struct Producer : concurrent_component { SingleBuf& buf_; Producer(SingleBuf& buf) : buf_(buf) {} void operator()() { for(;;) { char ch; std::cin >> ch; buf_.Put(ch); } } }; struct Consumer : concurrent_component { SingleBuf& buf_; Consumer(SingleBuf& buf) : buf_(buf) {} void operator()() { for(;;) { char ch = buf_.Get(); std::cout << ch << std::endl; } } }; concurrent_component defines also a template class concurrent_execution<n> which is used to group the concurrent execution of n concurrent components. int main() { SingleBuffer buf; Producer prod(buf); Consumer cons(buf); concurrent_execution<3> conc(buf, prod, cons); conc.join_all(); return 0; } Other kind of ports can also be defined to restrict the instances that can do a request: * object_port which only accepts request from a given instance, or * qualified_port which only accepts request from instances of a given class. These classes can be extended allowing concurrent_component to open more that one port at the same time, and wait until all ports have been requested. class port { public: port(concurrent_component&); class entry_synchronizer { public: entry_synchronizer(port&); ~entry_synchronizer(); }; static void accept(port&); static void accept_all(port& p1, ..., port& pn); }; Do you think that this concurrent_component library could have a place in Boost? Best regards _____________________ Vicente Juan Botet Escriba