Remove warnings

src/artis/builder/Builder.hpp

@@ -50,8 +50,7 @@ namespace artis {
             T* build() { return dynamic_cast < T* >(build_model(tree)); }
 
         private:
-            kernel::AbstractModel<U, V>* build_model(
-                    boost::property_tree::ptree const& pt)
+            kernel::AbstractModel<U, V>* build_model(boost::property_tree::ptree const& pt)
             {
                 using boost::property_tree::ptree;
 
@@ -112,8 +111,7 @@ namespace artis {
                 return model;
             }
 
-            void build_internals(boost::property_tree::ptree const& pt,
-                    kernel::AbstractModel<U, V>* model)
+            void build_internals(boost::property_tree::ptree const& pt, kernel::AbstractModel<U, V>* model)
             {
                 using boost::property_tree::ptree;
 
@@ -122,8 +120,7 @@ namespace artis {
                 }
             }
 
-            void build_externals(boost::property_tree::ptree const& pt,
-                    kernel::AbstractModel<U, V>* model)
+            void build_externals(boost::property_tree::ptree const& pt, kernel::AbstractModel<U, V>* model)
             {
                 using boost::property_tree::ptree;
 
@@ -132,8 +129,7 @@ namespace artis {
                 }
             }
 
-            void build_states(boost::property_tree::ptree const& pt,
-                    kernel::AbstractModel<U, V>* model)
+            void build_states(boost::property_tree::ptree const& pt, kernel::AbstractModel<U, V>* model)
             {
                 using boost::property_tree::ptree;
 
@@ -142,8 +138,7 @@ namespace artis {
                 }
             }
 
-            void build_variable(boost::property_tree::ptree const& pt,
-                    kernel::AbstractModel<U, V>* /* model */)
+            void build_variable(boost::property_tree::ptree const& pt, kernel::AbstractModel<U, V>* /* model */)
             {
                 using boost::property_tree::ptree;
 

src/artis/builder/ModelFactory.hpp

@@ -38,14 +38,13 @@ namespace artis {
         template<typename M, typename U, typename V>
         class ObjectCreator {
         public:
-            ObjectCreator() { }
+            ObjectCreator() = default;
 
-            virtual ~ObjectCreator() { }
+            virtual ~ObjectCreator() = default;
 
             virtual std::string get() const = 0;
 
-            virtual M* operator()(artis::kernel::AbstractModels<U,
-                    V> submodels) const = 0;
+            virtual M* operator()(const artis::kernel::AbstractModels<U, V>& /* submodels */) const = 0;
         };
 
         template<typename M, typename I, typename O, typename U, typename V>
@@ -53,23 +52,22 @@ namespace artis {
             typedef ModelFactory<M, I, O, U, V> type;
 
         public:
-            virtual ~ModelFactory() { }
+            virtual ~ModelFactory() = default;
 
             bool add(const I& id, O* creator)
             {
                 std::lock_guard<std::mutex> lock(_mutex);
-                return creators.insert(typename Creators::value_type(
+                return _creators.insert(typename Creators::value_type(
                         creator->get(),
                         std::make_pair(id, creator))).second;
             }
 
-            M* create(const std::string& id, artis::kernel::AbstractModels<U,
-                    V> submodels)
+            M* create(const std::string& id, const artis::kernel::AbstractModels<U, V>& submodels)
             {
                 std::lock_guard<std::mutex> lock(_mutex);
-                typename Creators::const_iterator it = creators.find(id);
+                typename Creators::const_iterator it = _creators.find(id);
 
-                if (it != creators.end()) {
+                if (it != _creators.end()) {
                     return (*it->second.second)(submodels);
                 } else {
                     return nullptr;
@@ -85,16 +83,16 @@ namespace artis {
             int make_id()
             {
                 std::lock_guard<std::mutex> lock(_mutex);
-                return ++id;
+                return ++_id;
             }
 
             bool remove(const I& id)
             {
                 std::lock_guard<std::mutex> lock(_mutex);
-                typename Creators::const_iterator it = creators.find(id);
+                typename Creators::const_iterator it = _creators.find(id);
 
-                if (it != creators.end()) {
-                    creators.erase(it);
+                if (it != _creators.end()) {
+                    _creators.erase(it);
                     return true;
                 } else {
                     return false;
@@ -102,7 +100,7 @@ namespace artis {
             }
 
         private:
-            ModelFactory() { id = -1; }
+            ModelFactory() { _id = -1; }
 
             typedef std::pair<I, O*> Creator;
             typedef std::map<std::string, Creator> Creators;
@@ -111,8 +109,8 @@ namespace artis {
             static std::once_flag _flag;
             std::mutex _mutex;
 
-            Creators creators;
-            int id;
+            Creators _creators;
+            int _id;
         };
 
     }
@@ -134,7 +132,7 @@ std::once_flag artis::builder::ModelFactory<M, I, O, U, V>::_flag;
         }                                                               \
     std::string get() const                                             \
         { return boost::core::demangle(typeid(mdl).name()); }           \
-    type* operator()(artis::kernel::AbstractModels < U, V > submodels) const \
+    type* operator()(const artis::kernel::AbstractModels < U, V >& submodels) const \
         { return new mdl(submodels); }                                  \
     static creator_##mdl an_##mdl;                                      \
     };                                                                  \

src/artis/kernel/AbstractCoupledModel.hpp

@@ -97,8 +97,7 @@ namespace artis {
             virtual ~AbstractCoupledModel()
             {
 #ifdef WITH_TRACE
-                trace_element(true, utils::DoubleTime::null,
-                        utils::DESTRUCT);
+                trace_element(true, utils::DoubleTime::null, utils::DESTRUCT);
 #endif
             }
 
@@ -436,6 +435,10 @@ namespace artis {
             void link_internal_(unsigned int index, std::string var_name,
                     type* model, int sub_index, std::string sub_var_name)
             {
+#ifndef WITH_TRACE
+                (void) sub_var_name;
+#endif
+
                 submodel_internals[index] =
                         std::pair<type*, int>(model, sub_index);
 #ifdef WITH_TRACE

src/test/models.hpp

@@ -35,21 +35,17 @@ struct GlobalParameters {
 struct ModelParameters {
 };
 
-using Model = artis::kernel::AbstractModel<artis::utils::DoubleTime,
-        ModelParameters>;
-using Models = artis::kernel::AbstractModels<artis::utils::DoubleTime,
-        ModelParameters>;
+using Model = artis::kernel::AbstractModel<artis::utils::DoubleTime, ModelParameters>;
+using Models = artis::kernel::AbstractModels<artis::utils::DoubleTime, ModelParameters>;
 
 using Trace = artis::utils::Trace<artis::utils::DoubleTime>;
 using TraceElement = artis::utils::TraceElement<artis::utils::DoubleTime>;
 
 template<typename T>
-using AtomicModel = artis::kernel::AbstractAtomicModel<
-        T, artis::utils::DoubleTime, ModelParameters>;
+using AtomicModel = artis::kernel::AbstractAtomicModel<T, artis::utils::DoubleTime, ModelParameters>;
 
 template<typename T>
-using CoupledModel = artis::kernel::AbstractCoupledModel<
-        T, artis::utils::DoubleTime, ModelParameters, GlobalParameters>;
+using CoupledModel = artis::kernel::AbstractCoupledModel<T, artis::utils::DoubleTime, ModelParameters, GlobalParameters>;
 
 class AModel : public AtomicModel<AModel> {
 public:
@@ -60,32 +56,31 @@ public:
         DX, BX, IX
     };
 
-    AModel(Models = Models())
+    AModel(const Models& = Models())
+            :_ix(0), _bx(false), _dx(0.0)
     {
+        // internals
         Internal(IX, &AModel::_ix);
         Internal(BX, &AModel::_bx);
         Internal(DX, &AModel::_dx);
     }
 
-    virtual ~AModel() { }
+    ~AModel() override = default;
 
-    void compute(double t, bool /* update */)
+    void compute(double t, bool /* update */) override
     {
-        ::Trace::trace() << ::TraceElement("A", t, artis::utils::COMPUTE)
-                         << "Start";
-        ::Trace::trace().flush();
+        Trace::trace() << TraceElement("A", t, artis::utils::COMPUTE) << "Start";
+        Trace::trace().flush();
 
         ++_ix;
         _bx = not _bx;
         ++_dx;
 
-        ::Trace::trace() << ::TraceElement("A", t, artis::utils::COMPUTE)
-                         << "Stop";
-        ::Trace::trace().flush();
-
+        Trace::trace() << TraceElement("A", t, artis::utils::COMPUTE) << "Stop";
+        Trace::trace().flush();
     }
 
-    void init(double /* t */, const ModelParameters& /* parameters */)
+    void init(double /* t */, const ModelParameters& /* parameters */) override
     {
         _ix = 0;
         _bx = false;
@@ -110,15 +105,16 @@ public:
         N
     };
 
-    BModel(Models = Models())
+    BModel(const Models& = Models())
+            :_ix(0), _bx(false), _dx(0.0), _iy(0), _by(false), _dy(0.0), _iz(0), _n(0)
     {
-        // external(IX, &BModel::_ix);
+        // externals
         Externals(int, ((IX, &BModel::_ix)));
 
         External(BX, &BModel::_bx);
         External(DX, &BModel::_dx);
 
-        // internal(IY, &BModel::_iy);
+        // internals
         Internals(int, ((IY, &BModel::_iy), (IZ, &BModel::_iz)));
 
         Internal(BY, &BModel::_by);
@@ -127,26 +123,23 @@ public:
         States(int, ((N, &BModel::_n)));
     }
 
-    virtual ~BModel() { }
+    ~BModel() override = default;
 
-    void compute(double t, bool /* update */)
+    void compute(double t, bool /* update */) override
     {
-        ::Trace::trace() << ::TraceElement("B", t, artis::utils::COMPUTE)
-                         << "Start";
-        ::Trace::trace().flush();
+        Trace::trace() << TraceElement("B", t, artis::utils::COMPUTE) << "Start";
+        Trace::trace().flush();
 
         _iy = _ix + 1;
         _by = not _bx;
         _dy = _dx + 1;
         ++_n;
 
-        ::Trace::trace() << ::TraceElement("B", t, artis::utils::COMPUTE)
-                         << "Stop";
-        ::Trace::trace().flush();
-
+        Trace::trace() << TraceElement("B", t, artis::utils::COMPUTE) << "Stop";
+        Trace::trace().flush();
     }
 
-    void init(double /* t */, const ModelParameters& /* parameters */)
+    void init(double /* t */, const ModelParameters& /* parameters */) override
     {
         _iy = 0;
         _by = false;
@@ -186,7 +179,9 @@ public:
     RootModel(Models submodels)
             :
             _a(dynamic_cast < AModel* >(submodels[0])),
-            _b(dynamic_cast < BModel* >(submodels[1]))
+            _b(dynamic_cast < BModel* >(submodels[1])),
+            _dx(0.0),
+            _n(0)
     {
         // submodels
         Submodels(((A, _a), (B, _b)));
@@ -202,7 +197,10 @@ public:
     }
 
     RootModel()
-            :_a(new AModel), _b(new BModel)
+            :_a(new AModel),
+             _b(new BModel),
+             _dx(0.0),
+             _n(0)
     {
         // submodels
         Submodels(((A, _a), (B, _b)));
@@ -214,21 +212,19 @@ public:
 
         // states
         States(int, ((N, &RootModel::_n)));
-        // State(N, &RootModel::_n);
     }
 
-    virtual ~RootModel()
+    ~RootModel() override
     {
         delete _a;
         delete _b;
     }
 
-    void compute(double t, bool /* update */)
+    void compute(double t, bool /* update */) override
     {
-        ::Trace::trace() << ::TraceElement(this->path(this), t,
-                artis::utils::COMPUTE)
-                         << "Start";
-        ::Trace::trace().flush();
+        Trace::trace() << TraceElement(this->path(this), t, artis::utils::COMPUTE) << "Start";
+        Trace::trace().flush();
+
         (*_a)(t);
         _b->put<double>(t, BModel::DX, _a->get<double>(t, AModel::DX));
         _b->put<int>(t, BModel::IX, _a->get<int>(t, AModel::IX));
@@ -237,10 +233,11 @@ public:
 
         ++_n;
 
-        this->trace_element(t, artis::utils::COMPUTE, "Stop");
+        Trace::trace() << TraceElement(this->path(this), t, artis::utils::COMPUTE) << "Stop";
+        Trace::trace().flush();
     }
 
-    void init(double t, const ModelParameters& parameters)
+    void init(double t, const ModelParameters& parameters) override
     {
         _a->init(t, parameters);
         _b->init(t, parameters);
@@ -260,4 +257,4 @@ private:
     int _n;
 };
 
-#endif
+#endif

src/test/test-context.cpp

@@ -20,9 +20,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-//#define CATCH_CONFIG_MAIN
-//#include <test/catch.hpp>
-
 #include <test/models.hpp>
 
 #include <artis/kernel/Simulator.hpp>
@@ -33,29 +30,23 @@
 
 #include <fstream>
 
-using namespace artis::kernel;
-
-typedef artis::kernel::Simulator<RootModel,
-        artis::utils::DoubleTime,
-        ModelParameters,
-        GlobalParameters> ASimulator;
-typedef artis::context::Context<artis::utils::DoubleTime> AContext;
+typedef artis::kernel::Simulator<RootModel, artis::utils::DoubleTime, ModelParameters, GlobalParameters> Simulator;
+typedef artis::context::Context<artis::utils::DoubleTime> Context;
 
 int main()
 {
     GlobalParameters globalParameters;
     ModelParameters modelParameters;
 
-    AContext context(artis::utils::DateTime::toJulianDayNumber("2016-1-1"),
+    Context context(artis::utils::DateTime::toJulianDayNumber("2016-1-1"),
             artis::utils::DateTime::toJulianDayNumber("2016-1-5"));
 
-    ::Trace::trace().clear();
+    Trace::trace().clear();
 
     {
-        ASimulator simulator(new RootModel, globalParameters);
+        Simulator simulator(new RootModel, globalParameters);
 
-        simulator.init(artis::utils::DateTime::toJulianDayNumber("2016-1-1"),
-                modelParameters);
+        simulator.init(artis::utils::DateTime::toJulianDayNumber("2016-1-1"), modelParameters);
         simulator.run(context);
         simulator.save(context);
 
@@ -65,47 +56,42 @@ int main()
         oa << context;
     }
 
-    std::cout << ::Trace::trace().elements().filter_variable("BX").to_string(
-            artis::utils::DATE_FORMAT_YMD) << std::endl;
+    std::cout << ::Trace::trace().elements().filter_variable("BX").to_string(artis::utils::DATE_FORMAT_YMD)
+              << std::endl;
 
-    std::cout << "==== PAUSE ====" << std::endl;
+    std::cout << "==== PAUSE ====" << std::endl << std::endl;
 
-    ::Trace::trace().clear();
+    Trace::trace().clear();
 
     {
-        AContext new_context(context);
-        ASimulator simulator(new RootModel, globalParameters);
+        Context new_context(context);
+        Simulator simulator(new RootModel, globalParameters);
 
-        new_context.begin(
-                artis::utils::DateTime::toJulianDayNumber("2016-1-6"));
-        new_context.end(
-                artis::utils::DateTime::toJulianDayNumber("2016-1-10"));
+        new_context.begin(artis::utils::DateTime::toJulianDayNumber("2016-1-6"));
+        new_context.end(artis::utils::DateTime::toJulianDayNumber("2016-1-10"));
         simulator.run(new_context);
     }
 
-    std::cout << ::Trace::trace().elements().filter_type(
-            artis::utils::COMPUTE).to_string() << std::endl;
+    std::cout << ::Trace::trace().elements().filter_type(artis::utils::COMPUTE).to_string() << std::endl;
 
-    std::cout << "==== PAUSE ====" << std::endl;
+    std::cout << "==== PAUSE ====" << std::endl << std::endl;;
 
-    ::Trace::trace().clear();
+    Trace::trace().clear();
 
     {
-        AContext new_context;
-        ASimulator simulator(new RootModel, globalParameters);
+        Context new_context;
+        Simulator simulator(new RootModel, globalParameters);
         std::ifstream is("state");
         boost::archive::binary_iarchive ia(is);
 
         ia >> new_context;
 
-        new_context.begin(
-                artis::utils::DateTime::toJulianDayNumber("2016-1-6"));
-        new_context.end(
-                artis::utils::DateTime::toJulianDayNumber("2016-1-10"));
+        new_context.begin(artis::utils::DateTime::toJulianDayNumber("2016-1-6"));
+        new_context.end(artis::utils::DateTime::toJulianDayNumber("2016-1-10"));
         simulator.run(new_context);
     }
 
-    std::cout << ::Trace::trace().elements().to_string() << std::endl;
+    std::cout << ::Trace::trace().elements().filter_type(artis::utils::COMPUTE).to_string() << std::endl;
 
     return 0;
 }

src/test/test.cpp

@@ -35,31 +35,17 @@
 using namespace artis::kernel;
 using namespace artis::builder;
 
-using Creator = ObjectCreator<Model, artis::utils::DoubleTime,
-        ModelParameters>;
-using Factory = ModelFactory<Model, int, Creator, artis::utils::DoubleTime,
-        ModelParameters>;
+using Creator = ObjectCreator<Model, artis::utils::DoubleTime, ModelParameters>;
+using Factory = ModelFactory<Model, int, Creator, artis::utils::DoubleTime, ModelParameters>;
 
-DECLARE_MODEL(AModel, ::Model, ::Factory, artis::utils::DoubleTime,
-        ModelParameters);
+DECLARE_MODEL(AModel, ::Model, ::Factory, artis::utils::DoubleTime, ModelParameters);
 
-DECLARE_MODEL(BModel, ::Model, ::Factory, artis::utils::DoubleTime,
-        ModelParameters);
+DECLARE_MODEL(BModel, ::Model, ::Factory, artis::utils::DoubleTime, ModelParameters);
 
-DECLARE_MODEL(RootModel, ::Model, ::Factory, artis::utils::DoubleTime,
-        ModelParameters);
-
-typedef artis::kernel::Simulator<RootModel,
-        artis::utils::DoubleTime,
-        ModelParameters,
-        GlobalParameters> ASimulator;
-
-typedef artis::builder::Builder<::Factory,
-        RootModel,
-        artis::utils::DoubleTime,
-        ModelParameters,
-        GlobalParameters> ABuilder;
+DECLARE_MODEL(RootModel, ::Model, ::Factory, artis::utils::DoubleTime, ModelParameters);
 
+typedef artis::kernel::Simulator<RootModel, artis::utils::DoubleTime, ModelParameters, GlobalParameters> ASimulator;
+typedef artis::builder::Builder<::Factory, RootModel, artis::utils::DoubleTime, ModelParameters, GlobalParameters> ABuilder;
 typedef artis::context::Context<artis::utils::DoubleTime> AContext;
 
 class AView : public artis::observer::View<artis::utils::DoubleTime,
@@ -75,7 +61,7 @@ public:
         selector("B::D", DOUBLE, {RootModel::B, BModel::DY});
     }
 
-    virtual ~AView() { }
+    virtual ~AView() override { }
 };
 
 typedef artis::observer::Output<artis::utils::DoubleTime,