Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

17 files changed, 1159 insertions, 0 deletions

diff --git a/src/boost/libs/signals2/example/CMakeLists.txt b/src/boost/libs/signals2/example/CMakeLists.txt
new file mode 100644
index 000000000..3b42e58d8
--- /dev/null
+++ b/src/boost/libs/signals2/example/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Copyright 2019 Mike Dev
+# Distributed under the Boost Software License, Version 1.0.
+# See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
+#
+# NOTE: CMake support for Boost.Signals2 is currently experimental at best
+#       and the interface is likely to change in the future
+
+file( GLOB example_src_files *.cpp )
+
+find_package(Threads REQUIRED)
+
+foreach( file IN LISTS example_src_files )
+
+    get_filename_component( example_name ${file} NAME_WE )
+
+    add_executable( boost_signals2_example_${example_name} ${file} )
+    target_link_libraries( boost_signals2_example_${example_name}
+        PUBLIC
+            Boost::signals2
+            Boost::io
+            Threads::Threads
+    )
+
+endforeach()
diff --git a/src/boost/libs/signals2/example/Jamfile.v2 b/src/boost/libs/signals2/example/Jamfile.v2
new file mode 100644
index 000000000..079ad4432
--- /dev/null
+++ b/src/boost/libs/signals2/example/Jamfile.v2
@@ -0,0 +1,42 @@
+# Boost.Signals2 example programs
+
+# Copyright Michael Caisse 2010
+# 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)
+
+# For more information, see http://www.boost.org
+
+project : requirements <implicit-dependency>/boost//headers ;
+
+exe hello_world_slot : hello_world_slot.cpp ;
+
+exe hello_world_multi_slot : hello_world_multi_slot.cpp ;
+
+exe ordering_slots : ordering_slots.cpp ;
+
+exe passing_slots : passing_slots.cpp ;
+
+exe extended_slot : extended_slot.cpp ;
+
+exe custom_combiners : custom_combiners.cpp ;
+
+exe disconnect_and_block : disconnect_and_block.cpp ;
+
+exe doc_view : doc_view.cpp ;
+
+exe doc_view_acm : doc_view_acm.cpp ;
+
+exe doc_view_acm_deconstruct : doc_view_acm_deconstruct.cpp ;
+
+exe postconstructor_ex1 : postconstructor_ex1.cpp ;
+
+exe postconstructor_ex2 : postconstructor_ex2.cpp ;
+
+exe predestructor_example : predestructor_example.cpp ;
+
+exe signal_return_value : signal_return_value.cpp ;
+
+exe slot_arguments : slot_arguments.cpp ;
+
diff --git a/src/boost/libs/signals2/example/custom_combiners.cpp b/src/boost/libs/signals2/example/custom_combiners.cpp
new file mode 100644
index 000000000..72e43b760
--- /dev/null
+++ b/src/boost/libs/signals2/example/custom_combiners.cpp
@@ -0,0 +1,109 @@
+// Example program showing signals with custom combiners.
+//
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+#include <vector>
+
+float product(float x, float y) { return x * y; }
+float quotient(float x, float y) { return x / y; }
+float sum(float x, float y) { return x + y; }
+float difference(float x, float y) { return x - y; }
+
+//[ custom_combiners_maximum_def_code_snippet
+// combiner which returns the maximum value returned by all slots
+template<typename T>
+struct maximum
+{
+  typedef T result_type;
+
+  template<typename InputIterator>
+  T operator()(InputIterator first, InputIterator last) const
+  {
+    // If there are no slots to call, just return the
+    // default-constructed value
+    if(first == last ) return T();
+    T max_value = *first++;
+    while (first != last) {
+      if (max_value < *first)
+        max_value = *first;
+      ++first;
+    }
+
+    return max_value;
+  }
+};
+//]
+
+void maximum_combiner_example()
+{
+  // signal which uses our custom "maximum" combiner
+  boost::signals2::signal<float (float x, float y), maximum<float> > sig;
+
+//[ custom_combiners_maximum_usage_code_snippet
+  sig.connect(&product);
+  sig.connect(&quotient);
+  sig.connect(&sum);
+  sig.connect(&difference);
+
+  // Outputs the maximum value returned by the connected slots, in this case
+  // 15 from the product function.
+  std::cout << "maximum: " << sig(5, 3) << std::endl;
+//]
+}
+
+//[ custom_combiners_aggregate_values_def_code_snippet
+// aggregate_values is a combiner which places all the values returned
+// from slots into a container
+template<typename Container>
+struct aggregate_values
+{
+  typedef Container result_type;
+
+  template<typename InputIterator>
+  Container operator()(InputIterator first, InputIterator last) const
+  {
+    Container values;
+
+    while(first != last) {
+      values.push_back(*first);
+      ++first;
+    }
+    return values;
+  }
+};
+//]
+
+void aggregate_values_example()
+{
+  // signal which uses aggregate_values as its combiner
+  boost::signals2::signal<float (float, float),
+    aggregate_values<std::vector<float> > > sig;
+
+//[ custom_combiners_aggregate_values_usage_code_snippet
+  sig.connect(&quotient);
+  sig.connect(&product);
+  sig.connect(&sum);
+  sig.connect(&difference);
+
+  std::vector<float> results = sig(5, 3);
+  std::cout << "aggregate values: ";
+  std::copy(results.begin(), results.end(),
+    std::ostream_iterator<float>(std::cout, " "));
+  std::cout << "\n";
+//]
+}
+
+int main()
+{
+  maximum_combiner_example();
+  aggregate_values_example();
+}
diff --git a/src/boost/libs/signals2/example/disconnect_and_block.cpp b/src/boost/libs/signals2/example/disconnect_and_block.cpp
new file mode 100644
index 000000000..4478be005
--- /dev/null
+++ b/src/boost/libs/signals2/example/disconnect_and_block.cpp
@@ -0,0 +1,114 @@
+// Various simple examples involving disconnecting and blocking slots.
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+#include <boost/signals2/shared_connection_block.hpp>
+
+struct HelloWorld
+{
+  void operator()() const
+  {
+    std::cout << "Hello, World!" << std::endl;
+  }
+};
+
+void disconnect_example()
+{
+  boost::signals2::signal<void ()> sig;
+
+//[ disconnect_code_snippet
+  boost::signals2::connection c = sig.connect(HelloWorld());
+  std::cout << "c is connected\n";
+  sig(); // Prints "Hello, World!"
+
+  c.disconnect(); // Disconnect the HelloWorld object
+  std::cout << "c is disconnected\n";
+  sig(); // Does nothing: there are no connected slots
+//]
+}
+
+void block_example()
+{
+  boost::signals2::signal<void ()> sig;
+
+//[ block_code_snippet
+  boost::signals2::connection c = sig.connect(HelloWorld());
+  std::cout << "c is not blocked.\n";
+  sig(); // Prints "Hello, World!"
+
+  {
+    boost::signals2::shared_connection_block block(c); // block the slot
+    std::cout << "c is blocked.\n";
+    sig(); // No output: the slot is blocked
+  } // shared_connection_block going out of scope unblocks the slot
+  std::cout << "c is not blocked.\n";
+  sig(); // Prints "Hello, World!"}
+//]
+}
+
+struct ShortLived
+{
+  void operator()() const
+  {
+    std::cout << "Life is short!" << std::endl;
+  }
+};
+
+void scoped_connection_example()
+{
+  boost::signals2::signal<void ()> sig;
+
+//[ scoped_connection_code_snippet
+  {
+    boost::signals2::scoped_connection c(sig.connect(ShortLived()));
+    sig(); // will call ShortLived function object
+  } // scoped_connection goes out of scope and disconnects
+
+  sig(); // ShortLived function object no longer connected to sig
+//]
+}
+
+//[ disconnect_by_slot_def_code_snippet
+void foo() { std::cout << "foo"; }
+void bar() { std::cout << "bar\n"; }
+//]
+
+void disconnect_by_slot_example()
+{
+  boost::signals2::signal<void()> sig;
+
+//[ disconnect_by_slot_usage_code_snippet
+  sig.connect(&foo);
+  sig.connect(&bar);
+  sig();
+
+  // disconnects foo, but not bar
+  sig.disconnect(&foo);
+  sig();
+//]
+}
+
+int main()
+{
+  std::cout << "Disconnect example:\n";
+  disconnect_example();
+
+  std::cout << "\nBlock example:\n";
+  block_example();
+
+  std::cout << "\nScoped connection example:\n";
+  scoped_connection_example();
+
+  std::cout << "\nDisconnect by slot example:\n";
+  disconnect_by_slot_example();
+
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/doc_view.cpp b/src/boost/libs/signals2/example/doc_view.cpp
new file mode 100644
index 000000000..7ff1990e9
--- /dev/null
+++ b/src/boost/libs/signals2/example/doc_view.cpp
@@ -0,0 +1,115 @@
+// Document/View sample for Boost.Signals
+// Copyright Keith MacDonald 2005.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <string>
+#include <boost/signals2/signal.hpp>
+#include <boost/bind.hpp>
+
+//[ document_def_code_snippet
+class Document
+{
+public:
+    typedef boost::signals2::signal<void ()>  signal_t;
+
+public:
+    Document()
+    {}
+
+    /* Connect a slot to the signal which will be emitted whenever
+      text is appended to the document. */
+    boost::signals2::connection connect(const signal_t::slot_type &subscriber)
+    {
+        return m_sig.connect(subscriber);
+    }
+
+    void append(const char* s)
+    {
+        m_text += s;
+        m_sig();
+    }
+
+    const std::string& getText() const
+    {
+        return m_text;
+    }
+
+private:
+    signal_t    m_sig;
+    std::string m_text;
+};
+//]
+
+//[ text_view_def_code_snippet
+class TextView
+{
+public:
+    TextView(Document& doc): m_document(doc)
+    {
+        m_connection = m_document.connect(boost::bind(&TextView::refresh, this));
+    }
+
+    ~TextView()
+    {
+        m_connection.disconnect();
+    }
+
+    void refresh() const
+    {
+        std::cout << "TextView: " << m_document.getText() << std::endl;
+    }
+private:
+    Document&               m_document;
+    boost::signals2::connection  m_connection;
+};
+//]
+
+//[ hex_view_def_code_snippet
+class HexView
+{
+public:
+    HexView(Document& doc): m_document(doc)
+    {
+        m_connection = m_document.connect(boost::bind(&HexView::refresh, this));
+    }
+
+    ~HexView()
+    {
+        m_connection.disconnect();
+    }
+
+    void refresh() const
+    {
+        const std::string&  s = m_document.getText();
+
+        std::cout << "HexView:";
+
+        for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+            std::cout << ' ' << std::hex << static_cast<int>(*it);
+
+        std::cout << std::endl;
+    }
+private:
+    Document&               m_document;
+    boost::signals2::connection  m_connection;
+};
+//]
+
+//[ document_view_main_code_snippet
+int main(int argc, char* argv[])
+{
+    Document    doc;
+    TextView    v1(doc);
+    HexView     v2(doc);
+
+    doc.append(argc == 2 ? argv[1] : "Hello world!");
+    return 0;
+}
+//]
diff --git a/src/boost/libs/signals2/example/doc_view_acm.cpp b/src/boost/libs/signals2/example/doc_view_acm.cpp
new file mode 100644
index 000000000..ffc790826
--- /dev/null
+++ b/src/boost/libs/signals2/example/doc_view_acm.cpp
@@ -0,0 +1,127 @@
+// Document/View sample for Boost.Signals2.
+// Expands on doc_view.cpp example by using automatic
+// connection management.
+//
+// Copyright Keith MacDonald 2005.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <string>
+#include <boost/bind.hpp>
+#include <boost/io/ios_state.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/shared_ptr.hpp>
+
+class Document
+{
+public:
+  typedef boost::signals2::signal<void ()>  signal_t;
+
+public:
+  Document()
+  {}
+
+  /* connect a slot to the signal which will be emitted whenever
+    text is appended to the document. */
+  boost::signals2::connection connect(const signal_t::slot_type &subscriber)
+  {
+    return m_sig.connect(subscriber);
+  }
+
+  void append(const char* s)
+  {
+    m_text += s;
+    m_sig();
+  }
+
+  const std::string& getText() const
+  {
+    return m_text;
+  }
+
+private:
+  signal_t    m_sig;
+  std::string m_text;
+};
+
+class TextView
+{
+public:
+  // static factory function that sets up automatic connection tracking
+  static boost::shared_ptr<TextView> create(Document& doc)
+  {
+    boost::shared_ptr<TextView> new_view(new TextView(doc));
+    {
+      typedef Document::signal_t::slot_type slot_type;
+      slot_type myslot(&TextView::refresh, new_view.get());
+      doc.connect(myslot.track(new_view));
+    }
+    return new_view;
+  }
+
+  void refresh() const
+  {
+    std::cout << "TextView: " << m_document.getText() << std::endl;
+  }
+private:
+    // private constructor to force use of static factory function
+    TextView(Document &doc): m_document(doc)
+    {}
+
+    Document&               m_document;
+};
+
+class HexView
+{
+public:
+  // static factory function that sets up automatic connection tracking
+  static boost::shared_ptr<HexView> create(Document& doc)
+  {
+    boost::shared_ptr<HexView> new_view(new HexView(doc));
+    {
+      typedef Document::signal_t::slot_type slot_type;
+      slot_type myslot(&HexView::refresh, new_view.get());
+      doc.connect(myslot.track(new_view));
+    }
+    return new_view;
+  }
+
+  void refresh() const
+  {
+    boost::io::ios_flags_saver ifs(std::cout);
+    const std::string&  s = m_document.getText();
+
+    std::cout << "HexView:";
+
+    for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+      std::cout << ' ' << std::hex << static_cast<int>(*it);
+
+    std::cout << std::endl;
+  }
+private:
+  // private constructor to force use of static factory function
+  HexView(Document& doc): m_document(doc)
+  {}
+
+  Document&               m_document;
+};
+
+int main(int argc, char* argv[])
+{
+  Document    doc;
+  boost::shared_ptr<TextView> v1 = TextView::create(doc);
+  boost::shared_ptr<HexView> v2 = HexView::create(doc);
+
+  doc.append(argc >= 2 ? argv[1] : "Hello world!");
+
+  v2.reset(); // destroy the HexView, automatically disconnecting
+  doc.append("  HexView should no longer be connected.");
+
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/doc_view_acm_deconstruct.cpp b/src/boost/libs/signals2/example/doc_view_acm_deconstruct.cpp
new file mode 100644
index 000000000..1855c7806
--- /dev/null
+++ b/src/boost/libs/signals2/example/doc_view_acm_deconstruct.cpp
@@ -0,0 +1,135 @@
+// Document/View sample for Boost.Signals2.
+// Expands on doc_view_acm.cpp example by using boost::signals2::deconstruct
+// as a post-constructing factory function.
+//
+// Copyright Keith MacDonald 2005.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <string>
+#include <boost/bind.hpp>
+#include <boost/ref.hpp>
+#include <boost/signals2/deconstruct.hpp>
+#include <boost/signals2/signal.hpp>
+#include <boost/shared_ptr.hpp>
+
+class Document
+{
+public:
+  typedef boost::signals2::signal<void ()>  signal_t;
+
+public:
+  Document()
+  {}
+
+  /* Connect a slot to the signal which will be emitted whenever
+    text is appended to the document. */
+  boost::signals2::connection connect(const signal_t::slot_type &subscriber)
+  {
+    return m_sig.connect(subscriber);
+  }
+
+  void append(const char* s)
+  {
+    m_text += s;
+    m_sig();
+  }
+
+  const std::string& getText() const
+  {
+    return m_text;
+  }
+
+private:
+  signal_t    m_sig;
+  std::string m_text;
+};
+
+class TextView
+{
+public:
+  /* This adl_postconstruct function will be found
+  via argument-dependent lookup when using boost::signals2::deconstruct. */
+  template<typename T>
+    friend void adl_postconstruct(const boost::shared_ptr<T> &view_sp, TextView *view, Document& doc)
+  {
+    view->m_document = &doc;
+    {
+      typedef Document::signal_t::slot_type slot_type;
+      slot_type myslot(&TextView::refresh, view);
+      doc.connect(myslot.track(view_sp));
+    }
+  }
+
+  void refresh() const
+  {
+    std::cout << "TextView: " << m_document->getText() << std::endl;
+  }
+private:
+  // give boost::signals2::deconstruct access to private constructor
+  friend class boost::signals2::deconstruct_access;
+  // private constructor to force use of deconstruct
+  TextView() : m_document(0)
+  {}
+
+  Document*               m_document;
+};
+
+class HexView
+{
+public:
+  /* This adl_postconstruct function will be found
+  via argument-dependent lookup when using boost::signals2::deconstruct. */
+  template<typename T>
+    friend void adl_postconstruct(const boost::shared_ptr<T> &view_sp, HexView *view, Document& doc)
+  {
+    view->m_document = &doc;
+    {
+      typedef Document::signal_t::slot_type slot_type;
+      slot_type myslot(&HexView::refresh, view);
+      doc.connect(myslot.track(view_sp));
+    }
+  }
+
+  void refresh() const
+  {
+    const std::string&  s = m_document->getText();
+
+    std::cout << "HexView:";
+
+    for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+      std::cout << ' ' << std::hex << static_cast<int>(*it);
+
+    std::cout << std::endl;
+  }
+private:
+  // give boost::signals2::deconstruct access to private constructor
+  friend class boost::signals2::deconstruct_access;
+  // private constructor to force use of deconstruct
+  HexView(): m_document(0)
+  {}
+
+  Document*               m_document;
+};
+
+namespace bs2 = boost::signals2;
+
+int main(int argc, char* argv[])
+{
+  Document    doc;
+  boost::shared_ptr<TextView> v1 = bs2::deconstruct<TextView>().postconstruct(boost::ref(doc));
+  boost::shared_ptr<HexView> v2 = bs2::deconstruct<HexView>().postconstruct(boost::ref(doc));
+
+  doc.append(argc >= 2 ? argv[1] : "Hello world!");
+
+  v2.reset(); // destroy the HexView, automatically disconnecting
+  doc.append("  HexView should no longer be connected.");
+
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/extended_slot.cpp b/src/boost/libs/signals2/example/extended_slot.cpp
new file mode 100644
index 000000000..40699e53c
--- /dev/null
+++ b/src/boost/libs/signals2/example/extended_slot.cpp
@@ -0,0 +1,42 @@
+// Example program for connecting an extended slot,
+// using a signal's connect_extended and extended_slot_type.
+//
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <boost/signals2/signal.hpp>
+#include <iostream>
+#include <string>
+
+namespace bs2 = boost::signals2;
+
+void single_shot_slot(const bs2::connection &conn, const std::string &message)
+{
+  conn.disconnect();
+  std::cout << message;
+}
+
+int main()
+{
+  typedef bs2::signal<void (void)> sig_type;
+  sig_type sig;
+  {
+    sig_type::extended_slot_type hello(&single_shot_slot, _1, "Hello");
+    sig.connect_extended(hello);
+  }
+  sig();  // prints "Hello"
+  {
+    sig_type::extended_slot_type world(&single_shot_slot, _1, ", World!\n");
+    sig.connect_extended(world);
+  }
+  sig();  // only prints ", World!\n" since hello slot has disconnected itself
+  sig();  // prints nothing, world slot has disconnected itself
+
+  return 0;
+}
+
diff --git a/src/boost/libs/signals2/example/hello_world_multi_slot.cpp b/src/boost/libs/signals2/example/hello_world_multi_slot.cpp
new file mode 100644
index 000000000..f47835148
--- /dev/null
+++ b/src/boost/libs/signals2/example/hello_world_multi_slot.cpp
@@ -0,0 +1,47 @@
+// Multiple slot hello world example for Boost.Signals2
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+//[ hello_def_code_snippet
+struct Hello
+{
+  void operator()() const
+  {
+    std::cout << "Hello";
+  }
+};
+//]
+
+//[ world_def_code_snippet
+struct World
+{
+  void operator()() const
+  {
+    std::cout << ", World!" << std::endl;
+  }
+};
+//]
+
+int main()
+{
+//[ hello_world_multi_code_snippet
+  boost::signals2::signal<void ()> sig;
+
+  sig.connect(Hello());
+  sig.connect(World());
+
+  sig();
+//]
+
+  return 0;
+}
+
diff --git a/src/boost/libs/signals2/example/hello_world_slot.cpp b/src/boost/libs/signals2/example/hello_world_slot.cpp
new file mode 100644
index 000000000..18e3c6a38
--- /dev/null
+++ b/src/boost/libs/signals2/example/hello_world_slot.cpp
@@ -0,0 +1,40 @@
+// Beginner hello world example for Boost.Signals2
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+//[ hello_world_def_code_snippet
+struct HelloWorld
+{
+  void operator()() const
+  {
+    std::cout << "Hello, World!" << std::endl;
+  }
+};
+//]
+
+int main()
+{
+//[ hello_world_single_code_snippet
+  // Signal with no arguments and a void return value
+  boost::signals2::signal<void ()> sig;
+
+  // Connect a HelloWorld slot
+  HelloWorld hello;
+  sig.connect(hello);
+
+  // Call all of the slots
+  sig();
+//]
+
+  return 0;
+}
+
diff --git a/src/boost/libs/signals2/example/ordering_slots.cpp b/src/boost/libs/signals2/example/ordering_slots.cpp
new file mode 100644
index 000000000..f69bc182c
--- /dev/null
+++ b/src/boost/libs/signals2/example/ordering_slots.cpp
@@ -0,0 +1,62 @@
+// Ordered slots hello world example for Boost.Signals2
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+struct Hello
+{
+  void operator()() const
+  {
+    std::cout << "Hello";
+  }
+};
+
+struct World
+{
+  void operator()() const
+  {
+    std::cout << ", World!" << std::endl;
+  }
+};
+
+//[ good_morning_def_code_snippet
+struct GoodMorning
+{
+  void operator()() const
+  {
+    std::cout << "... and good morning!" << std::endl;
+  }
+};
+//]
+
+int main()
+{
+//[ hello_world_ordered_code_snippet
+  boost::signals2::signal<void ()> sig;
+
+  sig.connect(1, World());  // connect with group 1
+  sig.connect(0, Hello());  // connect with group 0
+//]
+
+//[ hello_world_ordered_invoke_code_snippet
+  // by default slots are connected at the end of the slot list
+  sig.connect(GoodMorning());
+
+  // slots are invoked this order:
+  // 1) ungrouped slots connected with boost::signals2::at_front
+  // 2) grouped slots according to ordering of their groups
+  // 3) ungrouped slots connected with boost::signals2::at_back
+  sig();
+//]
+
+  return 0;
+}
+
diff --git a/src/boost/libs/signals2/example/passing_slots.cpp b/src/boost/libs/signals2/example/passing_slots.cpp
new file mode 100644
index 000000000..d2c098cb3
--- /dev/null
+++ b/src/boost/libs/signals2/example/passing_slots.cpp
@@ -0,0 +1,55 @@
+// Example program showing passing of slots through an interface.
+//
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+//[ passing_slots_defs_code_snippet
+// a pretend GUI button
+class Button
+{
+  typedef boost::signals2::signal<void (int x, int y)> OnClick;
+public:
+  typedef OnClick::slot_type OnClickSlotType;
+  // forward slots through Button interface to its private signal
+  boost::signals2::connection doOnClick(const OnClickSlotType & slot);
+
+  // simulate user clicking on GUI button at coordinates 52, 38
+  void simulateClick();
+private:
+  OnClick onClick;
+};
+
+boost::signals2::connection Button::doOnClick(const OnClickSlotType & slot)
+{
+  return onClick.connect(slot);
+}
+
+void Button::simulateClick()
+{
+  onClick(52, 38);
+}
+
+void printCoordinates(long x, long y)
+{
+  std::cout << "(" << x << ", " << y << ")\n";
+}
+//]
+
+int main()
+{
+//[ passing_slots_usage_code_snippet
+  Button button;
+  button.doOnClick(&printCoordinates);
+  button.simulateClick();
+//]
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/postconstructor_ex1.cpp b/src/boost/libs/signals2/example/postconstructor_ex1.cpp
new file mode 100644
index 000000000..89f684bba
--- /dev/null
+++ b/src/boost/libs/signals2/example/postconstructor_ex1.cpp
@@ -0,0 +1,45 @@
+// Minimal example of defining a postconstructor for a class which
+// uses boost::signals2::deconstruct as its factory function.
+//
+// Copyright Frank Mori Hess 2009.
+
+// 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)
+// For more information, see http://www.boost.org
+
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/deconstruct.hpp>
+#include <iostream>
+
+namespace bs2 = boost::signals2;
+
+namespace mynamespace
+{
+  class X
+  {
+  public:
+    /* This adl_postconstruct function will be found
+    via argument-dependent lookup when using boost::signals2::deconstruct. */
+    template<typename T> friend
+      void adl_postconstruct(const boost::shared_ptr<T> &, X *)
+    {
+      std::cout << "world!" << std::endl;
+    }
+  private:
+    friend class bs2::deconstruct_access;  // give boost::signals2::deconstruct access to private constructor
+    // private constructor forces use of boost::signals2::deconstruct to create objects.
+    X()
+    {
+      std::cout << "Hello, ";
+    }
+  };
+}
+
+int main()
+{
+  // adl_postconstruct will be called during implicit conversion of return value to shared_ptr
+  boost::shared_ptr<mynamespace::X> x = bs2::deconstruct<mynamespace::X>();
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/postconstructor_ex2.cpp b/src/boost/libs/signals2/example/postconstructor_ex2.cpp
new file mode 100644
index 000000000..fdd1bd4ec
--- /dev/null
+++ b/src/boost/libs/signals2/example/postconstructor_ex2.cpp
@@ -0,0 +1,55 @@
+// An example of defining a postconstructor for a class which
+// uses boost::signals2::deconstruct as its factory function.
+// This example expands on the basic postconstructor_ex1.cpp example
+// by passing arguments to the constructor and postconstructor.
+//
+// Copyright Frank Mori Hess 2009.
+
+// 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)
+// For more information, see http://www.boost.org
+
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/deconstruct.hpp>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace bs2 = boost::signals2;
+
+namespace mynamespace
+{
+  class Y
+  {
+  public:
+    /* This adl_postconstruct function will be found
+    via argument-dependent lookup when using boost::signals2::deconstruct. */
+    template<typename T> friend
+      void adl_postconstruct(const boost::shared_ptr<T> &, Y *y, const std::string &text)
+    {
+      y->_text_stream << text;
+    }
+    void print() const
+    {
+      std::cout << _text_stream.str() << std::endl;
+    }
+  private:
+    friend class bs2::deconstruct_access;  // give boost::signals2::deconstruct access to private constructor
+    // private constructor forces use of boost::signals2::deconstruct to create objects.
+    Y(const std::string &text)
+    {
+      _text_stream << text;
+    }
+
+    std::ostringstream _text_stream;
+  };
+}
+
+int main()
+{
+  boost::shared_ptr<mynamespace::Y> y = bs2::deconstruct<mynamespace::Y>("Hello, ").postconstruct("world!");
+  y->print();
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/predestructor_example.cpp b/src/boost/libs/signals2/example/predestructor_example.cpp
new file mode 100644
index 000000000..6f10195e5
--- /dev/null
+++ b/src/boost/libs/signals2/example/predestructor_example.cpp
@@ -0,0 +1,52 @@
+// Minimal example of defining a predestructor for a class which
+// uses boost::signals2::deconstruct as its factory function.
+//
+// Copyright Frank Mori Hess 2009.
+
+// 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)
+// For more information, see http://www.boost.org
+
+#include <boost/shared_ptr.hpp>
+#include <boost/signals2/deconstruct.hpp>
+#include <iostream>
+
+namespace bs2 = boost::signals2;
+
+namespace mynamespace
+{
+  class X
+  {
+  public:
+    ~X()
+    {
+      std::cout << "cruel world!" << std::endl;
+    }
+    /* This adl_predestruct friend function will be found by
+    via argument-dependent lookup when using boost::signals2::deconstruct. */
+    friend void adl_predestruct(X *)
+    {
+      std::cout << "Goodbye, ";
+    }
+    /* boost::signals2::deconstruct always requires an adl_postconstruct function
+    which can be found via argument-dependent, so we define one which does nothing. */
+    template<typename T> friend
+      void adl_postconstruct(const boost::shared_ptr<T> &, X *)
+    {}
+  private:
+    friend class bs2::deconstruct_access;  // give boost::signals2::deconstruct access to private constructor
+    // private constructor forces use of boost::signals2::deconstruct to create objects.
+    X()
+    {}
+  };
+}
+
+int main()
+{
+  {
+    boost::shared_ptr<mynamespace::X> x = bs2::deconstruct<mynamespace::X>();
+  }
+  return 0;
+}
diff --git a/src/boost/libs/signals2/example/signal_return_value.cpp b/src/boost/libs/signals2/example/signal_return_value.cpp
new file mode 100644
index 000000000..163f29abf
--- /dev/null
+++ b/src/boost/libs/signals2/example/signal_return_value.cpp
@@ -0,0 +1,38 @@
+// Example program for returning a value from slots to signal invocation.
+//
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+//[ signal_return_value_slot_defs_code_snippet
+float product(float x, float y) { return x * y; }
+float quotient(float x, float y) { return x / y; }
+float sum(float x, float y) { return x + y; }
+float difference(float x, float y) { return x - y; }
+//]
+
+int main()
+{
+  boost::signals2::signal<float (float x, float y)> sig;
+
+//[ signal_return_value_main_code_snippet
+  sig.connect(&product);
+  sig.connect(&quotient);
+  sig.connect(&sum);
+  sig.connect(&difference);
+
+  // The default combiner returns a boost::optional containing the return
+  // value of the last slot in the slot list, in this case the
+  // difference function.
+  std::cout << *sig(5, 3) << std::endl;
+//]
+}
+
diff --git a/src/boost/libs/signals2/example/slot_arguments.cpp b/src/boost/libs/signals2/example/slot_arguments.cpp
new file mode 100644
index 000000000..86c49cb6f
--- /dev/null
+++ b/src/boost/libs/signals2/example/slot_arguments.cpp
@@ -0,0 +1,57 @@
+// Example program for passing arguments from signal invocations to slots.
+//
+// Copyright Douglas Gregor 2001-2004.
+// Copyright Frank Mori Hess 2009.
+//
+// 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)
+// For more information, see http://www.boost.org
+
+#include <iostream>
+#include <boost/signals2/signal.hpp>
+
+//[ slot_arguments_slot_defs_code_snippet
+void print_args(float x, float y)
+{
+  std::cout << "The arguments are " << x << " and " << y << std::endl;
+}
+
+void print_sum(float x, float y)
+{
+  std::cout << "The sum is " << x + y << std::endl;
+}
+
+void print_product(float x, float y)
+{
+  std::cout << "The product is " << x * y << std::endl;
+}
+
+void print_difference(float x, float y)
+{
+  std::cout << "The difference is " << x - y << std::endl;
+}
+
+void print_quotient(float x, float y)
+{
+  std::cout << "The quotient is " << x / y << std::endl;
+}
+//]
+
+int main()
+{
+//[ slot_arguments_main_code_snippet
+  boost::signals2::signal<void (float, float)> sig;
+
+  sig.connect(&print_args);
+  sig.connect(&print_sum);
+  sig.connect(&print_product);
+  sig.connect(&print_difference);
+  sig.connect(&print_quotient);
+
+  sig(5., 3.);
+//]
+  return 0;
+}
+