Code style fixes

5 files changed, 111 insertions, 111 deletions

diff --git a/generator/feature_builder.cpp b/generator/feature_builder.cpp
index b152408fb0..bd7bacf8ec 100644
--- a/generator/feature_builder.cpp
+++ b/generator/feature_builder.cpp
@@ -23,7 +23,7 @@ using namespace feature;
 FeatureBuilder1::FeatureBuilder1()
 : m_coastCell(-1)
 {
-  m_Polygons.push_back(points_t());
+  m_polygons.push_back(points_t());
 }
 
 bool FeatureBuilder1::IsGeometryClosed() const
@@ -46,21 +46,21 @@ m2::PointD FeatureBuilder1::GetGeometryCenter() const
 
 void FeatureBuilder1::SetCenter(m2::PointD const & p)
 {
-  m_Center = p;
-  m_Params.SetGeomType(GEOM_POINT);
-  m_LimitRect.Add(p);
+  m_center = p;
+  m_params.SetGeomType(GEOM_POINT);
+  m_limitRect.Add(p);
 }
 
 void FeatureBuilder1::AddPoint(m2::PointD const & p)
 {
-  m_Polygons.front().push_back(p);
-  m_LimitRect.Add(p);
+  m_polygons.front().push_back(p);
+  m_limitRect.Add(p);
 }
 
 void FeatureBuilder1::SetAreaAddHoles(list<points_t> const & holes)
 {
-  m_Params.SetGeomType(GEOM_AREA);
-  m_Polygons.resize(1);
+  m_params.SetGeomType(GEOM_AREA);
+  m_polygons.resize(1);
 
   if (holes.empty()) return;
 
@@ -78,7 +78,7 @@ void FeatureBuilder1::SetAreaAddHoles(list<points_t> const & holes)
         break;
 
     if (j == count)
-      m_Polygons.push_back(*i);
+      m_polygons.push_back(*i);
   }
 }
 
@@ -89,26 +89,26 @@ void FeatureBuilder1::AddPolygon(vector<m2::PointD> & poly)
   if (poly.front() != poly.back())
     poly.push_back(poly.front());
 
-  CalcRect(poly, m_LimitRect);
+  CalcRect(poly, m_limitRect);
 
-  if (!m_Polygons.back().empty())
-    m_Polygons.push_back(points_t());
+  if (!m_polygons.back().empty())
+    m_polygons.push_back(points_t());
 
-  m_Polygons.back().swap(poly);
+  m_polygons.back().swap(poly);
 }
 
 bool FeatureBuilder1::RemoveInvalidTypes()
 {
-  if (!m_Params.FinishAddingTypes())
+  if (!m_params.FinishAddingTypes())
     return false;
 
-  return feature::RemoveNoDrawableTypes(m_Params.m_Types,
-                                        static_cast<FeatureGeoType>(m_Params.GetGeomType()));
+  return feature::RemoveNoDrawableTypes(m_params.m_Types,
+                                        static_cast<FeatureGeoType>(m_params.GetGeomType()));
 }
 
 bool FeatureBuilder1::FormatFullAddress(string & res) const
 {
-  return m_Params.FormatFullAddress(m_LimitRect.Center(), res);
+  return m_params.FormatFullAddress(m_limitRect.Center(), res);
 }
 
 FeatureBase FeatureBuilder1::GetFeatureBase() const
@@ -116,11 +116,11 @@ FeatureBase FeatureBuilder1::GetFeatureBase() const
   CHECK ( CheckValid(), (*this) );
 
   FeatureBase f;
-  f.SetHeader(m_Params.GetHeader());
+  f.SetHeader(m_params.GetHeader());
 
-  f.m_Params = m_Params;
-  memcpy(f.m_Types, &m_Params.m_Types[0], sizeof(uint32_t) * m_Params.m_Types.size());
-  f.m_LimitRect = m_LimitRect;
+  f.m_params = m_params;
+  memcpy(f.m_types, &m_params.m_Types[0], sizeof(uint32_t) * m_params.m_Types.size());
+  f.m_limitRect = m_limitRect;
 
   f.m_bTypesParsed = f.m_bCommonParsed = true;
 
@@ -163,27 +163,27 @@ namespace
 
 bool FeatureBuilder1::PreSerialize()
 {
-  if (!m_Params.IsValid())
+  if (!m_params.IsValid())
     return false;
 
   /// @todo Do not use flats info. Maybe in future.
-  m_Params.flats.clear();
+  m_params.flats.clear();
 
-  switch (m_Params.GetGeomType())
+  switch (m_params.GetGeomType())
   {
   case GEOM_POINT:
     // Store house number like HEADER_GEOM_POINT_EX.
-    if (!m_Params.house.IsEmpty())
+    if (!m_params.house.IsEmpty())
     {
-      m_Params.SetGeomTypePointEx();
-      m_Params.rank = 0;
+      m_params.SetGeomTypePointEx();
+      m_params.rank = 0;
     }
 
     // Store ref's in name field (used in "highway-motorway_junction").
-    if (m_Params.name.IsEmpty() && !m_Params.ref.empty())
-      m_Params.name.AddString(StringUtf8Multilang::DEFAULT_CODE, m_Params.ref);
+    if (m_params.name.IsEmpty() && !m_params.ref.empty())
+      m_params.name.AddString(StringUtf8Multilang::DEFAULT_CODE, m_params.ref);
 
-    m_Params.ref.clear();
+    m_params.ref.clear();
     break;
 
   case GEOM_LINE:
@@ -191,17 +191,17 @@ bool FeatureBuilder1::PreSerialize()
     static feature::TypeSetChecker checkHighway("highway");
 
     // We need refs for road's numbers.
-    if (!checkHighway.IsEqualV(m_Params.m_Types))
-      m_Params.ref.clear();
+    if (!checkHighway.IsEqualV(m_params.m_Types))
+      m_params.ref.clear();
 
-    m_Params.rank = 0;
-    m_Params.house.Clear();
+    m_params.rank = 0;
+    m_params.house.Clear();
     break;
   }
 
   case GEOM_AREA:
-    m_Params.rank = 0;
-    m_Params.ref.clear();
+    m_params.rank = 0;
+    m_params.ref.clear();
     break;
 
   default:
@@ -220,7 +220,7 @@ bool FeatureBuilder1::PreSerialize()
 void FeatureBuilder1::RemoveUselessNames()
 {
   int64_t dummy;
-  if (!m_Params.name.IsEmpty() && !GetCoastCell(dummy))
+  if (!m_params.name.IsEmpty() && !GetCoastCell(dummy))
   {
     using namespace feature;
 
@@ -232,7 +232,7 @@ void FeatureBuilder1::RemoveUselessNames()
     {
       pair<int, int> const range = GetDrawableScaleRangeForRules(types, RULE_ANY_TEXT);
       if (range.first == -1)
-        m_Params.name.Clear();
+        m_params.name.Clear();
     }
   }
 }
@@ -240,38 +240,38 @@ void FeatureBuilder1::RemoveUselessNames()
 void FeatureBuilder1::RemoveNameIfInvisible(int minS, int maxS)
 {
   int64_t dummy;
-  if (!m_Params.name.IsEmpty() && !GetCoastCell(dummy))
+  if (!m_params.name.IsEmpty() && !GetCoastCell(dummy))
   {
     pair<int, int> const range = GetDrawableScaleRangeForRules(GetFeatureBase(), RULE_ANY_TEXT);
     if (range.first > maxS || range.second < minS)
-      m_Params.name.Clear();
+      m_params.name.Clear();
   }
 }
 
 bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
 {
-  if (!(m_Params == fb.m_Params)) return false;
+  if (!(m_params == fb.m_params)) return false;
 
   if (m_coastCell != fb.m_coastCell) return false;
 
-  if (m_Params.GetGeomType() == GEOM_POINT &&
-      !is_equal(m_Center, fb.m_Center))
+  if (m_params.GetGeomType() == GEOM_POINT &&
+      !is_equal(m_center, fb.m_center))
   {
     return false;
   }
 
-  if (!is_equal(m_LimitRect, fb.m_LimitRect))
+  if (!is_equal(m_limitRect, fb.m_limitRect))
   {
     //LOG(LERROR, ("Different rects: ", m_LimitRect, fb.m_LimitRect));
     return false;
   }
 
-  if (m_Polygons.size() != fb.m_Polygons.size())
+  if (m_polygons.size() != fb.m_polygons.size())
     return false;
 
-  list<points_t>::const_iterator i = m_Polygons.begin();
-  list<points_t>::const_iterator j = fb.m_Polygons.begin();
-  for (; i != m_Polygons.end(); ++i, ++j)
+  list<points_t>::const_iterator i = m_polygons.begin();
+  list<points_t>::const_iterator j = fb.m_polygons.begin();
+  for (; i != m_polygons.end(); ++i, ++j)
     if (!is_equal(*i, *j))
     {
       //LOG(LERROR, ("Different points: ", *i, *j));
@@ -283,9 +283,9 @@ bool FeatureBuilder1::operator == (FeatureBuilder1 const & fb) const
 
 bool FeatureBuilder1::CheckValid() const
 {
-  CHECK(m_Params.CheckValid(), (*this));
+  CHECK(m_params.CheckValid(), (*this));
 
-  EGeomType const type = m_Params.GetGeomType();
+  EGeomType const type = m_params.GetGeomType();
 
   points_t const & poly = GetGeometry();
 
@@ -294,7 +294,7 @@ bool FeatureBuilder1::CheckValid() const
 
   if (type == GEOM_AREA)
   {
-    for (list<points_t>::const_iterator i = m_Polygons.begin(); i != m_Polygons.end(); ++i)
+    for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
       CHECK(i->size() >= 3, (*this));
   }
 
@@ -305,10 +305,10 @@ void FeatureBuilder1::SerializeBase(buffer_t & data, serial::CodingParams const
 {
   PushBackByteSink<buffer_t> sink(data);
 
-  m_Params.Write(sink);
+  m_params.Write(sink);
 
-  if (m_Params.GetGeomType() == GEOM_POINT)
-    serial::SavePoint(sink, m_Center, params);
+  if (m_params.GetGeomType() == GEOM_POINT)
+    serial::SavePoint(sink, m_center, params);
 }
 
 void FeatureBuilder1::Serialize(buffer_t & data) const
@@ -323,11 +323,11 @@ void FeatureBuilder1::Serialize(buffer_t & data) const
 
   PushBackByteSink<buffer_t> sink(data);
 
-  if (m_Params.GetGeomType() != GEOM_POINT)
+  if (m_params.GetGeomType() != GEOM_POINT)
   {
-    WriteVarUint(sink, static_cast<uint32_t>(m_Polygons.size()));
+    WriteVarUint(sink, static_cast<uint32_t>(m_polygons.size()));
 
-    for (list<points_t>::const_iterator i = m_Polygons.begin(); i != m_Polygons.end(); ++i)
+    for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
       serial::SaveOuterPath(*i, cp, sink);
   }
 
@@ -347,27 +347,27 @@ void FeatureBuilder1::Deserialize(buffer_t & data)
   serial::CodingParams cp;
 
   ArrayByteSource source(&data[0]);
-  m_Params.Read(source);
+  m_params.Read(source);
 
-  m_LimitRect.MakeEmpty();
+  m_limitRect.MakeEmpty();
 
-  EGeomType const type = m_Params.GetGeomType();
+  EGeomType const type = m_params.GetGeomType();
   if (type == GEOM_POINT)
   {
-    m_Center = serial::LoadPoint(source, cp);
-    m_LimitRect.Add(m_Center);
+    m_center = serial::LoadPoint(source, cp);
+    m_limitRect.Add(m_center);
     return;
   }
 
-  m_Polygons.clear();
+  m_polygons.clear();
   uint32_t const count = ReadVarUint<uint32_t>(source);
   ASSERT_GREATER ( count, 0, (*this) );
 
   for (uint32_t i = 0; i < count; ++i)
   {
-    m_Polygons.push_back(points_t());
-    serial::LoadOuterPath(source, cp, m_Polygons.back());
-    CalcRect(m_Polygons.back(), m_LimitRect);
+    m_polygons.push_back(points_t());
+    serial::LoadOuterPath(source, cp, m_polygons.back());
+    CalcRect(m_polygons.back(), m_limitRect);
   }
 
   m_coastCell = ReadVarInt<int64_t>(source);
@@ -400,8 +400,8 @@ void FeatureBuilder1::SetCoastCell(int64_t iCell, string const & strCell)
 {
   m_coastCell = iCell;
 
-  ASSERT ( m_Params.name.IsEmpty(), () );
-  m_Params.name.AddString(0, strCell);
+  ASSERT ( m_params.name.IsEmpty(), () );
+  m_params.name.AddString(0, strCell);
 }
 
 string DebugPrint(FeatureBuilder1 const & f)
@@ -410,13 +410,13 @@ string DebugPrint(FeatureBuilder1 const & f)
 
   switch (f.GetGeomType())
   {
-  case GEOM_POINT: out << DebugPrint(f.m_Center); break;
+  case GEOM_POINT: out << DebugPrint(f.m_center); break;
   case GEOM_LINE: out << "line with " << f.GetPointsCount() << " points"; break;
   case GEOM_AREA: out << "area with " << f.GetPointsCount() << " points"; break;
   default: out << "ERROR: unknown geometry type"; break;
   }
 
-  return (out.str() + " " + DebugPrint(f.m_LimitRect) + " " + DebugPrint(f.m_Params));
+  return (out.str() + " " + DebugPrint(f.m_limitRect) + " " + DebugPrint(f.m_params));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -440,7 +440,7 @@ bool FeatureBuilder2::IsDrawableInRange(int lowS, int highS) const
 bool FeatureBuilder2::PreSerialize(buffers_holder_t const & data)
 {
   // make flags actual before header serialization
-  EGeomType const geoType = m_Params.GetGeomType();
+  EGeomType const geoType = m_params.GetGeomType();
   if (geoType == GEOM_LINE)
   {
     if (data.m_ptsMask == 0 && data.m_innerPts.empty())
@@ -510,7 +510,7 @@ void FeatureBuilder2::Serialize(buffers_holder_t & data, serial::CodingParams co
 
   BitSink< PushBackByteSink<buffer_t> > bitSink(sink);
 
-  uint8_t const h = m_Params.GetTypeMask();
+  uint8_t const h = m_params.GetTypeMask();
 
   if (h == HEADER_GEOM_LINE)
   {
diff --git a/generator/feature_builder.hpp b/generator/feature_builder.hpp
index 9c150b862a..892db5d88e 100644
--- a/generator/feature_builder.hpp
+++ b/generator/feature_builder.hpp
@@ -29,8 +29,8 @@ public:
   void AddPoint(m2::PointD const & p);
 
   /// Set that feature is linear type.
-  void SetLinear() { m_Params.SetGeomType(feature::GEOM_LINE); }
-  void SetArea() { m_Params.SetGeomType(feature::GEOM_AREA); }
+  void SetLinear() { m_params.SetGeomType(feature::GEOM_LINE); }
+  void SetArea() { m_params.SetGeomType(feature::GEOM_AREA); }
 
   /// Set that feature is area and get ownership of holes.
   void SetAreaAddHoles(list<vector<m2::PointD> > const & holes);
@@ -38,12 +38,12 @@ public:
   void AddPolygon(vector<m2::PointD> & poly);
   //@}
 
-  inline feature::EGeomType GetGeomType() const { return m_Params.GetGeomType(); }
+  inline feature::EGeomType GetGeomType() const { return m_params.GetGeomType(); }
 
-  inline void AddType(uint32_t type) { m_Params.AddType(type); }
-  inline bool HasType(uint32_t t) const { return m_Params.IsTypeExist(t); }
-  inline bool PopExactType(uint32_t type) { return m_Params.PopExactType(type); }
-  inline void SetType(uint32_t type) { m_Params.SetType(type); }
+  inline void AddType(uint32_t type) { m_params.AddType(type); }
+  inline bool HasType(uint32_t t) const { return m_params.IsTypeExist(t); }
+  inline bool PopExactType(uint32_t type) { return m_params.PopExactType(type); }
+  inline void SetType(uint32_t type) { m_params.SetType(type); }
 
   /// Check classificator types for their compatibility with feature geometry type.
   /// Need to call when using any classificator types manipulating.
@@ -56,9 +56,9 @@ public:
 
   template <class FnT> bool RemoveTypesIf(FnT fn)
   {
-    m_Params.m_Types.erase(remove_if(m_Params.m_Types.begin(), m_Params.m_Types.end(), fn),
-                           m_Params.m_Types.end());
-    return m_Params.m_Types.empty();
+    m_params.m_Types.erase(remove_if(m_params.m_Types.begin(), m_params.m_Types.end(), fn),
+                           m_params.m_Types.end());
+    return m_params.m_Types.empty();
   }
 
   typedef vector<char> buffer_t;
@@ -73,7 +73,7 @@ public:
 
   /// @name Selectors.
   //@{
-  inline m2::RectD GetLimitRect() const { return m_LimitRect; }
+  inline m2::RectD GetLimitRect() const { return m_limitRect; }
 
   bool FormatFullAddress(string & res) const;
 
@@ -84,7 +84,7 @@ public:
   m2::PointD GetGeometryCenter() const;
 
   inline size_t GetPointsCount() const { return GetGeometry().size(); }
-  inline size_t GetPolygonsCount() const { return m_Polygons.size(); }
+  inline size_t GetPolygonsCount() const { return m_polygons.size(); }
   //@}
 
   /// @name Iterate through polygons points.
@@ -104,11 +104,11 @@ public:
   template <class ToDo>
   void ForEachGeometryPointEx(ToDo & toDo) const
   {
-    if (m_Params.GetGeomType() == feature::GEOM_POINT)
-      toDo(m_Center);
+    if (m_params.GetGeomType() == feature::GEOM_POINT)
+      toDo(m_center);
     else
     {
-      for (list<points_t>::const_iterator i = m_Polygons.begin(); i != m_Polygons.end(); ++i)
+      for (list<points_t>::const_iterator i = m_polygons.begin(); i != m_polygons.end(); ++i)
       {
         for (points_t::const_iterator j = i->begin(); j != i->end(); ++j)
           if (!toDo(*j))
@@ -130,7 +130,7 @@ public:
 
   /// @note This function overrides all previous assigned types.
   /// Set all the parameters, except geometry type (it's set by other functions).
-  inline void SetParams(FeatureParams const & params) { m_Params.SetParams(params); }
+  inline void SetParams(FeatureParams const & params) { m_params.SetParams(params); }
 
   /// For OSM debugging, store original OSM id
   void AddOsmId(string const & type, uint64_t osmId);
@@ -152,7 +152,7 @@ public:
   inline string GetName(int8_t lang = StringUtf8Multilang::DEFAULT_CODE) const
   {
     string s;
-    m_Params.name.GetString(lang, s);
+    m_params.name.GetString(lang, s);
     return s;
   }
 
@@ -167,22 +167,22 @@ protected:
   /// Used for feature debugging
   vector<osm::OsmId> m_osmIds;
 
-  FeatureParams m_Params;
+  FeatureParams m_params;
 
-  m2::RectD m_LimitRect;
+  m2::RectD m_limitRect;
 
   /// Can be one of the following:
   /// - point in point-feature
   /// - origin point of text [future] in line-feature
   /// - origin point of text or symbol in area-feature
-  m2::PointD m_Center;    // Check  HEADER_HAS_POINT
+  m2::PointD m_center;    // Check  HEADER_HAS_POINT
 
   typedef vector<m2::PointD> points_t;
 
-  inline points_t const & GetGeometry() const { return m_Polygons.front(); }
+  inline points_t const & GetGeometry() const { return m_polygons.front(); }
 
   /// List of geometry polygons.
-  list<points_t> m_Polygons; // Check HEADER_IS_AREA
+  list<points_t> m_polygons; // Check HEADER_IS_AREA
 
   int64_t m_coastCell;
 };
@@ -216,12 +216,12 @@ public:
     buffers_holder_t() : m_ptsMask(0), m_trgMask(0), m_ptsSimpMask(0) {}
   };
 
-  bool IsLine() const { return (m_Params.GetTypeMask() == feature::HEADER_GEOM_LINE); }
-  bool IsArea() const { return (m_Params.GetTypeMask() == feature::HEADER_GEOM_AREA); }
+  bool IsLine() const { return (m_params.GetTypeMask() == feature::HEADER_GEOM_LINE); }
+  bool IsArea() const { return (m_params.GetTypeMask() == feature::HEADER_GEOM_AREA); }
   bool IsDrawableInRange(int lowS, int highS) const;
 
   points_t const & GetOuterPoly() const { return GetGeometry(); }
-  list<points_t> const & GetPolygons() const { return m_Polygons; }
+  list<points_t> const & GetPolygons() const { return m_polygons; }
 
   /// @name Overwrite from base_type.
   //@{
diff --git a/generator/feature_merger.cpp b/generator/feature_merger.cpp
index e9c853cab8..a8b2744136 100644
--- a/generator/feature_merger.cpp
+++ b/generator/feature_merger.cpp
@@ -9,7 +9,7 @@
 MergedFeatureBuilder1::MergedFeatureBuilder1(FeatureBuilder1 const & fb)
   : FeatureBuilder1(fb), m_isRound(false)
 {
-  m_Params.FinishAddingTypes();
+  m_params.FinishAddingTypes();
 }
 
 void MergedFeatureBuilder1::SetRound()
@@ -24,7 +24,7 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
   // Also merge Osm IDs for debugging
   m_osmIds.insert(m_osmIds.end(), fb.m_osmIds.begin(), fb.m_osmIds.end());
 
-  points_t & thisG = m_Polygons.front();
+  points_t & thisG = m_polygons.front();
   points_t const & fbG = fb.GetGeometry();
 
   if (fb.m_isRound)
@@ -50,12 +50,12 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
     if (toBack)
     {
       thisG.insert(thisG.end(), fbG.begin() + 1, fbG.end());
-      CalcRect(fbG.begin() + 1, fbG.end(), m_LimitRect);
+      CalcRect(fbG.begin() + 1, fbG.end(), m_limitRect);
     }
     else
     {
       thisG.insert(thisG.begin(), fbG.begin(), fbG.end() - 1);
-      CalcRect(fbG.begin(), fbG.end() - 1, m_LimitRect);
+      CalcRect(fbG.begin(), fbG.end() - 1, m_limitRect);
     }
   }
   else
@@ -63,12 +63,12 @@ void MergedFeatureBuilder1::AppendFeature(MergedFeatureBuilder1 const & fb, bool
     if (toBack)
     {
       thisG.insert(thisG.end(), fbG.rbegin() + 1, fbG.rend());
-      CalcRect(fbG.rbegin() + 1, fbG.rend(), m_LimitRect);
+      CalcRect(fbG.rbegin() + 1, fbG.rend(), m_limitRect);
     }
     else
     {
       thisG.insert(thisG.begin(), fbG.rbegin(), fbG.rend() - 1);
-      CalcRect(fbG.rbegin(), fbG.rend() - 1, m_LimitRect);
+      CalcRect(fbG.rbegin(), fbG.rend() - 1, m_limitRect);
     }
   }
 }
diff --git a/generator/feature_merger.hpp b/generator/feature_merger.hpp
index 7ad2436e38..048eec80c7 100644
--- a/generator/feature_merger.hpp
+++ b/generator/feature_merger.hpp
@@ -20,7 +20,7 @@ public:
   void SetRound();
   bool IsRound() const { return m_isRound; }
 
-  void ZeroParams() { m_Params.MakeZero(); }
+  void ZeroParams() { m_params.MakeZero(); }
 
   void AppendFeature(MergedFeatureBuilder1 const & fb, bool fromBegin, bool toBack);
 
@@ -31,12 +31,12 @@ public:
   inline m2::PointD FirstPoint() const { return GetGeometry().front(); }
   inline m2::PointD LastPoint() const { return GetGeometry().back(); }
 
-  inline bool PopAnyType(uint32_t & type) { return m_Params.PopAnyType(type); }
+  inline bool PopAnyType(uint32_t & type) { return m_params.PopAnyType(type); }
 
   template <class ToDo> void ForEachChangeTypes(ToDo toDo)
   {
-    for_each(m_Params.m_Types.begin(), m_Params.m_Types.end(), toDo);
-    m_Params.FinishAddingTypes();
+    for_each(m_params.m_Types.begin(), m_params.m_Types.end(), toDo);
+    m_params.FinishAddingTypes();
   }
 
   template <class ToDo> void ForEachMiddlePoints(ToDo toDo) const
diff --git a/generator/statistics.cpp b/generator/statistics.cpp
index ddd9684625..4ba7dfffba 100644
--- a/generator/statistics.cpp
+++ b/generator/statistics.cpp
@@ -82,9 +82,9 @@ namespace stats
 
       FeatureType::inner_geom_stat_t const innerStats = f.GetInnerStatistic();
 
-      m_info.m_inner[0].Add(innerStats.m_Points);
-      m_info.m_inner[1].Add(innerStats.m_Strips);
-      m_info.m_inner[2].Add(innerStats.m_Size);
+      m_info.m_inner[0].Add(innerStats.m_points);
+      m_info.m_inner[1].Add(innerStats.m_strips);
+      m_info.m_inner[2].Add(innerStats.m_size);
 
       // get geometry size for the best geometry
       FeatureType::geom_stat_t const geom = f.GetGeometrySize(FeatureType::BEST_GEOMETRY);
@@ -93,7 +93,7 @@ namespace stats
       m_info.AddToSet(geom.m_count, geom.m_size, m_info.m_byPointsCount);
       m_info.AddToSet(trg.m_count / 3, trg.m_size, m_info.m_byTrgCount);
 
-      uint32_t const allSize = innerStats.m_Size + geom.m_size + trg.m_size;
+      uint32_t const allSize = innerStats.m_size + geom.m_size + trg.m_size;
 
       m_info.AddToSet(f.GetFeatureType(), allSize, m_info.m_byGeomType);