Library: replace boost::noncopyable by our own library solution

Benefits
 - get rid of yet another pervasive Boost dependency
 - define additional more fine grained policies (move only, clonable)

admin/scons/Platform.py

@@ -82,8 +82,6 @@ def configure(env):
     if not conf.CheckCXXHeader('boost/config.hpp'):
         problems.append('We need the C++ boost-libraries.')
     else:
-        if not conf.CheckCXXHeader('boost/noncopyable.hpp'):
-            problems.append('We need boost::noncopyable')
         if not conf.CheckCXXHeader('boost/lexical_cast.hpp'):
             problems.append('We need boost::lexical_cast')
         if not conf.CheckCXXHeader('boost/format.hpp'):

doc/technical/howto/UsingBoost.txt

@@ -54,41 +54,6 @@ source code comment near the static assertion statement to help solving the actu
 
 Relevant Bosst extensions
 ~~~~~~~~~~~~~~~~~~~~~~~~~
-.noncopyable
-Inheriting from `boost::noncoypable` inhibits any copy, assignment and copy construction. It's a highly
-recommended practice _by default to use that for every new class you create_ -- unless you know for sure
-your class is going to have _value semantics_. The C++ language has kind of a ``fixation'' on value
-semantics, passing objects by value, and the language adds a lot of magic on that behalf. Which might lead
-to surprising results if you aren't aware of the fine details.
-
-.type traits
-Boost provides a very elaborate collection of type trait templates, allowing to ``detect'' several
-properties of a given type at compile time. Since C++ has no reflection and only a very weak introspection
-feature (RTTI, run time type information), using these type traits is often indispensable.
-
-.enable_if
-a simple but ingenious metaprogramming trick, allowing to control precisely in which cases the compiler
-shall pick a specific class or function template specialisation. Basically this allows to control the
-code generation, based on some type traits or other (metaprogramming) predicates you provide. Again,
-since C++ is lacking introspection features, we're frequently forced to resort to metaprogramming
-techniques, i.e to influence the way the compiler translates our code from within that very code.
-
-.metaprogramming library
-A very elaborate, and sometimes mind-bending library and framework. While heavily used within
-Boost to build the more advanced features, it seems too complicated and esoteric for general purpose
-and everyday use. Code written using the MPL tends to be very abstract and almost unreadable for
-people without math background. In Lumiera, we _try to avoid using MPL directly._ Instead, we
-supplement some metaprogramming helpers (type lists and tuples), written in a simple LISP style,
-which -- hopefully -- should be decipherable without having to learn an abstract academic
-terminology and framework.
-
-.lambda
-In a similar vein, the `boost::lambda` library might be worth exploring a bit, yet doesn't add
-much value in practical use. It is stunning to see how this library adds the capability to define
-real _lambda expressions_ on-the-fly, but since C++ was never designed for language extensions of
-that kind, using lambda in practice is surprisingly tricky, sometimes even obscure and rarely
-not worth the hassle. (An notable exception might be when it comes to defining parser combinators)
-
 .operators
 The `boost::operators` library allows to build families of types/objects with consistent
 algebraic properties. Especially, it eases building _equality comparable_, _totally ordered_,
@@ -109,6 +74,15 @@ quite some compilation overhead and size impact (-> see our own
 link:http://git.lumiera.org/gitweb?p=lumiera/ichthyo;a=blob;f=src/lib/format-string.hpp;h=716aa0e3d23f09269973b7659910d74b3ee334ea;hb=37384f1b681f5bbfa7dc4d50b8588ed801fbddb3[formatting front-end]
 to reduce this overhead)
 
+.metaprogramming library
+A very elaborate, and sometimes mind-bending library and framework. While heavily used within
+Boost to build the more advanced features, it seems too complicated and esoteric for general purpose
+and everyday use. Code written using the MPL tends to be very abstract and almost unreadable for
+people without math background. In Lumiera, we _try to avoid using MPL directly._ Instead, we
+supplement some metaprogramming helpers (type lists and tuples), written in a simple LISP style,
+which -- hopefully -- should be decipherable without having to learn an abstract academic
+terminology and framework.
+
 .variant and any
 These library provide a nice option for building data structures able to hold a mixture of
 multiple types, especially types not directly related to each other. `boost::variant` is a

src/backend/engine/job.h

@@ -213,7 +213,7 @@ namespace engine {
    */
   class JobClosure
     : public lumiera_jobClosure
-    , boost::noncopyable          // ....has distinct identity and stable address
+    , util::NonCopyable            // ....has distinct identity and stable address
     {
     public:
       virtual ~JobClosure();     ///< this is an interface

src/backend/engine/scheduler-diagnostics.hpp

@@ -38,13 +38,11 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/hash-value.h"
 #include "lib/time/timevalue.hpp"
 #include "backend/engine/scheduler-frontend.hpp"
 
-#include <boost/noncopyable.hpp>
-//#include <string>
-
 
 namespace backend{
 namespace engine {
@@ -68,7 +66,7 @@ namespace engine {
    *          of SchedulerDiagnostics may be used.  
    */
   class SchedulerDiagnostics
-    : boost::noncopyable
+    : util::NonCopyable
     {
       SchedulerFrontend& scheduler_;
       

src/backend/real-clock.hpp

@@ -49,7 +49,6 @@
 //#include "lib/iter-source.hpp"
 //#include "lib/sync.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <vector>
 //#include <memory>

src/backend/thread-wrapper.hpp

@@ -41,6 +41,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "include/logging.h"
 #include "lib/meta/function.hpp"
 #include "lib/result.hpp"
@@ -107,6 +108,7 @@ namespace backend {
    * If this doesn't happen, you'll block forever.
    */
   class Thread
+    : util::MoveOnly
     {
       /** @internal perfect forwarding through a C-style `void*` */
       template<class FUN>
@@ -179,14 +181,6 @@ namespace backend {
       
       
     public:
-      // Threads can be moved only
-      Thread (Thread &&)                = default;
-      
-      // Threads must not be copied and assigned
-      Thread (Thread const&)            = delete;
-      Thread& operator= (Thread &&)     = delete;
-      Thread& operator= (Thread const&) = delete;
-      
       /** Create a new thread to execute the given operation.
        *  The new thread starts up synchronously, can't be cancelled and it can't be joined.
        *  @param purpose fixed char string used to denote the thread for diagnostics

src/common/advice.hpp

@@ -95,14 +95,13 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/null-value.hpp"
 #include "lib/symbol.hpp"
 #include "lib/util.hpp"
 
 #include "common/advice/binding.hpp"
 
-#include <boost/noncopyable.hpp>
-
 
 namespace lumiera{
 namespace advice {
@@ -315,7 +314,7 @@ namespace advice {
   template<class AD>
   class ActiveProvision
     : public PointOfAdvice
-    , boost::noncopyable
+    , util::NonCopyable
     {
       AD theAdvice_;
       

src/common/advice/advice.cpp

@@ -90,6 +90,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/del-stash.hpp"
 #include "lib/depend.hpp"
 #include "lib/symbol.hpp"
@@ -99,7 +100,6 @@
 #include "common/advice.hpp"
 #include "common/advice/index.hpp"
 
-#include <boost/noncopyable.hpp>
 
 using lib::Literal;
 using lib::DelStash;
@@ -121,7 +121,7 @@ namespace advice {
      */
     class AdviceSystem
       : public lib::Sync<>
-      , boost::noncopyable
+      , util::NonCopyable
       {
         
         DelStash adviceDataRegistry_;

src/common/appstate.hpp

@@ -41,11 +41,11 @@
 #define LUMIERA_APPSTATE_H
 
 #include "lib/symbol.hpp"
+#include "lib/nocopy.hpp"
 #include "common/option.hpp"
 #include "common/subsys.hpp"
 #include "common/basic-setup.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 #include <string>
 #include <map>
@@ -55,7 +55,6 @@
 namespace lumiera {
   
   using std::string;
-  using boost::noncopyable;
   
   class SubsystemRunner;
   
@@ -68,7 +67,7 @@ namespace lumiera {
    * @warning don't use AppState in destructors.
    */
   class AppState
-    : private noncopyable
+    : util::NonCopyable
     {
     private:
       AppState ();

src/common/basic-setup.hpp

@@ -55,10 +55,10 @@
 
 #include "lib/error.hpp"
 #include "lib/symbol.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/util.hpp"
 
 #include <boost/program_options.hpp>
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -95,7 +95,7 @@ namespace lumiera {
    * @see AppState 
    */
   class BasicSetup
-    : boost::noncopyable
+    : util::NonCopyable
     {
         opt::options_description syntax;
         opt::variables_map settings;

src/common/guifacade.cpp

@@ -57,7 +57,7 @@ namespace gui {
   
   /** load and start the GUI as a plugin */
   struct GuiRunner
-    : boost::noncopyable
+    : util::NonCopyable
     {
       typedef InstanceHandle<LUMIERA_INTERFACE_INAME(lumieraorg_Gui, 1)> GuiHandle;
       

src/common/instancehandle.hpp

@@ -43,6 +43,7 @@
 
 #include "include/logging.h"
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "include/interfaceproxy.hpp"
 
 extern "C" {
@@ -50,7 +51,6 @@ extern "C" {
 #include "common/interfaceregistry.h"
 }
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -118,7 +118,7 @@ namespace lumiera {
      */
     template<class I, class FA>
     struct Link
-      : boost::noncopyable
+      : util::NonCopyable
       {
         typedef InstanceHandle<I,FA> IH;
         
@@ -140,7 +140,7 @@ namespace lumiera {
      */
     template<class I>
     struct Link<I,I>
-      : boost::noncopyable
+      : util::NonCopyable
       {
         typedef InstanceHandle<I,I> IH;
         
@@ -174,7 +174,7 @@ namespace lumiera {
           , class FA = I    ///< facade interface type to be used by clients
           >
   class InstanceHandle
-    : private boost::noncopyable
+    : util::NonCopyable
     { 
       LumieraInterface desc_;
       I*                instance_;

src/common/interface-facade-link.hpp

@@ -51,11 +51,11 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/meta/util.hpp"
 #include "include/interfaceproxy.hpp"
 #include "lib/symbol.hpp"
 
-#include <boost/noncopyable.hpp>
 
 
 
@@ -83,7 +83,7 @@ namespace facade {
   template<class FA>
   class InterfaceFacadeLink
     : protected Accessor<FA>
-    , boost::noncopyable
+    , util::NonCopyable
     {
       string displayName_;
       

src/common/option.hpp

@@ -74,7 +74,7 @@ namespace lumiera {
    * unrecognised parts.
    */
   class Option
-    : boost::noncopyable
+    : util::NonCopyable
     {
     public:
       Option (lib::Cmdline& cmdline);

src/common/query.hpp

@@ -123,7 +123,7 @@ namespace lumiera {
    * of the type of query.
    */
   class Goal
-    : util::no_copy_by_client
+    : util::Cloneable
     {
     public:
       virtual ~Goal(); ///< this is a marker baseclass

src/common/query/defs-manager.hpp

@@ -96,9 +96,9 @@
 
 
 #include "lib/p.hpp"
+#include "lib/nocopy.hpp"
 #include "common/query.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 
 
@@ -127,7 +127,8 @@ namespace query  {
    *       roughly final, as of 12/09 most of the actual object
    *       handling is placeholder code.
    */
-  class DefsManager : private boost::noncopyable
+  class DefsManager
+    : util::NonCopyable
     {
       unique_ptr<impl::DefsRegistry> defsRegistry_;
       

src/common/query/defs-registry.hpp

@@ -55,11 +55,11 @@
 #include "lib/format-string.hpp"
 #include "lib/query-util.hpp"
 #include "common/query.hpp"
+#include "lib/nocopy.hpp"
 
 #include <set>
 #include <vector>
 #include <memory>
-#include <boost/noncopyable.hpp>
 
 
 namespace lumiera{
@@ -193,7 +193,7 @@ namespace query  {
      * exact behaviour has to be defined.
      */
     class DefsRegistry
-      : boost::noncopyable
+      : util::NonCopyable
       {
         Table table_;
         

src/common/query/query-resolver.hpp

@@ -37,8 +37,8 @@
 
 #include "lib/iter-adapter.hpp"
 #include "common/query.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <functional>
 #include <memory>
 #include <string>
@@ -47,7 +47,6 @@ using std::function;
 
 namespace lumiera {
   
-  using boost::noncopyable;
   using std::unique_ptr;
   using std::string;
   
@@ -65,7 +64,7 @@ namespace lumiera {
    * of an individual query resolution
    */
   class Resolution
-    : boost::noncopyable
+    : util::NonCopyable
     {
     public:
       typedef Goal::Result Result;
@@ -106,7 +105,7 @@ namespace lumiera {
    * Thus the implementation might downcast query and resultset.
    */
   class QueryResolver
-    : noncopyable
+    : util::NonCopyable
     {
       unique_ptr<QueryDispatcher> dispatcher_;
       

src/common/subsys.hpp

@@ -44,8 +44,8 @@
 #define LUMIERA_SUBSYS_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <functional>
 #include <string>
 #include <vector>
@@ -55,7 +55,6 @@
 namespace lumiera {
   
   using std::string;
-  using boost::noncopyable;
   using std::function;
   
   class Option;
@@ -69,7 +68,7 @@ namespace lumiera {
    * @note synchronisation is up to the implementor.
    */
   class Subsys
-    : private noncopyable
+    : util::NonCopyable
     {
     public:
       typedef function<void(string*)> SigTerm;

src/gui/ctrl/actions.hpp

@@ -47,8 +47,8 @@
 #include "gui/workspace/workspace-window.hpp"
 #include "gui/workspace/panel-manager.hpp"
 #include "lib/format-string.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -74,7 +74,7 @@ namespace ctrl {
   * user action events.
   */
   class Actions
-    : boost::noncopyable
+    : util::NonCopyable
     {
       GlobalCtx& globalCtx_;
       

src/gui/ctrl/bus-term.hpp

@@ -60,10 +60,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/idi/entry-id.hpp"
 #include "lib/diff/gen-node.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <utility>
 #include <string>
 
@@ -103,6 +103,7 @@ namespace ctrl{
    * some element.
    */
   class BusTerm
+    : util::MoveOnly
     {
     protected:
       using EntryID = lib::idi::BareEntryID;
@@ -135,9 +136,6 @@ namespace ctrl{
       /** may be moved, but not copied,
        *  due to the embedded identity */
       BusTerm(BusTerm&&)      = default;
-      BusTerm(BusTerm const&) = delete;
-      
-      BusTerm& operator= (BusTerm const&) = delete;
       
     protected:
       /**

src/gui/ctrl/core-service.hpp

@@ -81,6 +81,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/idi/entry-id.hpp"
 #include "lib/diff/gen-node.hpp"
 #include "include/session-command-facade.h"
@@ -88,8 +89,6 @@
 #include "gui/ctrl/bus-term.hpp"
 #include "gui/ctrl/nexus.hpp"
 
-#include <boost/noncopyable.hpp>
-
 
 namespace gui {
 namespace ctrl{
@@ -107,7 +106,7 @@ namespace ctrl{
    */
   class CoreService
     : public BusTerm
-    , boost::noncopyable
+    , util::NonCopyable
     {
       
       Nexus uiBusBackbone_;

src/gui/ctrl/facade.hpp

@@ -43,8 +43,8 @@
 #define GUI_CTRL_FACADE_H
 
 #include "gui/notification-service.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 
 
 namespace gui {
@@ -59,7 +59,7 @@ namespace ctrl {
    * @remark the UiManager is responsible to activate and deactivate those interfaces
    */
   class Facade
-    : boost::noncopyable
+    : util::NonCopyable
     {
       NotificationService notificationService_;
       

src/gui/ctrl/global-ctx.hpp

@@ -59,8 +59,8 @@
 #include "gui/ctrl/window-locator.hpp"
 #include "gui/interact/wizard.hpp"
 #include "gui/interact/interaction-director.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -80,7 +80,7 @@ namespace ctrl {
    * @remark the UiManager is responsible to install this top-level context
    */
   class GlobalCtx
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/ctrl/nexus.hpp

@@ -41,6 +41,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/idi/genfunc.hpp"
 #include "lib/diff/mutation-message.hpp"
 #include "lib/diff/tree-diff-application.hpp"
@@ -48,7 +49,6 @@
 #include "gui/model/tangible.hpp"
 #include "lib/idi/entry-id.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <unordered_map>
 
 
@@ -75,7 +75,7 @@ namespace ctrl{
    */
   class Nexus
     : public BusTerm
-    , boost::noncopyable
+    , util::NonCopyable
     {
       typedef std::unordered_map<EntryID, Tangible*, EntryID::UseEmbeddedHash> RoutingTable;
       

src/gui/ctrl/panel-locator.hpp

@@ -36,8 +36,8 @@
 #define GUI_CTRL_PANEL_LOCATOR_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 #include <list>
 
@@ -57,7 +57,7 @@ namespace ctrl {
    * located within the top-level windows.
    */
   class PanelLocator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using PWindow = std::shared_ptr<workspace::WorkspaceWindow>;
       using WindowList = list<PWindow>;

src/gui/ctrl/playback-controller.hpp

@@ -42,8 +42,8 @@
 #include "gui/gtk-base.hpp"
 #include "include/dummy-player-facade.h"
 #include "include/display-facade.h"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 
 
 namespace gui {
@@ -53,7 +53,7 @@ namespace ctrl {
   
   /** @deprecated we need a durable design for the playback process */
   class PlaybackController
-    : boost::noncopyable
+    : util::NonCopyable
     {
 
       volatile bool playing_;

src/gui/ctrl/state-manager.hpp

@@ -55,8 +55,8 @@
 
 #include "lib/idi/entry-id.hpp"
 #include "lib/diff/gen-node.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -77,7 +77,7 @@ namespace ctrl {
    * element.
    */
   class StateManager
-    : boost::noncopyable
+    : util::NonCopyable
     {
     protected:
       virtual ~StateManager();    ///< this is an interface

src/gui/ctrl/state-map-grouping-storage.hpp

@@ -38,11 +38,11 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/idi/entry-id.hpp"
 #include "lib/diff/gen-node.hpp"
 #include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <unordered_map>
 #include <algorithm>
 #include <set>
@@ -72,7 +72,7 @@ namespace ctrl {
    * @see StateMapGroupingStorage_test
    */
   class StateMapGroupingStorage
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using StateData = std::set<GenNode,  GenNode::IDComparator>;
       using Storage = std::unordered_map<BareEntryID, StateData,  BareEntryID::UseEmbeddedHash>;

src/gui/ctrl/ui-dispatcher.hpp

@@ -78,8 +78,8 @@
 #include "gui/gtk-base.hpp"
 #include "lib/call-queue.hpp"
 #include "lib/format-string.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <utility>
 
 
@@ -109,7 +109,7 @@ namespace ctrl {
    *          it outlives the GTK event loop
    */
   class UiDispatcher
-    : boost::noncopyable
+    : util::NonCopyable
     {
       lib::CallQueue queue_;
       Glib::Dispatcher dispatcher_;

src/gui/ctrl/ui-manager.hpp

@@ -48,8 +48,8 @@
 #define GUI_CTRL_UI_MANAGER_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 #include <memory>
 
@@ -72,7 +72,7 @@ namespace ctrl {
   
   /** Framework initialisation base */
   class ApplicationBase
-    : boost::noncopyable
+    : util::NonCopyable
     {
     protected:
       ApplicationBase();

src/gui/ctrl/ui-state.hpp

@@ -55,8 +55,8 @@
 #define GUI__H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -82,7 +82,7 @@ namespace ctrl {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class UiState
-    : boost::noncopyable
+    : util::NonCopyable
     {
       StateManager& stateManager_;
       interact::FocusTracker& tracker_;

src/gui/ctrl/window-locator.hpp

@@ -37,8 +37,8 @@
 
 #include "gui/gtk-base.hpp"
 #include "gui/ctrl/panel-locator.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 #include <list>
 
@@ -61,7 +61,7 @@ namespace ctrl {
    * A centralised manager of all top level application windows.
    */
   class WindowLocator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using PWindow = std::shared_ptr<workspace::WorkspaceWindow>;
       

src/gui/demo-gui-roundtrip.cpp

@@ -43,8 +43,8 @@
 #include "lib/depend.hpp"
 #include "gui/ui-bus.hpp"
 #include "gui/ctrl/ui-manager.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -77,7 +77,7 @@ namespace gui {
    * @see CallQueue_test
    */
   class DemoGuiRoundtrip
-    : boost::noncopyable
+    : util::NonCopyable
     {
       string nothing_;
 

src/gui/display-service.hpp

@@ -55,10 +55,10 @@
 #include "lib/singleton-ref.hpp"
 #include "lib/scoped-ptrvect.hpp"
 #include "include/logging.h"
+#include "lib/nocopy.hpp"
 
 #include <glibmm.h>
 #include <sigc++/sigc++.h>
-#include <boost/noncopyable.hpp>
 #include <string>
 #include <vector>
 
@@ -84,7 +84,7 @@ namespace gui {
    */
   class DisplayerSlot
     : public lumiera_displaySlot,
-      boost::noncopyable
+      util::NonCopyable
     {
       Dispatcher dispatcher_;
       FrameSignal hasFrame_;
@@ -128,7 +128,7 @@ namespace gui {
    * course of the play process for outputting frames.
    */
   class DisplayService
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
       string error_;

src/gui/gtk-lumiera.cpp

@@ -55,13 +55,13 @@
 #include "gui/display-service.hpp"
 #include "backend/thread-wrapper.hpp"
 #include "common/subsys.hpp"
+#include "lib/nocopy.hpp"
 
 extern "C" {
 #include "common/interface.h"
 #include "common/interface-descriptor.h"
 }
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -89,7 +89,7 @@ namespace gui {
      *       open other interfaces here...)            ///////////////////////////TICKET #82
      */
     class GtkLumiera
-      : boost::noncopyable
+      : util::NonCopyable
       {
         UiBus uiBus_;
         UiManager uiManager_;

src/gui/guifacade.hpp

@@ -39,12 +39,12 @@
 
 
 #include "common/subsys.hpp"
+#include "lib/nocopy.hpp"
 
 extern "C" {
 #include "common/interface.h"
 }
 
-#include <boost/noncopyable.hpp>
 
 
 namespace gui {
@@ -77,7 +77,7 @@ namespace gui {
    * 
    */
   class GuiFacade
-    : boost::noncopyable
+    : util::NonCopyable
     {
     public:
       

src/gui/interact/cmd-context.cpp

@@ -34,7 +34,6 @@
 //#include "include/logging.h"
 #include "gui/interact/cmd-context.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <map>
 

src/gui/interact/cmd-context.hpp

@@ -55,13 +55,13 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 //#include "gui/ctrl/bus-term.hpp"
 //#include "lib/idi/entry-id.hpp"
 #include "lib/hash-indexed.hpp"
 #include "lib/symbol.hpp"
 //#include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -81,7 +81,7 @@ namespace interact {
    * @todo write type comment...
    */
   class CmdContext
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/interact/focus-tracker.hpp

@@ -55,8 +55,8 @@
 #define GUI_INTERACT_FOCUS_TRACKER_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -81,7 +81,7 @@ namespace interact {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class FocusTracker
-    : boost::noncopyable
+    : util::NonCopyable
     {
       Navigator& navigator_;
       

src/gui/interact/interaction-director.hpp

@@ -56,7 +56,6 @@
 //#include "gui/gtk-base.hpp"
 #include "gui/model/controller.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <cairomm/cairomm.h>
 //#include <string>
 #include <vector>

src/gui/interact/interaction-state.cpp

@@ -34,7 +34,6 @@
 //#include "include/logging.h"
 #include "gui/interact/interaction-state.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <map>
 

src/gui/interact/interaction-state.hpp

@@ -39,12 +39,12 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "gui/ctrl/bus-term.hpp"
 #include "lib/idi/entry-id.hpp"
 //#include "lib/symbol.hpp"
 //#include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -59,9 +59,10 @@ namespace interact {
   /**
    * Abstract foundation of UI state tracking components.
    * @todo write type comment...
+   * ///////////////////////////////////TODO do we need a translation unit interaction-state.cpp (otherwise delete it!)
    */
   class InteractionState
-    : boost::noncopyable
+    : util::NonCopyable
     {
     protected:
       

src/gui/interact/navigator.hpp

@@ -40,8 +40,8 @@
 
 #include "gui/gtk-base.hpp"
 #include "gui/interact/ui-coord-resolver.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -66,7 +66,7 @@ namespace interact {
    */
   class Navigator
     : public LocationQuery
-    , boost::noncopyable
+    , util::NonCopyable
     {
       SpotLocator& spotLocator_;
       ViewLocator& viewLocator_;

src/gui/interact/spot-locator.hpp

@@ -40,8 +40,8 @@
 #define GUI_INTERACT_SPOT_LOCATOR_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -62,7 +62,7 @@ namespace interact {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class SpotLocator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/interact/ui-coord.hpp

@@ -85,6 +85,7 @@
 #include "lib/error.hpp"
 #include "lib/symbol.hpp"
 #include "lib/path-array.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/util.hpp"
 
 #include <cstring>
@@ -500,6 +501,7 @@ namespace interact {
   class LocationClause;
   
   class UICoord::Builder
+    : util::MoveOnly
     {
     protected:
       UICoord uic_;
@@ -510,10 +512,6 @@ namespace interact {
       Builder (UICoord && anonRef)  : uic_{std::move(anonRef)} { }
       Builder (UICoord const& base) : uic_{base} { }
       
-      Builder (Builder const&)            = delete;
-      Builder& operator= (Builder const&) = delete;
-      Builder& operator= (Builder &&)     = delete;
-      
       /** builder instances created by UICoord */
       friend class UICoord;
 

src/gui/interact/ui-location-solver.hpp

@@ -73,8 +73,8 @@
 #include "lib/format-util.hpp"
 #include "gui/interact/ui-coord.hpp"
 #include "gui/interact/ui-coord-resolver.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <utility>
 #include <vector>
 #include <string>
@@ -103,7 +103,7 @@ namespace interact {
    * @todo maybe add a flag to require the current query goal to exist in tree //////////////////////////////TICKET #1130
    */
   struct LocationClause
-    : boost::noncopyable
+    : util::NonCopyable
     {
       UICoord pattern;
       bool createParents;
@@ -129,7 +129,7 @@ namespace interact {
    * in order and the first successfully matched clause wins.
    */
   class LocationRule
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using Clauses = std::vector<LocationClause>;
       
@@ -233,7 +233,7 @@ namespace interact {
    * @see UILocationResolver_test::simple_usage_example()
    */
   class UILocationSolver
-    : boost::noncopyable
+    : util::NonCopyable
     {
       LocationQueryAccess getLocationQuery;
       

src/gui/interact/view-locator.hpp

@@ -59,8 +59,8 @@
 #include "gui/gtk-base.hpp"
 #include "gui/interact/view-spec-dsl.hpp"
 #include "gui/id-scheme.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <functional>
 //#include <string>
 #include <memory>
@@ -87,7 +87,7 @@ namespace interact {
    * @todo initial draft as of 9/2017 -- actual implementation need to be filled in
    */
   class ViewLocator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       ctrl::GlobalCtx& globals_;
       unique_ptr<UILocationSolver> locResolver_;

src/gui/interact/wizard.hpp

@@ -43,8 +43,8 @@
 #define GUI_INTERACT_WIZARD_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -69,7 +69,7 @@ namespace interact {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class Wizard
-    : boost::noncopyable
+    : util::NonCopyable
     {
       ctrl::GlobalCtx& globalCtx_;
     

src/gui/interact/work-site-trail.hpp

@@ -41,8 +41,8 @@
 #define GUI_INTERACT_WORK_SITE_TRAIL_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -63,7 +63,7 @@ namespace interact {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class WorkSiteTrail
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/interact/work-site.hpp

@@ -46,8 +46,8 @@
 #define GUI_INTERACT_WORK_SITE_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 
@@ -70,7 +70,7 @@ namespace interact {
    * @todo initial draft as of 2/2017 -- actual implementation has to be filled in
    */
   class WorkSite
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/model/diagnostics.hpp

@@ -39,10 +39,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 //#include "lib/symbol.hpp"
 //#include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 //#include <string>
 
 
@@ -64,7 +64,7 @@ namespace model {
    * @see NA_test
    */
   class Diagnostics
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/gui/model/element.hpp

@@ -43,11 +43,11 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/hash-value.h"
 //#include "lib/symbol.hpp"
 #include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 

src/gui/model/session-facade.cpp

@@ -41,7 +41,6 @@
 #include "gui/model/session-facade.hpp"
 #include "lib/depend.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <map>
 

src/gui/model/session-facade.hpp

@@ -39,10 +39,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 //#include "lib/symbol.hpp"
 //#include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -61,7 +61,7 @@ namespace model {
    * @see NA_test
    */
   class SessionFacade
-    : boost::noncopyable
+    : util::NonCopyable
     {
       string nothing_;
       

src/gui/model/tangible.hpp

@@ -131,12 +131,12 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "gui/ctrl/bus-term.hpp"
 #include "lib/diff/diff-mutable.hpp"
 #include "lib/idi/entry-id.hpp"
 #include "lib/symbol.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <sigc++/trackable.h>
 #include <utility>
 #include <string>
@@ -156,7 +156,7 @@ namespace model {
    * which is the [UI-Bus](ui-bus.hpp). Any tangible element acquires a distinct identity
    * and has to be formed starting from an already existing bus nexus.
    * @see [explanation of the basic interactions](tangible.hpp)
-   * @warning Tangible is `noncopyable` for good reason: the UI-Bus Nexus adds a direct
+   * @warning Tangible is `NonCopyable` for good reason: the UI-Bus Nexus adds a direct
    *          reference into the routing table, tied to the given Tangible's ID (identity.
    *          Consequently you must not store tangibles in STL containers, since these
    *          might re-allocate and thus change the location in memory.
@@ -164,7 +164,7 @@ namespace model {
   class Tangible
     : public sigc::trackable
     , public lib::diff::DiffMutable
-    , boost::noncopyable
+    , util::NonCopyable
     {
     public:
       using ID = ctrl::BusTerm::ID;

src/gui/setting/asset-controller.hpp

@@ -54,7 +54,6 @@
 //#include "gui/gtk-base.hpp"
 #include "gui/model/controller.hpp"
 
-//#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <memory>
 

src/gui/ui-bus.hpp

@@ -105,8 +105,8 @@
 
 #include "gui/gtk-base.hpp"  //////////////////////////////////////////////////////TODO remove any GTK dependency if possible
 #include "gui/ctrl/playback-controller.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 
 
@@ -157,7 +157,7 @@ namespace gui {
    * and must not be accessed from anywhere else.
    */
   class UiBus
-    : boost::noncopyable
+    : util::NonCopyable
     {
       unique_ptr<ctrl::CoreService> coreService_;
       

src/gui/widget/timeline/draw-strategy.hpp

@@ -43,7 +43,7 @@ namespace timeline {
   
   /////////TODO some questions:
   /////////     1) who is allowed to destroy DrawStrategy objects
-  /////////     2) shouldn't DrawStragegy be boost::noncopyable?
+  /////////     2) shouldn't DrawStragegy be util::NonCopyable?
   
   
   /**

src/gui/widget/timeline/timeline-layout-helper.hpp

@@ -61,7 +61,7 @@ namespace gui {
    * @see gui::widget::TimelineWidget
    */
   class TimelineLayoutHelper
-    : public boost::noncopyable
+    : util::NonCopyable
     {
     public:
       /** Definition of the layout track tree type.*/

src/gui/widget/timeline/timeline-state.hpp

@@ -66,7 +66,7 @@ namespace gui {
    */
   template<class TI>
   class SelectionListener
-    : boost::noncopyable
+    : util::NonCopyable
     {
       sigc::signal<void, TI> valueChangedSignal_;
       

src/gui/workspace/style-manager.hpp

@@ -37,8 +37,8 @@
 #define GUI_WORKSPACE_STYLE_MANAGER_H
 
 #include "gui/gtk-base.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <cairomm/cairomm.h>
 #include <string>
 
@@ -64,7 +64,7 @@ namespace workspace {
    */
   class StyleManager
     : public Gtk::UIManager
-    , boost::noncopyable
+    , util::NonCopyable
     {
       
       string iconSearchPath_;

src/include/display-facade.h

@@ -54,7 +54,6 @@
 #include "include/interfaceproxy.hpp"
 #include "lib/handle.hpp"
 
-#include <boost/noncopyable.hpp>
 
 
 

src/include/lifecycle.h

@@ -41,7 +41,7 @@
 #ifdef __cplusplus
 
 #include "lib/symbol.hpp"
-#include <boost/noncopyable.hpp>
+#include "lib/nocopy.hpp"
 
 
 
@@ -74,7 +74,7 @@ namespace lumiera {
    *  @note duplicate or repeated calls with the same callback are NOP 
    */
   class LifecycleHook
-    : private boost::noncopyable
+    : util::NonCopyable
     {
     public:
       typedef void (*Hook)(void);

src/lib/allocation-cluster.hpp

@@ -48,11 +48,11 @@
 #define LIB_ALLOCATION_CLUSTER_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/sync-classlock.hpp"
 #include "lib/scoped-holder.hpp"
 #include "lib/scoped-holder-transfer.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <vector>
 
 
@@ -88,7 +88,7 @@ namespace lib {
    *          Is this issue worth the hassle?            //////////////////////////////TICKET #169
    */
   class AllocationCluster
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:

src/lib/call-queue.hpp

@@ -40,8 +40,8 @@
 #include "lib/error.hpp"
 #include "lib/sync.hpp"
 #include "lib/iter-stack.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <functional>
 
 
@@ -56,7 +56,7 @@ namespace lib {
    * their concrete parameters into another thread for invocation.
    */
   class CallQueue
-    : boost::noncopyable
+    : util::NonCopyable
     , public Sync<>
     {
     public:

src/lib/del-stash.hpp

@@ -45,10 +45,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 
 #include <vector>
 #include <algorithm>
-#include <boost/noncopyable.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 
@@ -66,7 +66,7 @@ namespace lib {
    * @warning clients must not add a given object more than once
    */
   class DelStash
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
       typedef void KillFun(void*);

src/lib/depend-inject.hpp

@@ -36,6 +36,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/depend2.hpp"
 #include "lib/meta/function.hpp"
 #include "lib/sync-classlock.hpp"
@@ -110,7 +111,7 @@ namespace lib {
       
       /**
        * Configuration handle to expose a service implementation through the `Depend<SRV>` front-end.
-       * This noncopyable (but movable) handle shall be planted within the context operating the service
+       * This non-copyable (but movable) handle shall be planted within the context operating the service
        * to be exposed. It will immediately create (in RAII style) and manage a heap-allocated instance
        * of the subclass `IMP` and expose a baseclass pointer to this specific instance through `Depend<SRV>`.
        * Moreover, the implementation subclass can be accessed through this handle, which acts as smart-ptr.
@@ -122,6 +123,7 @@ namespace lib {
        */
       template<class IMP>
       class ServiceInstance
+        : util::MoveOnly
         {
           std::unique_ptr<IMP> instance_;
           
@@ -139,10 +141,6 @@ namespace lib {
               deactivateServiceAccess();
             }
           
-          ServiceInstance (ServiceInstance&&)            = default;
-          ServiceInstance (ServiceInstance const&)       = delete;
-          ServiceInstance& operator= (ServiceInstance&&) = delete;
-          
           explicit
           operator bool()  const
             {
@@ -167,7 +165,7 @@ namespace lib {
       
       /**
        * Configuration handle for temporarily shadowing a dependency by a test mock instance.
-       * This noncopyable (but movable) handle shall be planted within the immediate test context.
+       * This non-copyable (but movable) handle shall be planted within the immediate test context.
        * It immediately stashes away the existing state and configuration from `Depend<SRV>`, but
        * waits for actual invocation of the `Depend<SRV>`-front-end to create a heap-allocated
        * instance of the `MOC` subclass, which it manages and exposes like a smart-ptr.
@@ -175,6 +173,7 @@ namespace lib {
        */
       template<class MOC>
       class Local
+        : util::MoveOnly
         {
           std::unique_ptr<MOC> mock_;
           
@@ -205,10 +204,6 @@ namespace lib {
               restoreOriginalFactory (origInstance_, origFactory_);
             }
           
-          Local (Local&&)            = default;
-          Local (Local const&)       = delete;
-          Local& operator= (Local&&) = delete;
-          
           explicit
           operator bool()  const
             {

src/lib/depend2.hpp

@@ -73,11 +73,11 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/nobug-init.hpp"
 #include "lib/sync-classlock.hpp"
 #include "lib/meta/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <type_traits>
 #include <functional>
 #include <memory>
@@ -93,7 +93,7 @@ namespace lib {
     
     template<typename TAR, typename SEL =void>
     class InstanceHolder
-      : boost::noncopyable
+      : util::NonCopyable
       {
         std::unique_ptr<TAR> instance_;
         

src/lib/dependency-factory.hpp

@@ -145,7 +145,7 @@ namespace lib {
        */
       template<typename TAR>
       class InstanceHolder
-        : boost::noncopyable
+        : util::NonCopyable
         {
           /** storage for the service instance */
           char buff_[sizeof(TAR)];

src/lib/diagnostic-context.hpp

@@ -46,9 +46,9 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/thread-local.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <nobug.h>
 
 
@@ -68,7 +68,7 @@ namespace lib {
    */
   template<typename VAL>
   class DiagnosticContext
-    : boost::noncopyable
+    : util::NonCopyable
     {
       typedef ThreadLocalPtr<DiagnosticContext> ThreadLocalAccess;
       typedef std::vector<VAL>                  ValSequence;

src/lib/diff/diff-language.hpp

@@ -85,10 +85,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/verb-token.hpp"
 #include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <tuple>
 
 
@@ -285,7 +285,7 @@ namespace diff{
    */
   template<class TAR>
   class DiffApplicator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using Interpreter = DiffApplicationStrategy<TAR>;
       

src/lib/diff/list-diff-detector.hpp

@@ -61,8 +61,8 @@
 #include "lib/diff/list-diff.hpp"
 #include "lib/diff/index-table.hpp"
 #include "lib/iter-adapter.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <utility>
 
 
@@ -85,7 +85,7 @@ namespace diff{
    */
   template<class SEQ>
   class DiffDetector
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using Val = typename SEQ::value_type;
       using Idx = IndexTable<Val>;

src/lib/diff/record.hpp

@@ -87,6 +87,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/iter-adapter.hpp"
 #include "lib/iter-adapter-stl.hpp"
 #include "lib/itertools.hpp"
@@ -94,8 +95,6 @@
 #include "lib/util.hpp"
 
 
-#include <boost/noncopyable.hpp>
-
 #include <algorithm>
 #include <utility>
 #include <vector>
@@ -399,7 +398,7 @@ namespace diff{
   
   template<typename VAL>
   class Record<VAL>::Mutator
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using Rec = Record<VAL>;
       

src/lib/diff/test-mutation-target.hpp

@@ -53,9 +53,9 @@
 #include "lib/format-string.hpp"
 #include "lib/format-util.hpp"
 #include "lib/test/event-log.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <utility>
 #include <string>
 #include <vector>
@@ -193,7 +193,7 @@ namespace diff{
    * @see TreeMutatorBinding_test::mutateDummy()
    */
   class TestMutationTarget
-    : boost::noncopyable
+    : util::NonCopyable
     {
       using VecG = std::vector<GenNode>;
       

src/lib/diff/tree-diff-application.hpp

@@ -153,7 +153,7 @@ namespace diff{
    * TreeMutators dedicated to nested scopes
    */
   class ScopeManager
-    : boost::noncopyable
+    : util::NonCopyable
     {
     public:
       virtual ~ScopeManager();  ///< this is an interface

src/lib/diff/tree-mutator-collection-binding.hpp

@@ -52,6 +52,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/meta/trait.hpp"
 #include "lib/diff/gen-node.hpp"
 #include "lib/diff/tree-mutator.hpp"
@@ -96,6 +97,7 @@ namespace diff{
      */
     template<class COLL, class MAT, class CTR, class SEL, class ASS, class MUT>
     struct CollectionBinding
+      : util::MoveOnly
       {
         using Coll = typename Strip<COLL>::TypeReferred;
         using Elm  = typename Coll::value_type;
@@ -128,10 +130,8 @@ namespace diff{
           , openSub(u)
           { }
         
-        // allow move construction only,
+        // only move construction allowed,
         // to enable use of unique_ptr in collections
-        CollectionBinding(CollectionBinding&&) = default;
-        CollectionBinding(CollectionBinding&) = delete;
         
         
         
@@ -172,7 +172,7 @@ namespace diff{
           }
         
         
-      private: /* === technicallities of container access === */
+      private: /* === Technicalities of container access === */
         
         /** @internal technicality
          * Our iterator is actually a Lumiera RangeIter, and thus we need

src/lib/diff/tree-mutator.hpp

@@ -94,6 +94,7 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/symbol.hpp"
 #include "lib/meta/trait.hpp"
 #include "lib/diff/gen-node.hpp"
@@ -139,18 +140,15 @@ namespace diff{
    *   activities to concrete manipulations known within target scope.
    */
   class TreeMutator
+    : util::MoveOnly
     {
       
     public:
       virtual ~TreeMutator(); ///< this is an interface
       
-      /** only allow default and move construction */
+      // only default and move construction allowed
       TreeMutator ()                    =default;
       TreeMutator (TreeMutator&&)       =default;
-      TreeMutator (TreeMutator const&)  =delete;
-      
-      TreeMutator& operator= (TreeMutator const&) =delete;
-      TreeMutator& operator= (TreeMutator&&)      =delete;
       
       
       

src/lib/format-string.hpp

@@ -106,10 +106,10 @@
 #define UTIL_FORMAT_STRING_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/meta/util.hpp"
 #include "lib/meta/size-trait.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <string>
 
 
@@ -152,7 +152,7 @@ namespace util {
    * @see FormatString_test
    */
   class _Fmt
-    : boost::noncopyable
+    : util::NonCopyable
     {
       /** size of an opaque implementation Buffer */
       enum{ FORMATTER_SIZE = lib::meta::SizeTrait::BOOST_FORMAT };

src/lib/iter-source.hpp

@@ -55,8 +55,8 @@
 #include "lib/meta/util.hpp"
 #include "lib/iter-adapter.hpp"
 #include "lib/itertools.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <type_traits>
 #include <utility>
 #include <string>
@@ -232,7 +232,7 @@ namespace lib {
   template<class IT,  class ISO = IterSource<typename IT::value_type>>
   class WrappedLumieraIter
     : public ISO
-    , boost::noncopyable
+    , util::NonCopyable
     {
       IT src_;
       

src/lib/iter-stack.hpp

@@ -245,7 +245,7 @@ namespace lib {
        * to prepare and pre-fill a sequence
        */
       struct Builder
-        : util::no_copy_by_client
+        : util::Cloneable
         {
           Builder(IterQueue& initialElements)
             : queue_(initialElements)

src/lib/lifecycleregistry.hpp

@@ -40,8 +40,8 @@
 
 
 #include "lib/util.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <functional>
 #include <string>
 #include <set>
@@ -50,7 +50,6 @@
 
 namespace lumiera {
   
-  using boost::noncopyable;
   using util::contains;
   using std::function;
   using std::string;
@@ -64,7 +63,7 @@ namespace lumiera {
    * to implement the lumiera lifecycle (init, shutdown) hooks.
    */
   class LifecycleRegistry
-    : private noncopyable
+    : util::NonCopyable
     {
     public:
       typedef void (*Hook)(void);

src/lib/linked-elements.hpp

@@ -61,10 +61,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/iter-adapter.hpp"
 #include "lib/util.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <boost/static_assert.hpp>
 
 
@@ -315,7 +315,7 @@ namespace lib {
     , class ALO = linked_elements::OwningHeapAllocated
     >
   class LinkedElements
-    : boost::noncopyable
+    : util::NonCopyable
     , ALO
     {
       N* head_;

src/lib/meta/tuple-record-init.hpp

@@ -98,7 +98,7 @@ namespace meta {
      */
     template<typename TAR>
     struct GenNodeAccessor
-      : boost::noncopyable
+      : util::NonCopyable
       {
         
         template<typename TY>

src/lib/meta/virtual-copy-support.hpp

@@ -45,7 +45,7 @@
  **   - full copy support
  **   - copy construction but no assignment
  **   - only move construction allowed
- **   - noncopyable type
+ **   - non-copyable type
  ** - we use type traits and a policy template to pick the correct implementation
  **   for a given data type. Any assignment or copy operations not supported by the
  **   target type will be replaced by an implementation which raises a runtime error

src/lib/nobug-resource-handle-context.hpp

@@ -45,9 +45,9 @@
 
 
 #include "lib/error.hpp"
+#include "lib/diagnostic-context.hpp"
 #include "lib/thread-local.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <nobug.h>
 
 
@@ -77,7 +77,7 @@ namespace lib {
    * Disabled placeholder for the Diagnostic context, not used in release builds.
    */
   class NobugResourceHandleContext
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
       typedef nobug_resource_user* Handle;

src/lib/nocopy.hpp

@@ -23,44 +23,66 @@
 
 /** @file nocopy.hpp
  ** Mix-Ins to allow or prohibit various degrees of copying and cloning.
- ** @todo 2016 this could be organised way better. Also C++11 offers a way more
+ ** Whenever a class is conceived as entity with a well-defined "identity",
- **       elegant way of expressing the intention. We could get rid of `boost::noncopyable`
+ ** or whenever a service has to manage resources, we consider it good practice
- **       The basic idea of using a marker mixin seems very reasonable though.     ////////////////////////////TICKET #1084
+ ** to define it by default as "non copyable". This rules out a lot of complexities
+ ** with mutable state and confusion regarding equality.
+ ** @remark inspired by [Boost-Noncopyable]
+ ** 
+ ** [Boost-Noncopyable]: http://www.boost.org/doc/libs/1_55_0/libs/utility/utility.htm#Class_noncopyable
  */
 
 
 #ifndef LIB_NOCOPY_H
 #define LIB_NOCOPY_H
 
-#include <boost/noncopyable.hpp>
-
 
 
 namespace util {
   
   /**
-   * any copy and copy construction prohibited
+   * Any copy and copy construction prohibited
    */
-  class no_copy
+  class NonCopyable
-    : boost::noncopyable
+    {
-    { };
+    protected:
+     ~NonCopyable()                               = default;
+      NonCopyable()                               = default;
+      NonCopyable (NonCopyable const&)            = delete;
+      NonCopyable& operator= (NonCopyable const&) = delete;
+    };
   
   /**
-   * classes inheriting from this mixin
+   * Types marked with this mix-in may be moved but not copied
-   * may be created by copy-construction,
-   * but any copy-assignment is prohibited.
-   * @note especially this allows returning
-   *       by-value from a builder function,
-   *       while prohibiting any further copy
    */
-  class no_copy_by_client
+  class MoveOnly
     {
-     protected:
+    protected:
-       ~no_copy_by_client() {}
+     ~MoveOnly()                              = default;
-        no_copy_by_client() {}
+      MoveOnly()                              = default;
-        no_copy_by_client (no_copy_by_client const&) {}
+      MoveOnly (MoveOnly&&)                   = default;
-        no_copy_by_client const&
+      MoveOnly (MoveOnly const&)              = delete;
-        operator=(no_copy_by_client const&) { return *this; }
+      MoveOnly& operator= (MoveOnly&&)        = delete;
+      MoveOnly& operator= (MoveOnly const&)   = delete;
+    };
+  
+  /**
+   * Types marked with this mix-in may be created by
+   * copy-construction (or move construction),
+   * but may be not reassigned thereafter.
+   * @remark especially this allows returning
+   *         by-value from a builder function,
+   *         while prohibiting any further copy
+   */
+  class Cloneable
+    {
+    protected:
+     ~Cloneable()                             = default;
+      Cloneable()                             = default;
+      Cloneable (Cloneable&&)                 = default;
+      Cloneable (Cloneable const&)            = default;
+      Cloneable& operator= (Cloneable&&)      = delete;
+      Cloneable& operator= (Cloneable const&) = delete;
     };
   
 } // namespace util

src/lib/opaque-holder.hpp

@@ -68,13 +68,13 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/access-casted.hpp"
 #include "lib/meta/util.hpp"
 #include "lib/util.hpp"
 
-#include <utility>
 #include <type_traits>
-#include <boost/noncopyable.hpp>
+#include <utility>
 
 
 namespace lib {
@@ -593,7 +593,7 @@ namespace lib {
     , class DEFAULT = BA
     >
   class InPlaceBuffer
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
       mutable char buf_[siz];

src/lib/ref-array.hpp

@@ -32,7 +32,7 @@
 #define LIB_REF_ARRAY_H
 
 
-#include <boost/noncopyable.hpp>
+#include "lib/nocopy.hpp"
 
 
 namespace lib {
@@ -46,7 +46,7 @@ namespace lib {
    */
   template<class T>
   class RefArray
-    : boost::noncopyable
+    : util::NonCopyable
     {
     public:
       virtual ~RefArray() {}  ///< this is an interface

src/lib/scoped-collection.hpp

@@ -21,7 +21,7 @@
 */
 
 /** @file scoped-collection.hpp
- ** Managing a collection of noncopyable polymorphic objects in compact storage.
+ ** Managing a collection of non-copyable polymorphic objects in compact storage.
  ** This helper supports the frequently encountered situation where a service
  ** implementation internally manages a collection of implementation related
  ** sub-components with reference semantics. Typically, those objects are
@@ -70,10 +70,10 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/meta/trait.hpp"
 #include "lib/iter-adapter.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <type_traits>
 
 
@@ -86,7 +86,7 @@ namespace lib {
   
   
   /**
-   * A fixed collection of noncopyable polymorphic objects.
+   * A fixed collection of non-copyable polymorphic objects.
    * 
    * All child objects reside in a common chunk of storage
    * and are owned and managed by this collection holder.
@@ -99,7 +99,7 @@ namespace lib {
     , size_t siz = sizeof(I)
     >
   class ScopedCollection
-    : boost::noncopyable
+    : util::NonCopyable
     {
       
     public:
@@ -110,7 +110,7 @@ namespace lib {
        * @note doesn't manage the Child
        */
       class ElementHolder
-        : boost::noncopyable
+        : util::NonCopyable
         {
           
           mutable char buf_[siz];

src/lib/scoped-ptrvect.hpp

@@ -49,12 +49,12 @@
 
 #include "include/logging.h"
 #include "lib/iter-adapter-ptr-deref.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/error.hpp"
 #include "lib/util.hpp"
 
 #include <vector>
 #include <algorithm>
-#include <boost/noncopyable.hpp>
 
 
 namespace lib {
@@ -70,7 +70,7 @@ namespace lib {
   template<class T>
   class ScopedPtrVect
     : std::vector<T*>,
-      boost::noncopyable
+      util::NonCopyable
     {
       typedef std::vector<T*> _Vec;
       typedef typename _Vec::iterator VIter;

src/lib/searchpath.hpp

@@ -34,8 +34,8 @@
 #define COMMON_SEARCHPATH_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/regex.hpp>
 #include <string>
@@ -74,7 +74,7 @@ namespace lib {
    * @note #next picks the current component and advances the iteration. 
    */
   class SearchPathSplitter
-    : boost::noncopyable
+    : util::NonCopyable
     {
       string pathSpec_;
       sregex_iterator pos_,

src/lib/singleton-ref.hpp

@@ -42,8 +42,7 @@
 
 
 #include "lib/error.hpp"
-
+#include "lib/nocopy.hpp"
-#include <boost/noncopyable.hpp>
 
 
 namespace lib {
@@ -56,7 +55,7 @@ namespace lib {
      */
     template<class TY>
     class AccessAsReference
-      : boost::noncopyable
+      : util::NonCopyable
       {
         TY* obj_;
         
@@ -106,7 +105,7 @@ namespace lib {
    * @param Accessor how to implement the static instance access
    */
   template< class TY
-          , class B                       = boost::noncopyable
+          , class B                       = util::NonCopyable
           , template<class> class Access  = singleton::AccessAsReference
           >
   struct SingletonRef

src/lib/symbol-table.hpp

@@ -50,8 +50,8 @@
 
 #include "lib/sync.hpp"
 #include "lib/symbol.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <unordered_set>
 #include <utility>
 #include <string>
@@ -72,7 +72,7 @@ namespace lib {
    */
   class SymbolTable
     : public Sync<>
-    , boost::noncopyable
+    , util::NonCopyable
     {
       std::unordered_set<string> table_;
       

src/lib/sync.hpp

@@ -68,13 +68,13 @@
 #define LIB_SYNC_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/util.hpp"
 
 extern "C" {
 #include "lib/lockerror.h"
 }
 
-#include <boost/noncopyable.hpp>
 #include <pthread.h>
 #include <cerrno>
 #include <ctime>
@@ -440,7 +440,7 @@ namespace lib {
        * scoped object to control the actual locking.
        */
       class Lock
-        : boost::noncopyable
+        : util::NonCopyable
         {
           Monitor& mon_;
           

src/lib/test/depend-4test.hpp

@@ -35,7 +35,6 @@
 #include "lib/depend.hpp"
 #include "lib/meta/duck-detector.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <memory>
 
 
@@ -100,7 +99,7 @@ namespace test{
    */
   template<class TYPE>
   struct Depend4Test
-    : boost::noncopyable
+    : util::NonCopyable
     {
       typedef typename ServiceInterface<TYPE>::Type Interface;
       

src/lib/test/testdummy.hpp

@@ -29,8 +29,8 @@
  */
 
 
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <algorithm>
 
 
@@ -39,7 +39,7 @@ namespace test{
     
   
   class Dummy 
-    : boost::noncopyable
+    : util::NonCopyable
     {
       int val_;
       

src/lib/test/testoption.hpp

@@ -30,6 +30,7 @@
 #define TESTHELPER_TESTOPTION_H
 
 #include "lib/cmdline.hpp"
+#include "lib/nocopy.hpp"
 
 #include <string>
 #include <iostream>
@@ -55,7 +56,8 @@ namespace test {
    * vector will contain only the remaining
    * unrecognised parts.
    */
-  class TestOption : private boost::noncopyable
+  class TestOption
+    : util::NonCopyable
     {
     public:
       TestOption (lib::Cmdline& cmdline);

src/lib/thread-local.hpp

@@ -28,6 +28,7 @@
  ** 
  ** @todo care for unit test coverage
  ** @todo WIP-WIP. Maybe add facilities similar to boost::specific_ptr
+ ** @deprecated C++11 has a `thread_local` storage class...
  **/
 
 
@@ -36,8 +37,8 @@
 
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 
-#include <boost/noncopyable.hpp>
 #include <pthread.h>
 
 
@@ -54,7 +55,7 @@ namespace lib {
    */
   template<typename TAR>
   class ThreadLocalPtr
-    : boost::noncopyable
+    : util::NonCopyable
     {
       pthread_key_t key_;
       

src/lib/time/mutation.hpp

@@ -62,11 +62,11 @@
 #define LIB_TIME_MUTATION_H
 
 #include "lib/error.hpp"
+#include "lib/nocopy.hpp"
 #include "lib/time/timevalue.hpp"
 #include "lib/polymorphic-value.hpp"
 #include "lib/symbol.hpp"
 
-#include <boost/noncopyable.hpp>
 
 
 namespace lib {