NULL -> nullptr.

Author: l-korous

Win32/StackWalker.h

@@ -64,7 +64,7 @@ class StackWalker
 
   StackWalker(
     int options = OptionsAll, // 'int' is by design, to combine the enum-flags
-    LPCSTR szSymPath = NULL, 
+    LPCSTR szSymPath = nullptr, 
     DWORD dwProcessId = GetCurrentProcessId(), 
     HANDLE hProcess = GetCurrentProcess()
     );
@@ -84,9 +84,9 @@ class StackWalker
 
   BOOL ShowCallstack(
     HANDLE hThread = GetCurrentThread(), 
-    const CONTEXT *context = NULL, 
-    PReadProcessMemoryRoutine readMemoryFunction = NULL,
-    LPVOID pUserData = NULL  // optional to identify some data in the 'readMemoryFunction'-callback
+    const CONTEXT *context = nullptr, 
+    PReadProcessMemoryRoutine readMemoryFunction = nullptr,
+    LPVOID pUserData = nullptr  // optional to identify some data in the 'readMemoryFunction'-callback
     );
 
 #if _MSC_VER >= 1300
@@ -155,11 +155,11 @@ class StackWalker
 #define GET_CURRENT_CONTEXT(c, contextFlags) \
   do { \
     memset(&c, 0, sizeof(CONTEXT)); \
-    EXCEPTION_POINTERS *pExp = NULL; \
+    EXCEPTION_POINTERS *pExp = nullptr; \
     __try { \
       throw 0; \
     } __except( ( (pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_EXECUTE_HANDLER)) {} \
-    if (pExp != NULL) \
+    if (pExp != nullptr) \
       memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \
       c.ContextFlags = contextFlags; \
   } while(0);

hermes2d/include/adapt/adapt.h

@@ -128,9 +128,9 @@ namespace Hermes
     public:
       /// Constructor. Suitable for problems where various solution components belong to different spaces (L2, H1, Hcurl,
       /// Hdiv). If proj_norms are not specified, they are defined according to the spaces.
-      Adapt(Hermes::vector<SpaceSharedPtr<Scalar> > spaces, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = NULL);
-			Adapt(SpaceSharedPtr<Scalar> space, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = NULL);
-			Adapt(ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = NULL);
+      Adapt(Hermes::vector<SpaceSharedPtr<Scalar> > spaces, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
+			Adapt(SpaceSharedPtr<Scalar> space, ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
+			Adapt(ErrorCalculator<Scalar>* error_calculator, AdaptivityStoppingCriterion<Scalar>* strategy = nullptr);
       virtual ~Adapt();  ///< Destructor. Deallocates allocated private data.
 
       /// Refines elements based on results from the ErrorCalculator class.

hermes2d/include/adapt/kelly_type_adapt.h

@@ -217,7 +217,7 @@ namespace Hermes
 
       KellyTypeAdapt(SpaceSharedPtr<Scalar> space,
                      bool ignore_visited_segments = true,
-                     const InterfaceEstimatorScalingFunction* interface_scaling_fn_ = NULL,
+                     const InterfaceEstimatorScalingFunction* interface_scaling_fn_ = nullptr,
                      NormType norm_ = HERMES_UNSET_NORM);
 
       /// Destructor.
@@ -273,11 +273,11 @@ namespace Hermes
           throw Exceptions::Exception("Wrong number of solutions.");
         Hermes::vector<MeshFunctionSharedPtr<Scalar> > slns;
         slns.push_back(sln);
-        return calc_err_est(slns, NULL, error_flags);
+        return calc_err_est(slns, nullptr, error_flags);
       }
 
       double calc_err_est(Hermes::vector<MeshFunctionSharedPtr<Scalar> > slns,
-                          Hermes::vector<double>* component_errors = NULL,
+                          Hermes::vector<double>* component_errors = nullptr,
                           unsigned int error_flags = HERMES_TOTAL_ERROR_REL | HERMES_ELEMENT_ERROR_REL)
       {
         return calc_err_internal(slns, component_errors, error_flags);
@@ -323,7 +323,7 @@ namespace Hermes
                              Func<Scalar> **ext) const
         {
           Scalar result = 0.;
-          if(u->fn_central != NULL)
+          if(u->fn_central != nullptr)
             for (int i = 0; i < n; i++)
               result += wt[i] * Hermes::sqr( const_by_laplacian * ( e->nx[i] * u->dx[i] + e->ny[i] * u->dy[i]));
           else
@@ -337,7 +337,7 @@ namespace Hermes
                                 DiscontinuousFunc<Hermes::Ord> *u, Geom<Hermes::Ord> *e,
                                 Func<Ord> **ext) const
         {
-          if(u->fn_central != NULL)
+          if(u->fn_central != nullptr)
             return Hermes::sqr(u->dx[0] + u->dy[0]);
           else
             return Hermes::sqr(u->dx_neighbor[0] + u->dy_neighbor[0]);
@@ -362,7 +362,7 @@ namespace Hermes
       }
 
       BasicKellyAdapt(SpaceSharedPtr<Scalar> space_, double const_by_laplacian = 1.0, NormType norm_ = HERMES_UNSET_NORM)
-        : KellyTypeAdapt<Scalar>(space_, true, NULL, norm_)
+        : KellyTypeAdapt<Scalar>(space_, true, nullptr, norm_)
       {
         set_scaling_consts(const_by_laplacian);
         this->error_estimators_surf.push_back(new ErrorEstimatorFormKelly(0, const_by_laplacian));

hermes2d/include/discrete_problem.h

@@ -66,14 +66,14 @@ namespace Hermes
       void set_linear(bool to_set = true, bool dirichlet_lift_accordingly = true);
 
       /// Assembling.
-      void assemble(Scalar* coeff_vec, SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = NULL);
+      void assemble(Scalar* coeff_vec, SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = nullptr);
       /// Assembling.
       /// Without the matrix.
-      void assemble(Scalar* coeff_vec, Vector<Scalar>* rhs = NULL);
-      /// Light version passing NULL for the coefficient vector. External solutions
+      void assemble(Scalar* coeff_vec, Vector<Scalar>* rhs = nullptr);
+      /// Light version passing nullptr for the coefficient vector. External solutions
       /// are initialized with zeros.
-      void assemble(SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = NULL);
-      /// Light version passing NULL for the coefficient vector. External solutions
+      void assemble(SparseMatrix<Scalar>* mat, Vector<Scalar>* rhs = nullptr);
+      /// Light version passing nullptr for the coefficient vector. External solutions
       /// are initialized with zeros.
       /// Without the matrix.
       void assemble(Vector<Scalar>* rhs);
@@ -106,7 +106,7 @@ namespace Hermes
       void deinit_assembling(Traverse::State** states, int num_states);
 
       /// RungeKutta helpers.
-      void set_RK(int original_spaces_count, bool force_diagonal_blocks = NULL, Table* block_weights = NULL);
+      void set_RK(int original_spaces_count, bool force_diagonal_blocks = nullptr, Table* block_weights = nullptr);
 
       /// State querying helpers.
       bool isOkay() const;

hermes2d/include/discrete_problem/discrete_problem_helpers.h

@@ -33,7 +33,7 @@ namespace Hermes
         DiscreteProblemRungeKutta();
 
         /// Set the special handling of external functions of Runge-Kutta methods, including information how many spaces were there in the original problem.
-        virtual void set_RK(int original_spaces_count, bool force_diagonal_blocks = NULL, Table* block_weights = NULL);
+        virtual void set_RK(int original_spaces_count, bool force_diagonal_blocks = nullptr, Table* block_weights = nullptr);
 
         /// Turn on Runge-Kutta specific handling of external functions.
         bool rungeKutta;
@@ -57,7 +57,7 @@ namespace Hermes
         WeakForm<Scalar>* get_weak_formulation() const;
 
       protected:
-        DiscreteProblemWeakForm(WeakForm<Scalar>* wf = NULL);
+        DiscreteProblemWeakForm(WeakForm<Scalar>* wf = nullptr);
 
         virtual void set_weak_formulation(WeakForm<Scalar>* wf);
 

hermes2d/include/function/exact_solution.h

@@ -269,10 +269,10 @@ namespace Hermes
       virtual Hermes::Ord ord(Hermes::Ord* values, Hermes::Ord* dx, Hermes::Ord* dy, Hermes::Ord* dxx, Hermes::Ord* dxy, Hermes::Ord* dyy, Hermes::Ord result[6]) const = 0;
 #endif
 
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL)
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr)
       {
         throw Exceptions::Exception("UExtFunction is only usable in assembling, not for getting point values.");
-        return NULL;
+        return nullptr;
       }
 
       virtual void precalculate(int order, int mask) {};

hermes2d/include/function/filter.h

@@ -117,7 +117,7 @@ namespace Hermes
 
       SimpleFilter(Hermes::vector<MeshFunctionSharedPtr<Scalar> > solutions, Hermes::vector<int> items = Hermes::vector<int>());
 
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
 
     protected:
       int item[H2D_MAX_COMPONENTS];
@@ -140,7 +140,7 @@ namespace Hermes
 
       virtual ~ComplexFilter();
     protected:
-      virtual Func<double>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<double>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
 
       virtual void set_quad_2d(Quad2D* quad_2d);
 
@@ -180,7 +180,7 @@ namespace Hermes
     protected:
       void init(Hermes::vector<MeshFunctionSharedPtr<Scalar> > solutions);
 
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
 
       virtual void filter_fn (int n, Hermes::vector<Scalar *> values, Hermes::vector<Scalar *> dx, Hermes::vector<Scalar *> dy, Scalar* rslt, Scalar* rslt_dx, Scalar* rslt_dy) = 0;
 
@@ -398,7 +398,7 @@ namespace Hermes
       VonMisesFilter(MeshFunctionSharedPtr<double>* solutions, int num, double lambda, double mu,
         int cyl = 0, int item1 = H2D_FN_VAL, int item2 = H2D_FN_VAL);
 
-      virtual Func<double>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<double>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
 
       virtual MeshFunction<double>* clone() const;
       virtual ~VonMisesFilter();
@@ -423,7 +423,7 @@ namespace Hermes
 
       LinearFilter(MeshFunctionSharedPtr<Scalar> older, MeshFunctionSharedPtr<Scalar> old, double tau_frac = 1);
 
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
       virtual MeshFunction<Scalar>* clone() const;
       virtual ~LinearFilter();
 

hermes2d/include/function/mesh_function.h

@@ -37,7 +37,7 @@ class HERMES_API MeshFunctionSharedPtr : public std::tr1::shared_ptr<Hermes::Her
 #endif
 {
 public:
-  MeshFunctionSharedPtr(Hermes::Hermes2D::MeshFunction<Scalar>* ptr = NULL);
+  MeshFunctionSharedPtr(Hermes::Hermes2D::MeshFunction<Scalar>* ptr = nullptr);
 
   MeshFunctionSharedPtr(const MeshFunctionSharedPtr<Scalar>& other);
 
@@ -92,14 +92,14 @@ namespace Hermes
       RefMap* get_refmap(bool update = true);
 
       /// Return the value at the coordinates x,y.
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL) = 0;
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr) = 0;
 
       /// Cloning function - for parallel OpenMP blocks.
       /// Designed to return an identical clone of this instance.
       virtual MeshFunction<Scalar>* clone() const
       {
         throw Hermes::Exceptions::Exception("You need to implement MeshFunctionSharedPtr::clone() to be able to use paralellization");
-        return NULL;
+        return nullptr;
       }
 
       /// Multiplies the function represented by this class by the given coefficient.

hermes2d/include/function/solution.h

@@ -91,7 +91,7 @@ namespace Hermes
       virtual void copy(const MeshFunction<Scalar>* sln);
 
       /// Sets solution equal to Dirichlet lift only, solution vector = 0.
-      void set_dirichlet_lift(SpaceSharedPtr<Scalar> space, PrecalcShapeset* pss = NULL);
+      void set_dirichlet_lift(SpaceSharedPtr<Scalar> space, PrecalcShapeset* pss = nullptr);
 
       /// Saves the complete solution (i.e., including the internal copy of the mesh and
       /// element orders) to an XML file.
@@ -131,7 +131,7 @@ namespace Hermes
       /// NOTE: This function should be used for postprocessing only, it is not effective
       /// enough for calculations. Since it searches for an element sequentinally, it is extremelly
       /// slow. Prefer Solution::get_ref_value if possible.
-      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = NULL);
+      virtual Func<Scalar>* get_pt_value(double x, double y, bool use_MeshHashGrid = false, Element* e = nullptr);
 
       /// Adds another mesh function on the given space.
       /// See method of parent class.

hermes2d/include/global.h

@@ -38,9 +38,9 @@
 #define H2D_MAX_SOLUTION_COMPONENTS 2
 static const std::string H2D_DG_INNER_EDGE = "-1234567";
 
-#define HERMES_ONE NULL
-#define HERMES_DEFAULT_FUNCTION NULL
-#define HERMES_DEFAULT_SPLINE NULL
+#define HERMES_ONE nullptr
+#define HERMES_DEFAULT_FUNCTION nullptr
+#define HERMES_DEFAULT_SPLINE nullptr
 
 #define CENTROID_QUAD_X 0.
 #define CENTROID_QUAD_Y 0.

hermes2d/include/graph.h

@@ -33,17 +33,17 @@ namespace Hermes
     {
     public:
 
-      Graph(const char* title = NULL, const char* x_axis_name = NULL, const char* y_axis_name = NULL);
+      Graph(const char* title = nullptr, const char* x_axis_name = nullptr, const char* y_axis_name = nullptr);
 
-      void set_captions(const char* title = NULL, const char* x_axis_name = NULL, const char* y_axis_name = NULL);
+      void set_captions(const char* title = nullptr, const char* x_axis_name = nullptr, const char* y_axis_name = nullptr);
 
       void set_log_x(bool log = true);
       void set_log_y(bool log = true);
 
       void show_legend(bool show = true);
       void show_grid(bool show = true);
 
-      int  add_row(const char* name = NULL, const char* color = "k", const char* line = "-", const char* marker = "");
+      int  add_row(const char* name = nullptr, const char* color = "k", const char* line = "-", const char* marker = "");
       void set_row_style(int row, const char* color = "k", const char* line = "-", const char* marker = "");
 
       void add_values(int row, double x, double y);
@@ -79,7 +79,7 @@ namespace Hermes
     {
     public:
 
-      SimpleGraph(const char* title = NULL, const char* x_axis_name = NULL, const char* y_axis_name = NULL)
+      SimpleGraph(const char* title = nullptr, const char* x_axis_name = nullptr, const char* y_axis_name = nullptr)
         : Graph(title, x_axis_name, y_axis_name) {}
 
       virtual void save(const char* filename);
@@ -91,7 +91,7 @@ namespace Hermes
     {
     public:
 
-      MatlabGraph(const char* title = NULL, const char* x_axis_name = NULL, const char* y_axis_name = NULL)
+      MatlabGraph(const char* title = nullptr, const char* x_axis_name = nullptr, const char* y_axis_name = nullptr)
         : Graph(title, x_axis_name, y_axis_name) {}
 
       virtual void save(const char* filename);
@@ -106,8 +106,8 @@ namespace Hermes
     {
     public:
 
-      GnuplotGraph(const char* title = NULL, const char* x_axis_name = NULL, const
-        char* y_axis_name = NULL, double lines_width = 1.0, const
+      GnuplotGraph(const char* title = nullptr, const char* x_axis_name = nullptr, const
+        char* y_axis_name = nullptr, double lines_width = 1.0, const
         std::string& terminal_str = default_terminal) :
       Graph(title, x_axis_name, y_axis_name),
         legend_pos(),
@@ -142,7 +142,7 @@ namespace Hermes
     {
     public:
 
-      PNGGraph(const char* title = NULL, const char* x_axis_name = NULL, const char* y_axis_name = NULL,
+      PNGGraph(const char* title = nullptr, const char* x_axis_name = nullptr, const char* y_axis_name = nullptr,
         double lines_width = 1.0, double plot_width = 800, double plot_height = 600);
     };
   }

hermes2d/include/mesh/curved.h

@@ -45,8 +45,8 @@ namespace Hermes
       Nurbs()
       {
         ref = 0; twin = false;
-        pt = NULL;
-        kv = NULL;
+        pt = nullptr;
+        kv = nullptr;
       };
 
       ~Nurbs()
@@ -78,7 +78,7 @@ namespace Hermes
     public:
       CurvMap()
       {
-        coeffs = NULL;};
+        coeffs = nullptr;};
         CurvMap(CurvMap* cm);
         ~CurvMap();
     private:
@@ -110,7 +110,7 @@ namespace Hermes
       /// this is called for every curvilinear element when it is created
       /// or when it is necessary to re-calculate coefficients for another
       /// order: 'e' is a pointer to the element to which this CurvMap
-      /// belongs to. First, old "coeffs" are removed if they are not NULL,
+      /// belongs to. First, old "coeffs" are removed if they are not nullptr,
       /// then new coefficients are projected.
       void update_refmap_coeffs(Element* e);
 

hermes2d/include/mesh/element.h

@@ -69,8 +69,8 @@ namespace Hermes
       /// Returns true if the (vertex) node is constrained.
       bool is_constrained_vertex() const;
 
-      void ref_element(Element* e = NULL);
-      void unref_element(HashTable* ht, Element* e = NULL);
+      void ref_element(Element* e = nullptr);
+      void unref_element(HashTable* ht, Element* e = nullptr);
     };
 
     /// \brief Stores one element of a mesh.
@@ -92,7 +92,7 @@ namespace Hermes
     /// elements store pointers to thier son elements and to vertex nodes.
     ///
     /// If an element has curved edges, the member 'cm' points to an associated CurvMap structure,
-    /// otherwise it is NULL.
+    /// otherwise it is nullptr.
     ///
     class HERMES_API Element
     {
@@ -138,7 +138,7 @@ namespace Hermes
       bool vsplit() const;
       bool bsplit() const;
 
-      CurvMap* cm; ///< curved mapping, NULL if not curvilinear
+      CurvMap* cm; ///< curved mapping, nullptr if not curvilinear
       /// Serves for saving the once calculated area of this element.
       bool areaCalculated;
       /// Serves for saving the once calculated area of this element.
@@ -160,7 +160,7 @@ namespace Hermes
       int prev_vert(int i) const;
 
       /// Returns a pointer to the neighboring element across the edge 'ie', or
-      /// NULL if it does not exist or is across an irregular edge.
+      /// nullptr if it does not exist or is across an irregular edge.
       Element* get_neighbor(int ie) const;
 
       /// Internal.

hermes2d/include/mesh/hash.h

@@ -56,10 +56,10 @@ namespace Hermes
       /// Returns the total number of nodes stored.
       int get_num_nodes() const;
 
-      /// Returns a vertex node with parent id's p1 and p2 if it exists, NULL otherwise.
+      /// Returns a vertex node with parent id's p1 and p2 if it exists, nullptr otherwise.
       Node* peek_vertex_node(int p1, int p2) const;
 
-      /// Returns an edge node with parent id's p1 and p2 if it exists, NULL otherwise.
+      /// Returns an edge node with parent id's p1 and p2 if it exists, nullptr otherwise.
       Node* peek_edge_node(int p1, int p2) const;
 
       /// Central function: obtains a vertex node pointer given the id