Switch from TR1 preveiw to the new standard headers

- functional
- memory
- unordered collections

research/try.cpp

@@ -53,15 +53,15 @@
 #include "lib/meta/tuple.hpp"
 #include "lib/meta/function-closure.hpp"
 
-//#include <tr1/functional>
+//#include <functional>
 #include <iostream>
 
 using lib::meta::Types;
 using lib::meta::Tuple;
-//using std::tr1::placeholders::_1;
-//using std::tr1::placeholders::_2;
-using std::tr1::function;
-using std::tr1::bind;
+//using std::placeholders::_1;
+//using std::placeholders::_2;
+using std::function;
+using std::bind;
 
 using std::string;
 using std::cout;

src/backend/real-clock.hpp

@@ -52,13 +52,13 @@
 //#include <boost/noncopyable.hpp>
 //#include <string>
 //#include <vector>
-//#include <tr1/memory>
+//#include <memory>
 //#include <boost/scoped_ptr.hpp>
 
 //namespace lib {
 //namespace time{
 //  class Quantiser;
-//  typedef std::tr1::shared_ptr<const Quantiser> PQuant;
+//  typedef std::shared_ptr<const Quantiser> PQuant;
 //}}
 
 namespace backend {
@@ -68,7 +68,7 @@ namespace backend {
 //using std::string;
 
 //using std::vector;
-//using std::tr1::shared_ptr;
+//using std::shared_ptr;
 //using boost::scoped_ptr;
   
   

src/backend/thread-wrapper.hpp

@@ -36,14 +36,14 @@ extern "C" {
 }
 #include "backend/threadpool-init.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <boost/noncopyable.hpp>
 
 
 namespace backend {
   
-  using std::tr1::bind;
-  using std::tr1::function;
+  using std::bind;
+  using std::function;
   using lib::Literal;
   namespace error = lumiera::error;
   using error::LUMIERA_ERROR_STATE;

src/common/advice/index.hpp

@@ -96,7 +96,7 @@
 #include "common/advice/binding.hpp"
 
 #include <boost/operators.hpp>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <iostream>
 #include <string>
 
@@ -105,8 +105,8 @@ namespace advice {
   
   namespace error = lumiera::error;
   
-  using std::tr1::placeholders::_1;
-  using std::tr1::unordered_map;
+  using std::placeholders::_1;
+  using std::unordered_map;
   using lib::iter_stl::eachVal;
   using lib::iter_stl::eachElm;
   using util::for_each;

src/common/guifacade.cpp

@@ -30,7 +30,7 @@
 #include "common/instancehandle.hpp"
 
 #include <boost/scoped_ptr.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <string>
 
 
@@ -38,8 +38,8 @@ namespace gui {
   
   using std::string;
   using boost::scoped_ptr;
-  using std::tr1::bind;
-  using std::tr1::placeholders::_1;
+  using std::bind;
+  using std::placeholders::_1;
   using lumiera::Subsys;
   using lumiera::InstanceHandle;
   using util::dispatchSequenced;

src/common/query.hpp

@@ -87,7 +87,7 @@
 
 #include <boost/lexical_cast.hpp>
 #include <boost/operators.hpp>
-#include <tr1/memory>
+#include <memory>
 #include <typeinfo>
 #include <cctype>
 #include <string>
@@ -113,7 +113,7 @@ namespace lumiera {
 
   
   /** Allow for taking ownership of a result set */
-  typedef std::tr1::shared_ptr<Resolution> PReso;
+  typedef std::shared_ptr<Resolution> PReso;
 
   
   

src/common/query/defs-registry.hpp

@@ -58,7 +58,7 @@
 
 #include <set>
 #include <vector>
-#include <tr1/memory>
+#include <memory>
 #include <boost/utility.hpp>
 #include <boost/lambda/lambda.hpp>
 
@@ -68,7 +68,7 @@ namespace query  {
   
   using lib::P;
   using lib::ClassLock;
-  using std::tr1::weak_ptr;
+  using std::weak_ptr;
   
   using std::string;
   using boost::lambda::_1;

src/common/query/query-resolver.hpp

@@ -29,11 +29,11 @@
 
 #include <boost/noncopyable.hpp>
 #include <boost/scoped_ptr.hpp>
-#include <tr1/functional>
-#include <tr1/memory>
+#include <functional>
+#include <memory>
 #include <string>
 
-using std::tr1::function;
+using std::function;
 
 namespace lumiera {
   
@@ -47,7 +47,7 @@ namespace lumiera {
   class QueryDispatcher;
   
   /** Allow for taking ownership of a result set */
-  typedef std::tr1::shared_ptr<Resolution> PReso;
+  typedef std::shared_ptr<Resolution> PReso;
   
   
   /** 

src/common/subsys.hpp

@@ -47,7 +47,7 @@
 #include "common/option.hpp"
 
 #include <boost/noncopyable.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <string>
 #include <vector>
 
@@ -57,7 +57,7 @@ namespace lumiera {
   
   using std::string;
   using boost::noncopyable;
-  using std::tr1::function;
+  using std::function;
   
   
   

src/common/subsystem-runner.hpp

@@ -30,16 +30,16 @@
 #include "common/subsys.hpp"
 #include "lib/sync.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <vector>
 #include <string>
 
 
 namespace lumiera {
 
-  using std::tr1::bind;
-  using std::tr1::function;
-  using std::tr1::placeholders::_1;
+  using std::bind;
+  using std::function;
+  using std::placeholders::_1;
   using std::vector;
   using std::string;
   using util::cStr;

src/gui/gtk-lumiera.hpp

@@ -55,13 +55,13 @@
 #include "gui/window-manager.hpp"
 
 #include <boost/noncopyable.hpp>
-#include <tr1/memory>
+#include <memory>
 #include <vector>
 
 
 namespace gui {
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 
 

src/gui/guistart.cpp

@@ -62,14 +62,14 @@ extern "C" {
 #include "common/interfacedescriptor.h"
 }
 
-#include <tr1/functional>
+#include <functional>
 #include <string>
 
 
 
 using std::string;
 using backend::Thread;
-using std::tr1::bind;
+using std::bind;
 using lumiera::Subsys;
 using lumiera::error::LUMIERA_ERROR_STATE;
 using gui::LUMIERA_INTERFACE_INAME(lumieraorg_Gui, 1);

src/gui/model/clip-track.cpp

@@ -24,7 +24,6 @@
 
 #include "clip.hpp"
 
-using namespace std::tr1;
 
 namespace gui {
 namespace model {

src/gui/model/parent-track.cpp

@@ -23,7 +23,7 @@
 #include "parent-track.hpp"
 #include <boost/foreach.hpp>
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace model {
@@ -73,18 +73,18 @@ ParentTrack::find_descendant_track_parent(shared_ptr<Track> child)
   using namespace boost;
 
   REQUIRE(child != NULL);
-  BOOST_FOREACH(std::tr1::shared_ptr<Track> track, tracks)
+  BOOST_FOREACH(std::shared_ptr<Track> track, tracks)
     {
       if(track == child)
         return shared_from_this();
 
-      std::tr1::shared_ptr<ParentTrack> result =
+      std::shared_ptr<ParentTrack> result =
         track->find_descendant_track_parent(child);
       if(result)
         return result;
     }
   
-  return std::tr1::shared_ptr<ParentTrack>();
+  return std::shared_ptr<ParentTrack>();
 }
 
 }   // namespace model

src/gui/model/parent-track.hpp

@@ -40,7 +40,7 @@ namespace model {
  */
 class ParentTrack :
   public Track,
-  public std::tr1::enable_shared_from_this<ParentTrack>
+  public std::enable_shared_from_this<ParentTrack>
 {
 protected:
   /**

src/gui/model/project.cpp

@@ -20,13 +20,12 @@
 
 * *****************************************************/
 
-#include <boost/foreach.hpp>
 
 #include "project.hpp"
 #include "sequence.hpp"
 
-using namespace std;
-using namespace std::tr1;
+#include <memory>
+
 
 namespace gui {
 namespace model {
@@ -52,7 +51,7 @@ Project::get_sequences()
 void
 Project::add_new_sequence(uString name)
 {
-  shared_ptr<Sequence> sequence(new Sequence());
+  std::shared_ptr<Sequence> sequence(new Sequence());
   sequence->set_name(name);
   sequences.push_back(sequence);
 }

src/gui/model/sequence.cpp

@@ -23,11 +23,12 @@
 #include "sequence.hpp"
 #include "include/logging.h"
 
+#include <memory>
+
 // TEST CODE
 #include "group-track.hpp"
 #include "clip-track.hpp"
 
-using namespace std::tr1;
 
 namespace gui {
 namespace model {
@@ -37,8 +38,8 @@ Sequence::Sequence()
   // TEST CODE
   static bool first = true;
   
-  shared_ptr<GroupTrack> group_track, group_track2;
-  shared_ptr<ClipTrack> clip_track;
+  std::shared_ptr<GroupTrack> group_track, group_track2;
+  std::shared_ptr<ClipTrack> clip_track;
   tracks.push_back(group_track = shared_ptr<GroupTrack>(new GroupTrack()));
   group_track->set_name("Group Track");
     

src/gui/model/track.cpp

@@ -22,16 +22,22 @@
 
 #include "track.hpp"
 #include "parent-track.hpp"
-#include <boost/foreach.hpp>
 
-using namespace std::tr1;
-using namespace std;
+#include <boost/foreach.hpp>
+#include <memory>
+#include <string>
+#include <list>
 
 namespace gui {
 namespace model {
   
+using std::list;
+using std::string;
+using std::shared_ptr;
+
 const list< shared_ptr<Track> > Track::NoChildren;
 
+
 Track::Track()
   : enabled(true),
     locked(false)
@@ -40,7 +46,7 @@ Track::Track()
 Track::~Track() { }
 
 
-const std::list< shared_ptr<Track> >&
+const list< shared_ptr<Track> >&
 Track::get_child_tracks() const
 {
   return Track::NoChildren;
@@ -98,8 +104,7 @@ Track::print_branch()
 }
 
 shared_ptr<ParentTrack>
-Track::find_descendant_track_parent(
-  shared_ptr<Track> /*child*/)
+Track::find_descendant_track_parent (shared_ptr<Track>)
 { 
   return shared_ptr<ParentTrack>();
 }
@@ -123,7 +128,7 @@ Track::signalNameChanged() const
 }
 
 string
-Track::print_branch_recursive(const unsigned int indentation)
+Track::print_branch_recursive (const unsigned int indentation)
 {
   string str;
   

src/gui/panels/timeline-panel.cpp

@@ -39,8 +39,8 @@ using namespace gui::widgets;
 using namespace gui::widgets::timeline;
 using namespace gui::model;
 
-using std::tr1::shared_ptr;
-using std::tr1::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
 using util::contains;
 
 namespace gui {

src/gui/panels/timeline-panel.hpp

@@ -36,14 +36,14 @@
 
 #include "lib/time/timevalue.hpp"
 
-#include <tr1/memory>
+#include <memory>
 
 using namespace gui::widgets;
 
 namespace gui {
   
-using std::tr1::shared_ptr;
-using std::tr1::weak_ptr;
+using std::shared_ptr;
+using std::weak_ptr;
 
 
 namespace model {

src/gui/widgets/timeline-widget.cpp

@@ -24,16 +24,16 @@
 
 #include <boost/foreach.hpp>
 #include <typeinfo>
-
-using namespace Gtk;
-using namespace std;
-using namespace std::tr1;
-
-using namespace util;
-using namespace gui::widgets::timeline;
+#include <memory>
 
 using lib::time::Time;
 using lib::time::TimeValue;
+using std::dynamic_pointer_cast;
+
+using namespace Gtk;
+
+using namespace util;
+using namespace gui::widgets::timeline;
 
 namespace gui {
 namespace widgets {

src/gui/widgets/timeline-widget.hpp

@@ -42,11 +42,14 @@
 
 #include "lib/time/timevalue.hpp"
 
+#include <memory>
+
 
 namespace gui {
 namespace widgets {
 
 using lib::time::Time;
+using std::shared_ptr;
 
   
 /**

src/gui/widgets/timeline/timeline-body.cpp

@@ -37,7 +37,7 @@ using namespace std;
 using namespace lumiera;
 
 using gui::util::CairoUtil;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace widgets {

src/gui/widgets/timeline/timeline-clip-track.cpp

@@ -28,7 +28,7 @@
 
 using namespace Gtk;
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using util::contains;
 
 namespace gui {
@@ -115,7 +115,7 @@ namespace timeline {
   shared_ptr<model::ClipTrack>
   ClipTrack::getModelTrack ()
   {
-    return std::tr1::dynamic_pointer_cast<model::ClipTrack>(modelTrack);
+    return std::dynamic_pointer_cast<model::ClipTrack>(modelTrack);
   }
 
   void

src/gui/widgets/timeline/timeline-clip.cpp

@@ -27,7 +27,7 @@ namespace gui {
 namespace widgets {
 namespace timeline {
   
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   
 
   Clip::Clip (shared_ptr<model::Clip> clip,

src/gui/widgets/timeline/timeline-entity.hpp

@@ -31,7 +31,7 @@
 #include "lib/time/timevalue.hpp"
 
 #include <string>
-#include <tr1/memory>
+#include <memory>
 #include <cairomm/cairomm.h>
 
 
@@ -40,7 +40,7 @@ namespace widgets {
 namespace timeline {
   
   using lib::time::Time;
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   
   
   class DrawStrategy;

src/gui/widgets/timeline/timeline-group-track.cpp

@@ -24,7 +24,6 @@
 #include "gui/widgets/timeline-widget.hpp"
 
 using namespace Gtk;
-using namespace std::tr1;
 using namespace sigc;
 
 namespace gui {
@@ -32,7 +31,7 @@ namespace widgets {
 namespace timeline {
   
 GroupTrack::GroupTrack(TimelineWidget &timeline_widget,
-  shared_ptr<model::GroupTrack> track) :
+  std::shared_ptr<model::GroupTrack> track) :
   Track(timeline_widget, track)
 { 
   REQUIRE (track);

src/gui/widgets/timeline/timeline-header-container.cpp

@@ -28,9 +28,12 @@
 #include "gui/widgets/timeline-widget.hpp"
 #include "gui/util/rectangle.hpp"
 
+#include <memory>
+
+using std::pair;
+using std::shared_ptr;
+
 using namespace Gtk;
-using namespace std;
-using namespace std::tr1;
 using namespace util;
 
 namespace gui {

src/gui/widgets/timeline/timeline-header-widget.cpp

@@ -30,7 +30,7 @@ using namespace Gtk;
 using namespace std;
 using namespace util;
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace widgets {

src/gui/widgets/timeline/timeline-ibeam-tool.cpp

@@ -27,7 +27,7 @@
 using namespace gui::widgets;
 
 using lib::time::Mutation;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace widgets {

src/gui/widgets/timeline/timeline-layout-helper.cpp

@@ -21,16 +21,19 @@
 
 * *****************************************************/
 
-#include <boost/foreach.hpp>
 
 #include "timeline-layout-helper.hpp"
 #include "gui/widgets/timeline-widget.hpp"
 #include "gui/model/sequence.hpp"
 #include "gui/util/rectangle.hpp"
 
+#include <boost/foreach.hpp>
+#include <memory>
+
+using std::pair;
+using std::shared_ptr;
+
 using namespace Gtk;
-using namespace std;
-using namespace std::tr1;
 using namespace lumiera;
 using namespace util;
 using namespace gui::util;
@@ -82,7 +85,7 @@ TimelineLayoutHelper::add_branch(
 
 boost::optional<Gdk::Rectangle>
 TimelineLayoutHelper::get_track_header_rect(
-  std::tr1::weak_ptr<timeline::Track> track)
+  std::weak_ptr<timeline::Track> track)
 {
   if(contains(headerBoxes, track))
   {

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

@@ -30,6 +30,7 @@
 #include "gui/gtk-lumiera.hpp"
 #include "lib/tree.hpp"
 
+#include <memory>
 #include <boost/optional.hpp>
 
 namespace gui {
@@ -45,6 +46,8 @@ class TimelineWidget;
   
 namespace timeline {
   
+using std::shared_ptr;
+  
 class Track;
 
 /**
@@ -59,7 +62,7 @@ public:
   /**
    * Definition of the layout track tree type.
    */
-  typedef lib::Tree< std::tr1::shared_ptr<model::Track> > TrackTree;
+  typedef lib::Tree< std::shared_ptr<model::Track> > TrackTree;
   
 public:
   /**
@@ -101,7 +104,7 @@ public:
    * @see update_layout()
    */
   boost::optional<Gdk::Rectangle> get_track_header_rect(
-    std::tr1::weak_ptr<timeline::Track> track);
+    std::weak_ptr<timeline::Track> track);
   
   /**
    * Searches for a header which has the specified point inside of it.
@@ -363,7 +366,7 @@ protected:
    * the update_layout method.
    * @see update_layout()
    */
-  std::map<std::tr1::weak_ptr<timeline::Track>, Gdk::Rectangle>
+  std::map<std::weak_ptr<timeline::Track>, Gdk::Rectangle>
     headerBoxes;
   
   /**

src/gui/widgets/timeline/timeline-ruler.cpp

@@ -36,7 +36,7 @@ using namespace gui;
 using namespace gui::widgets;
 using namespace gui::widgets::timeline;
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 using gui::util::CairoUtil;
 using lib::time::Time;
 using lib::time::TimeVar;

src/gui/widgets/timeline/timeline-state.cpp

@@ -38,7 +38,7 @@ using lib::time::Offset;
 using lib::time::Duration;
 using lib::time::Mutation;
 using lib::time::Control;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 
 TimelineState::TimelineState (shared_ptr<model::Sequence> source_sequence)

src/gui/widgets/timeline/timeline-tool.cpp

@@ -24,7 +24,7 @@
 #include "gui/widgets/timeline-widget.hpp"
 
 using namespace Gdk;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace widgets {

src/gui/widgets/timeline/timeline-track.cpp

@@ -29,7 +29,7 @@
 using namespace Gtk;
 using namespace sigc;
 
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 namespace gui {
 namespace widgets {

src/gui/window-manager.cpp

@@ -28,13 +28,15 @@
 #include "lib/util.hpp"
 
 #include <boost/filesystem.hpp>
+#include <memory>
+#include <list>
 
 using util::cStr;
+using std::list;
+using std::shared_ptr;
 
 using namespace Gtk;
 using namespace Glib;
-using namespace std;
-using namespace std::tr1;
 using namespace gui::workspace;
 
 namespace fsys = boost::filesystem;

src/gui/window-manager.hpp

@@ -41,12 +41,12 @@
 #include <boost/noncopyable.hpp>
 #include <cairomm/cairomm.h>
 #include <string>
-#include <tr1/memory>
+#include <memory>
 
 namespace gui {
   
 using std::string;
-using std::tr1::shared_ptr;
+using std::shared_ptr;
 
 
 namespace model      { class Project; }

src/include/play-facade.h

@@ -56,7 +56,7 @@ namespace lumiera {
   
   namespace time = lib::time;
   
-  using std::tr1::weak_ptr;
+  using std::weak_ptr;
     
     
     /**************************************************************//**

src/lib/functor-util.hpp

@@ -39,16 +39,16 @@
 
 #include "lib/hash-value.h"
 
-#include <tr1/functional>
+#include <functional>
 #include <boost/functional/hash.hpp>
 
 
 
 namespace util { ////////////TODO: refactor namespace. But probably not directly into namespace lib. Needs some more consideration though
   
-  using std::tr1::function;
-  using std::tr1::bind;
-  using std::tr1::placeholders::_1;
+  using std::function;
+  using std::bind;
+  using std::placeholders::_1;
   
   
   /** "Combiner" which calls two functions one after another
@@ -125,7 +125,7 @@ namespace util { ////////////TODO: refactor namespace. But probably not directly
      * to be the same. 
      */
     class HijackedFunction 
-      : std::tr1::_Function_base
+      : std::_Function_base
       {
         typedef void (*DummyInvoker) (void);
         DummyInvoker invoker_;
@@ -220,7 +220,6 @@ namespace util { ////////////TODO: refactor namespace. But probably not directly
 } // namespace util
 
 namespace std {
-namespace tr1 {
   
   /** inject into std::tr1 to be picked up by ADL:
    * @return hash value of given functor
@@ -234,6 +233,6 @@ namespace tr1 {
     return util::rawHashValue (fun);
   }
   
-}}
+}
 
 #endif /*UTIL_HPP_*/

src/lib/handle.hpp

@@ -46,13 +46,13 @@
 #include "lib/nobug-init.hpp"
 #include "lib/bool-checkable.hpp"
 
-#include <tr1/memory>
+#include <memory>
 
 
 namespace lib {
   
-  using std::tr1::shared_ptr;
-  using std::tr1::weak_ptr;
+  using std::shared_ptr;
+  using std::weak_ptr;
   
   
   
@@ -71,7 +71,7 @@ namespace lib {
     : public lib::BoolCheckable<Handle<IMP> >
     {
     protected:
-      typedef std::tr1::shared_ptr<IMP> SmPtr;
+      typedef std::shared_ptr<IMP> SmPtr;
       
       SmPtr smPtr_;
       

src/lib/iter-explorer.hpp

@@ -255,7 +255,7 @@ namespace lib {
     using util::unConst;
     using boost::enable_if;
     using boost::disable_if;
-    using std::tr1::function;    
+    using std::function;
     using meta::_Fun;
 
     

src/lib/iter-source.hpp

@@ -53,14 +53,14 @@
 
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/noncopyable.hpp>
-#include <tr1/memory>
+#include <memory>
 
 
 
 
 namespace lib {
   
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   
   
   

src/lib/itertools.hpp

@@ -75,13 +75,13 @@
 #include "lib/wrapper.hpp"
 #include "lib/util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 
 namespace lib {
   
-  using std::tr1::function;
+  using std::function;
   using util::unConst;
   
   using lib::meta::RefTraits;

src/lib/lifecycleregistry.hpp

@@ -41,7 +41,7 @@
 #include <map>
 #include <set>
 #include <string>
-#include <tr1/functional>
+#include <functional>
 #include <boost/scoped_ptr.hpp>
 #include <boost/noncopyable.hpp>
 
@@ -52,7 +52,7 @@ namespace lumiera {
   
   using boost::scoped_ptr;
   using boost::noncopyable;
-  using std::tr1::function;
+  using std::function;
   using util::contains;
   using std::string;
 

src/lib/meta/function-closure.hpp

@@ -50,7 +50,7 @@
 #include "lib/meta/function.hpp"
 #include "lib/meta/tuple.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 
@@ -58,7 +58,7 @@ namespace lib {
 namespace meta{
 namespace func{
   
-  using std::tr1::function;
+  using std::function;
   
   
   
@@ -90,7 +90,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP&)
           {
-            return std::tr1::bind (f);
+            return std::bind (f);
           }
       };
     
@@ -109,7 +109,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg));
+            return std::bind (f, element<0>(arg));
           }
       };
     
@@ -130,7 +130,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                    );
           }
@@ -154,7 +154,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                    );
@@ -180,7 +180,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -208,7 +208,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -238,7 +238,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -270,7 +270,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -304,7 +304,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -340,7 +340,7 @@ namespace func{
         static RET
         bind (FUN& f, TUP & arg)
           {
-            return std::tr1::bind (f, element<0>(arg)
+            return std::bind (f, element<0>(arg)
                                     , element<1>(arg)
                                     , element<2>(arg)
                                     , element<3>(arg)
@@ -360,7 +360,7 @@ namespace func{
     
     /* ===== Helpers for partial function application ===== */
     
-    using std::tr1::_Placeholder;     // what is the "official" way to import them?
+    using std::_Placeholder;     // what is the "official" way to import them?
     
     
     /**
@@ -560,17 +560,17 @@ namespace func{
   
   
   namespace _composed { // repetitive impl.code for function composition
-    using std::tr1::bind;
-    using std::tr1::function;
-    using std::tr1::placeholders::_1;
-    using std::tr1::placeholders::_2;
-    using std::tr1::placeholders::_3;
-    using std::tr1::placeholders::_4;
-    using std::tr1::placeholders::_5;
-    using std::tr1::placeholders::_6;
-    using std::tr1::placeholders::_7;
-    using std::tr1::placeholders::_8;
-    using std::tr1::placeholders::_9;
+    using std::bind;
+    using std::function;
+    using std::placeholders::_1;
+    using std::placeholders::_2;
+    using std::placeholders::_3;
+    using std::placeholders::_4;
+    using std::placeholders::_5;
+    using std::placeholders::_6;
+    using std::placeholders::_7;
+    using std::placeholders::_8;
+    using std::placeholders::_9;
     
     template<typename RES, typename F1, typename F2, uint n>
     struct Build;

src/lib/meta/function-erasure.hpp

@@ -61,13 +61,13 @@
 #include "lib/opaque-holder.hpp"
 #include "lib/functor-util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 namespace lib {
 namespace meta{
   
-  using std::tr1::function;
+  using std::function;
   using util::unConst;
   
   

src/lib/meta/function.hpp

@@ -49,14 +49,14 @@
 
 #include "lib/meta/typelist.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 
 namespace lib {
 namespace meta{
 
-  using std::tr1::function;
+  using std::function;
   
   
   

src/lib/meta/maybe-compare.hpp

@@ -27,13 +27,13 @@
 
 #include "lib/functor-util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 namespace lib {
 namespace meta{
   
-  using std::tr1::function;
+  using std::function;
   
   /**
    * Trait template for invoking equality comparison.

src/lib/meta/trait-special.hpp

@@ -27,7 +27,7 @@
 
 #include "lib/meta/trait.hpp"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 
 
 namespace lib {
@@ -42,7 +42,7 @@ namespace meta {
    *  Thus we provide fixed diagnostics to bypass the traits check.
    */
   template<typename KEY, typename VAL, typename HASH>
-  struct can_STL_ForEach<std::tr1::unordered_map<KEY,VAL,HASH> >
+  struct can_STL_ForEach<std::unordered_map<KEY,VAL,HASH> >
     {
       enum { value = true };
     };

src/lib/meta/trait.hpp

@@ -41,10 +41,9 @@ namespace boost{
   template<class X> class reference_wrapper; 
 }
 namespace std {
-namespace tr1 {
   template<class X> class reference_wrapper;
   template<class X> class shared_ptr; 
-}}
+}
 namespace lib{
   template<class X, class B>  class P;
 }
@@ -102,24 +101,24 @@ namespace meta {
     };
   
   template<typename X>
-  struct Unwrap<std::tr1::reference_wrapper<X> >
+  struct Unwrap<std::reference_wrapper<X> >
     {
       typedef X  Type;
       
       static X&
-      extract (std::tr1::reference_wrapper<X> wrapped)
+      extract (std::reference_wrapper<X> wrapped)
         {
           return wrapped;
         }
     };
   
   template<typename X>
-  struct Unwrap<std::tr1::shared_ptr<X> >
+  struct Unwrap<std::shared_ptr<X> >
     {
       typedef X  Type;
       
       static X&
-      extract (std::tr1::shared_ptr<X> ptr)
+      extract (std::shared_ptr<X> ptr)
         {
           ASSERT (ptr);
           return *ptr;

src/lib/meta/tuple.hpp

@@ -29,7 +29,7 @@
  ** capturing specific types to use as template parameter.
  ** 
  ** Additionally, this header augments the Tuple template into a simple Tuple
- ** (run time) datatype. This isn't meant as competing with std::tr1::tuple, which is
+ ** (run time) datatype. This isn't meant as competing with std::tuple, which is
  ** much more capable, but also has the downside of pulling in a lot of other headers.
  ** But when all we need is to define a generic typed record of N data elements and
  ** later re-accessing them (but no further advanced processing), the Tuple template

src/lib/multifact-arg.hpp

@@ -57,7 +57,7 @@ namespace lib {
     using lib::meta::Types;
     using lib::meta::FunctionSignature;
     using lib::meta::FunctionTypedef;
-    using std::tr1::function;
+    using std::function;
     
     
     /**

src/lib/multifact.hpp

@@ -62,8 +62,8 @@
 #include "lib/depend.hpp"
 #include "util.hpp"
 
-#include <tr1/functional>
-#include <tr1/memory>
+#include <functional>
+#include <memory>
 #include <map>
 
 
@@ -95,7 +95,7 @@ namespace lib {
     struct BuildRefcountPtr
       {
         typedef TAR*                      RType;
-        typedef std::tr1::shared_ptr<TAR> PType;
+        typedef std::shared_ptr<TAR> PType;
         
         PType wrap (RType ptr) { return PType (ptr); }
       };
@@ -113,7 +113,7 @@ namespace lib {
     template<typename SIG, typename ID>
     struct Fab
       {
-        typedef std::tr1::function<SIG> FactoryFunc;
+        typedef std::function<SIG> FactoryFunc;
         
         
         FactoryFunc&
@@ -230,7 +230,7 @@ namespace lib {
             Creator
             createSingleton_accessFunction()
               {
-                return std::tr1::bind (&SingFac::operator()
+                return std::bind (&SingFac::operator()
                                       , static_cast<SingFac*>(this));
               }
             

src/lib/p.hpp

@@ -22,7 +22,7 @@
 
 /** @file p.hpp
  ** Customised refcounting smart pointer.
- ** Template derived from std::tr1::shared_ptr adding total ordering and 
+ ** Template derived from std::shared_ptr adding total ordering and
  ** type relationships implemented by forwarding to the pointees. In all other
  ** respects, it should behave exactly as shared_ptr and is able to cooperate
  ** and share ownership with other shared_ptr instantiations.
@@ -51,17 +51,17 @@
 
 
 #include "lib/error.hpp"
-#include <tr1/memory>
+#include <memory>
 
 
 namespace lib {
   
-  using std::tr1::shared_ptr;
-  using std::tr1::weak_ptr;
+  using std::shared_ptr;
+  using std::weak_ptr;
   
   /**
    * Customised refcounting smart pointer template, built upon
-   * std::tr1::shared_ptr, but forwarding type relationships and
+   * std::shared_ptr, but forwarding type relationships and
    * ordering operators to the pointee objects.
    * @param TAR the visible pointee type
    * @param BASE the shared-ptr type used as implementation

src/lib/test/suite.cpp

@@ -31,7 +31,7 @@
 #include "lib/util.hpp"
 
 #include <boost/algorithm/string.hpp>
-#include <tr1/memory>
+#include <memory>
 #include <iostream>
 #include <sstream>
 #include <memory>
@@ -49,7 +49,7 @@ namespace test {
   using std::endl;
   using std::vector;
   using std::auto_ptr;
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   using boost::algorithm::trim;
   
   using util::isnil;

src/lib/test/test-coll.hpp

@@ -29,7 +29,7 @@
 
 //#include <typeinfo>
 //#include <cstdlib>
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <iostream>
 #include <vector>
 #include <map>
@@ -60,8 +60,8 @@ namespace test{
   typedef std::map<int,int> MapII;
   typedef std::multimap<int,int> MMapII;
   
-  typedef std::tr1::unordered_map<int,int> HMapII;
-  typedef std::tr1::unordered_multimap<int,int> HMMapII;
+  typedef std::unordered_map<int,int> HMapII;
+  typedef std::unordered_multimap<int,int> HMMapII;
   
   
   template<class MAP>

src/lib/time/control-impl.hpp

@@ -57,7 +57,7 @@
 #include "lib/time/mutation.hpp"
 #include "lib/time/timevalue.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <vector>
 
 
@@ -65,7 +65,7 @@ namespace lib {
 namespace time {
 namespace mutation {
   
-  using std::tr1::function;
+  using std::function;
   
   
   
@@ -145,7 +145,7 @@ namespace mutation {
       void
       attach (SIG const& toNotify)
         {
-          ChangeSignal newListener (std::tr1::ref(toNotify));
+          ChangeSignal newListener (std::ref(toNotify));
           listeners_.push_back (newListener);
         }
       

src/lib/time/control-policy.hpp

@@ -106,7 +106,7 @@
 #include "lib/time/timevalue.hpp"
 
 #include <boost/utility/enable_if.hpp>
-#include <tr1/functional>
+#include <functional>
 
 
 namespace lib {
@@ -116,10 +116,10 @@ namespace mutation {
   
   using boost::disable_if;
   using lib::meta::is_sameType;
-  using std::tr1::placeholders::_1;
-  using std::tr1::function;
-  using std::tr1::bind;
-  using std::tr1::ref;
+  using std::placeholders::_1;
+  using std::function;
+  using std::bind;
+  using std::ref;
   
   
   

src/lib/time/digxel.hpp

@@ -70,7 +70,7 @@
 
 #include <boost/operators.hpp>
 #include <boost/lexical_cast.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <string>
 #include <cstdio>
 #include <cmath>
@@ -196,9 +196,9 @@ namespace time {
   
   
   
-  using std::tr1::bind;
-  using std::tr1::function;
-  using std::tr1::placeholders::_1;
+  using std::bind;
+  using std::function;
+  using std::placeholders::_1;
   
   
   /**

src/lib/time/formats.hpp

@@ -30,7 +30,7 @@
 #include "lib/meta/generator.hpp"
 #include "lib/typed-counter.hpp"
 
-#include <tr1/memory>
+#include <memory>
 #include <string>
 #include <bitset>
 
@@ -49,7 +49,7 @@ namespace time {
   
   class Quantiser; // API for grid aligning
   typedef Quantiser const& QuantR;
-  typedef std::tr1::shared_ptr<const Quantiser> PQuant;
+  typedef std::shared_ptr<const Quantiser> PQuant;
   
   
   namespace format {

src/lib/time/grid.hpp

@@ -26,7 +26,7 @@
 
 #include "lib/time/timevalue.hpp"
 
-#include <tr1/memory>
+#include <memory>
 
 
 namespace lib {
@@ -68,7 +68,7 @@ namespace time {
       virtual TimeValue timeOf    (FSecs gridTime, int=0) const   =0;
     };
   
-  typedef std::tr1::shared_ptr<const Grid> PGrid;
+  typedef std::shared_ptr<const Grid> PGrid;
   
   
   

src/lib/time/timecode.cpp

@@ -29,7 +29,7 @@
 #include "lib/util.hpp"
 #include "lib/util-quant.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <boost/regex.hpp>
 #include <boost/lexical_cast.hpp>
 
@@ -277,8 +277,8 @@ namespace time {
     }
     
     
-    using std::tr1::bind;
-    using std::tr1::placeholders::_1;
+    using std::bind;
+    using std::placeholders::_1;
     
     /** bind the individual Digxel mutation functors
      *  to normalise raw component values */

src/lib/typed-allocation-manager.hpp

@@ -72,13 +72,13 @@
 #include "include/logging.h"
 
 
-#include <tr1/memory>
+#include <memory>
 
 
 
 namespace lib {
   
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   
   
   

src/lib/util-foreach.hpp

@@ -55,7 +55,7 @@
 #include "lib/meta/trait.hpp"
 
 #include <boost/utility/enable_if.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <algorithm>
 
 
@@ -204,7 +204,7 @@ namespace util {
   inline void                                                                            //________________________________
   for_each (CON const& elements, FUN function, P1 bind1)                                ///< Accept binding for 1 Argument 
   {
-    for_each (elements, std::tr1::bind (function, bind1));
+    for_each (elements, std::bind (function, bind1));
   }
   
   
@@ -215,7 +215,7 @@ namespace util {
   inline void                                                                            //________________________________
   for_each (CON const& elements, FUN function, P1 bind1, P2 bind2)                      ///< Accept binding for 2 Arguments
   {
-    for_each (elements, std::tr1::bind (function, bind1, bind2));
+    for_each (elements, std::bind (function, bind1, bind2));
   }
   
   
@@ -227,7 +227,7 @@ namespace util {
   inline void                                                                            //________________________________
   for_each (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3)            ///< Accept binding for 3 Arguments
   {
-    for_each (elements, std::tr1::bind (function, bind1, bind2, bind3));
+    for_each (elements, std::bind (function, bind1, bind2, bind3));
   }
   
   
@@ -240,7 +240,7 @@ namespace util {
   inline void                                                                            //________________________________
   for_each (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3, P4 bind4)  ///< Accept binding for 4 Arguments
   {
-    for_each (elements, std::tr1::bind (function, bind1, bind2, bind3, bind4));
+    for_each (elements, std::bind (function, bind1, bind2, bind3, bind4));
   }
   
   
@@ -253,7 +253,7 @@ namespace util {
   inline bool                                                                            //________________________________
   and_all (CON const& elements, FUN function, P1 bind1)                                 ///< Accept binding for 1 Argument 
   {
-    return and_all (elements, std::tr1::bind<bool> (function, bind1));
+    return and_all (elements, std::bind<bool> (function, bind1));
   }
   
   
@@ -264,7 +264,7 @@ namespace util {
   inline bool                                                                            //________________________________
   and_all (CON const& elements, FUN function, P1 bind1, P2 bind2)                       ///< Accept binding for 2 Arguments
   {
-    return and_all (elements, std::tr1::bind<bool> (function, bind1, bind2));
+    return and_all (elements, std::bind<bool> (function, bind1, bind2));
   }
   
   
@@ -276,7 +276,7 @@ namespace util {
   inline bool                                                                            //________________________________
   and_all (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3)             ///< Accept binding for 3 Arguments
   {
-    return and_all (elements, std::tr1::bind<bool> (function, bind1, bind2, bind3));
+    return and_all (elements, std::bind<bool> (function, bind1, bind2, bind3));
   }
   
   
@@ -289,7 +289,7 @@ namespace util {
   inline bool                                                                            //________________________________
   and_all (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3, P4 bind4)   ///< Accept binding for 4 Arguments
   {
-    return and_all (elements, std::tr1::bind<bool> (function, bind1, bind2, bind3, bind4));
+    return and_all (elements, std::bind<bool> (function, bind1, bind2, bind3, bind4));
   }
   
   
@@ -302,7 +302,7 @@ namespace util {
   inline bool                                                                            //________________________________
   has_any (CON const& elements, FUN function, P1 bind1)                                 ///< Accept binding for 1 Argument 
   {
-    return has_any (elements, std::tr1::bind<bool> (function, bind1));
+    return has_any (elements, std::bind<bool> (function, bind1));
   }
   
   
@@ -313,7 +313,7 @@ namespace util {
   inline bool                                                                            //________________________________
   has_any (CON const& elements, FUN function, P1 bind1, P2 bind2)                       ///< Accept binding for 2 Arguments
   {
-    return has_any (elements, std::tr1::bind<bool> (function, bind1, bind2));
+    return has_any (elements, std::bind<bool> (function, bind1, bind2));
   }
   
   
@@ -325,7 +325,7 @@ namespace util {
   inline bool                                                                            //________________________________
   has_any (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3)             ///< Accept binding for 3 Arguments
   {
-    return has_any (elements, std::tr1::bind<bool> (function, bind1, bind2, bind3));
+    return has_any (elements, std::bind<bool> (function, bind1, bind2, bind3));
   }
   
   
@@ -338,7 +338,7 @@ namespace util {
   inline bool                                                                            //________________________________
   has_any (CON const& elements, FUN function, P1 bind1, P2 bind2, P3 bind3, P4 bind4)   ///< Accept binding for 4 Arguments
   {
-    return has_any (elements, std::tr1::bind<bool> (function, bind1, bind2, bind3, bind4));
+    return has_any (elements, std::bind<bool> (function, bind1, bind2, bind3, bind4));
   }
   
   

src/lib/util.cpp

@@ -24,7 +24,7 @@
 #include "lib/util.hpp"
 
 #include <boost/algorithm/string.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <boost/bind.hpp>          // we need operator! for bind-expressions
 
 using boost::algorithm::trim_right_copy_if;
@@ -35,7 +35,7 @@ using boost::algorithm::is_space;
 
 namespace util {
 
-  using std::tr1::function;
+  using std::function;
   
   typedef function<bool(string::value_type)> ChPredicate;
   ChPredicate operator! (ChPredicate p) { return ! bind(p,_1); }

src/lib/wrapper.hpp

@@ -48,7 +48,7 @@
 
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/noncopyable.hpp>
-#include <tr1/functional>
+#include <functional>
 
 
 namespace lib {
@@ -60,7 +60,7 @@ namespace wrapper {
   using lumiera::error::LUMIERA_ERROR_BOTTOM_VALUE;
   
   using boost::remove_const;
-  using std::tr1::function;
+  using std::function;
   
   
   /** 
@@ -71,9 +71,9 @@ namespace wrapper {
    */
   template<typename TY>
   class AssignableRefWrapper
-    : public std::tr1::reference_wrapper<TY>
+    : public std::reference_wrapper<TY>
     {
-      typedef std::tr1::reference_wrapper<TY> RefWrapper;
+      typedef std::reference_wrapper<TY> RefWrapper;
     public:
       
       explicit AssignableRefWrapper(TY& ref)
@@ -378,8 +378,8 @@ namespace wrapper {
       template<typename FUN>
       FunctionResult (FUN targetFunction)
         {
-          using std::tr1::bind;
-          using std::tr1::placeholders::_1;
+          using std::bind;
+          using std::placeholders::_1;
           using lib::meta::func::chained;
                                                       // note: binding "this" mandates noncopyable
           function<Res(Res)> doCaptureResult  = bind (&FunctionResult::captureResult, this, _1 );

src/proc/asset.cpp

@@ -28,13 +28,13 @@
 #include "lib/util-foreach.hpp"
 #include "lib/util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <string>
 
 
-using std::tr1::function;
-using std::tr1::placeholders::_1;
-using std::tr1::bind;
+using std::function;
+using std::placeholders::_1;
+using std::bind;
 using util::contains;
 using util::removeall;
 using util::for_each;

src/proc/asset.hpp

@@ -83,8 +83,8 @@ namespace asset {
   namespace error = lumiera::error;
   
   using std::size_t;
-  using std::tr1::shared_ptr;
-  using std::tr1::static_pointer_cast;
+  using std::shared_ptr;
+  using std::static_pointer_cast;
   
   using lib::HashVal;
   using lib::P;

src/proc/asset/clip.cpp

@@ -24,7 +24,7 @@
 #include "proc/asset/clip.hpp"
 #include "proc/mobject/session/mobjectfactory.hpp"   ////TODO: avoidable?
 
-using std::tr1::static_pointer_cast;
+using std::static_pointer_cast;
 
 
 namespace proc {

src/proc/asset/db.hpp

@@ -29,8 +29,8 @@
 #include "lib/error.hpp"
 #include "proc/asset.hpp"
 
-#include <tr1/memory>
-#include <tr1/unordered_map>
+#include <memory>
+#include <unordered_map>
 // #include <boost/functional/hash.hpp>   /////////TODO which boost include to use here??
 #include <boost/utility.hpp>
 
@@ -38,8 +38,8 @@
 namespace proc {
 namespace asset {
   
-  using std::tr1::static_pointer_cast;
-  using std::tr1::dynamic_pointer_cast;
+  using std::static_pointer_cast;
+  using std::dynamic_pointer_cast;
   
   using lib::Sync;
   using lib::RecursiveLock_NoWait;
@@ -77,7 +77,7 @@ namespace asset {
       operator() (size_t val)  const { return val; }
     };
   
-  typedef std::tr1::unordered_map<size_t, PAsset, IdentityHash> IdHashtable;
+  typedef std::unordered_map<size_t, PAsset, IdentityHash> IdHashtable;
   
   
   

src/proc/asset/media.cpp

@@ -46,7 +46,7 @@ using boost::format;
 using boost::regex;
 using boost::smatch;
 using boost::regex_search;
-using std::tr1::dynamic_pointer_cast;
+using std::dynamic_pointer_cast;
 
 namespace error = lumiera::error;
 

src/proc/asset/meta/time-grid.cpp

@@ -64,7 +64,7 @@ namespace meta {
   using lib::time::PQuant;
   using lib::time::Quantiser;
   using lib::time::FixedFrameQuantiser;
-  using std::tr1::dynamic_pointer_cast;
+  using std::dynamic_pointer_cast;
   
   namespace advice = lumiera::advice;
   

src/proc/asset/typed-id.hpp

@@ -53,7 +53,7 @@
 #include "lib/symbol.hpp"
 
 //#include <boost/operators.hpp>
-#include <tr1/memory>
+#include <memory>
 //#include <iostream>
 //#include <string>
 
@@ -125,7 +125,7 @@ namespace asset {
       
     public:
       void
-      registerInstance (std::tr1::weak_ptr<TY> smart_ptr_instance)
+      registerInstance (std::weak_ptr<TY> smart_ptr_instance)
         {
           TODO ("actually attach the smart-ptr to the existing TypedID registration");
         }

src/proc/assetmanager.cpp

@@ -27,12 +27,12 @@
 #include "lib/sync.hpp"
 #include "lib/util-foreach.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <boost/format.hpp>
 
-using std::tr1::static_pointer_cast;
-using std::tr1::function;
-using std::tr1::placeholders::_1;
+using std::static_pointer_cast;
+using std::function;
+using std::placeholders::_1;
 using boost::format;
 using util::for_each;
 
@@ -165,7 +165,7 @@ namespace asset {
   bool
   AssetManager::known (IDA id)
   {
-    return ( registry.get (ID<Asset>(id)) );
+    return bool(registry.get (ID<Asset>(id)));
   }       // query most general Asset ID-kind and use implicit 
          //  conversion from smart-ptr to bool (test if empty)
   

src/proc/control/command-closure.hpp

@@ -79,8 +79,8 @@
 #include "proc/control/argument-erasure.hpp"
 #include "lib/typed-allocation-manager.hpp"
 
-#include <tr1/memory>
-#include <tr1/functional>
+#include <memory>
+#include <functional>
 #include <iostream>
 #include <sstream>
 #include <string>
@@ -102,7 +102,7 @@ namespace control {
   using lib::meta::equals_safeInvoke;
   using lib::TypedAllocationManager;
   using util::unConst;
-  using std::tr1::function;
+  using std::function;
   using std::ostream;
   using std::string;
   
@@ -121,7 +121,7 @@ namespace control {
   
   
   class CmdClosure;
-  typedef std::tr1::shared_ptr<CmdClosure> PClo;
+  typedef std::shared_ptr<CmdClosure> PClo;
   
   
   

src/proc/control/command-def.hpp

@@ -70,8 +70,8 @@
 #include "lib/meta/tuple.hpp"
 #include "lib/util.hpp"
 
-#include <tr1/memory>
-#include <tr1/functional>
+#include <memory>
+#include <functional>
 
 
 
@@ -79,10 +79,10 @@
 namespace proc {
 namespace control {
   
-  using std::tr1::shared_ptr;
-  using std::tr1::function;
-  using std::tr1::bind;
-  using std::tr1::placeholders::_1;
+  using std::shared_ptr;
+  using std::function;
+  using std::bind;
+  using std::placeholders::_1;
   using lib::Symbol;
   using util::cStr;
   

src/proc/control/command-impl-clone-builder.hpp

@@ -56,16 +56,16 @@
 #include <boost/noncopyable.hpp>
 //#include <boost/operators.hpp>
 
-//#include <tr1/memory>
-//#include <tr1/functional>
+//#include <memory>
+//#include <functional>
 
 
 namespace proc {
 namespace control {
   
   using lib::TypedAllocationManager;
-//  using std::tr1::function;
-//  using std::tr1::shared_ptr;
+//  using std::function;
+//  using std::shared_ptr;
   using lib::InPlaceBuffer;
   
   

src/proc/control/command-impl.hpp

@@ -51,15 +51,15 @@
 #include <boost/noncopyable.hpp>
 #include <boost/operators.hpp>
 
-#include <tr1/memory>
-#include <tr1/functional>
+#include <memory>
+#include <functional>
 
 
 namespace proc {
 namespace control {
   
-  using std::tr1::function;
-  using std::tr1::shared_ptr;
+  using std::function;
+  using std::shared_ptr;
   
   
   

src/proc/control/command-registry.hpp

@@ -70,8 +70,8 @@
 
 #include <boost/functional/hash.hpp>
 #include <boost/noncopyable.hpp>
-#include <tr1/unordered_map>
-#include <tr1/memory>
+#include <unordered_map>
+#include <memory>
 #include <string>
 #include <map>
 
@@ -82,8 +82,8 @@ namespace control {
   
   using boost::hash;
   using boost::noncopyable;
-  using std::tr1::shared_ptr;
-  using std::tr1::unordered_map;
+  using std::shared_ptr;
+  using std::unordered_map;
   using lib::TypedAllocationManager;
   using util::getValue_or_default;
   using util::contains;

src/proc/control/command-signature.hpp

@@ -51,7 +51,7 @@
 #include "lib/meta/typelist-manip.hpp"
 #include "lib/meta/typeseq-util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 
 
 
@@ -59,7 +59,7 @@
 namespace proc {
 namespace control {
   
-  using std::tr1::function;
+  using std::function;
   
   using lib::meta::FunctionSignature;
   using lib::meta::FunctionTypedef;

src/proc/control/command.hpp

@@ -73,7 +73,7 @@ namespace control {
   
   using std::string;
   using lib::Symbol;
-  using std::tr1::shared_ptr;
+  using std::shared_ptr;
   using lib::meta::Tuple;
   
   

src/proc/control/memento-tie.hpp

@@ -49,7 +49,7 @@
 #include "lib/util.hpp"
 
 #include <boost/operators.hpp>
-#include <tr1/functional>
+#include <functional>
 #include <string>
 
 
@@ -135,7 +135,7 @@ namespace control {
       function<SIG> 
       tieUndoFunc()
         {
-          using std::tr1::bind;
+          using std::bind;
           
           return bindLast( undo_           // getState() bound to last argument of undo(...)
                          , bind (&MementoTie::getState, this)
@@ -150,7 +150,7 @@ namespace control {
       function<SIG>
       tieCaptureFunc()
         {
-          using std::tr1::placeholders::_1;
+          using std::placeholders::_1;
           
           function<void(MEM)> doCaptureMemento = bind (&MementoTie::capture, this, _1 );
           

src/proc/control/proc-dispatcher.hpp

@@ -39,7 +39,7 @@
 #include "proc/control/command.hpp"
 #include "lib/depend.hpp"
 
-//#include <tr1/memory>
+//#include <memory>
 
 
 
@@ -47,7 +47,7 @@ namespace proc {
 namespace control {
   
 //  using lib::Symbol;
-//  using std::tr1::shared_ptr;
+//  using std::shared_ptr;
   
   
   /**

src/proc/control/styperegistry.hpp

@@ -44,7 +44,7 @@
 
 //#include <set>
 //#include <vector>
-//#include <tr1/memory>
+//#include <memory>
 //#include <boost/format.hpp>
 #include <boost/noncopyable.hpp>
 

src/proc/engine/buffer-metadata.hpp

@@ -62,7 +62,7 @@
 #include "proc/engine/type-handler.hpp"
 #include "proc/engine/buffer-local-key.hpp"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <boost/noncopyable.hpp>
 
 
@@ -443,7 +443,7 @@ namespace engine {
      */
     class Table
       {
-        typedef std::tr1::unordered_map<HashVal,Entry> MetadataStore;
+        typedef std::unordered_map<HashVal,Entry> MetadataStore;
         
         MetadataStore entries_;
 

src/proc/engine/calc-plan-continuation.hpp

@@ -37,7 +37,7 @@
 namespace proc {
 namespace engine {
   
-//  using std::tr1::function;
+//  using std::function;
   using backend::engine::JobParameter;
   using backend::engine::JobClosure;
   using mobject::ModelPort;

src/proc/engine/dispatcher.hpp

@@ -33,13 +33,13 @@
 #include "lib/time/timevalue.hpp"
 
 #include <boost/noncopyable.hpp>
-#include <tr1/functional>
+#include <functional>
 
 
 namespace proc {
 namespace engine {
   
-  using std::tr1::function;
+  using std::function;
   using mobject::ModelPort;
   using lib::time::FrameCnt;
   using lib::time::TimeSpan;

src/proc/engine/engine-service-mock.cpp

@@ -26,7 +26,7 @@
 
 //#include <string>
 //#include <memory>
-//#include <tr1/functional>
+//#include <functional>
 //#include <boost/scoped_ptr.hpp>
 
 
@@ -38,7 +38,7 @@ namespace engine{
 //    using lumiera::Subsys;
 //    using std::auto_ptr;
 //    using boost::scoped_ptr;
-//    using std::tr1::bind;
+//    using std::bind;
   
   
   namespace { // hidden local details of the service implementation....

src/proc/engine/engine-service.cpp

@@ -26,7 +26,7 @@
 
 //#include <string>
 //#include <memory>
-#include <tr1/functional>
+#include <functional>
 //#include <boost/scoped_ptr.hpp>
 
 
@@ -38,9 +38,9 @@ namespace engine{
 //    using lumiera::Subsys;
 //    using std::auto_ptr;
 //    using boost::scoped_ptr;
-  using std::tr1::function;
-  using std::tr1::bind;
-  using std::tr1::ref;
+  using std::function;
+  using std::bind;
+  using std::ref;
   using lib::transform;
   using lib::append_all;
 

src/proc/engine/engine-service.hpp

@@ -76,7 +76,7 @@ namespace engine{
 //    using lumiera::Subsys;
 //    using lumiera::Display;
 //    using lumiera::DummyPlayer;
-//  using std::tr1::function;
+//  using std::function;
   using mobject::ModelPort;
   using proc::play::Timings;
   

src/proc/engine/nodewiring-config.hpp

@@ -55,7 +55,7 @@
 #include "lib/meta/configflags.hpp"
 #include "lib/util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <bitset>
 #include <map>
 
@@ -112,7 +112,7 @@ namespace config {
           >
   class ConfigSelector
     {
-      typedef std::tr1::function<FUNC> FacFunction;
+      typedef std::function<FUNC> FacFunction;
       
       template<class FAC>
       struct FactoryHolder ///< impl type erasure
@@ -126,7 +126,7 @@ namespace config {
         };
       
       
-      typedef std::tr1::shared_ptr<FacFunction> PFunc;
+      typedef std::shared_ptr<FacFunction> PFunc;
       typedef std::map<IxID, PFunc> ConfigTable;
       
       ConfigTable possibleConfig_; ///< Table of factories

src/proc/engine/tracking-heap-block-provider.hpp

@@ -48,7 +48,7 @@
 #include "proc/engine/buffer-provider.hpp"
 #include "lib/scoped-ptrvect.hpp"
 
-#include <tr1/unordered_map>
+#include <unordered_map>
 #include <boost/scoped_ptr.hpp>
 #include <boost/scoped_array.hpp>
 
@@ -114,7 +114,7 @@ namespace engine {
       
     class BlockPool;
     
-    typedef std::tr1::unordered_map<HashVal,BlockPool> PoolTable;
+    typedef std::unordered_map<HashVal,BlockPool> PoolTable;
   }
   
   

src/proc/engine/type-handler.hpp

@@ -46,7 +46,7 @@
 #include "lib/hash-value.h"
 #include "lib/functor-util.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <boost/functional/hash.hpp>
 
 
@@ -54,9 +54,9 @@ namespace proc {
 namespace engine {
   
   using lib::HashVal;
-  using std::tr1::bind;
-  using std::tr1::function;
-  using std::tr1::placeholders::_1;
+  using std::bind;
+  using std::function;
+  using std::placeholders::_1;
   
   namespace error = lumiera::error;
   

src/proc/engine/worker/dummy-tick.hpp

@@ -41,15 +41,15 @@
 #include "lib/error.hpp"
 #include "backend/thread-wrapper.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <limits>
 
 
 namespace proc {
 namespace node {
 
-  using std::tr1::function;
-  using std::tr1::bind;
+  using std::function;
+  using std::bind;
   
   
   

src/proc/engine/worker/tick-service.hpp

@@ -41,15 +41,15 @@
 #include "lib/error.hpp"
 #include "backend/thread-wrapper.hpp"
 
-#include <tr1/functional>
+#include <functional>
 #include <limits>
 
 
 namespace proc {
 namespace node {
 
-  using std::tr1::function;
-  using std::tr1::bind;
+  using std::function;
+  using std::bind;
   
   
   

src/proc/mobject/placement.hpp

@@ -74,7 +74,7 @@
 
 #include "proc/asset/pipe.hpp"   //////////////TICKET #109 : get rid of this
 
-#include <tr1/memory>
+#include <memory>
 
 
 namespace proc {
@@ -85,8 +85,8 @@ namespace mobject {
   class MObject;
   class ExplicitPlacement;
   
-  using std::tr1::shared_ptr;
-  using std::tr1::static_pointer_cast;
+  using std::shared_ptr;
+  using std::static_pointer_cast;
   using lib::HashIndexed;
   
   

src/proc/mobject/session.hpp

@@ -59,7 +59,7 @@
 #include "lib/p.hpp"
 
 #include <boost/noncopyable.hpp>
-#include <tr1/memory>
+#include <memory>
 
 
 
@@ -75,7 +75,7 @@ namespace mobject {
     class SessManager;
     class ElementQuery;
     class Fixture;
-    typedef std::tr1::shared_ptr<Fixture> PFix;
+    typedef std::shared_ptr<Fixture> PFix;
   }
   
   typedef session::SessManager& PSess;  ///< acts as a "PImpl" smart ptr

src/proc/mobject/session/element-query.hpp

@@ -31,7 +31,7 @@
 #include "proc/mobject/session/session-service-explore-scope.hpp"
 
 #include <boost/noncopyable.hpp>
-#include <tr1/functional>
+#include <functional>
 
 
 
@@ -40,7 +40,7 @@ namespace mobject {
 namespace session {
   
   
-  using std::tr1::function;
+  using std::function;
   
   
   namespace { // type matching helper

src/proc/mobject/session/fixture.hpp

@@ -35,7 +35,7 @@
 
 
 using std::list;
-using std::tr1::shared_ptr;
+using std::shared_ptr;