Code modernization: src/n*, src/o* (#6280)

* Code modernization: src/n*, src/o*

* empty function
* default constructor/destructor
* for range-based loops
* use emplace_back instead of push_back
* remove unused IWritableNodeDefManager::clone()
* C++ STL header style
* Pointer constness in some functions

1 files changed, 55 insertions, 97 deletions

diff --git a/src/pathfinder.cpp b/src/pathfinder.cpp
index 16c5678ee..76dd5560d 100644
--- a/src/pathfinder.cpp
+++ b/src/pathfinder.cpp
@@ -68,7 +68,7 @@ class PathCost {
 public:
 
 	/** default constructor */
-	PathCost();
+	PathCost() = default;
 
 	/** copy constructor */
 	PathCost(const PathCost &b);
@@ -76,10 +76,10 @@ public:
 	/** assignment operator */
 	PathCost &operator= (const PathCost &b);
 
-	bool valid;              /**< movement is possible         */
-	int  value;              /**< cost of movement             */
-	int  direction;          /**< y-direction of movement      */
-	bool updated;            /**< this cost has ben calculated */
+	bool valid = false;              /**< movement is possible         */
+	int  value = 0;                  /**< cost of movement             */
+	int  direction = 0;              /**< y-direction of movement      */
+	bool updated = false;            /**< this cost has ben calculated */
 
 };
 
@@ -89,7 +89,7 @@ class PathGridnode {
 
 public:
 	/** default constructor */
-	PathGridnode();
+	PathGridnode() = default;
 
 	/** copy constructor */
 	PathGridnode(const PathGridnode &b);
@@ -113,17 +113,17 @@ public:
 	 */
 	void      setCost(v3s16 dir, const PathCost &cost);
 
-	bool      valid;               /**< node is on surface                    */
-	bool      target;              /**< node is target position               */
-	bool      source;              /**< node is stating position              */
-	int       totalcost;           /**< cost to move here from starting point */
-	v3s16     sourcedir;           /**< origin of movement for current cost   */
-	v3s16     pos;                 /**< real position of node                 */
-	PathCost directions[4];        /**< cost in different directions          */
+	bool      valid = false;               /**< node is on surface                    */
+	bool      target = false;              /**< node is target position               */
+	bool      source = false;              /**< node is stating position              */
+	int       totalcost = -1;              /**< cost to move here from starting point */
+	v3s16     sourcedir;                   /**< origin of movement for current cost   */
+	v3s16     pos;                         /**< real position of node                 */
+	PathCost directions[4];                /**< cost in different directions          */
 
 	/* debug values */
-	bool      is_element;          /**< node is element of path detected      */
-	char      type;                /**< type of node                          */
+	bool      is_element = false;          /**< node is element of path detected      */
+	char      type = 'u';                  /**< type of node                          */
 };
 
 class Pathfinder;
@@ -132,7 +132,8 @@ class Pathfinder;
 class GridNodeContainer {
 public:
 	virtual PathGridnode &access(v3s16 p)=0;
-	virtual ~GridNodeContainer() {}
+	virtual ~GridNodeContainer() = default;
+
 protected:
 	Pathfinder *m_pathf;
 
@@ -141,7 +142,8 @@ protected:
 
 class ArrayGridNodeContainer : public GridNodeContainer {
 public:
-	virtual ~ArrayGridNodeContainer() {}
+	virtual ~ArrayGridNodeContainer() = default;
+
 	ArrayGridNodeContainer(Pathfinder *pathf, v3s16 dimensions);
 	virtual PathGridnode &access(v3s16 p);
 private:
@@ -154,7 +156,8 @@ private:
 
 class MapGridNodeContainer : public GridNodeContainer {
 public:
-	virtual ~MapGridNodeContainer() {}
+	virtual ~MapGridNodeContainer() = default;
+
 	MapGridNodeContainer(Pathfinder *pathf);
 	virtual PathGridnode &access(v3s16 p);
 private:
@@ -168,7 +171,7 @@ public:
 	/**
 	 * default constructor
 	 */
-	Pathfinder();
+	Pathfinder() = default;
 
 	~Pathfinder();
 
@@ -281,7 +284,7 @@ private:
 	 * @param level current recursion depth
 	 * @return true/false path to destination has been found
 	 */
-	bool          updateAllCosts(v3s16 ipos, v3s16 srcdir, int total_cost, int level);
+	bool          updateAllCosts(v3s16 ipos, v3s16 srcdir, int current_cost, int level);
 
 	/**
 	 * recursive try to find a patrh to destionation
@@ -302,17 +305,17 @@ private:
 	void          buildPath(std::vector<v3s16> &path, v3s16 pos, int level);
 
 	/* variables */
-	int m_max_index_x;            /**< max index of search area in x direction  */
-	int m_max_index_y;            /**< max index of search area in y direction  */
-	int m_max_index_z;            /**< max index of search area in z direction  */
+	int m_max_index_x = 0;            /**< max index of search area in x direction  */
+	int m_max_index_y = 0;            /**< max index of search area in y direction  */
+	int m_max_index_z = 0;            /**< max index of search area in z direction  */
 
 
-	int m_searchdistance;         /**< max distance to search in each direction */
-	int m_maxdrop;                /**< maximum number of blocks a path may drop */
-	int m_maxjump;                /**< maximum number of blocks a path may jump */
-	int m_min_target_distance;    /**< current smalest path to target           */
+	int m_searchdistance = 0;         /**< max distance to search in each direction */
+	int m_maxdrop = 0;                /**< maximum number of blocks a path may drop */
+	int m_maxjump = 0;                /**< maximum number of blocks a path may jump */
+	int m_min_target_distance = 0;    /**< current smalest path to target           */
 
-	bool m_prefetch;              /**< prefetch cost data                       */
+	bool m_prefetch = true;              /**< prefetch cost data                       */
 
 	v3s16 m_start;                /**< source position                          */
 	v3s16 m_destination;          /**< destination position                     */
@@ -322,9 +325,9 @@ private:
 	/** contains all map data already collected and analyzed.
 		Access it via the getIndexElement/getIdxElem methods. */
 	friend class GridNodeContainer;
-	GridNodeContainer *m_nodes_container;
+	GridNodeContainer *m_nodes_container = nullptr;
 
-	ServerEnvironment *m_env;     /**< minetest environment pointer             */
+	ServerEnvironment *m_env = 0;     /**< minetest environment pointer             */
 
 #ifdef PATHFINDER_DEBUG
 
@@ -395,16 +398,6 @@ std::vector<v3s16> get_path(ServerEnvironment* env,
 }
 
 /******************************************************************************/
-PathCost::PathCost()
-:	valid(false),
-	value(0),
-	direction(0),
-	updated(false)
-{
-	//intentionaly empty
-}
-
-/******************************************************************************/
 PathCost::PathCost(const PathCost &b)
 {
 	valid     = b.valid;
@@ -425,20 +418,6 @@ PathCost &PathCost::operator= (const PathCost &b)
 }
 
 /******************************************************************************/
-PathGridnode::PathGridnode()
-:	valid(false),
-	target(false),
-	source(false),
-	totalcost(-1),
-	sourcedir(v3s16(0, 0, 0)),
-	pos(v3s16(0, 0, 0)),
-	is_element(false),
-	type('u')
-{
-	//intentionaly empty
-}
-
-/******************************************************************************/
 PathGridnode::PathGridnode(const PathGridnode &b)
 :	valid(b.valid),
 	target(b.target),
@@ -728,9 +707,8 @@ std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
 
 		//finalize path
 		std::vector<v3s16> full_path;
-		for (std::vector<v3s16>::iterator i = path.begin();
-					i != path.end(); ++i) {
-			full_path.push_back(getIndexElement(*i).pos);
+		for (const v3s16 &i : path) {
+			full_path.push_back(getIndexElement(i).pos);
 		}
 
 #ifdef PATHFINDER_DEBUG
@@ -763,24 +741,6 @@ std::vector<v3s16> Pathfinder::getPath(ServerEnvironment *env,
 	return retval;
 }
 
-/******************************************************************************/
-Pathfinder::Pathfinder() :
-	m_max_index_x(0),
-	m_max_index_y(0),
-	m_max_index_z(0),
-	m_searchdistance(0),
-	m_maxdrop(0),
-	m_maxjump(0),
-	m_min_target_distance(0),
-	m_prefetch(true),
-	m_start(0, 0, 0),
-	m_destination(0, 0, 0),
-	m_nodes_container(NULL),
-	m_env(0)
-{
-	//intentionaly empty
-}
-
 Pathfinder::~Pathfinder()
 {
 	delete m_nodes_container;
@@ -970,19 +930,19 @@ bool Pathfinder::updateAllCosts(v3s16 ipos,
 
 	std::vector<v3s16> directions;
 
-	directions.push_back(v3s16( 1,0, 0));
-	directions.push_back(v3s16(-1,0, 0));
-	directions.push_back(v3s16( 0,0, 1));
-	directions.push_back(v3s16( 0,0,-1));
+	directions.emplace_back(1,0, 0);
+	directions.emplace_back(-1,0, 0);
+	directions.emplace_back(0,0, 1);
+	directions.emplace_back(0,0,-1);
 
-	for (unsigned int i=0; i < directions.size(); i++) {
-		if (directions[i] != srcdir) {
-			PathCost cost = g_pos.getCost(directions[i]);
+	for (v3s16 &direction : directions) {
+		if (direction != srcdir) {
+			PathCost cost = g_pos.getCost(direction);
 
 			if (cost.valid) {
-				directions[i].Y = cost.direction;
+				direction.Y = cost.direction;
 
-				v3s16 ipos2 = ipos + directions[i];
+				v3s16 ipos2 = ipos + direction;
 
 				if (!isValidIndex(ipos2)) {
 					DEBUG_OUT(LVL " Pathfinder: " << PP(ipos2) <<
@@ -1013,7 +973,7 @@ bool Pathfinder::updateAllCosts(v3s16 ipos,
 					DEBUG_OUT(LVL "Pathfinder: updating path at: "<<
 							PP(ipos2) << " from: " << g_pos2.totalcost << " to "<<
 							new_cost << std::endl);
-					if (updateAllCosts(ipos2, invert(directions[i]),
+					if (updateAllCosts(ipos2, invert(direction),
 											new_cost, level)) {
 						retval = true;
 						}
@@ -1054,18 +1014,16 @@ v3s16 Pathfinder::getDirHeuristic(std::vector<v3s16> &directions, PathGridnode &
 	DEBUG_OUT("Pathfinder: remaining dirs at beginning:"
 				<< directions.size() << std::endl);
 
-	for (std::vector<v3s16>::iterator iter = directions.begin();
-			iter != directions.end();
-			++iter) {
+	for (v3s16 &direction : directions) {
 
-		v3s16 pos1 = v3s16(srcpos.X + iter->X, 0, srcpos.Z+iter->Z);
+		v3s16 pos1 = v3s16(srcpos.X + direction.X, 0, srcpos.Z+ direction.Z);
 
 		int cur_manhattan = getXZManhattanDist(pos1);
-		PathCost cost    = g_pos.getCost(*iter);
+		PathCost cost    = g_pos.getCost(direction);
 
 		if (!cost.updated) {
-			cost = calcCost(g_pos.pos, *iter);
-			g_pos.setCost(*iter, cost);
+			cost = calcCost(g_pos.pos, direction);
+			g_pos.setCost(direction, cost);
 		}
 
 		if (cost.valid) {
@@ -1073,7 +1031,7 @@ v3s16 Pathfinder::getDirHeuristic(std::vector<v3s16> &directions, PathGridnode &
 
 			if ((minscore < 0)|| (score < minscore)) {
 				minscore = score;
-				retdir = *iter;
+				retdir = direction;
 			}
 		}
 	}
@@ -1123,10 +1081,10 @@ bool Pathfinder::updateCostHeuristic(	v3s16 ipos,
 
 	std::vector<v3s16> directions;
 
-	directions.push_back(v3s16( 1, 0,  0));
-	directions.push_back(v3s16(-1, 0,  0));
-	directions.push_back(v3s16( 0, 0,  1));
-	directions.push_back(v3s16( 0, 0, -1));
+	directions.emplace_back(1, 0,  0);
+	directions.emplace_back(-1, 0,  0);
+	directions.emplace_back(0, 0,  1);
+	directions.emplace_back(0, 0, -1);
 
 	v3s16 direction = getDirHeuristic(directions, g_pos);