moving to C++14... deal with it

Author: Davide Faconti

CMakeLists.txt

@@ -2,10 +2,10 @@ cmake_minimum_required(VERSION 2.8.12) # version on Ubuntu Trusty
 project(behaviortree_cpp_v3)
 
 if(NOT CMAKE_VERSION VERSION_LESS 3.1)
-    set(CMAKE_CXX_STANDARD 11)
+    set(CMAKE_CXX_STANDARD 14)
     set(CMAKE_CXX_STANDARD_REQUIRED ON)
 else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
 endif()
 
 if(MSVC)

docs/tutorial_08_additional_args.md

@@ -115,17 +115,12 @@ int main()
     NodeBuilder builder_A = 
        [](const std::string& name, const NodeConfiguration& config)
     {
-        auto ptr = new Action_A(name, config, 42, 3.14, "hello world")
-        return std::unique_ptr<Action_A>( ptr );
+        return std::make_unique<Action_A>( name, config, 42, 3.14, "hello world" );
     };
 
-    // You may create manifest_A by hand, but in this case we can use a 
-    // convenient helper function called BehaviorTreeFactory::buildManifest
-    auto manifest_A = BehaviorTreeFactory::buildManifest<Action_A>("Action_A");
-
-    // BehaviorTreeFactory::registerBuilder is the more general way to 
+    // BehaviorTreeFactory::registerBuilder is a more general way to
     // register a custom node. 
-    factory.registerBuilder( manifest_A, builder_A);
+    factory.registerBuilder<Action_A>( "Action_A", builder_A);
 
     // The regitration of  Action_B is done as usual, but remember 
     // that we still need to call Action_B::init()

examples/t08_additional_node_args.cpp

@@ -88,16 +88,12 @@ int main()
     // Using lambdas or std::bind, we can easily "inject" additional arguments.
     NodeBuilder builder_A = [](const std::string& name, const NodeConfiguration& config)
     {
-        return std::unique_ptr<Action_A>( new Action_A(name, config, 42, 3.14, "hello world") );
+        return std::make_unique<Action_A>( name, config, 42, 3.14, "hello world" );
     };
 
-    // You may create manifest_A by hand, but in this case we can use a convenient helper function
-    // called BehaviorTreeFactory::buildManifest
-    TreeNodeManifest manifest_A = BehaviorTreeFactory::buildManifest<Action_A>("Action_A");
-
     // BehaviorTreeFactory::registerBuilder is the more general way to register a custom node.
     // Not the most user friendly, but definitely the most flexible one.
-    factory.registerBuilder( manifest_A, builder_A);
+    factory.registerBuilder<Action_A>( "Action_A", builder_A);
 
     // The regitration of  Action_B is done as usual, but we still need to call Action_B::init()
     factory.registerNodeType<Action_B>( "Action_B" );

include/behaviortree_cpp/bt_factory.h

@@ -95,6 +95,13 @@ class BehaviorTreeFactory
     /// The most generic way to register your own builder.
     void registerBuilder(const TreeNodeManifest& manifest, const NodeBuilder& builder);
 
+    template <typename T>
+    void registerBuilder(const std::string& ID, const NodeBuilder& builder )
+    {
+        auto manifest = BehaviorTreeFactory::buildManifest<T>(ID);
+        registerBuilder(manifest, builder);
+    }
+
     /**
     * @brief registerSimpleAction help you register nodes of type SimpleActionNode.
     *
@@ -244,9 +251,9 @@ class BehaviorTreeFactory
                 config.output_ports.empty() &&
                 has_default_constructor<T>::value)
             {
-                return std::unique_ptr<TreeNode>(new T(name));
+                return std::make_unique<T>(name);
             }
-            return std::unique_ptr<TreeNode>(new T(name, config));
+            return std::make_unique<T>(name, config);
         };
     }
 

src/bt_factory.cpp

@@ -82,7 +82,7 @@ void BehaviorTreeFactory::registerSimpleCondition(const std::string& ID,
                                                   PortsList ports)
 {
     NodeBuilder builder = [tick_functor, ID](const std::string& name, const NodeConfiguration& config) {
-        return std::unique_ptr<TreeNode>(new SimpleConditionNode(name, tick_functor, config));
+        return std::make_unique<SimpleConditionNode>(name, tick_functor, config);
     };
 
     TreeNodeManifest manifest = { NodeType::CONDITION, ID, std::move(ports) };
@@ -94,7 +94,7 @@ void BehaviorTreeFactory::registerSimpleAction(const std::string& ID,
                                                PortsList ports)
 {
     NodeBuilder builder = [tick_functor, ID](const std::string& name, const NodeConfiguration& config) {
-        return std::unique_ptr<TreeNode>(new SimpleActionNode(name, tick_functor, config));
+        return std::make_unique<SimpleActionNode>(name, tick_functor, config);
     };
 
     TreeNodeManifest manifest = { NodeType::ACTION, ID, std::move(ports) };
@@ -106,7 +106,7 @@ void BehaviorTreeFactory::registerSimpleDecorator(const std::string& ID,
                                                   PortsList ports)
 {
     NodeBuilder builder = [tick_functor, ID](const std::string& name, const NodeConfiguration& config) {
-        return std::unique_ptr<TreeNode>(new SimpleDecoratorNode(name, tick_functor, config));
+        return std::make_unique<SimpleDecoratorNode>(name, tick_functor, config);
     };
 
     TreeNodeManifest manifest = { NodeType::DECORATOR, ID, std::move(ports) };

src/xml_parsing.cpp

@@ -577,7 +577,7 @@ TreeNode::Ptr XMLParser::Pimpl::createNodeFromXML(const XMLElement *element,
         child_node = factory.instantiateTreeNode(instance_name, ID, config);
     }
     else if( tree_roots.count(ID) != 0) {
-        child_node = std::unique_ptr<TreeNode>( new DecoratorSubtreeNode(instance_name) );
+        child_node = std::make_unique<DecoratorSubtreeNode>( instance_name );
     }
     else{
         throw RuntimeError( ID, " is not a registered node, nor a Subtree");