[Boost-commit] svn:boost r4107

From: srajko_at_[hidden]
Date: 2007-05-18 01:18:42

Author: srajko
Date: 2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
New Revision: 4107
URL: http://svn.boost.org/trac/boost/changeset/4107

Log:
Add rpc OS X xcode ide, and make rpc build on darwin/gcc

Added:
   sandbox/rpc/libs/rpc/xcodeide/
   sandbox/rpc/libs/rpc/xcodeide/example.xcodeproj/
   sandbox/rpc/libs/rpc/xcodeide/example.xcodeproj/project.pbxproj   (contents, props changed)
Text files modified: 
   sandbox/rpc/boost/rpc/call.hpp                     |   293 +++++++++++++++---------------          
   sandbox/rpc/boost/rpc/client.hpp                   |   131 ++++++------                            
   sandbox/rpc/boost/rpc/detail/archive_out_param.hpp |   380 ++++++++++++++++++++--------------------
   sandbox/rpc/boost/rpc/detail/handler_template.hpp  |    88 ++++----                                
   sandbox/rpc/boost/rpc/detail/protocol.hpp          |   244 ++++++++++++------------                
   sandbox/rpc/boost/rpc/detail/threaded_service.hpp  |     2                                         
   sandbox/rpc/boost/rpc/function.hpp                 |     1                                         
   sandbox/rpc/boost/rpc/server.hpp                   |     4                                         
   8 files changed, 573 insertions(+), 570 deletions(-)

Modified: sandbox/rpc/boost/rpc/call.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/call.hpp	(original)
+++ sandbox/rpc/boost/rpc/call.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -1,146 +1,147 @@
-// Copyright Stjepan Rajko 2007. Use, modification and
-// distribution is subject to the Boost Software License, Version
-// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_RPC_CALL_HPP
-#define BOOST_RPC_CALL_HPP
-
-#include <boost/rpc/config.hpp>
-#include <boost/detail/arity.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/rpc/detail/archive_out_param.hpp>
-#include <boost/rpc/call_options.hpp>
-
-namespace boost {
-namespace rpc {
-
-/// Used to verify whether a remote function call has completed.
-class acknowledgement
-{
-public:
-    virtual ~acknowledgement() {};
-    /// Returns a promise for completion
-    boost::future<void> completion()
-    {
-        return completion_promise;
-    }
-    /// Marks the call as completed.
-    void complete() {completion_promise.set();}
-private:
-    boost::promise<void> completion_promise;
-};
-
-class handler_base : public acknowledgement
-{
-public:
-    /// Processes the serialized call results.
-    virtual void result_string(const std::string &str) = 0;
-    virtual bool has_out_parameters() = 0;
-
-    call_options options;
-};
-
-typedef boost::shared_ptr<acknowledgement> acknowledgement_ptr;
-
-/// Base class for all of the call classes
-class call_base
-{
-public:
-    /// Returns the serialized call parameters.
-    virtual const std::string &parameters() const = 0;
-    virtual std::auto_ptr<handler_base> spawn_handler() = 0;
-};
-
-
-template<typename ReturnType>
-class async_returning_call : public call_base
-{
-};
-
-template<typename ReturnType>
-class returning_handler : public handler_base
-{
-public:
-    typedef typename boost::detail::storable<ReturnType>::type storable_return_type;
-
-    /// Returns the return value of the completed function call.
-    /**
-    */
-    typename boost::call_traits<storable_return_type>::const_reference
-        return_value() const {return return_val;}
-protected:
-    template<typename Archive>
-    void extract_return_val(Archive &archive, const boost::rpc::call_options &options)
-    {
-        if (options.marshal_option >= call_options::return_only)
-            archive & return_val;
-    }
-    storable_return_type return_val;
-};
-
-template<>
-class returning_handler<void> : public handler_base
-{
-public:
-    typedef void storable_return_type;
-
-    void return_value() const {}
-protected:
-    template<typename Archive>
-    void extract_return_val(Archive &archive, const boost::rpc::call_options &options)
-    {}
-};
-
-template<typename ReturnType>
-class async_returning_handler : public returning_handler<ReturnType>
-{
-public:
-    typedef boost::shared_ptr<async_returning_handler<ReturnType> > ptr;
-
-    virtual void assign_promises() = 0;
-    const boost::promise<ReturnType> &return_promise() {return return_prom;}
-    operator boost::future<ReturnType> () {return return_prom;}
-protected:
-    promise<ReturnType> return_prom;
-};
-
-/// A call handler used to receive acknowledgment of rpc completion and return value.
-template<typename Signature, typename ArchivePair = binary_archive
-#ifndef DOXYGEN_DOCS_ONLY
-    ,typename Enable=void, typename Enable2=void
-#endif
->
-class handler
-#ifdef DOXYGEN_DOCS_ONLY
-#include <boost/rpc/detail/handler_template.hpp>
-#endif // DOXYGEN_DOCS_ONLY
-;
-
-#define BOOST_ARITY_SEPARATE_VOID_RETURN
-#define BOOST_ARITY_ITERATION_PARAMS \
-    (3,(0,BOOST_RPC_MAX_ARGS,<boost/rpc/detail/handler_template.hpp>))
-#include <boost/detail/arity_iterate.hpp>
-#undef BOOST_ARITY_ITERATION_PARAMS
-#undef BOOST_ARITY_SEPARATE_VOID_RETURN
-
-template<typename Id, typename Signature, typename ArchivePair = binary_archive
-#ifndef DOXYGEN_DOCS_ONLY
-    ,typename Enable=void
-#endif
->
-class call
-#ifdef DOXYGEN_DOCS_ONLY
-#include <boost/rpc/detail/call_template.hpp>
-#endif // DOXYGEN_DOCS_ONLY
-;
-
-#define BOOST_ARITY_ITERATION_PARAMS \
-    (3,(0,BOOST_RPC_MAX_ARGS,<boost/rpc/detail/call_template.hpp>))
-#include <boost/detail/arity_iterate.hpp>
-#undef BOOST_ARITY_ITERATION_PARAMS
-
-} // namespace rpc
-} // namespace boost
-
-#endif // BOOST_RPC_CALL_HPP
+// Copyright Stjepan Rajko 2007. Use, modification and
+// distribution is subject to the Boost Software License, Version
+// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_RPC_CALL_HPP
+#define BOOST_RPC_CALL_HPP
+
+#include <boost/rpc/config.hpp>
+#include <boost/detail/arity.hpp>
+#include <boost/call_traits.hpp>
+#include <boost/rpc/detail/archive_out_param.hpp>
+#include <boost/rpc/call_options.hpp>
+
+namespace boost {
+namespace rpc {
+
+/// Used to verify whether a remote function call has completed.
+class acknowledgement
+{
+public:
+    virtual ~acknowledgement() {};
+    /// Returns a promise for completion
+    boost::future<void> completion()
+    {
+        return completion_promise;
+    }
+    /// Marks the call as completed.
+    void complete() {completion_promise.set();}
+private:
+    boost::promise<void> completion_promise;
+};
+
+class handler_base : public acknowledgement
+{
+public:
+    /// Processes the serialized call results.
+    virtual void result_string(const std::string &str) = 0;
+    virtual bool has_out_parameters() = 0;
+
+    call_options options;
+};
+
+typedef boost::shared_ptr<acknowledgement> acknowledgement_ptr;
+
+/// Base class for all of the call classes
+class call_base
+{
+public:
+    /// Returns the serialized call parameters.
+    virtual const std::string &parameters() const = 0;
+    virtual std::auto_ptr<handler_base> spawn_handler() = 0;
+    virtual ~call_base() {}
+};
+
+
+template<typename ReturnType>
+class async_returning_call : public call_base
+{
+};
+
+template<typename ReturnType>
+class returning_handler : public handler_base
+{
+public:
+    typedef typename boost::detail::storable<ReturnType>::type storable_return_type;
+
+    /// Returns the return value of the completed function call.
+    /**
+    */
+    typename boost::call_traits<storable_return_type>::const_reference
+        return_value() const {return return_val;}
+protected:
+    template<typename Archive>
+    void extract_return_val(Archive &archive, const boost::rpc::call_options &options)
+    {
+        if (options.marshal_option >= call_options::return_only)
+            archive & return_val;
+    }
+    storable_return_type return_val;
+};
+
+template<>
+class returning_handler<void> : public handler_base
+{
+public:
+    typedef void storable_return_type;
+
+    void return_value() const {}
+protected:
+    template<typename Archive>
+    void extract_return_val(Archive &archive, const boost::rpc::call_options &options)
+    {}
+};
+
+template<typename ReturnType>
+class async_returning_handler : public returning_handler<ReturnType>
+{
+public:
+    typedef boost::shared_ptr<async_returning_handler<ReturnType> > ptr;
+
+    virtual void assign_promises() = 0;
+    const boost::promise<ReturnType> &return_promise() {return return_prom;}
+    operator boost::future<ReturnType> () {return return_prom;}
+protected:
+    promise<ReturnType> return_prom;
+};
+
+/// A call handler used to receive acknowledgment of rpc completion and return value.
+template<typename Signature, typename ArchivePair = binary_archive
+#ifndef DOXYGEN_DOCS_ONLY
+    ,typename Enable=void, typename Enable2=void
+#endif
+>
+class handler
+#ifdef DOXYGEN_DOCS_ONLY
+#include <boost/rpc/detail/handler_template.hpp>
+#endif // DOXYGEN_DOCS_ONLY
+;
+
+#define BOOST_ARITY_SEPARATE_VOID_RETURN
+#define BOOST_ARITY_ITERATION_PARAMS \
+    (3,(0,BOOST_RPC_MAX_ARGS,<boost/rpc/detail/handler_template.hpp>))
+#include <boost/detail/arity_iterate.hpp>
+#undef BOOST_ARITY_ITERATION_PARAMS
+#undef BOOST_ARITY_SEPARATE_VOID_RETURN
+
+template<typename Id, typename Signature, typename ArchivePair = binary_archive
+#ifndef DOXYGEN_DOCS_ONLY
+    ,typename Enable=void
+#endif
+>
+class call
+#ifdef DOXYGEN_DOCS_ONLY
+#include <boost/rpc/detail/call_template.hpp>
+#endif // DOXYGEN_DOCS_ONLY
+;
+
+#define BOOST_ARITY_ITERATION_PARAMS \
+    (3,(0,BOOST_RPC_MAX_ARGS,<boost/rpc/detail/call_template.hpp>))
+#include <boost/detail/arity_iterate.hpp>
+#undef BOOST_ARITY_ITERATION_PARAMS
+
+} // namespace rpc
+} // namespace boost
+
+#endif // BOOST_RPC_CALL_HPP

Modified: sandbox/rpc/boost/rpc/client.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/client.hpp	(original)
+++ sandbox/rpc/boost/rpc/client.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -8,7 +8,7 @@
 #include <boost/rpc/call_options.hpp>
 #include <boost/rpc/call.hpp>
 //#include <boost/rpc/handler_return.hpp>
-#include <boost/future/future.hpp>
+#include <boost/future/future.hpp>
 
 namespace boost {
 namespace rpc {
@@ -30,9 +30,9 @@
     /** \todo Handle protocol error.
     */
     client()
-        : next_request_id(0),
+        : socket(service),
+        next_request_id(0),
         result_marshal_buffer(BOOST_RPC_RPC_BUFFER_SIZE),
-        socket(service),
         stream(std::ios::in | std::ios::out | std::ios::binary),
         default_options(call_options::all_out_parameters, call_options::no_exception_handling),
         mutex_lock(mutex), sending(false)
@@ -46,9 +46,10 @@
     {
         stop_service_thread();
     }
-    template<typename Registry, typename ReturnType>
+private:
+    template<typename ReturnType>
     class handler_return;
-
+public:
     /// Prepares and sends a complete rpc call.
     /** The call is made in the following way:
         \li This method will lock the client's mutex, and spawn a handler for the call.
@@ -60,7 +61,7 @@
         \li The process_call method can now finish the call.
     */
     template<typename ReturnType>
-    handler_return<Registry, ReturnType> operator()(async_returning_call<ReturnType> &call)
+    handler_return<ReturnType> operator()(async_returning_call<ReturnType> &call)
     {
         mutex_lock.lock();
         if (sending)
@@ -70,7 +71,7 @@
         boost::shared_ptr<handler_base> handler(call.spawn_handler());
         requests[next_request_id] = handler;
 
-        handler_return<Registry, ReturnType> handler_r(this,next_request_id);
+        handler_return<ReturnType> handler_r(this,next_request_id);
 
         // send the header
         boost::asio::write(socket,
@@ -198,61 +199,61 @@
 //    template<typename ReturnType>
 //    friend class handler_return;
 
-    template<typename Registry, typename T>
-    class handler_return
-    {
-    public:
-        typedef client<Registry> client_type;
-        handler_return(client_type *client_ptr, typename client_type::id_type id)
-            : client_ptr(client_ptr), id(id), called(false)
-        {}
-        handler_return(const handler_return<Registry, T> &h_r)
-            : client_ptr(h_r.client_ptr), id(h_r.id), called(h_r.called)
-        {
-            h_r.called = true;
-        }
-        operator T ()
-        {
-            BOOST_ASSERT(!called);
-            called = true;
-            boost::future<T> future
-                (static_pointer_cast<async_returning_handler<T>, handler_base>
-                    (client_ptr->handler_accepted_as<T>(id, call_options::return_only))->return_promise());
-            return future;
-        }
-        operator boost::future<T> ()
-        {
-            BOOST_ASSERT(!called);
-            called = true;
-            return static_pointer_cast<async_returning_handler<T>, handler_base>
-                (client_ptr->handler_accepted_as<T>(id, call_options::return_only))->return_promise();
-        }
-        operator boost::shared_ptr<async_returning_handler<T> >()
-        {
-            BOOST_ASSERT(!called);
-            called = true;
-            return static_pointer_cast<async_returning_handler<T>, handler_base>
-                (client_ptr->handler_accepted_as<T>(id, call_options::return_only));
-        }
-        operator shared_ptr<acknowledgement>()
-        {
-            BOOST_ASSERT(!called);
-            called = true;
-            shared_ptr<acknowledgement> ack = static_pointer_cast<acknowledgement, handler_base>
-                (client_ptr->handler_accepted_as<T>(id, call_options::return_only));
-            return ack;
-        }
-        ~handler_return()
-        {
-            if (!called) client_ptr->handler_accepted_as<T>(id, call_options::no_results);
-        }
-    private:
-        client_type *client_ptr;
-        typename client_type::id_type id;
-        mutable bool called;
-
-//        friend class client<Registry>;
-    };
+    template<typename T>
+    class handler_return
+    {
+    public:
+        typedef client<Registry> client_type;
+        handler_return(client_type *client_ptr, typename client_type::id_type id)
+            : client_ptr(client_ptr), id(id), called(false)
+        {}
+        handler_return(const handler_return<T> &h_r)
+            : client_ptr(h_r.client_ptr), id(h_r.id), called(h_r.called)
+        {
+            h_r.called = true;
+        }
+        operator T ()
+        {
+            BOOST_ASSERT(!called);
+            called = true;
+            boost::future<T> future
+                (static_pointer_cast<async_returning_handler<T>, handler_base>
+                    (client_ptr->handler_accepted_as<T>(id, call_options::return_only))->return_promise());
+            return future;
+        }
+        operator boost::future<T> ()
+        {
+            BOOST_ASSERT(!called);
+            called = true;
+            return static_pointer_cast<async_returning_handler<T>, handler_base>
+                (client_ptr->handler_accepted_as<T>(id, call_options::return_only))->return_promise();
+        }
+        operator boost::shared_ptr<async_returning_handler<T> >()
+        {
+            BOOST_ASSERT(!called);
+            called = true;
+            return static_pointer_cast<async_returning_handler<T>, handler_base>
+                (client_ptr->handler_accepted_as<T>(id, call_options::return_only));
+        }
+        operator shared_ptr<acknowledgement>()
+        {
+            BOOST_ASSERT(!called);
+            called = true;
+            shared_ptr<acknowledgement> ack = static_pointer_cast<acknowledgement, handler_base>
+                (client_ptr->handler_accepted_as<T>(id, call_options::return_only));
+            return ack;
+        }
+        ~handler_return()
+        {
+            if (!called) client_ptr->handler_accepted_as<T>(id, call_options::no_results);
+        }
+    private:
+        client_type *client_ptr;
+        typename client_type::id_type id;
+        mutable bool called;
+
+//        friend class client<Registry>;
+    };
 };
 
 /// A client with the capability to connect to a server.
@@ -270,19 +271,19 @@
     connecting_client(boost::asio::ip::tcp::endpoint endpoint) : connector(endpoint)
     {
         // Connect the socket.
-        connector.connect(socket);
+        connector.connect(client<Registry>::socket);
 //        protocol::message_reader<boost::asio::ip::tcp::socket> reader(socket);
 
 
         // Wait for acknowledgement on the socket.
         //if (reader.message() != protocol::message::ok)
-        if (protocol::read_message(socket) != protocol::message::ok)
+        if (protocol::read_message(client<Registry>::socket) != protocol::message::ok)
         {
            // protocol error
            std::cerr << "client protocol error" << std::endl;
         }
 
-        prepare_async_read();
+        client<Registry>::prepare_async_read();
     }
 private:
     Connector connector;

Modified: sandbox/rpc/boost/rpc/detail/archive_out_param.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/detail/archive_out_param.hpp	(original)
+++ sandbox/rpc/boost/rpc/detail/archive_out_param.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -1,199 +1,199 @@
-#ifndef BOOST_RPC_ARCHIVE_OUT_PARAM_HPP
-#define BOOST_RPC_ARCHIVE_OUT_PARAM_HPP
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits.hpp>
-#include <boost/future/future.hpp>
-
-#define BOOST_RPC_VAR_arg_storableN_NAME(z,n,data) BOOST_PP_CAT(arg_storable,BOOST_PP_INC(n))
-#define BOOST_RPC_VAR_arg_storableN_INIT(z,n,name) \
-    BOOST_RPC_VAR_arg_storableN_NAME(z,n,BOOST_PP_EMPTY()) ( name(z,n,BOOST_PP_EMPTY()) )
-
-#define BOOST_RPC_TYPE_ARGUMENT_ARG(z,n,arg) \
-    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> arg(z,n,BOOST_PP_EMPTY())
-#define BOOST_RPC_TYPE_ARGUMENT_CREF_ARG(z,n,arg) \
-    const typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> & arg(z,n,BOOST_PP_EMPTY())
-#define BOOST_RPC_TYPE_ARGUMENT_VAR(z,n,var) \
-    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> var(z,n,BOOST_PP_EMPTY());
-
-#define BOOST_RPC_TYPE_PARGUMENT_ARG(z,n,arg) \
-    typename boost::rpc::promising_argument<BOOST_ARITY_ARG_TYPE_NAME(n)> arg(z,n,BOOST_PP_EMPTY())
-#define BOOST_RPC_TYPE_PARGUMENT_VAR(z,n,var) \
-    typename boost::rpc::promising_argument<BOOST_ARITY_ARG_TYPE_NAME(n)> var(z,n,BOOST_PP_EMPTY());
-
-#define BOOST_RPC_ARCHIVE_OUT_PARAM(z,I,archive) \
-    boost::rpc::detail:: \
-    archive_out_param<boost::function_traits<Signature>::arg##I##_type>(archive,arg_storable##I);
-
-#define BOOST_RPC_PARAM_TYPE(I) \
-    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(I)>::type
-
-#define BOOST_RPC_PARAM_TYPE_ARG(J,I,D) BOOST_RPC_PARAM_TYPE(I) BOOST_PP_CAT(a,BOOST_PP_INC(I))
-
+#ifndef BOOST_RPC_ARCHIVE_OUT_PARAM_HPP
+#define BOOST_RPC_ARCHIVE_OUT_PARAM_HPP
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/future/future.hpp>
+
+#define BOOST_RPC_VAR_arg_storableN_NAME(z,n,data) BOOST_PP_CAT(arg_storable,BOOST_PP_INC(n))
+#define BOOST_RPC_VAR_arg_storableN_INIT(z,n,name) \
+    BOOST_RPC_VAR_arg_storableN_NAME(z,n,BOOST_PP_EMPTY()) ( name(z,n,BOOST_PP_EMPTY()) )
+
+#define BOOST_RPC_TYPE_ARGUMENT_ARG(z,n,arg) \
+    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> arg(z,n,BOOST_PP_EMPTY())
+#define BOOST_RPC_TYPE_ARGUMENT_CREF_ARG(z,n,arg) \
+    const typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> & arg(z,n,BOOST_PP_EMPTY())
+#define BOOST_RPC_TYPE_ARGUMENT_VAR(z,n,var) \
+    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(n)> var(z,n,BOOST_PP_EMPTY());
+
+#define BOOST_RPC_TYPE_PARGUMENT_ARG(z,n,arg) \
+    typename boost::rpc::promising_argument<BOOST_ARITY_ARG_TYPE_NAME(n)> arg(z,n,BOOST_PP_EMPTY())
+#define BOOST_RPC_TYPE_PARGUMENT_VAR(z,n,var) \
+    typename boost::rpc::promising_argument<BOOST_ARITY_ARG_TYPE_NAME(n)> var(z,n,BOOST_PP_EMPTY());
+
+#define BOOST_RPC_ARCHIVE_OUT_PARAM(z,I,archive) \
+    boost::rpc::detail:: \
+    archive_out_param<typename boost::function_traits<Signature>::arg##I##_type>(archive,arg_storable##I);
+
+#define BOOST_RPC_PARAM_TYPE(I) \
+    typename boost::rpc::argument<BOOST_ARITY_ARG_TYPE_NAME(I)>::type
+
+#define BOOST_RPC_PARAM_TYPE_ARG(J,I,D) BOOST_RPC_PARAM_TYPE(I) BOOST_PP_CAT(a,BOOST_PP_INC(I))
+
 #define BOOST_RPC_ARGUMENT(z,n,text) \
   boost::rpc:: \
   argument<typename boost::function_traits<Signature>::arg##n##_type> arg_storable##n;
-
+
 #define BOOST_RPC_INIT_ARGUMENT(z,n,text) \
- BOOST_PP_CAT(arg_storable,n)(BOOST_PP_CAT(a,n))
-
-#define BOOST_RPC_ARGUMENT_CHECK_OUT(z,I,text) \
-    has_out |= BOOST_PP_CAT(arg_storable,I).is_out();
-
-#define BOOST_RPC_ARGUMENT_ASSIGN_PROMISE(z,I,text) \
-    BOOST_PP_CAT(arg_storable,I).assign_promise();
-namespace boost {
-namespace rpc {
-
-template<typename T, typename Enable=void, typename Enable2=void>
-struct is_out_argument
-    : public boost::is_void<int>
-{};
-
-template<typename T>
-struct is_out_argument<T,
-    typename boost::enable_if<boost::is_reference<T> >::type,
-    typename boost::disable_if<boost::is_const<typename boost::remove_reference<T>::type> >::type>
-    : public boost::is_void<void>
-{};
-
-/// Wrapper for possibly "out" arguments to a remote call
-template<typename T, typename Enable=void>
-class argument
-{
-public:
-    typedef T type;
-    argument(T){}
-};
-
-template<typename T>
-class argument<T, typename boost::enable_if<is_out_argument<T> >::type>
-{
-public:
-    typedef argument<T> type;
-    typedef typename boost::detail::storable<T>::type storable_type;
-    typedef typename boost::remove_reference<T>::type referred_type;
-
-    argument(T ref)
-    {
-        passed = by_ref;
-        referred_ptr = &ref;
-    }
-    argument(boost::future<referred_type> &future)
-    {
-        passed = by_future;
-        future_ptr = &future;
-    }
-    operator T()
-    {
-        switch(passed)
-        {
-        case by_ref:
-            return *referred_ptr;
-        case by_future:
-            storable = future_ptr->get();
-            return storable;
-        }
-        return storable;
-    }
-protected:
-    union
-    {
-        referred_type *referred_ptr;
-        boost::future<referred_type> *future_ptr;
-    };
-    enum
-    {
-        by_ref,
-        by_future,
-    } passed;
-    storable_type storable;
-};
-
-template<typename T, typename Enable=void>
-class promising_argument : public argument<T>
-{
-public:
-    promising_argument(const argument<T> &a) : argument<T>(a) {}
-    void assign_promise(){}
-    bool is_out(){return false;}
-};
-
-template<typename T>
-class promising_argument<T, typename boost::enable_if<is_out_argument<T> >::type>
-    : public argument<T>
-{
-public:
-    typedef typename boost::detail::storable<T>::type storable_type;
-    typedef typename boost::remove_reference<T>::type referred_type;
-
-    promising_argument(const argument<T> &a) : argument<T>(a), ref_future(promise)
-    {
-        if (passed == by_future)
-            *future_ptr = boost::future<referred_type>(promise);
-    }
-    bool is_out(){return true;}
-    template<typename Archive>
-    void deserialize(Archive &archive)
-    {
-        if (passed == by_future)
-        {
-            archive & storable;
-            promise.set(storable);
-        }
-        else // if (passed == by_ref)
-        {
-            archive & storable;
-            promise.set(storable);
-        }
-    }
-    void assign_promise()
-    {
-        if (passed == by_ref)
-            *referred_ptr = ref_future;
-    }
-private:
-    boost::promise<referred_type> promise;
-    boost::future<referred_type> ref_future;
-};
-
-namespace detail {
-
+ BOOST_PP_CAT(arg_storable,n)(BOOST_PP_CAT(a,n))
+
+#define BOOST_RPC_ARGUMENT_CHECK_OUT(z,I,text) \
+    has_out |= BOOST_PP_CAT(arg_storable,I).is_out();
+
+#define BOOST_RPC_ARGUMENT_ASSIGN_PROMISE(z,I,text) \
+    BOOST_PP_CAT(arg_storable,I).assign_promise();
+namespace boost {
+namespace rpc {
+
+template<typename T, typename Enable=void, typename Enable2=void>
+struct is_out_argument
+    : public boost::is_void<int>
+{};
+
+template<typename T>
+struct is_out_argument<T,
+    typename boost::enable_if<boost::is_reference<T> >::type,
+    typename boost::disable_if<boost::is_const<typename boost::remove_reference<T>::type> >::type>
+    : public boost::is_void<void>
+{};
+
+/// Wrapper for possibly "out" arguments to a remote call
+template<typename T, typename Enable=void>
+class argument
+{
+public:
+    typedef T type;
+    argument(T){}
+};
+
+template<typename T>
+class argument<T, typename boost::enable_if<is_out_argument<T> >::type>
+{
+public:
+    typedef argument<T> type;
+    typedef typename boost::detail::storable<T>::type storable_type;
+    typedef typename boost::remove_reference<T>::type referred_type;
+
+    argument(T ref)
+    {
+        passed = by_ref;
+        referred_ptr = &ref;
+    }
+    argument(boost::future<referred_type> &future)
+    {
+        passed = by_future;
+        future_ptr = &future;
+    }
+    operator T()
+    {
+        switch(passed)
+        {
+        case by_ref:
+            return *referred_ptr;
+        case by_future:
+            storable = future_ptr->get();
+            return storable;
+        }
+        return storable;
+    }
+protected:
+    union
+    {
+        referred_type *referred_ptr;
+        boost::future<referred_type> *future_ptr;
+    };
+    enum
+    {
+        by_ref,
+        by_future,
+    } passed;
+    storable_type storable;
+};
+
+template<typename T, typename Enable=void>
+class promising_argument : public argument<T>
+{
+public:
+    promising_argument(const argument<T> &a) : argument<T>(a) {}
+    void assign_promise(){}
+    bool is_out(){return false;}
+};
+
+template<typename T>
+class promising_argument<T, typename boost::enable_if<is_out_argument<T> >::type>
+    : public argument<T>
+{
+public:
+    typedef typename boost::detail::storable<T>::type storable_type;
+    typedef typename boost::remove_reference<T>::type referred_type;
+
+    promising_argument(const argument<T> &a) : argument<T>(a), ref_future(promise)
+    {
+        if (argument<T>::passed == argument<T>::by_future)
+            *argument<T>::future_ptr = boost::future<referred_type>(promise);
+    }
+    bool is_out(){return true;}
+    template<typename Archive>
+    void deserialize(Archive &archive)
+    {
+        if (argument<T>::passed == argument<T>::by_future)
+        {
+            archive & argument<T>::storable;
+            promise.set(argument<T>::storable);
+        }
+        else // if (passed == by_ref)
+        {
+            archive & argument<T>::storable;
+            promise.set(argument<T>::storable);
+        }
+    }
+    void assign_promise()
+    {
+        if (argument<T>::passed == argument<T>::by_ref)
+            *argument<T>::referred_ptr = ref_future;
+    }
+private:
+    boost::promise<referred_type> promise;
+    boost::future<referred_type> ref_future;
+};
+
+namespace detail {
+
 #define BOOST_RPC_REF_COPY(z,n,text) \
   boost::rpc::detail:: \
   reference_copy<typename boost::function_traits<Signature>::arg##n##_type> arg_storable##n;
-
+
 #define BOOST_RPC_INIT_REF_COPY(z,n,text) \
  BOOST_PP_CAT(arg_storable,n)(BOOST_PP_CAT(a,n))
-
-template<typename T, typename Archive>
-typename boost::enable_if<typename boost::is_reference<T> >::type
-archive_out_param(Archive &archive, T t)
-{
-    archive & t;
-}
-
-template<typename T, typename Archive>
-typename boost::disable_if<boost::is_reference<T> >::type
-archive_out_param(Archive &archive, T t)
-{
-}
-
-template<typename T, typename Archive>
-typename boost::enable_if<boost::rpc::is_out_argument<T> >::type
-archive_out_param (Archive &archive, promising_argument<T> &t)
-{
-    t.deserialize(archive);
-}
-
-template<typename T, typename Archive>
-typename boost::disable_if<boost::rpc::is_out_argument<T> >::type
-archive_out_param (Archive &, promising_argument<T> &)
-{
-}
-
-} // namespace detail
-} // namespace rpc
-} // namespace boost
-
-#endif
+
+template<typename T, typename Archive>
+typename boost::enable_if<typename boost::is_reference<T> >::type
+archive_out_param(Archive &archive, T t)
+{
+    archive & t;
+}
+
+template<typename T, typename Archive>
+typename boost::disable_if<boost::is_reference<T> >::type
+archive_out_param(Archive &archive, T t)
+{
+}
+
+template<typename T, typename Archive>
+typename boost::enable_if<boost::rpc::is_out_argument<T> >::type
+archive_out_param (Archive &archive, promising_argument<T> &t)
+{
+    t.deserialize(archive);
+}
+
+template<typename T, typename Archive>
+typename boost::disable_if<boost::rpc::is_out_argument<T> >::type
+archive_out_param (Archive &, promising_argument<T> &)
+{
+}
+
+} // namespace detail
+} // namespace rpc
+} // namespace boost
+
+#endif

Modified: sandbox/rpc/boost/rpc/detail/handler_template.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/detail/handler_template.hpp	(original)
+++ sandbox/rpc/boost/rpc/detail/handler_template.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -1,20 +1,20 @@
 // Copyright Stjepan Rajko 2007. Use, modification and
 // distribution is subject to the Boost Software License, Version
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef DOXYGEN_DOCS_ONLY
-template<typename Signature, typename ArchivePair>
-class handler<Signature, ArchivePair
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef DOXYGEN_DOCS_ONLY
+template<typename Signature, typename ArchivePair>
+class handler<Signature, ArchivePair
     , typename enable_if_c<boost::function_traits<Signature>::arity==BOOST_ARITY_NUM_ARGS>::type,
    BOOST_ARITY_ENABLE_DISABLE_VOID
    >
    : public async_returning_handler<typename boost::function_traits<Signature>::result_type>
-#endif // !DOXYGEN_DOCS_ONLY
-{
-#ifdef DOXYGEN_DOCS_ONLY
-public:
-    /// Initializes the handler with the specified arguments.
+#endif // !DOXYGEN_DOCS_ONLY
+{
+#ifdef DOXYGEN_DOCS_ONLY
+public:
+    /// Initializes the handler with the specified arguments.
     handler(...)
     /// True if this handler has "out" arguments.
     bool has_out_parameters()
@@ -24,20 +24,20 @@
         return has_out;
     }
     /// Assigns the promises of the handler to storage variables.
-    void assign_promises()
-    {
-        BOOST_PP_REPEAT_FROM_TO(1,BOOST_ARITY_NUM_ARGS_INC,BOOST_RPC_ARGUMENT_ASSIGN_PROMISE,BOOST_PP_EMPTY())
-    }
-    /// Handler will process the marshalled result string.
-    virtual void result_string(const std::string &str)
-};
-#else
-    typedef async_returning_handler<typename boost::function_traits<Signature>::result_type> base_type;
-    typedef typename base_type::ptr ptr;
-    
-    BOOST_ARITY_STORABLE_TYPES(Signature)
-    BOOST_ARITY_TYPES(Signature)
-
+    void assign_promises()
+    {
+        BOOST_PP_REPEAT_FROM_TO(1,BOOST_ARITY_NUM_ARGS_INC,BOOST_RPC_ARGUMENT_ASSIGN_PROMISE,BOOST_PP_EMPTY())
+    }
+    /// Handler will process the marshalled result string.
+    virtual void result_string(const std::string &str)
+};
+#else
+    typedef async_returning_handler<typename boost::function_traits<Signature>::result_type> base_type;
+    typedef typename base_type::ptr ptr;
+    
+    BOOST_ARITY_STORABLE_TYPES(Signature)
+    BOOST_ARITY_TYPES(Signature)
+
     BOOST_ARITY_REPEAT(BOOST_RPC_TYPE_PARGUMENT_VAR,BOOST_RPC_VAR_arg_storableN_NAME)
 public:
     handler(BOOST_ARITY_ENUM(BOOST_RPC_TYPE_ARGUMENT_CREF_ARG,BOOST_RPC_VAR_arg_storableN_NAME))
@@ -50,24 +50,24 @@
         BOOST_PP_REPEAT_FROM_TO(1,BOOST_ARITY_NUM_ARGS_INC,BOOST_RPC_ARGUMENT_CHECK_OUT,BOOST_PP_EMPTY())
         return has_out;
     }
-    void assign_promises()
-    {
-        BOOST_PP_REPEAT_FROM_TO(1,BOOST_ARITY_NUM_ARGS_INC,BOOST_RPC_ARGUMENT_ASSIGN_PROMISE,BOOST_PP_EMPTY())
-    }
-    virtual void result_string(const std::string &str)
-    {
-        std::stringstream stream(str, std::ios::in | std::ios::out | std::ios::binary);
-        typename ArchivePair::iarchive_type archive(stream);
-        extract_return_val(archive, options);
-#ifdef BOOST_ARITY_NON_VOID_RETURN_TYPE
-        return_prom.set(return_val);
-#else
-        return_prom.set();
-#endif
-        if (options.marshal_option >= boost::rpc::call_options::all_out_parameters)
-        {
-            BOOST_PP_REPEAT_FROM_TO(1, BOOST_ARITY_NUM_ARGS_INC, BOOST_RPC_ARCHIVE_OUT_PARAM, archive)
-        }
-    };
-#endif
+    void assign_promises()
+    {
+        BOOST_PP_REPEAT_FROM_TO(1,BOOST_ARITY_NUM_ARGS_INC,BOOST_RPC_ARGUMENT_ASSIGN_PROMISE,BOOST_PP_EMPTY())
+    }
+    virtual void result_string(const std::string &str)
+    {
+        std::stringstream stream(str, std::ios::in | std::ios::out | std::ios::binary);
+        typename ArchivePair::iarchive_type archive(stream);
+        extract_return_val(archive, base_type::options);
+#ifdef BOOST_ARITY_NON_VOID_RETURN_TYPE
+        base_type::return_prom.set(base_type::return_val);
+#else
+		base_type::return_prom.set();
+#endif
+        if (base_type::options.marshal_option >= boost::rpc::call_options::all_out_parameters)
+        {
+            BOOST_PP_REPEAT_FROM_TO(1, BOOST_ARITY_NUM_ARGS_INC, BOOST_RPC_ARCHIVE_OUT_PARAM, archive)
+        }
+    };
+#endif
 };
\ No newline at end of file

Modified: sandbox/rpc/boost/rpc/detail/protocol.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/detail/protocol.hpp	(original)
+++ sandbox/rpc/boost/rpc/detail/protocol.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -1,128 +1,128 @@
-#ifndef BOOST_RPC_PROTOCOL_HPP
-#define BOOST_RPC_PROTOCOL_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/asio.hpp>
-#include <boost/rpc/call_options.hpp>
-#include <boost/future/future.hpp>
-
-namespace boost {
-namespace rpc {
-namespace protocol {
-namespace message
-{
-    /// Message types used in the communication.
-    enum category
-    {
-        ok = 0x4F4B,
-        call = 0x434C
-    };
-}
-
-typedef boost::int32_t message_category_type;
-typedef boost::int32_t request_id_type;
-typedef boost::uint64_t marshal_size_type;
-
-const message_category_type ok_message = message::ok;
-
-/// Header for a call request from the client.
-/** Contains the request id, call options, and size of the marshal part of the buffer.
-*/
-struct call_header
-{
-    /// Does not initialize the header.
-    call_header() {}
-    /// Initializes the call header with the specified values.
-    call_header(request_id_type request_id, marshal_size_type marshal_size)
-        : message_category(message::ok),
-        request_id(request_id),
-        marshal_size(marshal_size) {}
-
-    /// message_type is call_message.
-    message_category_type message_category;
-    /// Id associated with this call request
-    request_id_type request_id;
-    /// Size of the marshal part of the package.
-    marshal_size_type marshal_size;
-
-    boost::asio::mutable_buffers_1 as_buffer()
-    {
-        return boost::asio::buffer(this, sizeof(call_header));
-    }
-};
-
-struct call_footer
-{
-    call_footer(){}
-    call_footer(const boost::rpc::call_options &options)
-        : options(options)
-    {}
-
-    /// Options of the call being made.
-    boost::rpc::call_options options;
-
-    boost::asio::mutable_buffers_1 as_buffer()
-    {
-        return boost::asio::buffer(this, sizeof(call_footer));
-    }
-};
-
-/// Header for a call request from the client
-struct client_side_call_header
-{
-    /// Pointer to the client-side call structure.
-    intptr_t call_ptr;
-};
-
-/// Waits for a message on the socket and returns it.
-/** \todo What if an error happened?
-*/
-template<typename Socket>
-message_category_type read_message(Socket &socket)
-{
-    message_category_type category;
-    boost::asio::read(socket, boost::asio::buffer(&category, sizeof(category)));
-    return category;
-}
-
-template<typename Socket>
-class message_reader
-{
-public:
-    message_reader(Socket &socket) : future(promise)
-    {
+#ifndef BOOST_RPC_PROTOCOL_HPP
+#define BOOST_RPC_PROTOCOL_HPP
+
+#include <boost/cstdint.hpp>
+#include <boost/asio.hpp>
+#include <boost/rpc/call_options.hpp>
+#include <boost/future/future.hpp>
+
+namespace boost {
+namespace rpc {
+namespace protocol {
+namespace message
+{
+    /// Message types used in the communication.
+    enum category
+    {
+        ok = 0x4F4B,
+        call = 0x434C
+    };
+}
+
+typedef boost::int32_t message_category_type;
+typedef boost::int32_t request_id_type;
+typedef boost::uint64_t marshal_size_type;
+
+const message_category_type ok_message = message::ok;
+
+/// Header for a call request from the client.
+/** Contains the request id, call options, and size of the marshal part of the buffer.
+*/
+struct call_header
+{
+    /// Does not initialize the header.
+    call_header() {}
+    /// Initializes the call header with the specified values.
+    call_header(request_id_type request_id, marshal_size_type marshal_size)
+        : message_category(message::ok),
+        request_id(request_id),
+        marshal_size(marshal_size) {}
+
+    /// message_type is call_message.
+    message_category_type message_category;
+    /// Id associated with this call request
+    request_id_type request_id;
+    /// Size of the marshal part of the package.
+    marshal_size_type marshal_size;
+
+    boost::asio::mutable_buffers_1 as_buffer()
+    {
+        return boost::asio::buffer(this, sizeof(call_header));
+    }
+};
+
+struct call_footer
+{
+    call_footer(){}
+    call_footer(const boost::rpc::call_options &options)
+        : options(options)
+    {}
+
+    /// Options of the call being made.
+    boost::rpc::call_options options;
+
+    boost::asio::mutable_buffers_1 as_buffer()
+    {
+        return boost::asio::buffer(this, sizeof(call_footer));
+    }
+};
+
+/// Header for a call request from the client
+struct client_side_call_header
+{
+    /// Pointer to the client-side call structure.
+    intptr_t call_ptr;
+};
+
+/// Waits for a message on the socket and returns it.
+/** \todo What if an error happened?
+*/
+template<typename Socket>
+message_category_type read_message(Socket &socket)
+{
+    message_category_type category;
+    boost::asio::read(socket, boost::asio::buffer(&category, sizeof(category)));
+    return category;
+}
+
+template<typename Socket>
+class message_reader
+{
+public:
+    message_reader(Socket &socket) : future(promise)
+    {
         boost::asio::async_read(socket, boost::asio::buffer(&category, sizeof(category)),
             boost::bind(&message_reader::read_message, this,
-            boost::asio::placeholders::error));
-    };
-    message_category_type message()
-    {
-        for (int i=1; i<1000; i++)
-            std::cout << "";
-        return future;
-    }
-protected:
+            boost::asio::placeholders::error));
+    };
+    message_category_type message()
+    {
+        for (int i=1; i<1000; i++)
+            std::cout << "";
+        return future;
+    }
+protected:
     void read_message(const boost::system::error_code& error)
     {
         if (!error)
             promise.set(category);
-    }
-    boost::promise<message_category_type> promise;
-    boost::future<message_category_type> future;
-    message_category_type category;
-};
-
-/// Sends a message on the socket.
-/** \todo What if an error happened?
-*/
-template<typename Socket>
-void write_message(Socket &socket, const message_category_type &category)
-{
-    boost::asio::write(socket, boost::asio::buffer(&category, sizeof(category)));
-}
-
-} // namespace protocol
-} // namespace rpc
-} // namespace boost
-
-#endif // BOOST_RPC_PROTOCOL_HPP
+    }
+    boost::promise<message_category_type> promise;
+    boost::future<message_category_type> future;
+    message_category_type category;
+};
+
+/// Sends a message on the socket.
+/** \todo What if an error happened?
+*/
+template<typename Socket>
+void write_message(Socket &socket, const message_category_type &category)
+{
+    boost::asio::write(socket, boost::asio::buffer(&category, sizeof(category)));
+}
+
+} // namespace protocol
+} // namespace rpc
+} // namespace boost
+
+#endif // BOOST_RPC_PROTOCOL_HPP

Modified: sandbox/rpc/boost/rpc/detail/threaded_service.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/detail/threaded_service.hpp	(original)
+++ sandbox/rpc/boost/rpc/detail/threaded_service.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -16,7 +16,7 @@
 protected:
     /// Associates a permanent work with the service so it doesn't exit its run method
     /// until stopped.
-    threaded_service() : t(0), work(service) {}
+    threaded_service() : work(service), t(0) {}
     /// Starts the thread and runs the service.
     void start_service_thread()
     {

Modified: sandbox/rpc/boost/rpc/function.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/function.hpp	(original)
+++ sandbox/rpc/boost/rpc/function.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -16,6 +16,7 @@
     virtual void call(const boost::rpc::call_options &options,
         typename ArchivePair::iarchive_type &params,
         typename ArchivePair::oarchive_type *results = 0) {};
+    virtual ~function() {}
 };
 
 } // namespace detail

Modified: sandbox/rpc/boost/rpc/server.hpp
==============================================================================
--- sandbox/rpc/boost/rpc/server.hpp	(original)
+++ sandbox/rpc/boost/rpc/server.hpp	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -27,8 +27,8 @@
         Each successful connection will get a dedicated rpc::registry_server.
     */
     server(Registry &reg, int port)
-        : registry_(reg)
-        , acceptor(service, port, boost::bind(&server<Registry, Acceptor>::connected, this, _1))
+        : acceptor(service, port, boost::bind(&server<Registry, Acceptor>::connected, this, _1)),
+        registry_(reg)
     {
         start_service_thread();
     }

Added: sandbox/rpc/libs/rpc/xcodeide/example.xcodeproj/project.pbxproj
==============================================================================
--- (empty file)
+++ sandbox/rpc/libs/rpc/xcodeide/example.xcodeproj/project.pbxproj	2007-05-18 01:18:41 EDT (Fri, 18 May 2007)
@@ -0,0 +1,244 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXAggregateTarget section */
+		08868DBD0BFBE7B7004D6DFB /* rpc_example */ = {
+			isa = PBXAggregateTarget;
+			buildConfigurationList = 08868DC00BFBE7D5004D6DFB /* Build configuration list for PBXAggregateTarget "rpc_example" */;
+			buildPhases = (
+				08868DBC0BFBE7B7004D6DFB /* ShellScript */,
+			);
+			dependencies = (
+			);
+			name = rpc_example;
+			productName = rpc_example;
+		};
+/* End PBXAggregateTarget section */
+
+/* Begin PBXFileReference section */
+		08EA48570BFBEAC200EA623C /* arity.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = arity.hpp; sourceTree = "<group>"; };
+		08EA48580BFBEAC200EA623C /* arity_epilogue.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = arity_epilogue.hpp; sourceTree = "<group>"; };
+		08EA48590BFBEAC200EA623C /* arity_iterate.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = arity_iterate.hpp; sourceTree = "<group>"; };
+		08EA485A0BFBEAC200EA623C /* arity_prologue.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = arity_prologue.hpp; sourceTree = "<group>"; };
+		08EA485B0BFBEAC200EA623C /* storable.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = storable.hpp; sourceTree = "<group>"; };
+		08EA485D0BFBEAC200EA623C /* binary_archive.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = binary_archive.hpp; sourceTree = "<group>"; };
+		08EA485E0BFBEAC200EA623C /* call.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = call.hpp; sourceTree = "<group>"; };
+		08EA485F0BFBEAC200EA623C /* call_options.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = call_options.hpp; sourceTree = "<group>"; };
+		08EA48600BFBEAC200EA623C /* client.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = client.hpp; sourceTree = "<group>"; };
+		08EA48610BFBEAC200EA623C /* config.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = config.hpp; sourceTree = "<group>"; };
+		08EA48630BFBEAC200EA623C /* archive_out_param.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = archive_out_param.hpp; sourceTree = "<group>"; };
+		08EA48640BFBEAC200EA623C /* call_template.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = call_template.hpp; sourceTree = "<group>"; };
+		08EA48650BFBEAC200EA623C /* expanding_buffer.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = expanding_buffer.hpp; sourceTree = "<group>"; };
+		08EA48660BFBEAC200EA623C /* handler_template.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = handler_template.hpp; sourceTree = "<group>"; };
+		08EA48670BFBEAC200EA623C /* marshaled_template.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = marshaled_template.hpp; sourceTree = "<group>"; };
+		08EA48680BFBEAC200EA623C /* protocol.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = protocol.hpp; sourceTree = "<group>"; };
+		08EA48690BFBEAC200EA623C /* remote_caller_template.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = remote_caller_template.hpp; sourceTree = "<group>"; };
+		08EA486A0BFBEAC200EA623C /* serialize_template.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = serialize_template.hpp; sourceTree = "<group>"; };
+		08EA486B0BFBEAC200EA623C /* threaded_service.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = threaded_service.hpp; sourceTree = "<group>"; };
+		08EA486C0BFBEAC200EA623C /* function.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = function.hpp; sourceTree = "<group>"; };
+		08EA486D0BFBEAC200EA623C /* marshal.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = marshal.hpp; sourceTree = "<group>"; };
+		08EA486E0BFBEAC200EA623C /* marshaled.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = marshaled.hpp; sourceTree = "<group>"; };
+		08EA486F0BFBEAC200EA623C /* registry.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = registry.hpp; sourceTree = "<group>"; };
+		08EA48700BFBEAC200EA623C /* registry_server.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = registry_server.hpp; sourceTree = "<group>"; };
+		08EA48710BFBEAC200EA623C /* remote_caller.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = remote_caller.hpp; sourceTree = "<group>"; };
+		08EA48720BFBEAC200EA623C /* serialize.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = serialize.hpp; sourceTree = "<group>"; };
+		08EA48730BFBEAC200EA623C /* server.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = server.hpp; sourceTree = "<group>"; };
+		08EA48740BFBEAC200EA623C /* simple_acceptor.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = simple_acceptor.hpp; sourceTree = "<group>"; };
+		08EA48750BFBEAC200EA623C /* simple_connector.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = simple_connector.hpp; sourceTree = "<group>"; };
+		08EA48760BFBEAC200EA623C /* socket_string_receiver.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = socket_string_receiver.hpp; sourceTree = "<group>"; };
+		08EA48770BFBEAC200EA623C /* socket_string_sender.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = socket_string_sender.hpp; sourceTree = "<group>"; };
+		08EA48780BFBEAC200EA623C /* text_archive.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = text_archive.hpp; sourceTree = "<group>"; };
+		08EA48790BFBEAC200EA623C /* xml_archive.hpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.h; path = xml_archive.hpp; sourceTree = "<group>"; };
+		08EA487B0BFBEAD300EA623C /* Jamfile.v2 */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text; path = Jamfile.v2; sourceTree = "<group>"; };
+		08EA487C0BFBEAD300EA623C /* rpc_example.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = rpc_example.cpp; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+		089C166AFE841209C02AAC07 /* Automator Action */ = {
+			isa = PBXGroup;
+			children = (
+				08EA487A0BFBEAD300EA623C /* example */,
+				08EA48550BFBEAC200EA623C /* boost */,
+			);
+			name = "Automator Action";
+			sourceTree = "<group>";
+		};
+		08EA48550BFBEAC200EA623C /* boost */ = {
+			isa = PBXGroup;
+			children = (
+				08EA48560BFBEAC200EA623C /* detail */,
+				08EA485C0BFBEAC200EA623C /* rpc */,
+			);
+			name = boost;
+			path = ../../../boost;
+			sourceTree = SOURCE_ROOT;
+		};
+		08EA48560BFBEAC200EA623C /* detail */ = {
+			isa = PBXGroup;
+			children = (
+				08EA48570BFBEAC200EA623C /* arity.hpp */,
+				08EA48580BFBEAC200EA623C /* arity_epilogue.hpp */,
+				08EA48590BFBEAC200EA623C /* arity_iterate.hpp */,
+				08EA485A0BFBEAC200EA623C /* arity_prologue.hpp */,
+				08EA485B0BFBEAC200EA623C /* storable.hpp */,
+			);
+			path = detail;
+			sourceTree = "<group>";
+		};
+		08EA485C0BFBEAC200EA623C /* rpc */ = {
+			isa = PBXGroup;
+			children = (
+				08EA485D0BFBEAC200EA623C /* binary_archive.hpp */,
+				08EA485E0BFBEAC200EA623C /* call.hpp */,
+				08EA485F0BFBEAC200EA623C /* call_options.hpp */,
+				08EA48600BFBEAC200EA623C /* client.hpp */,
+				08EA48610BFBEAC200EA623C /* config.hpp */,
+				08EA48620BFBEAC200EA623C /* detail */,
+				08EA486C0BFBEAC200EA623C /* function.hpp */,
+				08EA486D0BFBEAC200EA623C /* marshal.hpp */,
+				08EA486E0BFBEAC200EA623C /* marshaled.hpp */,
+				08EA486F0BFBEAC200EA623C /* registry.hpp */,
+				08EA48700BFBEAC200EA623C /* registry_server.hpp */,
+				08EA48710BFBEAC200EA623C /* remote_caller.hpp */,
+				08EA48720BFBEAC200EA623C /* serialize.hpp */,
+				08EA48730BFBEAC200EA623C /* server.hpp */,
+				08EA48740BFBEAC200EA623C /* simple_acceptor.hpp */,
+				08EA48750BFBEAC200EA623C /* simple_connector.hpp */,
+				08EA48760BFBEAC200EA623C /* socket_string_receiver.hpp */,
+				08EA48770BFBEAC200EA623C /* socket_string_sender.hpp */,
+				08EA48780BFBEAC200EA623C /* text_archive.hpp */,
+				08EA48790BFBEAC200EA623C /* xml_archive.hpp */,
+			);
+			path = rpc;
+			sourceTree = "<group>";
+		};
+		08EA48620BFBEAC200EA623C /* detail */ = {
+			isa = PBXGroup;
+			children = (
+				08EA48630BFBEAC200EA623C /* archive_out_param.hpp */,
+				08EA48640BFBEAC200EA623C /* call_template.hpp */,
+				08EA48650BFBEAC200EA623C /* expanding_buffer.hpp */,
+				08EA48660BFBEAC200EA623C /* handler_template.hpp */,
+				08EA48670BFBEAC200EA623C /* marshaled_template.hpp */,
+				08EA48680BFBEAC200EA623C /* protocol.hpp */,
+				08EA48690BFBEAC200EA623C /* remote_caller_template.hpp */,
+				08EA486A0BFBEAC200EA623C /* serialize_template.hpp */,
+				08EA486B0BFBEAC200EA623C /* threaded_service.hpp */,
+			);
+			path = detail;
+			sourceTree = "<group>";
+		};
+		08EA487A0BFBEAD300EA623C /* example */ = {
+			isa = PBXGroup;
+			children = (
+				08EA487B0BFBEAD300EA623C /* Jamfile.v2 */,
+				08EA487C0BFBEAD300EA623C /* rpc_example.cpp */,
+			);
+			name = example;
+			path = ../example;
+			sourceTree = SOURCE_ROOT;
+		};
+/* End PBXGroup section */
+
+/* Begin PBXProject section */
+		089C1669FE841209C02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 4E59BCAE08A8249B001206A8 /* Build configuration list for PBXProject "example" */;
+			hasScannedForEncodings = 1;
+			mainGroup = 089C166AFE841209C02AAC07 /* Automator Action */;
+			projectDirPath = "";
+			targets = (
+				08868DBD0BFBE7B7004D6DFB /* rpc_example */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		08868DBC0BFBE7B7004D6DFB /* ShellScript */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "# shell script goes here\ncd ../example\nls\nbjam --v2 --toolset=darwin\nexit 0";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		08868DC10BFBE7D5004D6DFB /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				PRODUCT_NAME = rpc_example;
+			};
+			name = Debug;
+		};
+		08868DC20BFBE7D5004D6DFB /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = YES;
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+				PRODUCT_NAME = rpc_example;
+				ZERO_LINK = NO;
+			};
+			name = Release;
+		};
+		4E59BCAF08A8249B001206A8 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				PREBINDING = NO;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Debug;
+		};
+		4E59BCB008A8249B001206A8 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				PREBINDING = NO;
+				SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		08868DC00BFBE7D5004D6DFB /* Build configuration list for PBXAggregateTarget "rpc_example" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				08868DC10BFBE7D5004D6DFB /* Debug */,
+				08868DC20BFBE7D5004D6DFB /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4E59BCAE08A8249B001206A8 /* Build configuration list for PBXProject "example" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				4E59BCAF08A8249B001206A8 /* Debug */,
+				4E59BCB008A8249B001206A8 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 089C1669FE841209C02AAC07 /* Project object */;
+}